code
stringlengths 208
42.9k
| apis
list | extract_api
stringlengths 129
69.9k
|
|---|---|---|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine as mge
import megengine._internal as mgb
from megengine.core import tensor
from megengine.test import assertTensorClose
def test_recoverable():
a = tensor()
b = tensor()
a_np = np.random.random((4, 3)).astype("float32")
b_np = np.random.random((3, 7)).astype("float32")
a.set_value(a_np)
b.set_value(b_np)
# Do some normal computation.
a2 = a * 2
ab = a @ b
# Raise a computation error.
with pytest.raises(mgb.MegBrainError):
_ = a * b
# Variable a2 and ab should be still usable after error happened.
assertTensorClose(a2.numpy(), a_np * 2)
assertTensorClose(ab.numpy(), a_np @ b_np)
# Should allow computation as well.
ab2 = ab ** 2
assertTensorClose(ab2.numpy(), (a_np @ b_np) ** 2)
|
[
"megengine.core.tensor"
] |
[((582, 590), 'megengine.core.tensor', 'tensor', ([], {}), '()\n', (588, 590), False, 'from megengine.core import tensor\n'), ((599, 607), 'megengine.core.tensor', 'tensor', ([], {}), '()\n', (605, 607), False, 'from megengine.core import tensor\n'), ((868, 900), 'pytest.raises', 'pytest.raises', (['mgb.MegBrainError'], {}), '(mgb.MegBrainError)\n', (881, 900), False, 'import pytest\n'), ((619, 643), 'numpy.random.random', 'np.random.random', (['(4, 3)'], {}), '((4, 3))\n', (635, 643), True, 'import numpy as np\n'), ((673, 697), 'numpy.random.random', 'np.random.random', (['(3, 7)'], {}), '((3, 7))\n', (689, 697), True, 'import numpy as np\n')]
|
import pytest
import megengine as mge
import megengine.functional as F
from megengine.core._imperative_rt.core2 import config_async_level, get_async_level
def test_basic():
config_async_level(2)
assert get_async_level() == 2
with pytest.raises(RuntimeError):
config_async_level(3)
def test_level1_infer_value():
config_async_level(1)
a = mge.tensor([[1, 2], [2, 3], [3, 4]], dtype="float32")
b = mge.tensor([1, 1], dtype="float32")
# make DepType::VALUE unknown
c = b * 2
with pytest.raises(RuntimeError):
d = F.reshape(a, c)
def test_level1_infer_shape_with_unknown():
config_async_level(2)
a = mge.tensor([[1, 2, 2, 3]], dtype="float32")
b = mge.tensor([1, 1])
c = b * 2
# make DepType::SHAPE unknown
d = F.reshape(a, c)
config_async_level(1)
e = mge.tensor([[1, 2]], dtype="float32")
with pytest.raises(RuntimeError):
f = F.matmul(d, e)
|
[
"megengine.core._imperative_rt.core2.get_async_level",
"megengine.core._imperative_rt.core2.config_async_level",
"megengine.tensor",
"megengine.functional.matmul",
"megengine.functional.reshape"
] |
[((180, 201), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', (['(2)'], {}), '(2)\n', (198, 201), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((341, 362), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', (['(1)'], {}), '(1)\n', (359, 362), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((371, 424), 'megengine.tensor', 'mge.tensor', (['[[1, 2], [2, 3], [3, 4]]'], {'dtype': '"""float32"""'}), "([[1, 2], [2, 3], [3, 4]], dtype='float32')\n", (381, 424), True, 'import megengine as mge\n'), ((433, 468), 'megengine.tensor', 'mge.tensor', (['[1, 1]'], {'dtype': '"""float32"""'}), "([1, 1], dtype='float32')\n", (443, 468), True, 'import megengine as mge\n'), ((633, 654), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', (['(2)'], {}), '(2)\n', (651, 654), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((663, 706), 'megengine.tensor', 'mge.tensor', (['[[1, 2, 2, 3]]'], {'dtype': '"""float32"""'}), "([[1, 2, 2, 3]], dtype='float32')\n", (673, 706), True, 'import megengine as mge\n'), ((715, 733), 'megengine.tensor', 'mge.tensor', (['[1, 1]'], {}), '([1, 1])\n', (725, 733), True, 'import megengine as mge\n'), ((790, 805), 'megengine.functional.reshape', 'F.reshape', (['a', 'c'], {}), '(a, c)\n', (799, 805), True, 'import megengine.functional as F\n'), ((810, 831), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', (['(1)'], {}), '(1)\n', (828, 831), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((840, 877), 'megengine.tensor', 'mge.tensor', (['[[1, 2]]'], {'dtype': '"""float32"""'}), "([[1, 2]], dtype='float32')\n", (850, 877), True, 'import megengine as mge\n'), ((213, 230), 'megengine.core._imperative_rt.core2.get_async_level', 'get_async_level', ([], {}), '()\n', (228, 230), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((245, 272), 'pytest.raises', 'pytest.raises', (['RuntimeError'], {}), '(RuntimeError)\n', (258, 272), False, 'import pytest\n'), ((282, 303), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', (['(3)'], {}), '(3)\n', (300, 303), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((526, 553), 'pytest.raises', 'pytest.raises', (['RuntimeError'], {}), '(RuntimeError)\n', (539, 553), False, 'import pytest\n'), ((567, 582), 'megengine.functional.reshape', 'F.reshape', (['a', 'c'], {}), '(a, c)\n', (576, 582), True, 'import megengine.functional as F\n'), ((887, 914), 'pytest.raises', 'pytest.raises', (['RuntimeError'], {}), '(RuntimeError)\n', (900, 914), False, 'import pytest\n'), ((928, 942), 'megengine.functional.matmul', 'F.matmul', (['d', 'e'], {}), '(d, e)\n', (936, 942), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import pickle
from tempfile import TemporaryFile
import numpy as np
import megengine as mge
from megengine import Parameter, Tensor
def test_tensor_serialization():
def tensor_eq(a, b):
assert a.dtype == b.dtype
assert a.device == b.device
np.testing.assert_equal(a.numpy(), b.numpy())
with TemporaryFile() as f:
data = np.random.randint(low=0, high=7, size=[233])
a = Tensor(data, device="xpux", dtype=np.int32)
pickle.dump(a, f)
f.seek(0)
b = pickle.load(f)
np.testing.assert_equal(a.numpy(), b.numpy())
with TemporaryFile() as f:
a = Parameter(np.random.random(size=(233, 2)).astype(np.float32))
pickle.dump(a, f)
f.seek(0)
b = pickle.load(f)
assert isinstance(b, Parameter)
np.testing.assert_equal(a.numpy(), b.numpy())
with TemporaryFile() as f:
a = Tensor(np.random.random(size=(2, 233)).astype(np.float32))
pickle.dump(a, f)
f.seek(0)
b = pickle.load(f)
assert type(b) is Tensor
np.testing.assert_equal(a.numpy(), b.numpy())
with TemporaryFile() as f:
a = Tensor(np.random.random(size=(2, 233)).astype(np.float32))
mge.save(a, f)
f.seek(0)
b = mge.load(f, map_location="cpux")
assert type(b) is Tensor
assert "cpu" in str(b.device)
np.testing.assert_equal(a.numpy(), b.numpy())
with TemporaryFile() as f:
if mge.is_cuda_available():
device_org = mge.get_default_device()
mge.set_default_device("gpu0")
a = Tensor(np.random.random(size=(2, 233)).astype(np.float32))
mge.save(a, f)
f.seek(0)
mge.set_default_device("cpux")
b = mge.load(f, map_location={"gpu0": "cpu0"})
assert type(b) is Tensor
assert "cpu0" in str(b.device)
np.testing.assert_equal(a.numpy(), b.numpy())
mge.set_default_device(device_org)
|
[
"megengine.is_cuda_available",
"megengine.Tensor",
"megengine.load",
"megengine.get_default_device",
"megengine.set_default_device",
"megengine.save"
] |
[((705, 720), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (718, 720), False, 'from tempfile import TemporaryFile\n'), ((742, 786), 'numpy.random.randint', 'np.random.randint', ([], {'low': '(0)', 'high': '(7)', 'size': '[233]'}), '(low=0, high=7, size=[233])\n', (759, 786), True, 'import numpy as np\n'), ((799, 842), 'megengine.Tensor', 'Tensor', (['data'], {'device': '"""xpux"""', 'dtype': 'np.int32'}), "(data, device='xpux', dtype=np.int32)\n", (805, 842), False, 'from megengine import Parameter, Tensor\n'), ((851, 868), 'pickle.dump', 'pickle.dump', (['a', 'f'], {}), '(a, f)\n', (862, 868), False, 'import pickle\n'), ((899, 913), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (910, 913), False, 'import pickle\n'), ((978, 993), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (991, 993), False, 'from tempfile import TemporaryFile\n'), ((1082, 1099), 'pickle.dump', 'pickle.dump', (['a', 'f'], {}), '(a, f)\n', (1093, 1099), False, 'import pickle\n'), ((1130, 1144), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (1141, 1144), False, 'import pickle\n'), ((1249, 1264), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (1262, 1264), False, 'from tempfile import TemporaryFile\n'), ((1350, 1367), 'pickle.dump', 'pickle.dump', (['a', 'f'], {}), '(a, f)\n', (1361, 1367), False, 'import pickle\n'), ((1398, 1412), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (1409, 1412), False, 'import pickle\n'), ((1510, 1525), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (1523, 1525), False, 'from tempfile import TemporaryFile\n'), ((1611, 1625), 'megengine.save', 'mge.save', (['a', 'f'], {}), '(a, f)\n', (1619, 1625), True, 'import megengine as mge\n'), ((1656, 1688), 'megengine.load', 'mge.load', (['f'], {'map_location': '"""cpux"""'}), "(f, map_location='cpux')\n", (1664, 1688), True, 'import megengine as mge\n'), ((1824, 1839), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (1837, 1839), False, 'from tempfile import TemporaryFile\n'), ((1857, 1880), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (1878, 1880), True, 'import megengine as mge\n'), ((1907, 1931), 'megengine.get_default_device', 'mge.get_default_device', ([], {}), '()\n', (1929, 1931), True, 'import megengine as mge\n'), ((1944, 1974), 'megengine.set_default_device', 'mge.set_default_device', (['"""gpu0"""'], {}), "('gpu0')\n", (1966, 1974), True, 'import megengine as mge\n'), ((2062, 2076), 'megengine.save', 'mge.save', (['a', 'f'], {}), '(a, f)\n', (2070, 2076), True, 'import megengine as mge\n'), ((2111, 2141), 'megengine.set_default_device', 'mge.set_default_device', (['"""cpux"""'], {}), "('cpux')\n", (2133, 2141), True, 'import megengine as mge\n'), ((2158, 2200), 'megengine.load', 'mge.load', (['f'], {'map_location': "{'gpu0': 'cpu0'}"}), "(f, map_location={'gpu0': 'cpu0'})\n", (2166, 2200), True, 'import megengine as mge\n'), ((2351, 2385), 'megengine.set_default_device', 'mge.set_default_device', (['device_org'], {}), '(device_org)\n', (2373, 2385), True, 'import megengine as mge\n'), ((1022, 1053), 'numpy.random.random', 'np.random.random', ([], {'size': '(233, 2)'}), '(size=(233, 2))\n', (1038, 1053), True, 'import numpy as np\n'), ((1290, 1321), 'numpy.random.random', 'np.random.random', ([], {'size': '(2, 233)'}), '(size=(2, 233))\n', (1306, 1321), True, 'import numpy as np\n'), ((1551, 1582), 'numpy.random.random', 'np.random.random', ([], {'size': '(2, 233)'}), '(size=(2, 233))\n', (1567, 1582), True, 'import numpy as np\n'), ((1998, 2029), 'numpy.random.random', 'np.random.random', ([], {'size': '(2, 233)'}), '(size=(2, 233))\n', (2014, 2029), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# This repo is licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import bisect
import copy
import os
import time
import megengine as mge
import megengine.distributed as dist
from megengine.autodiff import GradManager
from megengine.data import DataLoader, Infinite, RandomSampler
from megengine.data import transform as T
from megengine.optimizer import AdamW, SGD
import math
from megengine.core._imperative_rt.utils import _set_defrag
_set_defrag(True)
from layers.tools.data_mapper import data_mapper
from layers.tools.utils import (
AverageMeter,
DetectionPadCollator,
GroupedRandomSampler,
get_config_info,
import_from_file
)
logger = mge.get_logger(__name__)
logger.setLevel("INFO")
mge.device.set_prealloc_config(1024, 1024, 256 * 1024 * 1024, 4.0)
def make_parser():
parser = argparse.ArgumentParser()
parser.add_argument(
"-f", "--file", default="net.py", type=str, help="net description file"
)
parser.add_argument(
"-df", "--distill_file", default="distill_configs/ICD.py", type=str, help="distill description file"
)
parser.add_argument(
"-tf", "--teacher_file", default="net.py", type=str, help="net description file"
)
parser.add_argument(
"-w", "--weight_file", default=None, type=str, help="weights file",
)
parser.add_argument(
"-tw", "--teacher_weight_file", default=None, type=str, help="weights file",
)
parser.add_argument(
"-n", "--devices", default=1, type=int, help="total number of gpus for training",
)
parser.add_argument(
"-b", "--batch_size", default=2, type=int, help="batch size for training",
)
parser.add_argument(
"-d", "--dataset_dir", default="/data/datasets", type=str,
)
parser.add_argument(
"-l", "--load_head", action='store_true'
)
parser.add_argument(
"-sp", "--save_path", type=str,
)
return parser
def main():
parser = make_parser()
args = parser.parse_args()
# ------------------------ begin training -------------------------- #
logger.info("Device Count = %d", args.devices)
from datetime import datetime
now = datetime.now()
log_dir = "log-of-ICD-{}-{}".format(os.path.basename(args.file).split(".")[0], now.strftime('%H:%M') + ('-Inherent' if args.load_head else ''))
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
args.save_path = log_dir
if args.devices > 1:
trainer = dist.launcher(worker, n_gpus=args.devices)
trainer(args)
else:
worker(args)
def worker(args):
mge.dtr.eviction_threshold = "6GB" # set the eviction threshold to 5 GB
mge.dtr.enable() # enable the DTR optimization
current_network = import_from_file(args.file)
model = current_network.Net(current_network.Cfg())
model.train()
########### BUILD TEACHER MODEL ############
current_teacher = import_from_file(args.teacher_file)
cfg_tea = current_teacher.Cfg()
cfg_tea.backbone_pretrained = False
model_tea = current_teacher.Net(cfg_tea)
model_tea.train()
# model_tea.training = True # run in train mod
state_dict_tea = mge.load(args.teacher_weight_file)
if "state_dict" in state_dict_tea:
state_dict_tea = state_dict_tea["state_dict"]
model_tea.load_state_dict(state_dict_tea)
############### LOADED ####################
################## DISTILLER ##############
distiller_cfg = import_from_file(args.distill_file)
distiller = distiller_cfg.Net()
############### END ####################
if dist.get_rank() == 0:
logger.info(get_config_info(model.cfg))
logger.info(repr(model))
params_with_grad = []
for name, param in model.named_parameters():
if "bottom_up.conv1" in name and model.cfg.backbone_freeze_at >= 1:
continue
if "bottom_up.layer1" in name and model.cfg.backbone_freeze_at >= 2:
continue
params_with_grad.append(param)
opt = SGD(
params_with_grad,
lr=model.cfg.basic_lr * args.batch_size * dist.get_world_size(),
momentum=model.cfg.momentum,
weight_decay=model.cfg.weight_decay,
)
opt_d = AdamW(
distiller.parameters(),
lr=1e-4,
weight_decay=1e-4,
)
params_with_grad.extend(distiller.parameters())
gm = GradManager()
if dist.get_world_size() > 1:
gm.attach(
params_with_grad,
callbacks=[dist.make_allreduce_cb("mean", dist.WORLD)]
)
else:
gm.attach(params_with_grad)
if args.weight_file is not None:
weights = mge.load(args.weight_file)
model.backbone.bottom_up.load_state_dict(weights, strict=False)
if args.load_head:
print('Loading Prameters Besides from Backbones.')
res = model.load_state_dict({k:v for k, v in model_tea.state_dict().items() if 'bottom_up' not in k}, strict=False)
if dist.get_world_size() > 1:
dist.bcast_list_(model.parameters()) # sync parameters
dist.bcast_list_(distiller.parameters()) # sync parameters
dist.bcast_list_(model.buffers()) # sync buffers
dist.bcast_list_(distiller.buffers()) # sync parameters
if dist.get_rank() == 0:
logger.info("Prepare dataset")
train_loader = iter(build_dataloader(args.batch_size, args.dataset_dir, model.cfg))
############## REGISTER ###############
# To get intermediate representations
holder = [None, None]
def register_tea_hooker(m, i, o):
holder[0] = o
return
model_tea.backbone.register_forward_hook(register_tea_hooker)
def register_stu_hooker(m, i, o):
holder[1] = o
return
model.backbone.register_forward_hook(register_stu_hooker)
for epoch in range(model.cfg.max_epoch):
train_one_epoch(model, model_tea, distiller, holder, train_loader, opt, opt_d, gm, epoch, args)
if dist.get_rank() == 0:
save_path = "{}/epoch_{}.pkl".format(
args.save_path, epoch
)
mge.save(
{"epoch": epoch, "state_dict": model.state_dict()}, save_path,
)
logger.info("dump weights to %s", save_path)
def train_one_epoch(model, model_tea, distiller, feat_holder, data_queue, opt, opt_d, gm, epoch, args):
def train_func(image, im_info, gt_boxes, **args):
model_tea(image=image, im_info=im_info, gt_boxes=gt_boxes)
with gm:
loss_dict = model(image=image, im_info=im_info, gt_boxes=gt_boxes)
loss_distill = distiller(feat_holder[0], feat_holder[1], image, gt_boxes, im_info, distill_flag=0 if args['cur_step'] < 1000 else 1)
loss_dict.update(loss_distill)
loss_dict["total_loss"] = loss_dict["total_loss"] + sum(loss_distill.values())
gm.backward(loss_dict["total_loss"])
loss_list = list(loss_dict.values())
mge.optimizer.clip_grad_norm(
distiller.parameters(), 0.01)
opt.step().clear_grad()
opt_d.step().clear_grad()
return loss_list
meter = AverageMeter(record_len=model.cfg.num_losses + distiller.num_losses)
time_meter = AverageMeter(record_len=2)
log_interval = model.cfg.log_interval
tot_step = model.cfg.nr_images_epoch // (args.batch_size * dist.get_world_size())
full_step = tot_step * model.cfg.max_epoch
for step in range(tot_step):
cur_step = tot_step * epoch + step
adjust_learning_rate(opt, epoch, step, model.cfg, args)
adjust_learning_rate_cos(opt_d, cur_step, full_step)
data_tik = time.time()
mini_batch = next(data_queue)
data_tok = time.time()
tik = time.time()
loss_list = train_func(
image=mge.tensor(mini_batch["data"]),
im_info=mge.tensor(mini_batch["im_info"]),
gt_boxes=mge.tensor(mini_batch["gt_boxes"]),
cur_step=cur_step,
full_step=full_step
)
tok = time.time()
time_meter.update([tok - tik, data_tok - data_tik])
if dist.get_rank() == 0:
info_str = "e%d, %d/%d, lr:%f, "
loss_str = ", ".join(
["{}:%f".format(loss) for loss in model.cfg.losses_keys] + ["{}:%f".format(loss) for loss in distiller.loss_keys]
)
time_str = ", train_time:%.3fs, data_time:%.3fs"
log_info_str = info_str + loss_str + time_str
meter.update([loss.numpy() for loss in loss_list])
if step % log_interval == 0:
logger.info(
log_info_str,
epoch,
step,
tot_step,
opt.param_groups[0]["lr"],
*meter.average(),
*time_meter.average()
)
meter.reset()
time_meter.reset()
def adjust_learning_rate_cos(optimizer, cur_iter, total_iter):
base_lr = 1e-4
# Warm up
lr = 0.5 * base_lr * (1 + math.cos(cur_iter / total_iter * math.pi))
for param_group in optimizer.param_groups:
param_group["lr"] = lr
def adjust_learning_rate(optimizer, epoch, step, cfg, args):
base_lr = (
cfg.basic_lr * args.batch_size * dist.get_world_size() * (
cfg.lr_decay_rate
** bisect.bisect_right(cfg.lr_decay_stages, epoch)
)
)
# Warm up
lr_factor = 1.0
if epoch == 0 and step < cfg.warm_iters:
lr_factor = (step + 1.0) / cfg.warm_iters
for param_group in optimizer.param_groups:
param_group["lr"] = base_lr * lr_factor
def build_dataset(dataset_dir, cfg):
data_cfg = copy.deepcopy(cfg.train_dataset)
data_name = data_cfg.pop("name")
data_cfg["root"] = os.path.join(dataset_dir, data_name, data_cfg["root"])
if "ann_file" in data_cfg:
data_cfg["ann_file"] = os.path.join(dataset_dir, data_name, data_cfg["ann_file"])
data_cfg["order"] = ["image", "boxes", "boxes_category", "info"]
return data_mapper[data_name](**data_cfg)
# pylint: disable=dangerous-default-value
def build_sampler(train_dataset, batch_size, aspect_grouping=[1]):
def _compute_aspect_ratios(dataset):
aspect_ratios = []
for i in range(len(dataset)):
info = dataset.get_img_info(i)
aspect_ratios.append(info["height"] / info["width"])
return aspect_ratios
def _quantize(x, bins):
return list(map(lambda y: bisect.bisect_right(sorted(bins), y), x))
if len(aspect_grouping) == 0:
return Infinite(RandomSampler(train_dataset, batch_size, drop_last=True))
aspect_ratios = _compute_aspect_ratios(train_dataset)
group_ids = _quantize(aspect_ratios, aspect_grouping)
return Infinite(GroupedRandomSampler(train_dataset, batch_size, group_ids))
def build_dataloader(batch_size, dataset_dir, cfg):
train_dataset = build_dataset(dataset_dir, cfg)
train_sampler = build_sampler(train_dataset, batch_size)
train_dataloader = DataLoader(
train_dataset,
sampler=train_sampler,
transform=T.Compose(
transforms=[
T.ShortestEdgeResize(
cfg.train_image_short_size,
cfg.train_image_max_size,
sample_style="choice",
),
T.RandomHorizontalFlip(),
T.ToMode(),
],
order=["image", "boxes", "boxes_category"],
),
collator=DetectionPadCollator(),
num_workers=2,
)
return train_dataloader
if __name__ == "__main__":
main()
|
[
"megengine.data.transform.ToMode",
"megengine.device.set_prealloc_config",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.dtr.enable",
"megengine.get_logger",
"megengine.distributed.make_allreduce_cb",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.tensor",
"megengine.data.RandomSampler",
"megengine.data.transform.ShortestEdgeResize",
"megengine.autodiff.GradManager",
"megengine.load",
"megengine.distributed.launcher",
"megengine.core._imperative_rt.utils._set_defrag"
] |
[((767, 784), 'megengine.core._imperative_rt.utils._set_defrag', '_set_defrag', (['(True)'], {}), '(True)\n', (778, 784), False, 'from megengine.core._imperative_rt.utils import _set_defrag\n'), ((992, 1016), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (1006, 1016), True, 'import megengine as mge\n'), ((1041, 1107), 'megengine.device.set_prealloc_config', 'mge.device.set_prealloc_config', (['(1024)', '(1024)', '(256 * 1024 * 1024)', '(4.0)'], {}), '(1024, 1024, 256 * 1024 * 1024, 4.0)\n', (1071, 1107), True, 'import megengine as mge\n'), ((1142, 1167), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1165, 1167), False, 'import argparse\n'), ((2517, 2531), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2529, 2531), False, 'from datetime import datetime\n'), ((3015, 3031), 'megengine.dtr.enable', 'mge.dtr.enable', ([], {}), '()\n', (3029, 3031), True, 'import megengine as mge\n'), ((3103, 3130), 'layers.tools.utils.import_from_file', 'import_from_file', (['args.file'], {}), '(args.file)\n', (3119, 3130), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((3277, 3312), 'layers.tools.utils.import_from_file', 'import_from_file', (['args.teacher_file'], {}), '(args.teacher_file)\n', (3293, 3312), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((3529, 3563), 'megengine.load', 'mge.load', (['args.teacher_weight_file'], {}), '(args.teacher_weight_file)\n', (3537, 3563), True, 'import megengine as mge\n'), ((3821, 3856), 'layers.tools.utils.import_from_file', 'import_from_file', (['args.distill_file'], {}), '(args.distill_file)\n', (3837, 3856), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((4725, 4738), 'megengine.autodiff.GradManager', 'GradManager', ([], {}), '()\n', (4736, 4738), False, 'from megengine.autodiff import GradManager\n'), ((7515, 7583), 'layers.tools.utils.AverageMeter', 'AverageMeter', ([], {'record_len': '(model.cfg.num_losses + distiller.num_losses)'}), '(record_len=model.cfg.num_losses + distiller.num_losses)\n', (7527, 7583), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((7601, 7627), 'layers.tools.utils.AverageMeter', 'AverageMeter', ([], {'record_len': '(2)'}), '(record_len=2)\n', (7613, 7627), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((10114, 10146), 'copy.deepcopy', 'copy.deepcopy', (['cfg.train_dataset'], {}), '(cfg.train_dataset)\n', (10127, 10146), False, 'import copy\n'), ((10208, 10262), 'os.path.join', 'os.path.join', (['dataset_dir', 'data_name', "data_cfg['root']"], {}), "(dataset_dir, data_name, data_cfg['root'])\n", (10220, 10262), False, 'import os\n'), ((2692, 2714), 'os.path.isdir', 'os.path.isdir', (['log_dir'], {}), '(log_dir)\n', (2705, 2714), False, 'import os\n'), ((2724, 2744), 'os.makedirs', 'os.makedirs', (['log_dir'], {}), '(log_dir)\n', (2735, 2744), False, 'import os\n'), ((2819, 2861), 'megengine.distributed.launcher', 'dist.launcher', (['worker'], {'n_gpus': 'args.devices'}), '(worker, n_gpus=args.devices)\n', (2832, 2861), True, 'import megengine.distributed as dist\n'), ((3946, 3961), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (3959, 3961), True, 'import megengine.distributed as dist\n'), ((4746, 4767), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4765, 4767), True, 'import megengine.distributed as dist\n'), ((5001, 5027), 'megengine.load', 'mge.load', (['args.weight_file'], {}), '(args.weight_file)\n', (5009, 5027), True, 'import megengine as mge\n'), ((5315, 5336), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (5334, 5336), True, 'import megengine.distributed as dist\n'), ((5605, 5620), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (5618, 5620), True, 'import megengine.distributed as dist\n'), ((8029, 8040), 'time.time', 'time.time', ([], {}), '()\n', (8038, 8040), False, 'import time\n'), ((8098, 8109), 'time.time', 'time.time', ([], {}), '()\n', (8107, 8109), False, 'import time\n'), ((8125, 8136), 'time.time', 'time.time', ([], {}), '()\n', (8134, 8136), False, 'import time\n'), ((8419, 8430), 'time.time', 'time.time', ([], {}), '()\n', (8428, 8430), False, 'import time\n'), ((10326, 10384), 'os.path.join', 'os.path.join', (['dataset_dir', 'data_name', "data_cfg['ann_file']"], {}), "(dataset_dir, data_name, data_cfg['ann_file'])\n", (10338, 10384), False, 'import os\n'), ((11215, 11273), 'layers.tools.utils.GroupedRandomSampler', 'GroupedRandomSampler', (['train_dataset', 'batch_size', 'group_ids'], {}), '(train_dataset, batch_size, group_ids)\n', (11235, 11273), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((3988, 4014), 'layers.tools.utils.get_config_info', 'get_config_info', (['model.cfg'], {}), '(model.cfg)\n', (4003, 4014), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((6315, 6330), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (6328, 6330), True, 'import megengine.distributed as dist\n'), ((7733, 7754), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (7752, 7754), True, 'import megengine.distributed as dist\n'), ((8504, 8519), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (8517, 8519), True, 'import megengine.distributed as dist\n'), ((9456, 9497), 'math.cos', 'math.cos', (['(cur_iter / total_iter * math.pi)'], {}), '(cur_iter / total_iter * math.pi)\n', (9464, 9497), False, 'import math\n'), ((9701, 9722), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (9720, 9722), True, 'import megengine.distributed as dist\n'), ((9772, 9819), 'bisect.bisect_right', 'bisect.bisect_right', (['cfg.lr_decay_stages', 'epoch'], {}), '(cfg.lr_decay_stages, epoch)\n', (9791, 9819), False, 'import bisect\n'), ((11020, 11076), 'megengine.data.RandomSampler', 'RandomSampler', (['train_dataset', 'batch_size'], {'drop_last': '(True)'}), '(train_dataset, batch_size, drop_last=True)\n', (11033, 11076), False, 'from megengine.data import DataLoader, Infinite, RandomSampler\n'), ((11948, 11970), 'layers.tools.utils.DetectionPadCollator', 'DetectionPadCollator', ([], {}), '()\n', (11968, 11970), False, 'from layers.tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, get_config_info, import_from_file\n'), ((4451, 4472), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4470, 4472), True, 'import megengine.distributed as dist\n'), ((8187, 8217), 'megengine.tensor', 'mge.tensor', (["mini_batch['data']"], {}), "(mini_batch['data'])\n", (8197, 8217), True, 'import megengine as mge\n'), ((8239, 8272), 'megengine.tensor', 'mge.tensor', (["mini_batch['im_info']"], {}), "(mini_batch['im_info'])\n", (8249, 8272), True, 'import megengine as mge\n'), ((8295, 8329), 'megengine.tensor', 'mge.tensor', (["mini_batch['gt_boxes']"], {}), "(mini_batch['gt_boxes'])\n", (8305, 8329), True, 'import megengine as mge\n'), ((2573, 2600), 'os.path.basename', 'os.path.basename', (['args.file'], {}), '(args.file)\n', (2589, 2600), False, 'import os\n'), ((4845, 4887), 'megengine.distributed.make_allreduce_cb', 'dist.make_allreduce_cb', (['"""mean"""', 'dist.WORLD'], {}), "('mean', dist.WORLD)\n", (4867, 4887), True, 'import megengine.distributed as dist\n'), ((11601, 11702), 'megengine.data.transform.ShortestEdgeResize', 'T.ShortestEdgeResize', (['cfg.train_image_short_size', 'cfg.train_image_max_size'], {'sample_style': '"""choice"""'}), "(cfg.train_image_short_size, cfg.train_image_max_size,\n sample_style='choice')\n", (11621, 11702), True, 'from megengine.data import transform as T\n'), ((11795, 11819), 'megengine.data.transform.RandomHorizontalFlip', 'T.RandomHorizontalFlip', ([], {}), '()\n', (11817, 11819), True, 'from megengine.data import transform as T\n'), ((11837, 11847), 'megengine.data.transform.ToMode', 'T.ToMode', ([], {}), '()\n', (11845, 11847), True, 'from megengine.data import transform as T\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import copy
import numpy as np
import megengine.functional as F
from megengine.core import Function, tensor
from megengine.jit import trace
from megengine.test import assertTensorClose
def test_a_plus_b():
data_shape = (1, 9, 2, 6)
av = np.random.random(data_shape).astype(np.float32)
bv = np.random.random(data_shape).astype(np.float32)
a = tensor(av)
b = tensor(bv)
class MulFunc(Function):
def forward(self, a, b):
return a * b
def backward(self, grad_o):
return (grad_o * b * 2, grad_o * a * 3)
c = MulFunc()(a, b).sum()
assertTensorClose(c.numpy(), (av * bv).sum())
assertTensorClose(F.grad(c, a, use_virtual_grad=False).numpy(), bv * 2)
assertTensorClose(F.grad(c, b, use_virtual_grad=False).numpy(), av * 3)
def test_skip_invalid_grad():
data_shape = (1, 9, 2, 6)
av = np.random.random(data_shape).astype(np.float32)
bv = np.random.random(data_shape).astype(np.float32)
a = tensor(av)
b = tensor(bv)
cookie = tensor(np.random.random(data_shape).astype(np.float32))
class EqWithFakeGrad(Function):
def forward(self, a, b):
return a == b
def backward(self, grad_o):
_ = grad_o
return cookie, cookie
c = EqWithFakeGrad()(a, b).sum()
assertTensorClose(c.numpy(), (av == bv).sum().astype(np.float32))
assertTensorClose(F.grad(c, a, use_virtual_grad=False).numpy(), cookie)
assertTensorClose(F.grad(c, b, use_virtual_grad=False).numpy(), cookie)
def test_ste():
class STE(Function):
def forward(self, x):
maxv, minv = x.max(), x.min()
scale = F.maximum(maxv, -minv) / 127
return F.round(x / scale) * scale
def backward(self, grad_y):
return grad_y
data_shape = (1, 9, 2, 6)
av = np.random.random(data_shape).astype(np.float32)
a = tensor(av)
q = STE()(a)
q_2 = (q * 2.0).sum()
assertTensorClose(
F.grad(q_2, a, use_virtual_grad=False).numpy(),
np.broadcast_to(np.array([2.0], dtype=np.float32), data_shape),
)
def test_deepcopy():
class Sigmoid(Function):
def __init__(self, param):
super().__init__()
self.param = param
def forward(self, x):
y = 1 / (1 + F.exp(-x))
self.save_for_backward(y)
return y
def backward(self, grad_y):
(y,) = self.saved_tensors
return grad_y * y * (1 - y)
origin = Sigmoid(0)
new = copy.deepcopy(Sigmoid(0))
assert new.param == origin.param
def test_save_context():
class Sigmoid(Function):
def forward(self, x):
y = 1 / (1 + F.exp(-x))
self.save_for_backward(y)
return y
def backward(self, grad_y):
(y,) = self.saved_tensors
return grad_y * y * (1 - y)
def run_saved_context(a, net=None):
return net(a)
def run(use_trace, symbolic):
a = tensor(np.array([1926.0817], dtype=np.float32))
net = Sigmoid()
func_run = run_saved_context
if use_trace:
func_run = trace(run_saved_context, symbolic=symbolic)
s = func_run(a, net=net)
s2 = F.sigmoid(a)
assertTensorClose(s.numpy(), s2.numpy())
assertTensorClose(
F.grad(s, a, use_virtual_grad=False).numpy(),
F.grad(s2, a, use_virtual_grad=False).numpy(),
)
run(False, False)
run(True, False)
run(True, True)
def test_none_in_out_grad():
class Test(Function):
def forward(self, a, b):
return a, b
def backward(self, grad_a, grad_b):
assert grad_b is None
return (grad_a, 0)
a = tensor(np.array([1.0], dtype=np.float32))
b = tensor(np.array([2.0], dtype=np.float32))
aa, bb = Test()(a, b)
assertTensorClose(
F.grad(aa, a, use_virtual_grad=False).numpy(), np.array([1.0], dtype=np.float32)
)
assertTensorClose(
F.grad(aa, b, use_virtual_grad=False).numpy(), np.array([0.0], dtype=np.float32)
)
def test_zero_grad():
class StopGradient(Function):
def forward(self, a):
return a
def backward(self, *_):
return None
a = tensor(np.array([1.0], dtype=np.float32))
b = a * 3.0
c = a * 4.0
loss = StopGradient()(b) + c
assertTensorClose(
F.grad(loss, a, use_virtual_grad=False).numpy(),
np.array([4.0], dtype=np.float32),
)
|
[
"megengine.functional.sigmoid",
"megengine.jit.trace",
"megengine.functional.exp",
"megengine.core.tensor",
"megengine.functional.maximum",
"megengine.functional.grad",
"megengine.functional.round"
] |
[((715, 725), 'megengine.core.tensor', 'tensor', (['av'], {}), '(av)\n', (721, 725), False, 'from megengine.core import Function, tensor\n'), ((734, 744), 'megengine.core.tensor', 'tensor', (['bv'], {}), '(bv)\n', (740, 744), False, 'from megengine.core import Function, tensor\n'), ((1339, 1349), 'megengine.core.tensor', 'tensor', (['av'], {}), '(av)\n', (1345, 1349), False, 'from megengine.core import Function, tensor\n'), ((1358, 1368), 'megengine.core.tensor', 'tensor', (['bv'], {}), '(bv)\n', (1364, 1368), False, 'from megengine.core import Function, tensor\n'), ((2257, 2267), 'megengine.core.tensor', 'tensor', (['av'], {}), '(av)\n', (2263, 2267), False, 'from megengine.core import Function, tensor\n'), ((3606, 3618), 'megengine.functional.sigmoid', 'F.sigmoid', (['a'], {}), '(a)\n', (3615, 3618), True, 'import megengine.functional as F\n'), ((4126, 4159), 'numpy.array', 'np.array', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (4134, 4159), True, 'import numpy as np\n'), ((4176, 4209), 'numpy.array', 'np.array', (['[2.0]'], {'dtype': 'np.float32'}), '([2.0], dtype=np.float32)\n', (4184, 4209), True, 'import numpy as np\n'), ((4315, 4348), 'numpy.array', 'np.array', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (4323, 4348), True, 'import numpy as np\n'), ((4433, 4466), 'numpy.array', 'np.array', (['[0.0]'], {'dtype': 'np.float32'}), '([0.0], dtype=np.float32)\n', (4441, 4466), True, 'import numpy as np\n'), ((4655, 4688), 'numpy.array', 'np.array', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (4663, 4688), True, 'import numpy as np\n'), ((4843, 4876), 'numpy.array', 'np.array', (['[4.0]'], {'dtype': 'np.float32'}), '([4.0], dtype=np.float32)\n', (4851, 4876), True, 'import numpy as np\n'), ((602, 630), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (618, 630), True, 'import numpy as np\n'), ((659, 687), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (675, 687), True, 'import numpy as np\n'), ((1226, 1254), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (1242, 1254), True, 'import numpy as np\n'), ((1283, 1311), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (1299, 1311), True, 'import numpy as np\n'), ((2201, 2229), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (2217, 2229), True, 'import numpy as np\n'), ((2414, 2447), 'numpy.array', 'np.array', (['[2.0]'], {'dtype': 'np.float32'}), '([2.0], dtype=np.float32)\n', (2422, 2447), True, 'import numpy as np\n'), ((3369, 3408), 'numpy.array', 'np.array', (['[1926.0817]'], {'dtype': 'np.float32'}), '([1926.0817], dtype=np.float32)\n', (3377, 3408), True, 'import numpy as np\n'), ((3516, 3559), 'megengine.jit.trace', 'trace', (['run_saved_context'], {'symbolic': 'symbolic'}), '(run_saved_context, symbolic=symbolic)\n', (3521, 3559), False, 'from megengine.jit import trace\n'), ((1025, 1061), 'megengine.functional.grad', 'F.grad', (['c', 'a'], {'use_virtual_grad': '(False)'}), '(c, a, use_virtual_grad=False)\n', (1031, 1061), True, 'import megengine.functional as F\n'), ((1101, 1137), 'megengine.functional.grad', 'F.grad', (['c', 'b'], {'use_virtual_grad': '(False)'}), '(c, b, use_virtual_grad=False)\n', (1107, 1137), True, 'import megengine.functional as F\n'), ((1389, 1417), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (1405, 1417), True, 'import numpy as np\n'), ((1758, 1794), 'megengine.functional.grad', 'F.grad', (['c', 'a'], {'use_virtual_grad': '(False)'}), '(c, a, use_virtual_grad=False)\n', (1764, 1794), True, 'import megengine.functional as F\n'), ((1834, 1870), 'megengine.functional.grad', 'F.grad', (['c', 'b'], {'use_virtual_grad': '(False)'}), '(c, b, use_virtual_grad=False)\n', (1840, 1870), True, 'import megengine.functional as F\n'), ((2023, 2045), 'megengine.functional.maximum', 'F.maximum', (['maxv', '(-minv)'], {}), '(maxv, -minv)\n', (2032, 2045), True, 'import megengine.functional as F\n'), ((2071, 2089), 'megengine.functional.round', 'F.round', (['(x / scale)'], {}), '(x / scale)\n', (2078, 2089), True, 'import megengine.functional as F\n'), ((2342, 2380), 'megengine.functional.grad', 'F.grad', (['q_2', 'a'], {'use_virtual_grad': '(False)'}), '(q_2, a, use_virtual_grad=False)\n', (2348, 2380), True, 'import megengine.functional as F\n'), ((4268, 4305), 'megengine.functional.grad', 'F.grad', (['aa', 'a'], {'use_virtual_grad': '(False)'}), '(aa, a, use_virtual_grad=False)\n', (4274, 4305), True, 'import megengine.functional as F\n'), ((4386, 4423), 'megengine.functional.grad', 'F.grad', (['aa', 'b'], {'use_virtual_grad': '(False)'}), '(aa, b, use_virtual_grad=False)\n', (4392, 4423), True, 'import megengine.functional as F\n'), ((4786, 4825), 'megengine.functional.grad', 'F.grad', (['loss', 'a'], {'use_virtual_grad': '(False)'}), '(loss, a, use_virtual_grad=False)\n', (4792, 4825), True, 'import megengine.functional as F\n'), ((2673, 2682), 'megengine.functional.exp', 'F.exp', (['(-x)'], {}), '(-x)\n', (2678, 2682), True, 'import megengine.functional as F\n'), ((3067, 3076), 'megengine.functional.exp', 'F.exp', (['(-x)'], {}), '(-x)\n', (3072, 3076), True, 'import megengine.functional as F\n'), ((3707, 3743), 'megengine.functional.grad', 'F.grad', (['s', 'a'], {'use_virtual_grad': '(False)'}), '(s, a, use_virtual_grad=False)\n', (3713, 3743), True, 'import megengine.functional as F\n'), ((3765, 3802), 'megengine.functional.grad', 'F.grad', (['s2', 'a'], {'use_virtual_grad': '(False)'}), '(s2, a, use_virtual_grad=False)\n', (3771, 3802), True, 'import megengine.functional as F\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import copy
import time
from typing import Iterable
import megengine as mge
import megengine.amp as amp
import megengine.distributed as dist
import megengine.functional as F
import megengine.module as M
import megengine.optimizer as optim
from basecore.config import ConfigDict
from basecore.engine import BaseHook, BaseTrainer
from basecore.utils import MeterBuffer
from megengine import jit
from basecls.data import DataLoaderType
from basecls.layers import Preprocess, build_loss
from basecls.solver import Solver
from basecls.utils import registers
__all__ = ["ClsTrainer"]
@registers.trainers.register()
class ClsTrainer(BaseTrainer):
"""Classification trainer.
Args:
cfg: config for training.
model: model for training.
dataloader: dataloader for training.
solver: solver for training.
hooks: hooks for training.
Attributes:
cfg: config for training.
model: model for training.
ema: model exponential moving average.
dataloader: dataloader for training.
solver: solver for training.
progress: object for recording training process.
loss: loss function for training.
meter : object for recording metrics.
"""
def __init__(
self,
cfg: ConfigDict,
model: M.Module,
dataloader: DataLoaderType,
solver: Solver,
hooks: Iterable[BaseHook] = None,
):
super().__init__(model, dataloader, solver, hooks)
self.cfg = cfg
self.ema = copy.deepcopy(model) if cfg.model_ema.enabled else None
self.preprocess = Preprocess(cfg.preprocess.img_mean, cfg.preprocess.img_std)
self.loss = build_loss(cfg)
self.meter = MeterBuffer(cfg.log_every_n_iter)
if cfg.trace:
# FIXME: tracing makes the training slower than before, why?
self.model_step = jit.trace(self.model_step, symbolic=True)
def train(self):
start_training_info = (1, 1)
max_iter = len(self.dataloader)
max_training_info = (self.cfg.solver.max_epoch, max_iter)
super().train(start_training_info, max_training_info)
def before_train(self):
super().before_train()
def before_epoch(self):
super().before_epoch()
self.dataloader_iter = iter(self.dataloader)
def after_epoch(self):
del self.dataloader_iter
super().after_epoch()
def train_one_iter(self):
"""Basic logic of training one iteration."""
data_tik = time.perf_counter()
data = next(self.dataloader_iter)
samples, targets = self.preprocess(data)
mge._full_sync() # use full_sync func to sync launch queue for dynamic execution
data_tok = time.perf_counter()
train_tik = time.perf_counter()
losses, accs = self.model_step(samples, targets)
mge._full_sync() # use full_sync func to sync launch queue for dynamic execution
train_tok = time.perf_counter()
# TODO: stats and accs
loss_meters = {"loss": losses.item()}
stat_meters = {"stat_acc@1": accs[0].item() * 100, "stat_acc@5": accs[1].item() * 100}
time_meters = {"train_time": train_tok - train_tik, "data_time": data_tok - data_tik}
self.meter.update(**loss_meters, **stat_meters, **time_meters)
def model_step(self, samples, targets):
optimizer = self.solver.optimizer
grad_manager = self.solver.grad_manager
grad_scaler = self.solver.grad_scaler
with grad_manager:
with amp.autocast(enabled=self.cfg.amp.enabled):
outputs = self.model(samples)
losses = self.loss(outputs, targets)
if isinstance(losses, mge.Tensor):
total_loss = losses
elif isinstance(losses, dict):
if "total_loss" in losses:
total_loss = losses["total_loss"]
else:
# only key contains "loss" will be calculated.
total_loss = sum([v for k, v in losses.items() if "loss" in k])
losses["total_loss"] = total_loss
else:
# list or tuple
total_loss = sum(losses)
total_loss = total_loss / self.cfg.solver.accumulation_steps
# this is made compatible with one hot labels
if targets.ndim == 2:
targets = F.argmax(targets, axis=1)
accs = F.metric.topk_accuracy(outputs, targets, (1, 5))
if self.cfg.amp.enabled:
grad_scaler.backward(grad_manager, total_loss)
else:
grad_manager.backward(total_loss)
if self.progress.iter % self.cfg.solver.accumulation_steps == 0:
self.modify_grad()
optimizer.step().clear_grad()
self.model_ema_step()
return losses, accs
def modify_grad(self):
grad_cfg = self.cfg.solver.grad_clip
# TODO: support advanced params for grad clip in the future
params = self.model.parameters()
if grad_cfg.name is None:
return
elif grad_cfg.name == "norm":
optim.clip_grad_norm(params, grad_cfg.max_norm)
elif grad_cfg.name == "value":
optim.clip_grad_value(params, grad_cfg.lower, grad_cfg.upper)
else:
raise ValueError(f"Grad clip type '{grad_cfg.name}' not supported")
def model_ema_step(self):
"""Implement momentum based Exponential Moving Average (EMA) for model states
https://github.com/rwightman/pytorch-image-models/blob/master/timm/utils/model_ema.py
Also inspired by Pycls https://github.com/facebookresearch/pycls/pull/138/, which is more
flexible and efficient
Heuristically, one can use a momentum of 0.9999 as used by Tensorflow and 0.9998 as used
by timm, which updates model ema every iter. To be more efficient, one can set
``update_period`` to e.g. 8 or 32 to speed up your training, and decrease your momentum
at scale: set ``momentum=0.9978`` from 0.9999 (32 times) when you ``update_period=32``.
Also, to make model EMA really work (improve generalization), one should carefully tune
the momentum based on various factors, e.g. the learning rate scheduler,
the total batch size, the training epochs, e.t.c.
To initialize a momentum in Pycls style, one set ``model_ema.alpha = 1e-5`` instead.
Momentum will be calculated through ``_calculate_pycls_momentum``.
"""
if self.ema is None:
return
ema_cfg = self.cfg.model_ema
cur_iter, cur_epoch = self.progress.iter, self.progress.epoch
if cur_iter % ema_cfg.update_period == 0:
if cur_epoch > (ema_cfg.start_epoch or self.cfg.solver.warmup_epochs):
momentum = (
ema_cfg.momentum
if ema_cfg.alpha is None
else _calculate_pycls_momentum(
alpha=ema_cfg.alpha,
total_batch_size=self.cfg.batch_size * dist.get_world_size(),
max_epoch=self.cfg.solver.max_epoch,
update_period=ema_cfg.update_period,
)
)
else:
# copy model to ema
momentum = 0.0
if not hasattr(self, "_ema_states"):
self._ema_states = (
list(self.ema.parameters()) + list(self.ema.buffers()),
list(self.model.parameters()) + list(self.model.buffers()),
)
for e, p in zip(*self._ema_states):
# _inplace_add_(e, p, alpha=mge.tensor(momentum), beta=mge.tensor(1 - momentum))
e._reset(e * momentum + p * (1 - momentum))
def _calculate_pycls_momentum(
alpha: float, total_batch_size: int, max_epoch: int, update_period: int
):
"""pycls style momentum calculation which uses a relative model_ema to decouple momentum with
other training hyper-parameters e.g.
* training epochs
* interval to update ema
* batch sizes
Usually the alpha is a tiny positive floating number, e.g. 1e-4 or 1e-5,
with ``max_epoch=100``, ``total_batch_size=1024`` and ``update_period=32``, the ema
momentum should be 0.996723175, which has roughly same behavior to the default setting.
i.e. ``momentum=0.9999`` together with ``update_period=1``
"""
return max(0, 1 - alpha * (total_batch_size / max_epoch * update_period))
|
[
"megengine.jit.trace",
"megengine.distributed.get_world_size",
"megengine.optimizer.clip_grad_value",
"megengine.amp.autocast",
"megengine.optimizer.clip_grad_norm",
"megengine.functional.argmax",
"megengine._full_sync",
"megengine.functional.metric.topk_accuracy"
] |
[((666, 695), 'basecls.utils.registers.trainers.register', 'registers.trainers.register', ([], {}), '()\n', (693, 695), False, 'from basecls.utils import registers\n'), ((1698, 1757), 'basecls.layers.Preprocess', 'Preprocess', (['cfg.preprocess.img_mean', 'cfg.preprocess.img_std'], {}), '(cfg.preprocess.img_mean, cfg.preprocess.img_std)\n', (1708, 1757), False, 'from basecls.layers import Preprocess, build_loss\n'), ((1778, 1793), 'basecls.layers.build_loss', 'build_loss', (['cfg'], {}), '(cfg)\n', (1788, 1793), False, 'from basecls.layers import Preprocess, build_loss\n'), ((1815, 1848), 'basecore.utils.MeterBuffer', 'MeterBuffer', (['cfg.log_every_n_iter'], {}), '(cfg.log_every_n_iter)\n', (1826, 1848), False, 'from basecore.utils import MeterBuffer\n'), ((2610, 2629), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (2627, 2629), False, 'import time\n'), ((2729, 2745), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (2743, 2745), True, 'import megengine as mge\n'), ((2830, 2849), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (2847, 2849), False, 'import time\n'), ((2871, 2890), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (2888, 2890), False, 'import time\n'), ((2956, 2972), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (2970, 2972), True, 'import megengine as mge\n'), ((3058, 3077), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (3075, 3077), False, 'import time\n'), ((1616, 1636), 'copy.deepcopy', 'copy.deepcopy', (['model'], {}), '(model)\n', (1629, 1636), False, 'import copy\n'), ((1974, 2015), 'megengine.jit.trace', 'jit.trace', (['self.model_step'], {'symbolic': '(True)'}), '(self.model_step, symbolic=True)\n', (1983, 2015), False, 'from megengine import jit\n'), ((4565, 4613), 'megengine.functional.metric.topk_accuracy', 'F.metric.topk_accuracy', (['outputs', 'targets', '(1, 5)'], {}), '(outputs, targets, (1, 5))\n', (4587, 4613), True, 'import megengine.functional as F\n'), ((3642, 3684), 'megengine.amp.autocast', 'amp.autocast', ([], {'enabled': 'self.cfg.amp.enabled'}), '(enabled=self.cfg.amp.enabled)\n', (3654, 3684), True, 'import megengine.amp as amp\n'), ((4520, 4545), 'megengine.functional.argmax', 'F.argmax', (['targets'], {'axis': '(1)'}), '(targets, axis=1)\n', (4528, 4545), True, 'import megengine.functional as F\n'), ((5280, 5327), 'megengine.optimizer.clip_grad_norm', 'optim.clip_grad_norm', (['params', 'grad_cfg.max_norm'], {}), '(params, grad_cfg.max_norm)\n', (5300, 5327), True, 'import megengine.optimizer as optim\n'), ((5379, 5440), 'megengine.optimizer.clip_grad_value', 'optim.clip_grad_value', (['params', 'grad_cfg.lower', 'grad_cfg.upper'], {}), '(params, grad_cfg.lower, grad_cfg.upper)\n', (5400, 5440), True, 'import megengine.optimizer as optim\n'), ((7230, 7251), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (7249, 7251), True, 'import megengine.distributed as dist\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import io
import numpy as np
import pytest
import megengine.functional as F
import megengine.module as M
import megengine.utils.comp_graph_tools as cgtools
from megengine import Parameter, Tensor
from megengine.core.tensor import megbrain_graph as G
from megengine.jit.tracing import trace
from megengine.quantization.quantize import quantize, quantize_qat
from megengine.utils.naming import AutoNaming
def _dump_and_load(func, symbolic, keep_opr_name=True):
AutoNaming.clear()
func = trace(func, symbolic=symbolic, capture_as_const=True)
x = Tensor(np.ones(shape=(2, 3)))
func(x).numpy()
file = io.BytesIO()
func.dump(
file,
optimize_for_inference=False,
arg_names=("x",),
keep_opr_name=keep_opr_name,
keep_var_name=2,
)
file.seek(0)
outputs = G.load_graph(file).output_vars_list
ops = cgtools.get_oprs_seq(outputs)
return ops
@pytest.mark.parametrize("symbolic", [False, True])
def test_auto_naming(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
def forward(self, x):
return x + x
m = Simple("simple")
op = _dump_and_load(m, symbolic)[-1]
assert op.name == "simple.ADD"
assert op.outputs[0].name == "simple.ADD"
@pytest.mark.parametrize("symbolic", [False, True])
def test_user_named_tensor(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
self.k = Parameter(1.0, name="k")
def forward(self, x):
x = x + x
x.name = "o_x"
return x
m = Simple("simple")
op = _dump_and_load(m, symbolic)[-1]
assert op.name == "simple.ADD"
assert op.outputs[0].name == "o_x"
@pytest.mark.parametrize("symbolic", [False, True])
def test_user_named_param(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
self.k = Parameter(2.0, name="k")
def forward(self, x):
return self.k * x
m = Simple("simple")
op = _dump_and_load(m, symbolic)[-1]
assert op.inputs[0].name == "x"
assert op.inputs[1].name == "simple.k"
@pytest.mark.parametrize("symbolic", [False, True])
def test_without_module(symbolic):
def f(x):
return 2 * x
op = _dump_and_load(f, symbolic)[-1]
assert op.name == "MUL"
@pytest.mark.parametrize("symbolic", [False, True])
def test_ignore_top_module(symbolic):
class Simple(M.Module):
def forward(self, x):
return x + x
m = Simple()
op = _dump_and_load(m, symbolic)[-1]
assert op.name == "ADD"
assert op.outputs[0].name == "ADD"
@pytest.mark.parametrize("symbolic", [False, True])
def test_with_submodule(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
self.linear = M.Linear(3, 3)
def forward(self, x):
x = self.linear(x)
return x
m = Simple("simple")
ops = _dump_and_load(m, symbolic)
assert ops[-1].name == "simple.linear.ADD"
assert ops[-2].name == "simple.linear.MatrixMul"
assert ops[-1].outputs[0].name == "simple.linear.ADD"
@pytest.mark.parametrize("symbolic", [False, True])
def test_with_submodule_in_container(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
self.l0 = [M.Linear(3, 3) for _ in range(2)]
self.l1 = tuple(self.l0)
self.l2 = dict(zip(["l2-0", "l2-1"], self.l0))
def forward(self, x):
for i in range(2):
x = self.l0[i](x)
x = self.l1[i](x)
x = self.l2["l2-%d" % i](x)
return x
m = Simple("simple")
ops = _dump_and_load(m, symbolic)
assert ops[-1].outputs[0].name == "simple.l0.1.ADD[2]"
assert ops[-1].name == "simple.l0.1.ADD[2]"
assert ops[-2].name == "simple.l0.1.MatrixMul[2]"
assert ops[-3].name == "simple.l0.1.ADD[1]"
assert ops[-4].name == "simple.l0.1.MatrixMul[1]"
assert ops[-5].name == "simple.l0.1.ADD[0]"
assert ops[-6].name == "simple.l0.1.MatrixMul[0]"
@pytest.mark.parametrize("symbolic", [False, True])
def test_named_submodule(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
self.linear = M.Linear(3, 3, name="x")
def forward(self, x):
x = self.linear(x)
return x
m = Simple("simple")
ops = _dump_and_load(m, symbolic)
assert ops[-1].name == "simple.x.ADD"
assert ops[-2].name == "simple.x.MatrixMul"
assert ops[-1].outputs[0].name == "simple.x.ADD"
@pytest.mark.parametrize("symbolic", [False, True])
def test_with_same_operators(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__()
self.name = name
def forward(self, x):
x = F.relu(x)
x = F.relu(x)
return x
m = Simple("simple")
ops = _dump_and_load(m, symbolic)
assert ops[-1].name == "simple.RELU[1]"
assert ops[-2].name == "simple.RELU[0]"
@pytest.mark.parametrize("symbolic", [False, True])
def test_not_keep_opr_name(symbolic):
def f(x):
return 2 * x
op = _dump_and_load(f, symbolic, False)[-1]
assert op.name == "MUL(x,const<2>[2])[4]"
@pytest.mark.parametrize("tensor_name, var_name", [("data", "data"), (None, "arg_0")])
def test_catch_input_name(tensor_name, var_name):
def f(x):
return 2 * x
func = trace(f, symbolic=True, capture_as_const=True)
x = Tensor(np.ones(shape=(2, 3)), name=tensor_name)
func(x).numpy()
file = io.BytesIO()
func.dump(file, optimize_for_inference=False, keep_opr_name=True, keep_var_name=2)
file.seek(0)
outputs = G.load_graph(file).output_vars_list
op = cgtools.get_oprs_seq(outputs)[-1]
assert op.inputs[0].name == var_name
@pytest.mark.parametrize("symbolic", [False, True])
def test_quantized_module_auto_naming(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__(name=name)
self.quant = M.QuantStub()
self.linear = M.Linear(3, 3, bias=True)
self.dequant = M.DequantStub()
def forward(self, x):
out = self.quant(x)
out = self.linear(out)
out = self.dequant(out)
return out
m = Simple("simple")
quantize_qat(m)
quantize(m)
m.eval()
ops = _dump_and_load(m, symbolic)
ops_name = (
"x",
"simple.quant.TypeCvt",
"simple.linear.MatrixMul",
"simple.linear.ADD",
"simple.linear.TypeCvt",
"simple.dequant.TypeCvt",
)
for op, name in zip(ops, ops_name):
assert op.name == name
@pytest.mark.parametrize("symbolic", [False, True])
def test_quantized_module_user_naming(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__(name=name)
self.quant = M.QuantStub()
self.linear = M.Linear(3, 3, bias=True, name="user-linear")
self.dequant = M.DequantStub()
def forward(self, x):
out = self.quant(x)
out = self.linear(out)
out = self.dequant(out)
return out
m = Simple("simple")
quantize_qat(m)
quantize(m)
m.eval()
ops = _dump_and_load(m, symbolic)
ops_name = (
"x",
"simple.quant.TypeCvt",
"simple.user-linear.MatrixMul",
"simple.user-linear.ADD",
"simple.user-linear.TypeCvt",
"simple.dequant.TypeCvt",
)
for op, name in zip(ops, ops_name):
assert op.name == name
@pytest.mark.parametrize("symbolic", [False, True])
def test_quantized_module_user_naming_param(symbolic):
class Simple(M.Module):
def __init__(self, name):
super().__init__(name=name)
self.quant = M.QuantStub()
self.linear = M.Linear(3, 3, bias=True)
self.dequant = M.DequantStub()
self.linear.weight.name = "user-weight"
self.linear.bias.name = "user-bias"
def forward(self, x):
out = self.quant(x)
out = self.linear(out)
out = self.dequant(out)
return out
m = Simple("simple")
quantize_qat(m)
quantize(m)
m.eval()
ops = _dump_and_load(m, symbolic)
(matrix_mul_op,) = [op for op in ops if op.name == "simple.linear.MatrixMul"]
for var in matrix_mul_op.inputs:
assert var.name in ("simple.quant.TypeCvt", "simple.linear.user-weight")
# WONTFIX: bias' name does not meet expectations because of astype operator after quantization
|
[
"megengine.module.Linear",
"megengine.quantization.quantize.quantize_qat",
"megengine.module.QuantStub",
"megengine.Parameter",
"megengine.functional.relu",
"megengine.module.DequantStub",
"megengine.jit.tracing.trace",
"megengine.core.tensor.megbrain_graph.load_graph",
"megengine.utils.naming.AutoNaming.clear",
"megengine.quantization.quantize.quantize",
"megengine.utils.comp_graph_tools.get_oprs_seq"
] |
[((1296, 1346), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (1319, 1346), False, 'import pytest\n'), ((1708, 1758), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (1731, 1758), False, 'import pytest\n'), ((2211, 2261), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (2234, 2261), False, 'import pytest\n'), ((2678, 2728), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (2701, 2728), False, 'import pytest\n'), ((2872, 2922), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (2895, 2922), False, 'import pytest\n'), ((3173, 3223), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (3196, 3223), False, 'import pytest\n'), ((3731, 3781), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (3754, 3781), False, 'import pytest\n'), ((4733, 4783), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (4756, 4783), False, 'import pytest\n'), ((5287, 5337), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (5310, 5337), False, 'import pytest\n'), ((5760, 5810), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (5783, 5810), False, 'import pytest\n'), ((5982, 6071), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""tensor_name, var_name"""', "[('data', 'data'), (None, 'arg_0')]"], {}), "('tensor_name, var_name', [('data', 'data'), (None,\n 'arg_0')])\n", (6005, 6071), False, 'import pytest\n'), ((6553, 6603), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (6576, 6603), False, 'import pytest\n'), ((7433, 7483), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (7456, 7483), False, 'import pytest\n'), ((8348, 8398), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (8371, 8398), False, 'import pytest\n'), ((844, 862), 'megengine.utils.naming.AutoNaming.clear', 'AutoNaming.clear', ([], {}), '()\n', (860, 862), False, 'from megengine.utils.naming import AutoNaming\n'), ((874, 927), 'megengine.jit.tracing.trace', 'trace', (['func'], {'symbolic': 'symbolic', 'capture_as_const': '(True)'}), '(func, symbolic=symbolic, capture_as_const=True)\n', (879, 927), False, 'from megengine.jit.tracing import trace\n'), ((997, 1009), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (1007, 1009), False, 'import io\n'), ((1248, 1277), 'megengine.utils.comp_graph_tools.get_oprs_seq', 'cgtools.get_oprs_seq', (['outputs'], {}), '(outputs)\n', (1268, 1277), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((6165, 6211), 'megengine.jit.tracing.trace', 'trace', (['f'], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(f, symbolic=True, capture_as_const=True)\n', (6170, 6211), False, 'from megengine.jit.tracing import trace\n'), ((6299, 6311), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (6309, 6311), False, 'import io\n'), ((7076, 7091), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['m'], {}), '(m)\n', (7088, 7091), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((7096, 7107), 'megengine.quantization.quantize.quantize', 'quantize', (['m'], {}), '(m)\n', (7104, 7107), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((7976, 7991), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['m'], {}), '(m)\n', (7988, 7991), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((7996, 8007), 'megengine.quantization.quantize.quantize', 'quantize', (['m'], {}), '(m)\n', (8004, 8007), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((8978, 8993), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['m'], {}), '(m)\n', (8990, 8993), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((8998, 9009), 'megengine.quantization.quantize.quantize', 'quantize', (['m'], {}), '(m)\n', (9006, 9009), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((943, 964), 'numpy.ones', 'np.ones', ([], {'shape': '(2, 3)'}), '(shape=(2, 3))\n', (950, 964), True, 'import numpy as np\n'), ((1202, 1220), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['file'], {}), '(file)\n', (1214, 1220), True, 'from megengine.core.tensor import megbrain_graph as G\n'), ((6227, 6248), 'numpy.ones', 'np.ones', ([], {'shape': '(2, 3)'}), '(shape=(2, 3))\n', (6234, 6248), True, 'import numpy as np\n'), ((6430, 6448), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['file'], {}), '(file)\n', (6442, 6448), True, 'from megengine.core.tensor import megbrain_graph as G\n'), ((6475, 6504), 'megengine.utils.comp_graph_tools.get_oprs_seq', 'cgtools.get_oprs_seq', (['outputs'], {}), '(outputs)\n', (6495, 6504), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((1940, 1964), 'megengine.Parameter', 'Parameter', (['(1.0)'], {'name': '"""k"""'}), "(1.0, name='k')\n", (1949, 1964), False, 'from megengine import Parameter, Tensor\n'), ((2442, 2466), 'megengine.Parameter', 'Parameter', (['(2.0)'], {'name': '"""k"""'}), "(2.0, name='k')\n", (2451, 2466), False, 'from megengine import Parameter, Tensor\n'), ((3407, 3421), 'megengine.module.Linear', 'M.Linear', (['(3)', '(3)'], {}), '(3, 3)\n', (3415, 3421), True, 'import megengine.module as M\n'), ((4968, 4992), 'megengine.module.Linear', 'M.Linear', (['(3)', '(3)'], {'name': '"""x"""'}), "(3, 3, name='x')\n", (4976, 4992), True, 'import megengine.module as M\n'), ((5547, 5556), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (5553, 5556), True, 'import megengine.functional as F\n'), ((5573, 5582), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (5579, 5582), True, 'import megengine.functional as F\n'), ((6780, 6793), 'megengine.module.QuantStub', 'M.QuantStub', ([], {}), '()\n', (6791, 6793), True, 'import megengine.module as M\n'), ((6820, 6845), 'megengine.module.Linear', 'M.Linear', (['(3)', '(3)'], {'bias': '(True)'}), '(3, 3, bias=True)\n', (6828, 6845), True, 'import megengine.module as M\n'), ((6873, 6888), 'megengine.module.DequantStub', 'M.DequantStub', ([], {}), '()\n', (6886, 6888), True, 'import megengine.module as M\n'), ((7660, 7673), 'megengine.module.QuantStub', 'M.QuantStub', ([], {}), '()\n', (7671, 7673), True, 'import megengine.module as M\n'), ((7700, 7745), 'megengine.module.Linear', 'M.Linear', (['(3)', '(3)'], {'bias': '(True)', 'name': '"""user-linear"""'}), "(3, 3, bias=True, name='user-linear')\n", (7708, 7745), True, 'import megengine.module as M\n'), ((7773, 7788), 'megengine.module.DequantStub', 'M.DequantStub', ([], {}), '()\n', (7786, 7788), True, 'import megengine.module as M\n'), ((8581, 8594), 'megengine.module.QuantStub', 'M.QuantStub', ([], {}), '()\n', (8592, 8594), True, 'import megengine.module as M\n'), ((8621, 8646), 'megengine.module.Linear', 'M.Linear', (['(3)', '(3)'], {'bias': '(True)'}), '(3, 3, bias=True)\n', (8629, 8646), True, 'import megengine.module as M\n'), ((8674, 8689), 'megengine.module.DequantStub', 'M.DequantStub', ([], {}), '()\n', (8687, 8689), True, 'import megengine.module as M\n'), ((3975, 3989), 'megengine.module.Linear', 'M.Linear', (['(3)', '(3)'], {}), '(3, 3)\n', (3983, 3989), True, 'import megengine.module as M\n')]
|
import megengine
import megengine.module as M
import megengine.functional as F
def default_init_weights(module, scale=1, nonlinearity="relu"):
"""
nonlinearity: leaky_relu
"""
for m in module.modules():
if isinstance(m, M.Conv2d):
M.init.msra_normal_(m.weight, mode="fan_in", nonlinearity=nonlinearity)
m.weight *= scale
if m.bias is not None:
M.init.zeros_(m.bias)
else:
pass
|
[
"megengine.module.init.zeros_",
"megengine.module.init.msra_normal_"
] |
[((272, 343), 'megengine.module.init.msra_normal_', 'M.init.msra_normal_', (['m.weight'], {'mode': '"""fan_in"""', 'nonlinearity': 'nonlinearity'}), "(m.weight, mode='fan_in', nonlinearity=nonlinearity)\n", (291, 343), True, 'import megengine.module as M\n'), ((425, 446), 'megengine.module.init.zeros_', 'M.init.zeros_', (['m.bias'], {}), '(m.bias)\n', (438, 446), True, 'import megengine.module as M\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import megengine.functional as F
from megengine import Parameter
from .init import ones_, zeros_
from .module import Module
class GroupNorm(Module):
"""
Simple implementation of GroupNorm. Only support 4d tensor now.
Reference: https://arxiv.org/pdf/1803.08494.pdf.
"""
def __init__(self, num_groups, num_channels, eps=1e-5, affine=True, **kwargs):
super().__init__(**kwargs)
assert num_channels % num_groups == 0
self.num_groups = num_groups
self.num_channels = num_channels
self.eps = eps
self.affine = affine
if self.affine:
self.weight = Parameter(np.ones(num_channels, dtype=np.float32))
self.bias = Parameter(np.zeros(num_channels, dtype=np.float32))
else:
self.weight = None
self.bias = None
self.reset_parameters()
def reset_parameters(self):
if self.affine:
ones_(self.weight)
zeros_(self.bias)
def forward(self, x):
N, C, H, W = x.shape
assert C == self.num_channels
x = x.reshape(N, self.num_groups, -1)
mean = x.mean(axis=2, keepdims=True)
var = (x * x).mean(axis=2, keepdims=True) - mean * mean
x = (x - mean) / F.sqrt(var + self.eps)
x = x.reshape(N, C, H, W)
if self.affine:
x = self.weight.reshape(1, -1, 1, 1) * x + self.bias.reshape(1, -1, 1, 1)
return x
def _module_info_string(self) -> str:
s = (
"groups={num_groups}, channels={num_channels}, "
"eps={eps}, affine={affine}"
)
return s.format(**self.__dict__)
class InstanceNorm(Module):
"""
Simple implementation of InstanceNorm. Only support 4d tensor now.
Reference: https://arxiv.org/abs/1607.08022.
Note that InstanceNorm equals using GroupNome with num_groups=num_channels.
"""
def __init__(self, num_channels, eps=1e-05, affine=True, **kwargs):
super().__init__(**kwargs)
self.num_channels = num_channels
self.eps = eps
self.affine = affine
if self.affine:
self.weight = Parameter(np.ones(num_channels, dtype="float32"))
self.bias = Parameter(np.zeros(num_channels, dtype="float32"))
else:
self.weight = None
self.bias = None
self.reset_parameters()
def reset_parameters(self):
if self.affine:
ones_(self.weight)
zeros_(self.bias)
def forward(self, x):
N, C, H, W = x.shape
assert C == self.num_channels
x = x.reshape(N, C, -1)
mean = x.mean(axis=2, keepdims=True)
var = (x ** 2).mean(axis=2, keepdims=True) - mean * mean
x = (x - mean) / F.sqrt(var + self.eps)
x = x.reshape(N, C, H, W)
if self.affine:
x = self.weight.reshape(1, -1, 1, 1) * x + self.bias.reshape(1, -1, 1, 1)
return x
def _module_info_string(self) -> str:
s = "channels={num_channels}, eps={eps}, affine={affine}"
return s.format(**self.__dict__)
class LayerNorm(Module):
"""
Simple implementation of LayerNorm. Support tensor of any shape as input.
Reference: https://arxiv.org/pdf/1803.08494.pdf.
"""
def __init__(self, normalized_shape, eps=1e-05, affine=True, **kwargs):
super().__init__(**kwargs)
if isinstance(normalized_shape, int):
normalized_shape = (normalized_shape,)
self.normalized_shape = tuple(normalized_shape)
self.eps = eps
self.affine = affine
if self.affine:
self.weight = Parameter(np.ones(self.normalized_shape, dtype="float32"))
self.bias = Parameter(np.zeros(self.normalized_shape, dtype="float32"))
else:
self.weight = None
self.bias = None
self.reset_parameters()
def reset_parameters(self):
if self.affine:
ones_(self.weight)
zeros_(self.bias)
def forward(self, x):
x_shape = x.shape
dim_delta = len(x_shape) - len(self.normalized_shape)
non_flatten_shape = x_shape[:dim_delta]
x = x.reshape(*non_flatten_shape, -1)
mean = x.mean(axis=-1, keepdims=True)
var = (x ** 2).mean(axis=-1, keepdims=True) - mean * mean
x = (x - mean) / F.sqrt(var + self.eps)
x = x.reshape(x_shape)
if self.affine:
x = self.weight * x + self.bias
return x
def _module_info_string(self) -> str:
s = "normalized_shape={normalized_shape}, eps={eps}, affine={affine}"
return s.format(**self.__dict__)
|
[
"megengine.functional.sqrt"
] |
[((1634, 1656), 'megengine.functional.sqrt', 'F.sqrt', (['(var + self.eps)'], {}), '(var + self.eps)\n', (1640, 1656), True, 'import megengine.functional as F\n'), ((3137, 3159), 'megengine.functional.sqrt', 'F.sqrt', (['(var + self.eps)'], {}), '(var + self.eps)\n', (3143, 3159), True, 'import megengine.functional as F\n'), ((4729, 4751), 'megengine.functional.sqrt', 'F.sqrt', (['(var + self.eps)'], {}), '(var + self.eps)\n', (4735, 4751), True, 'import megengine.functional as F\n'), ((1017, 1056), 'numpy.ones', 'np.ones', (['num_channels'], {'dtype': 'np.float32'}), '(num_channels, dtype=np.float32)\n', (1024, 1056), True, 'import numpy as np\n'), ((1092, 1132), 'numpy.zeros', 'np.zeros', (['num_channels'], {'dtype': 'np.float32'}), '(num_channels, dtype=np.float32)\n', (1100, 1132), True, 'import numpy as np\n'), ((2536, 2574), 'numpy.ones', 'np.ones', (['num_channels'], {'dtype': '"""float32"""'}), "(num_channels, dtype='float32')\n", (2543, 2574), True, 'import numpy as np\n'), ((2610, 2649), 'numpy.zeros', 'np.zeros', (['num_channels'], {'dtype': '"""float32"""'}), "(num_channels, dtype='float32')\n", (2618, 2649), True, 'import numpy as np\n'), ((4023, 4070), 'numpy.ones', 'np.ones', (['self.normalized_shape'], {'dtype': '"""float32"""'}), "(self.normalized_shape, dtype='float32')\n", (4030, 4070), True, 'import numpy as np\n'), ((4106, 4154), 'numpy.zeros', 'np.zeros', (['self.normalized_shape'], {'dtype': '"""float32"""'}), "(self.normalized_shape, dtype='float32')\n", (4114, 4154), True, 'import numpy as np\n')]
|
import io
import pickle
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
import megengine.utils.comp_graph_tools as cgtools
from megengine.core._trace_option import set_symbolic_shape
from megengine.jit import trace
from megengine.traced_module import trace_module
set_symbolic_shape(True)
class Main(M.Module):
def forward(self, x):
return x["data"]
class PreProcess(M.Module):
def __init__(self):
super().__init__()
self.A = F.zeros((1,))
self.I = F.ones((1,))
self.bb_out = mge.tensor(
np.array([[[0, 0], [160, 0], [160, 48], [0, 48]]], dtype="float32")
)
def forward(self, data, quad):
"""
data: (1, 3, 48, 160)
quad: (1, 4, 2)
"""
N = quad.shape[0]
dst = F.repeat(self.bb_out, N, axis=0).reshape(-1, 4, 2)
I = F.broadcast_to(self.I, quad.shape)
A = F.broadcast_to(self.A, (N, 8, 8))
A[:, 0:4, 0:2] = quad
A[:, 4:8, 5:6] = I[:, :, 0:1]
A[:, 0:4, 6:8] = -quad * dst[:, :, 0:1]
A[:, 4:8, 3:5] = quad
A[:, 0:4, 2:3] = I[:, :, 0:1]
A[:, 4:8, 6:8] = -quad * dst[:, :, 1:2]
B = dst.transpose(0, 2, 1).reshape(-1, 8, 1)
M = F.concat([F.matmul(F.matinv(A), B)[:, :, 0], I[:, 0:1, 0]], axis=1).reshape(
-1, 3, 3
)
new_data = F.warp_perspective(data, M, (48, 160)) # (N, 3, 48, 160)
return {"data": new_data}
class Net(M.Module):
def __init__(self, traced_module):
super().__init__()
self.pre_process = PreProcess()
self.traced_module = traced_module
def forward(self, data, quad):
x = self.pre_process(data, quad)
x = self.traced_module(x)
return x
def test_preprocess():
batch_size = 2
module = Main()
data = mge.tensor(
np.random.randint(0, 256, size=(batch_size, 3, 48, 160)), dtype=np.float32
)
traced_module = trace_module(module, {"data": data})
obj = pickle.dumps(traced_module)
traced_module = pickle.loads(obj)
module = Net(traced_module)
module.eval()
quad = mge.tensor(np.random.normal(size=(batch_size, 4, 2)), dtype=np.float32)
expect = module(data, quad)
traced_module = trace_module(module, data, quad)
actual = traced_module(data, quad)
for i, j in zip(expect, actual):
np.testing.assert_array_equal(i, j)
func = trace(traced_module, capture_as_const=True)
actual = func(data, quad)
for i, j in zip(expect, actual):
np.testing.assert_array_equal(i, j)
model = io.BytesIO()
func.dump(model, arg_names=("data", "quad"))
model.seek(0)
infer_cg = cgtools.GraphInference(model)
actual = list(
infer_cg.run(inp_dict={"data": data.numpy(), "quad": quad.numpy()}).values()
)[0]
np.testing.assert_allclose(expect, actual)
|
[
"megengine.jit.trace",
"megengine.functional.repeat",
"megengine.functional.zeros",
"megengine.functional.broadcast_to",
"megengine.functional.ones",
"megengine.functional.matinv",
"megengine.functional.warp_perspective",
"megengine.core._trace_option.set_symbolic_shape",
"megengine.traced_module.trace_module",
"megengine.utils.comp_graph_tools.GraphInference"
] |
[((324, 348), 'megengine.core._trace_option.set_symbolic_shape', 'set_symbolic_shape', (['(True)'], {}), '(True)\n', (342, 348), False, 'from megengine.core._trace_option import set_symbolic_shape\n'), ((2000, 2036), 'megengine.traced_module.trace_module', 'trace_module', (['module', "{'data': data}"], {}), "(module, {'data': data})\n", (2012, 2036), False, 'from megengine.traced_module import trace_module\n'), ((2047, 2074), 'pickle.dumps', 'pickle.dumps', (['traced_module'], {}), '(traced_module)\n', (2059, 2074), False, 'import pickle\n'), ((2095, 2112), 'pickle.loads', 'pickle.loads', (['obj'], {}), '(obj)\n', (2107, 2112), False, 'import pickle\n'), ((2298, 2330), 'megengine.traced_module.trace_module', 'trace_module', (['module', 'data', 'quad'], {}), '(module, data, quad)\n', (2310, 2330), False, 'from megengine.traced_module import trace_module\n'), ((2462, 2505), 'megengine.jit.trace', 'trace', (['traced_module'], {'capture_as_const': '(True)'}), '(traced_module, capture_as_const=True)\n', (2467, 2505), False, 'from megengine.jit import trace\n'), ((2629, 2641), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (2639, 2641), False, 'import io\n'), ((2724, 2753), 'megengine.utils.comp_graph_tools.GraphInference', 'cgtools.GraphInference', (['model'], {}), '(model)\n', (2746, 2753), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((2871, 2913), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['expect', 'actual'], {}), '(expect, actual)\n', (2897, 2913), True, 'import numpy as np\n'), ((522, 535), 'megengine.functional.zeros', 'F.zeros', (['(1,)'], {}), '((1,))\n', (529, 535), True, 'import megengine.functional as F\n'), ((553, 565), 'megengine.functional.ones', 'F.ones', (['(1,)'], {}), '((1,))\n', (559, 565), True, 'import megengine.functional as F\n'), ((907, 941), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['self.I', 'quad.shape'], {}), '(self.I, quad.shape)\n', (921, 941), True, 'import megengine.functional as F\n'), ((954, 987), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['self.A', '(N, 8, 8)'], {}), '(self.A, (N, 8, 8))\n', (968, 987), True, 'import megengine.functional as F\n'), ((1412, 1450), 'megengine.functional.warp_perspective', 'F.warp_perspective', (['data', 'M', '(48, 160)'], {}), '(data, M, (48, 160))\n', (1430, 1450), True, 'import megengine.functional as F\n'), ((1899, 1955), 'numpy.random.randint', 'np.random.randint', (['(0)', '(256)'], {'size': '(batch_size, 3, 48, 160)'}), '(0, 256, size=(batch_size, 3, 48, 160))\n', (1916, 1955), True, 'import numpy as np\n'), ((2185, 2226), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(batch_size, 4, 2)'}), '(size=(batch_size, 4, 2))\n', (2201, 2226), True, 'import numpy as np\n'), ((2415, 2450), 'numpy.testing.assert_array_equal', 'np.testing.assert_array_equal', (['i', 'j'], {}), '(i, j)\n', (2444, 2450), True, 'import numpy as np\n'), ((2581, 2616), 'numpy.testing.assert_array_equal', 'np.testing.assert_array_equal', (['i', 'j'], {}), '(i, j)\n', (2610, 2616), True, 'import numpy as np\n'), ((612, 679), 'numpy.array', 'np.array', (['[[[0, 0], [160, 0], [160, 48], [0, 48]]]'], {'dtype': '"""float32"""'}), "([[[0, 0], [160, 0], [160, 48], [0, 48]]], dtype='float32')\n", (620, 679), True, 'import numpy as np\n'), ((844, 876), 'megengine.functional.repeat', 'F.repeat', (['self.bb_out', 'N'], {'axis': '(0)'}), '(self.bb_out, N, axis=0)\n', (852, 876), True, 'import megengine.functional as F\n'), ((1304, 1315), 'megengine.functional.matinv', 'F.matinv', (['A'], {}), '(A)\n', (1312, 1315), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine.functional as F
import megengine.functional.elemwise as elemwise
from megengine import tensor
from megengine.core.tensor import dtype
from megengine.functional.elemwise import Elemwise
from megengine.jit import trace
def test_abs():
np.testing.assert_allclose(
F.abs(tensor([-3.0, -4.0, -5.0])).numpy(),
np.abs(np.array([-3.0, -4.0, -5.0], dtype=np.float32)),
)
np.testing.assert_allclose(F.abs(-3.0).numpy(), np.abs(np.float32(-3.0)))
def test_elemwise_mode_string():
for key, mode in vars(Elemwise.Mode).items():
if isinstance(mode, Elemwise.Mode):
assert key == mode
assert Elemwise(mode=key) == Elemwise(mode=mode)
def test_multiply():
np.testing.assert_allclose(
F.mul(-3.0, -4.0).numpy(), np.multiply(np.float32(-3.0), np.float32(-4.0))
)
np.testing.assert_allclose(
F.mul(tensor([3.0, 4.0]), 4.0).numpy(),
np.multiply(np.array([3.0, 4.0], dtype=np.float32), 4.0),
)
np.testing.assert_allclose(
F.mul(4.0, tensor([3.0, 4.0])).numpy(),
np.multiply(4.0, np.array([3.0, 4.0], dtype=np.float32)),
)
np.testing.assert_allclose(
F.mul(tensor([3.0, 4.0]), tensor([3.0, 4.0])).numpy(),
np.multiply(
np.array([3.0, 4.0], dtype=np.float32),
np.array([3.0, 4.0], dtype=np.float32),
),
)
def test_div():
np.testing.assert_allclose(
F.div(tensor([3.0, 4.0]), 2).numpy(),
np.divide(np.array([3, 4], dtype=np.float32), 2),
)
np.testing.assert_allclose(
(tensor([3, 4]) / 2).numpy(), np.divide(np.array([3, 4], dtype=np.float32), 2),
)
np.testing.assert_allclose(
F.floor_div(tensor([-5.0, -7.0]), 2).numpy(),
np.floor_divide(np.array([-5.0, -7.0], dtype=np.float32), 2),
)
np.testing.assert_allclose(
(tensor([-5, -7]) // 2).numpy(),
np.floor_divide(np.array([-5, -7], dtype=np.int32), 2),
)
def test_clamp():
"""Fix an issue when `lower` or `upper` is 0, it will be recognized as `False` and
`F.clip` will fall into wrong conditions unexpectedly.
"""
x = np.linspace(-6, 6, dtype="float32")
np.testing.assert_allclose(
F.clip(tensor(x) + 3, 0, 6).numpy(), np.clip(x + 3, 0, 6)
)
np.testing.assert_allclose(
F.clip(tensor(x) - 3, -6, 0).numpy(), np.clip(x - 3, -6, 0)
)
def test_isnan():
for case in [[1, float("nan"), 0]]:
np.testing.assert_allclose(F.isnan(tensor(case)).numpy(), np.isnan(case))
def test_isinf():
for case in [[1, float("inf"), 0]]:
np.testing.assert_allclose(F.isinf(tensor(case)).numpy(), np.isinf(case))
def test_sign():
for case in [[1, -1, 0]]:
x = tensor(case)
np.testing.assert_allclose(F.sign(x).numpy(), np.sign(case).astype(x.dtype))
def test_cosh():
np.random.seed(42)
x = np.random.randn(100).astype("float32")
y_np = np.cosh(x)
y_mge = F.cosh(tensor(x)).numpy()
np.testing.assert_allclose(y_np, y_mge, rtol=1e-5)
def test_sinh():
np.random.seed(42)
x = np.random.randn(100).astype("float32")
y_np = np.sinh(x)
y_mge = F.sinh(tensor(x)).numpy()
np.testing.assert_allclose(y_np, y_mge, rtol=1e-5)
def test_asinh():
np.random.seed(42)
x = np.random.randn(100).astype("float32")
y_np = np.arcsinh(x)
y_mge = F.asinh(tensor(x)).numpy()
np.testing.assert_almost_equal(y_np, y_mge, decimal=5)
def test_acosh():
x = np.arange(0, 10000).astype("float32") / 100 + 1
y_np = np.arccosh(x)
y_mge = F.acosh(tensor(x)).numpy()
np.testing.assert_almost_equal(y_np, y_mge, decimal=6)
def test_atanh():
np.random.seed(42)
x = np.random.rand(100).astype("float32") * 2 - 1
y_np = np.arctanh(x)
y_mge = F.atanh(tensor(x)).numpy()
np.testing.assert_almost_equal(y_np, y_mge, decimal=5)
def test_hswish():
np.random.seed(42)
x = np.random.randn(100).astype("float32")
y_np = x * np.minimum(np.maximum(x + 3, 0), 6) / 6
y_mge = F.hswish(tensor(x)).numpy()
np.testing.assert_almost_equal(y_np, y_mge, decimal=6)
def test_silu():
x = np.array([-1.5, 0.0, 1.0, 1.5]).astype("float32")
y_np = x / (1 + np.exp(-x))
y_mge = F.silu(tensor(x)).numpy()
np.testing.assert_almost_equal(y_np, y_mge, decimal=6)
def test_hsigmoid():
np.random.seed(42)
x = np.random.randn(100).astype("float32")
y_np = np.minimum(np.maximum(x + 3, 0), 6) / 6
y_mge = F.hsigmoid(tensor(x)).numpy()
np.testing.assert_almost_equal(y_np, y_mge, decimal=6)
def test_logical_oprs():
x = np.array([[True, False], [False, True]])
y = np.array([[True, True], [False, False]])
xx = tensor(x)
yy = tensor(y)
np.testing.assert_equal(~x, (F.logical_not(xx)).numpy())
np.testing.assert_equal(x & y, F.logical_and(xx, yy).numpy())
np.testing.assert_equal(x | y, F.logical_or(xx, yy).numpy())
np.testing.assert_equal(x ^ y, F.logical_xor(xx, yy).numpy())
def test_logaddexp():
x = np.random.randn(2, 100)
y = np.random.randn(2, 100)
xx = tensor(x)
yy = tensor(y)
out_np = np.log(np.exp(x) + np.exp(y))
out_mge = F.logaddexp(xx, yy)
np.testing.assert_almost_equal(out_np, out_mge.numpy(), decimal=6)
def test_qadd():
inp_scale = 0.5
outp_scale = 0.2
x = np.arange(6).reshape(2, 3).astype("float32")
y = np.arange(6).reshape(2, 3).astype("float32")
x = tensor(x, dtype=dtype.qint8(inp_scale))
y = tensor(y, dtype=dtype.qint8(inp_scale))
result_mge = F.elemwise._elemwise_multi_type(
x, y, mode="qadd", dtype=dtype.qint8(outp_scale)
)
result_mge = result_mge.astype("float32").numpy()
result_expect = x.astype("float32").numpy() + y.astype("float32").numpy()
np.testing.assert_almost_equal(result_mge, result_expect, decimal=6)
def test_int32_input():
x = tensor(np.array([1, 2, 3, 4, 5]), dtype="int32")
for op_name in elemwise.__all__:
op = getattr(elemwise, op_name)
nargs = op.__code__.co_argcount
if op_name == "clip":
inp = (x, 0, 1)
elif op_name.endswith("_shift"):
inp = (x, 1)
elif op_name.startswith("logical_"):
continue
else:
inp = (x,) * nargs
y = op(*inp)
y.numpy()
@pytest.mark.parametrize("is_trace", [True, False])
def test_empty_tensor(is_trace):
binary_func = []
unary_func = []
for op_name in elemwise.__all__:
op = getattr(elemwise, op_name)
nargs = op.__code__.co_argcount
if op_name == "clip":
unary_func.append(["clip", lambda x, f=op: f(x, lower=0, upper=1)])
elif op_name.endswith("_shift"):
unary_func.append(
[op_name, lambda x, f=op: f(tensor(x.numpy(), dtype="int32"), 1)]
)
elif op_name.startswith("logical_"): # logical_xxx op only accept boolean type
if nargs == 1:
unary_func.append(
[op_name, lambda x, f=op: f(tensor(x.numpy(), dtype="bool"))]
)
else:
assert nargs == 2
binary_func.append(
[
op_name,
lambda x, y, f=op: f(
tensor(x.numpy(), dtype="bool"),
tensor(y.numpy(), dtype="bool"),
),
]
)
elif nargs == 1:
unary_func.append([op_name, op])
elif nargs == 2:
binary_func.append([op_name, op])
else:
raise NotImplementedError("nargs {}".format(nargs))
def run_test(func, args, ref_shape, is_trace, sym=False):
args = [tensor(t, dtype="float32") for t in args]
if is_trace:
func = trace(symbolic=sym)(func)
for _ in range(3):
out = func(*args)
assert out.numpy().shape == ref_shape
else:
out = func(*args)
assert out.numpy().shape == ref_shape, out.numpy().shape
inps = [
np.array([]).astype("float32"),
np.random.randn(2, 0, 3).astype("float32"),
123,
]
for op_name, op in unary_func:
if is_trace:
for sym in [True, False]:
run_test(op, [inps[0],], inps[0].shape, True, sym)
run_test(op, [inps[1],], inps[1].shape, True, sym)
else:
run_test(op, [inps[0],], inps[0].shape, False)
run_test(op, [inps[1],], inps[1].shape, False)
for op_name, op in binary_func:
if is_trace:
for sym in [True, False]:
run_test(op, [inps[0], inps[0]], (inps[0] + inps[0]).shape, True, sym)
run_test(op, [inps[1], inps[1]], (inps[1] + inps[1]).shape, True, sym)
run_test(op, [inps[0], inps[2]], (inps[0] + inps[2]).shape, True, sym)
run_test(op, [inps[1], inps[2]], (inps[1] + inps[2]).shape, True, sym)
else:
run_test(op, [inps[0], inps[0]], (inps[0] + inps[0]).shape, False)
run_test(op, [inps[1], inps[1]], (inps[1] + inps[1]).shape, False)
run_test(op, [inps[0], inps[2]], (inps[0] + inps[2]).shape, False)
run_test(op, [inps[1], inps[2]], (inps[1] + inps[2]).shape, False)
|
[
"megengine.functional.sign",
"megengine.functional.elemwise.Elemwise",
"megengine.core.tensor.dtype.qint8",
"megengine.functional.logical_not",
"megengine.jit.trace",
"megengine.tensor",
"megengine.functional.logical_xor",
"megengine.functional.logical_or",
"megengine.functional.mul",
"megengine.functional.logaddexp",
"megengine.functional.logical_and",
"megengine.functional.abs"
] |
[((6757, 6807), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""is_trace"""', '[True, False]'], {}), "('is_trace', [True, False])\n", (6780, 6807), False, 'import pytest\n'), ((2580, 2615), 'numpy.linspace', 'np.linspace', (['(-6)', '(6)'], {'dtype': '"""float32"""'}), "(-6, 6, dtype='float32')\n", (2591, 2615), True, 'import numpy as np\n'), ((3292, 3310), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (3306, 3310), True, 'import numpy as np\n'), ((3369, 3379), 'numpy.cosh', 'np.cosh', (['x'], {}), '(x)\n', (3376, 3379), True, 'import numpy as np\n'), ((3422, 3473), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['y_np', 'y_mge'], {'rtol': '(1e-05)'}), '(y_np, y_mge, rtol=1e-05)\n', (3448, 3473), True, 'import numpy as np\n'), ((3496, 3514), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (3510, 3514), True, 'import numpy as np\n'), ((3573, 3583), 'numpy.sinh', 'np.sinh', (['x'], {}), '(x)\n', (3580, 3583), True, 'import numpy as np\n'), ((3626, 3677), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['y_np', 'y_mge'], {'rtol': '(1e-05)'}), '(y_np, y_mge, rtol=1e-05)\n', (3652, 3677), True, 'import numpy as np\n'), ((3701, 3719), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (3715, 3719), True, 'import numpy as np\n'), ((3778, 3791), 'numpy.arcsinh', 'np.arcsinh', (['x'], {}), '(x)\n', (3788, 3791), True, 'import numpy as np\n'), ((3835, 3889), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['y_np', 'y_mge'], {'decimal': '(5)'}), '(y_np, y_mge, decimal=5)\n', (3865, 3889), True, 'import numpy as np\n'), ((3977, 3990), 'numpy.arccosh', 'np.arccosh', (['x'], {}), '(x)\n', (3987, 3990), True, 'import numpy as np\n'), ((4034, 4088), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['y_np', 'y_mge'], {'decimal': '(6)'}), '(y_np, y_mge, decimal=6)\n', (4064, 4088), True, 'import numpy as np\n'), ((4113, 4131), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (4127, 4131), True, 'import numpy as np\n'), ((4197, 4210), 'numpy.arctanh', 'np.arctanh', (['x'], {}), '(x)\n', (4207, 4210), True, 'import numpy as np\n'), ((4254, 4308), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['y_np', 'y_mge'], {'decimal': '(5)'}), '(y_np, y_mge, decimal=5)\n', (4284, 4308), True, 'import numpy as np\n'), ((4334, 4352), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (4348, 4352), True, 'import numpy as np\n'), ((4499, 4553), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['y_np', 'y_mge'], {'decimal': '(6)'}), '(y_np, y_mge, decimal=6)\n', (4529, 4553), True, 'import numpy as np\n'), ((4705, 4759), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['y_np', 'y_mge'], {'decimal': '(6)'}), '(y_np, y_mge, decimal=6)\n', (4735, 4759), True, 'import numpy as np\n'), ((4787, 4805), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (4801, 4805), True, 'import numpy as np\n'), ((4950, 5004), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['y_np', 'y_mge'], {'decimal': '(6)'}), '(y_np, y_mge, decimal=6)\n', (4980, 5004), True, 'import numpy as np\n'), ((5040, 5080), 'numpy.array', 'np.array', (['[[True, False], [False, True]]'], {}), '([[True, False], [False, True]])\n', (5048, 5080), True, 'import numpy as np\n'), ((5089, 5129), 'numpy.array', 'np.array', (['[[True, True], [False, False]]'], {}), '([[True, True], [False, False]])\n', (5097, 5129), True, 'import numpy as np\n'), ((5139, 5148), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (5145, 5148), False, 'from megengine import tensor\n'), ((5158, 5167), 'megengine.tensor', 'tensor', (['y'], {}), '(y)\n', (5164, 5167), False, 'from megengine import tensor\n'), ((5458, 5481), 'numpy.random.randn', 'np.random.randn', (['(2)', '(100)'], {}), '(2, 100)\n', (5473, 5481), True, 'import numpy as np\n'), ((5490, 5513), 'numpy.random.randn', 'np.random.randn', (['(2)', '(100)'], {}), '(2, 100)\n', (5505, 5513), True, 'import numpy as np\n'), ((5523, 5532), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (5529, 5532), False, 'from megengine import tensor\n'), ((5542, 5551), 'megengine.tensor', 'tensor', (['y'], {}), '(y)\n', (5548, 5551), False, 'from megengine import tensor\n'), ((5609, 5628), 'megengine.functional.logaddexp', 'F.logaddexp', (['xx', 'yy'], {}), '(xx, yy)\n', (5620, 5628), True, 'import megengine.functional as F\n'), ((6211, 6279), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['result_mge', 'result_expect'], {'decimal': '(6)'}), '(result_mge, result_expect, decimal=6)\n', (6241, 6279), True, 'import numpy as np\n'), ((2693, 2713), 'numpy.clip', 'np.clip', (['(x + 3)', '(0)', '(6)'], {}), '(x + 3, 0, 6)\n', (2700, 2713), True, 'import numpy as np\n'), ((2798, 2819), 'numpy.clip', 'np.clip', (['(x - 3)', '(-6)', '(0)'], {}), '(x - 3, -6, 0)\n', (2805, 2819), True, 'import numpy as np\n'), ((3171, 3183), 'megengine.tensor', 'tensor', (['case'], {}), '(case)\n', (3177, 3183), False, 'from megengine import tensor\n'), ((6321, 6346), 'numpy.array', 'np.array', (['[1, 2, 3, 4, 5]'], {}), '([1, 2, 3, 4, 5])\n', (6329, 6346), True, 'import numpy as np\n'), ((761, 807), 'numpy.array', 'np.array', (['[-3.0, -4.0, -5.0]'], {'dtype': 'np.float32'}), '([-3.0, -4.0, -5.0], dtype=np.float32)\n', (769, 807), True, 'import numpy as np\n'), ((876, 892), 'numpy.float32', 'np.float32', (['(-3.0)'], {}), '(-3.0)\n', (886, 892), True, 'import numpy as np\n'), ((1218, 1234), 'numpy.float32', 'np.float32', (['(-3.0)'], {}), '(-3.0)\n', (1228, 1234), True, 'import numpy as np\n'), ((1236, 1252), 'numpy.float32', 'np.float32', (['(-4.0)'], {}), '(-4.0)\n', (1246, 1252), True, 'import numpy as np\n'), ((1361, 1399), 'numpy.array', 'np.array', (['[3.0, 4.0]'], {'dtype': 'np.float32'}), '([3.0, 4.0], dtype=np.float32)\n', (1369, 1399), True, 'import numpy as np\n'), ((1519, 1557), 'numpy.array', 'np.array', (['[3.0, 4.0]'], {'dtype': 'np.float32'}), '([3.0, 4.0], dtype=np.float32)\n', (1527, 1557), True, 'import numpy as np\n'), ((1695, 1733), 'numpy.array', 'np.array', (['[3.0, 4.0]'], {'dtype': 'np.float32'}), '([3.0, 4.0], dtype=np.float32)\n', (1703, 1733), True, 'import numpy as np\n'), ((1747, 1785), 'numpy.array', 'np.array', (['[3.0, 4.0]'], {'dtype': 'np.float32'}), '([3.0, 4.0], dtype=np.float32)\n', (1755, 1785), True, 'import numpy as np\n'), ((1918, 1952), 'numpy.array', 'np.array', (['[3, 4]'], {'dtype': 'np.float32'}), '([3, 4], dtype=np.float32)\n', (1926, 1952), True, 'import numpy as np\n'), ((2045, 2079), 'numpy.array', 'np.array', (['[3, 4]'], {'dtype': 'np.float32'}), '([3, 4], dtype=np.float32)\n', (2053, 2079), True, 'import numpy as np\n'), ((2202, 2242), 'numpy.array', 'np.array', (['[-5.0, -7.0]'], {'dtype': 'np.float32'}), '([-5.0, -7.0], dtype=np.float32)\n', (2210, 2242), True, 'import numpy as np\n'), ((2352, 2386), 'numpy.array', 'np.array', (['[-5, -7]'], {'dtype': 'np.int32'}), '([-5, -7], dtype=np.int32)\n', (2360, 2386), True, 'import numpy as np\n'), ((2952, 2966), 'numpy.isnan', 'np.isnan', (['case'], {}), '(case)\n', (2960, 2966), True, 'import numpy as np\n'), ((3094, 3108), 'numpy.isinf', 'np.isinf', (['case'], {}), '(case)\n', (3102, 3108), True, 'import numpy as np\n'), ((3319, 3339), 'numpy.random.randn', 'np.random.randn', (['(100)'], {}), '(100)\n', (3334, 3339), True, 'import numpy as np\n'), ((3523, 3543), 'numpy.random.randn', 'np.random.randn', (['(100)'], {}), '(100)\n', (3538, 3543), True, 'import numpy as np\n'), ((3728, 3748), 'numpy.random.randn', 'np.random.randn', (['(100)'], {}), '(100)\n', (3743, 3748), True, 'import numpy as np\n'), ((4361, 4381), 'numpy.random.randn', 'np.random.randn', (['(100)'], {}), '(100)\n', (4376, 4381), True, 'import numpy as np\n'), ((4581, 4612), 'numpy.array', 'np.array', (['[-1.5, 0.0, 1.0, 1.5]'], {}), '([-1.5, 0.0, 1.0, 1.5])\n', (4589, 4612), True, 'import numpy as np\n'), ((4651, 4661), 'numpy.exp', 'np.exp', (['(-x)'], {}), '(-x)\n', (4657, 4661), True, 'import numpy as np\n'), ((4814, 4834), 'numpy.random.randn', 'np.random.randn', (['(100)'], {}), '(100)\n', (4829, 4834), True, 'import numpy as np\n'), ((4875, 4895), 'numpy.maximum', 'np.maximum', (['(x + 3)', '(0)'], {}), '(x + 3, 0)\n', (4885, 4895), True, 'import numpy as np\n'), ((5572, 5581), 'numpy.exp', 'np.exp', (['x'], {}), '(x)\n', (5578, 5581), True, 'import numpy as np\n'), ((5584, 5593), 'numpy.exp', 'np.exp', (['y'], {}), '(y)\n', (5590, 5593), True, 'import numpy as np\n'), ((5890, 5912), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['inp_scale'], {}), '(inp_scale)\n', (5901, 5912), False, 'from megengine.core.tensor import dtype\n'), ((5938, 5960), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['inp_scale'], {}), '(inp_scale)\n', (5949, 5960), False, 'from megengine.core.tensor import dtype\n'), ((6045, 6068), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['outp_scale'], {}), '(outp_scale)\n', (6056, 6068), False, 'from megengine.core.tensor import dtype\n'), ((8203, 8229), 'megengine.tensor', 'tensor', (['t'], {'dtype': '"""float32"""'}), "(t, dtype='float32')\n", (8209, 8229), False, 'from megengine import tensor\n'), ((848, 859), 'megengine.functional.abs', 'F.abs', (['(-3.0)'], {}), '(-3.0)\n', (853, 859), True, 'import megengine.functional as F\n'), ((1074, 1092), 'megengine.functional.elemwise.Elemwise', 'Elemwise', ([], {'mode': 'key'}), '(mode=key)\n', (1082, 1092), False, 'from megengine.functional.elemwise import Elemwise\n'), ((1096, 1115), 'megengine.functional.elemwise.Elemwise', 'Elemwise', ([], {'mode': 'mode'}), '(mode=mode)\n', (1104, 1115), False, 'from megengine.functional.elemwise import Elemwise\n'), ((1179, 1196), 'megengine.functional.mul', 'F.mul', (['(-3.0)', '(-4.0)'], {}), '(-3.0, -4.0)\n', (1184, 1196), True, 'import megengine.functional as F\n'), ((3399, 3408), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (3405, 3408), False, 'from megengine import tensor\n'), ((3603, 3612), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (3609, 3612), False, 'from megengine import tensor\n'), ((3812, 3821), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (3818, 3821), False, 'from megengine import tensor\n'), ((4011, 4020), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (4017, 4020), False, 'from megengine import tensor\n'), ((4231, 4240), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (4237, 4240), False, 'from megengine import tensor\n'), ((4426, 4446), 'numpy.maximum', 'np.maximum', (['(x + 3)', '(0)'], {}), '(x + 3, 0)\n', (4436, 4446), True, 'import numpy as np\n'), ((4476, 4485), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (4482, 4485), False, 'from megengine import tensor\n'), ((4682, 4691), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (4688, 4691), False, 'from megengine import tensor\n'), ((4927, 4936), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (4933, 4936), False, 'from megengine import tensor\n'), ((5201, 5218), 'megengine.functional.logical_not', 'F.logical_not', (['xx'], {}), '(xx)\n', (5214, 5218), True, 'import megengine.functional as F\n'), ((5264, 5285), 'megengine.functional.logical_and', 'F.logical_and', (['xx', 'yy'], {}), '(xx, yy)\n', (5277, 5285), True, 'import megengine.functional as F\n'), ((5330, 5350), 'megengine.functional.logical_or', 'F.logical_or', (['xx', 'yy'], {}), '(xx, yy)\n', (5342, 5350), True, 'import megengine.functional as F\n'), ((5395, 5416), 'megengine.functional.logical_xor', 'F.logical_xor', (['xx', 'yy'], {}), '(xx, yy)\n', (5408, 5416), True, 'import megengine.functional as F\n'), ((8285, 8304), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'sym'}), '(symbolic=sym)\n', (8290, 8304), False, 'from megengine.jit import trace\n'), ((8565, 8577), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (8573, 8577), True, 'import numpy as np\n'), ((8605, 8629), 'numpy.random.randn', 'np.random.randn', (['(2)', '(0)', '(3)'], {}), '(2, 0, 3)\n', (8620, 8629), True, 'import numpy as np\n'), ((709, 735), 'megengine.tensor', 'tensor', (['[-3.0, -4.0, -5.0]'], {}), '([-3.0, -4.0, -5.0])\n', (715, 735), False, 'from megengine import tensor\n'), ((1307, 1325), 'megengine.tensor', 'tensor', (['[3.0, 4.0]'], {}), '([3.0, 4.0])\n', (1313, 1325), False, 'from megengine import tensor\n'), ((1465, 1483), 'megengine.tensor', 'tensor', (['[3.0, 4.0]'], {}), '([3.0, 4.0])\n', (1471, 1483), False, 'from megengine import tensor\n'), ((1613, 1631), 'megengine.tensor', 'tensor', (['[3.0, 4.0]'], {}), '([3.0, 4.0])\n', (1619, 1631), False, 'from megengine import tensor\n'), ((1633, 1651), 'megengine.tensor', 'tensor', (['[3.0, 4.0]'], {}), '([3.0, 4.0])\n', (1639, 1651), False, 'from megengine import tensor\n'), ((1868, 1886), 'megengine.tensor', 'tensor', (['[3.0, 4.0]'], {}), '([3.0, 4.0])\n', (1874, 1886), False, 'from megengine import tensor\n'), ((2006, 2020), 'megengine.tensor', 'tensor', (['[3, 4]'], {}), '([3, 4])\n', (2012, 2020), False, 'from megengine import tensor\n'), ((2144, 2164), 'megengine.tensor', 'tensor', (['[-5.0, -7.0]'], {}), '([-5.0, -7.0])\n', (2150, 2164), False, 'from megengine import tensor\n'), ((2296, 2312), 'megengine.tensor', 'tensor', (['[-5, -7]'], {}), '([-5, -7])\n', (2302, 2312), False, 'from megengine import tensor\n'), ((3219, 3228), 'megengine.functional.sign', 'F.sign', (['x'], {}), '(x)\n', (3225, 3228), True, 'import megengine.functional as F\n'), ((3238, 3251), 'numpy.sign', 'np.sign', (['case'], {}), '(case)\n', (3245, 3251), True, 'import numpy as np\n'), ((3918, 3937), 'numpy.arange', 'np.arange', (['(0)', '(10000)'], {}), '(0, 10000)\n', (3927, 3937), True, 'import numpy as np\n'), ((4140, 4159), 'numpy.random.rand', 'np.random.rand', (['(100)'], {}), '(100)\n', (4154, 4159), True, 'import numpy as np\n'), ((5768, 5780), 'numpy.arange', 'np.arange', (['(6)'], {}), '(6)\n', (5777, 5780), True, 'import numpy as np\n'), ((5821, 5833), 'numpy.arange', 'np.arange', (['(6)'], {}), '(6)\n', (5830, 5833), True, 'import numpy as np\n'), ((2663, 2672), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (2669, 2672), False, 'from megengine import tensor\n'), ((2767, 2776), 'megengine.tensor', 'tensor', (['x'], {}), '(x)\n', (2773, 2776), False, 'from megengine import tensor\n'), ((2929, 2941), 'megengine.tensor', 'tensor', (['case'], {}), '(case)\n', (2935, 2941), False, 'from megengine import tensor\n'), ((3071, 3083), 'megengine.tensor', 'tensor', (['case'], {}), '(case)\n', (3077, 3083), False, 'from megengine import tensor\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine.functional as F
from megengine import tensor
def test_cross_entropy_with_logits():
data = tensor([[0, 50], [0, -150]]).astype(np.float32)
label = tensor([1, 0]).astype(np.int32)
loss = F.nn.cross_entropy(data, label)
np.testing.assert_allclose(loss.numpy(), 0.0)
label = tensor([0, 1]).astype(np.int32)
loss = F.nn.cross_entropy(data, label)
np.testing.assert_allclose(loss.numpy(), 100)
label = np.array([1, 0])
loss = F.nn.cross_entropy(data, label)
np.testing.assert_allclose(loss.numpy(), 0.0)
def test_cross_entropy():
def softmax(x):
x = np.exp(x)
x /= x.sum(1, keepdims=True)
return x
def ref(x, y):
return np.mean([-np.log(x[i, y[i]]) for i in range(len(y))])
x = (np.random.rand(5, 10) - 0.5) * 4
y = np.random.randint(10, size=(5,))
for i in range(len(x)):
x[i, y[i]] += np.random.rand() * 2
x = softmax(x)
l_ref = ref(x, y)
l = F.nn.cross_entropy(tensor(x, "float32"), tensor(y, "int32"), with_logits=False)
np.testing.assert_allclose(l.numpy(), l_ref)
def test_cross_entropy_reduction():
logits = np.random.randn(16, 10)
label = np.random.randint(10, size=[16])
logits = tensor(logits, dtype="float32")
label = tensor(label, dtype="int32")
perm = np.random.permutation(16)
logits_perm = tensor(logits[perm], dtype="float32")
label_perm = tensor(label[perm], dtype="int32")
loss = F.nn.cross_entropy(logits, label, reduction="none")
loss_perm = F.nn.cross_entropy(logits_perm, label_perm, reduction="none")
np.testing.assert_allclose(loss.numpy()[perm], loss_perm.numpy())
loss_sum = F.nn.cross_entropy(logits, label, reduction="sum")
np.testing.assert_allclose(loss.numpy().sum(), loss_sum.numpy(), rtol=2e-7)
loss_mean = F.nn.cross_entropy(logits, label, reduction="mean")
np.testing.assert_allclose(loss_mean.numpy(), loss_sum.numpy() / 16)
loss_ls = F.nn.cross_entropy(logits, label, reduction="mean", label_smooth=0.1)
loss_ls_none_reduce = F.nn.cross_entropy(
logits, label, reduction="none", label_smooth=0.1
)
np.testing.assert_allclose(
loss_ls.numpy(), loss_ls_none_reduce.numpy().mean(), rtol=2e-7
)
with pytest.raises(ValueError):
F.nn.cross_entropy(logits, label, reduction="MEAN")
with pytest.raises(ValueError):
F.nn.cross_entropy(logits, label, reduction="max")
def ctc_nll_naive_npy(
pred,
pred_lengths,
label,
label_lengths,
blank=0,
reduction="mean",
time_major=False,
):
"""naive :func:`ctc_nll` using numpy arrays. Used for testing and helping
our user to understand how CTC works. Only ``LABEL_COMPACT`` mode is
supported."""
pred = np.asarray(pred, dtype=np.float32)
pred_lengths = np.asarray(pred_lengths, dtype=np.int8)
label = np.asarray(label, dtype=np.int32)
label_lengths = np.asarray(label_lengths, dtype=np.int32)
if time_major:
pred = np.transpose(pred, (1, 0, 2))
# pred in (N, T, P) format
batch_size, time_len, nr_class = pred.shape
assert pred_lengths.shape == (batch_size,) and pred_lengths.max() <= pred.shape[1]
assert label_lengths.shape == (batch_size,)
assert label.shape == (label_lengths.sum(),) and label.max() < nr_class
ret = np.empty((batch_size,), dtype=np.float32)
label_start = 0
for i in range(batch_size):
label_end = label_start + label_lengths[i]
ret[i] = _ctc_npy_single_seq(
pred[i][: pred_lengths[i]], label[label_start:label_end], blank
)
label_start = label_end
if reduction == "mean":
return (ret / label_lengths).mean()
elif reduction == "sum":
return ret.sum()
elif reduction == "none":
return ret
else:
raise ValueError("{} is not a valid value for reduction".format(reduction))
def _ctc_npy_single_seq(pred, label, blank):
def safelog(x):
eps = np.finfo(x.dtype).tiny
return np.log(np.maximum(x, eps))
def log_sum_exp(x, y):
x, y = np.maximum(x, y), np.minimum(x, y)
return x + np.log1p(np.exp(y - x))
assert np.abs(pred.sum(axis=1) - 1).max() <= 1e-3
len_pred, alphabet_size = pred.shape
(len_label,) = label.shape
len_ex_label = len_label * 2 + 1
ex_label = (np.zeros(len_ex_label)).astype(np.int32) + blank
ex_label[1::2] = label
prob = np.zeros(len_ex_label, dtype=np.float32)
prob[0] = pred[0][ex_label[0]]
prob[1] = pred[0][ex_label[1]]
prob = safelog(prob) # compute on log scale
ex_label_pmask = ex_label[2:] != ex_label[:-2]
for t in range(1, len_pred):
# enter loop: prob[i] = log(p(pred[:t+1], label[:i+1]))
new_prob = prob.copy()
new_prob[1:] = log_sum_exp(new_prob[1:], prob[:-1])
new_prob[2:] = (
new_prob[2:] * (1 - ex_label_pmask)
+ log_sum_exp(new_prob[2:], prob[:-2]) * ex_label_pmask
)
new_prob += safelog(pred[t, ex_label])
prob = new_prob
return -log_sum_exp(prob[-1], prob[-2])
def test_ctc_loss():
def test_func(T, C, N):
input = np.random.randn(T, N, C)
input = F.softmax(tensor(input), axis=-1).numpy()
input_lengths = np.ones(N, dtype=np.int32) * T
target_lengths = np.random.randint(low=1, high=T + 1, size=(N,), dtype=np.int32)
target = np.random.randint(
low=1, high=C, size=(sum(target_lengths)), dtype=np.int32
)
input_mge = tensor(input)
input_lengths_mge = tensor(input_lengths)
target_mge = tensor(target)
target_lengths_mge = tensor(target_lengths)
blank = np.random.randint(C)
for method in ["mean", "sum", "none"]:
np_out = ctc_nll_naive_npy(
input,
input_lengths,
target,
target_lengths,
blank=blank,
reduction=method,
time_major=True,
)
mge_out = F.nn.ctc_loss(
input_mge,
input_lengths_mge,
target_mge,
target_lengths_mge,
blank=blank,
reduction=method,
)
np.testing.assert_allclose(mge_out.numpy(), np_out, rtol=2e-6)
cases = [[1, 2, 1], [100, 50, 200], [100, 5, 1]]
for case in cases:
test_func(*case)
|
[
"megengine.functional.nn.cross_entropy",
"megengine.functional.nn.ctc_loss",
"megengine.tensor"
] |
[((627, 658), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['data', 'label'], {}), '(data, label)\n', (645, 658), True, 'import megengine.functional as F\n'), ((764, 795), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['data', 'label'], {}), '(data, label)\n', (782, 795), True, 'import megengine.functional as F\n'), ((859, 875), 'numpy.array', 'np.array', (['[1, 0]'], {}), '([1, 0])\n', (867, 875), True, 'import numpy as np\n'), ((887, 918), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['data', 'label'], {}), '(data, label)\n', (905, 918), True, 'import megengine.functional as F\n'), ((1233, 1265), 'numpy.random.randint', 'np.random.randint', (['(10)'], {'size': '(5,)'}), '(10, size=(5,))\n', (1250, 1265), True, 'import numpy as np\n'), ((1566, 1589), 'numpy.random.randn', 'np.random.randn', (['(16)', '(10)'], {}), '(16, 10)\n', (1581, 1589), True, 'import numpy as np\n'), ((1602, 1634), 'numpy.random.randint', 'np.random.randint', (['(10)'], {'size': '[16]'}), '(10, size=[16])\n', (1619, 1634), True, 'import numpy as np\n'), ((1648, 1679), 'megengine.tensor', 'tensor', (['logits'], {'dtype': '"""float32"""'}), "(logits, dtype='float32')\n", (1654, 1679), False, 'from megengine import tensor\n'), ((1692, 1720), 'megengine.tensor', 'tensor', (['label'], {'dtype': '"""int32"""'}), "(label, dtype='int32')\n", (1698, 1720), False, 'from megengine import tensor\n'), ((1733, 1758), 'numpy.random.permutation', 'np.random.permutation', (['(16)'], {}), '(16)\n', (1754, 1758), True, 'import numpy as np\n'), ((1777, 1814), 'megengine.tensor', 'tensor', (['logits[perm]'], {'dtype': '"""float32"""'}), "(logits[perm], dtype='float32')\n", (1783, 1814), False, 'from megengine import tensor\n'), ((1832, 1866), 'megengine.tensor', 'tensor', (['label[perm]'], {'dtype': '"""int32"""'}), "(label[perm], dtype='int32')\n", (1838, 1866), False, 'from megengine import tensor\n'), ((1879, 1930), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""none"""'}), "(logits, label, reduction='none')\n", (1897, 1930), True, 'import megengine.functional as F\n'), ((1947, 2008), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits_perm', 'label_perm'], {'reduction': '"""none"""'}), "(logits_perm, label_perm, reduction='none')\n", (1965, 2008), True, 'import megengine.functional as F\n'), ((2095, 2145), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""sum"""'}), "(logits, label, reduction='sum')\n", (2113, 2145), True, 'import megengine.functional as F\n'), ((2243, 2294), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""mean"""'}), "(logits, label, reduction='mean')\n", (2261, 2294), True, 'import megengine.functional as F\n'), ((2383, 2452), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""mean"""', 'label_smooth': '(0.1)'}), "(logits, label, reduction='mean', label_smooth=0.1)\n", (2401, 2452), True, 'import megengine.functional as F\n'), ((2479, 2548), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""none"""', 'label_smooth': '(0.1)'}), "(logits, label, reduction='none', label_smooth=0.1)\n", (2497, 2548), True, 'import megengine.functional as F\n'), ((3189, 3223), 'numpy.asarray', 'np.asarray', (['pred'], {'dtype': 'np.float32'}), '(pred, dtype=np.float32)\n', (3199, 3223), True, 'import numpy as np\n'), ((3243, 3282), 'numpy.asarray', 'np.asarray', (['pred_lengths'], {'dtype': 'np.int8'}), '(pred_lengths, dtype=np.int8)\n', (3253, 3282), True, 'import numpy as np\n'), ((3295, 3328), 'numpy.asarray', 'np.asarray', (['label'], {'dtype': 'np.int32'}), '(label, dtype=np.int32)\n', (3305, 3328), True, 'import numpy as np\n'), ((3349, 3390), 'numpy.asarray', 'np.asarray', (['label_lengths'], {'dtype': 'np.int32'}), '(label_lengths, dtype=np.int32)\n', (3359, 3390), True, 'import numpy as np\n'), ((3758, 3799), 'numpy.empty', 'np.empty', (['(batch_size,)'], {'dtype': 'np.float32'}), '((batch_size,), dtype=np.float32)\n', (3766, 3799), True, 'import numpy as np\n'), ((4865, 4905), 'numpy.zeros', 'np.zeros', (['len_ex_label'], {'dtype': 'np.float32'}), '(len_ex_label, dtype=np.float32)\n', (4873, 4905), True, 'import numpy as np\n'), ((1029, 1038), 'numpy.exp', 'np.exp', (['x'], {}), '(x)\n', (1035, 1038), True, 'import numpy as np\n'), ((1405, 1425), 'megengine.tensor', 'tensor', (['x', '"""float32"""'], {}), "(x, 'float32')\n", (1411, 1425), False, 'from megengine import tensor\n'), ((1427, 1445), 'megengine.tensor', 'tensor', (['y', '"""int32"""'], {}), "(y, 'int32')\n", (1433, 1445), False, 'from megengine import tensor\n'), ((2682, 2707), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (2695, 2707), False, 'import pytest\n'), ((2717, 2768), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""MEAN"""'}), "(logits, label, reduction='MEAN')\n", (2735, 2768), True, 'import megengine.functional as F\n'), ((2779, 2804), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (2792, 2804), False, 'import pytest\n'), ((2814, 2864), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['logits', 'label'], {'reduction': '"""max"""'}), "(logits, label, reduction='max')\n", (2832, 2864), True, 'import megengine.functional as F\n'), ((3426, 3455), 'numpy.transpose', 'np.transpose', (['pred', '(1, 0, 2)'], {}), '(pred, (1, 0, 2))\n', (3438, 3455), True, 'import numpy as np\n'), ((5599, 5623), 'numpy.random.randn', 'np.random.randn', (['T', 'N', 'C'], {}), '(T, N, C)\n', (5614, 5623), True, 'import numpy as np\n'), ((5762, 5825), 'numpy.random.randint', 'np.random.randint', ([], {'low': '(1)', 'high': '(T + 1)', 'size': '(N,)', 'dtype': 'np.int32'}), '(low=1, high=T + 1, size=(N,), dtype=np.int32)\n', (5779, 5825), True, 'import numpy as np\n'), ((5963, 5976), 'megengine.tensor', 'tensor', (['input'], {}), '(input)\n', (5969, 5976), False, 'from megengine import tensor\n'), ((6005, 6026), 'megengine.tensor', 'tensor', (['input_lengths'], {}), '(input_lengths)\n', (6011, 6026), False, 'from megengine import tensor\n'), ((6049, 6063), 'megengine.tensor', 'tensor', (['target'], {}), '(target)\n', (6055, 6063), False, 'from megengine import tensor\n'), ((6093, 6115), 'megengine.tensor', 'tensor', (['target_lengths'], {}), '(target_lengths)\n', (6099, 6115), False, 'from megengine import tensor\n'), ((6133, 6153), 'numpy.random.randint', 'np.random.randint', (['C'], {}), '(C)\n', (6150, 6153), True, 'import numpy as np\n'), ((524, 552), 'megengine.tensor', 'tensor', (['[[0, 50], [0, -150]]'], {}), '([[0, 50], [0, -150]])\n', (530, 552), False, 'from megengine import tensor\n'), ((584, 598), 'megengine.tensor', 'tensor', (['[1, 0]'], {}), '([1, 0])\n', (590, 598), False, 'from megengine import tensor\n'), ((721, 735), 'megengine.tensor', 'tensor', (['[0, 1]'], {}), '([0, 1])\n', (727, 735), False, 'from megengine import tensor\n'), ((1192, 1213), 'numpy.random.rand', 'np.random.rand', (['(5)', '(10)'], {}), '(5, 10)\n', (1206, 1213), True, 'import numpy as np\n'), ((1316, 1332), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (1330, 1332), True, 'import numpy as np\n'), ((4410, 4427), 'numpy.finfo', 'np.finfo', (['x.dtype'], {}), '(x.dtype)\n', (4418, 4427), True, 'import numpy as np\n'), ((4455, 4473), 'numpy.maximum', 'np.maximum', (['x', 'eps'], {}), '(x, eps)\n', (4465, 4473), True, 'import numpy as np\n'), ((4518, 4534), 'numpy.maximum', 'np.maximum', (['x', 'y'], {}), '(x, y)\n', (4528, 4534), True, 'import numpy as np\n'), ((4536, 4552), 'numpy.minimum', 'np.minimum', (['x', 'y'], {}), '(x, y)\n', (4546, 4552), True, 'import numpy as np\n'), ((5706, 5732), 'numpy.ones', 'np.ones', (['N'], {'dtype': 'np.int32'}), '(N, dtype=np.int32)\n', (5713, 5732), True, 'import numpy as np\n'), ((6483, 6593), 'megengine.functional.nn.ctc_loss', 'F.nn.ctc_loss', (['input_mge', 'input_lengths_mge', 'target_mge', 'target_lengths_mge'], {'blank': 'blank', 'reduction': 'method'}), '(input_mge, input_lengths_mge, target_mge, target_lengths_mge,\n blank=blank, reduction=method)\n', (6496, 6593), True, 'import megengine.functional as F\n'), ((4581, 4594), 'numpy.exp', 'np.exp', (['(y - x)'], {}), '(y - x)\n', (4587, 4594), True, 'import numpy as np\n'), ((4777, 4799), 'numpy.zeros', 'np.zeros', (['len_ex_label'], {}), '(len_ex_label)\n', (4785, 4799), True, 'import numpy as np\n'), ((1138, 1156), 'numpy.log', 'np.log', (['x[i, y[i]]'], {}), '(x[i, y[i]])\n', (1144, 1156), True, 'import numpy as np\n'), ((5650, 5663), 'megengine.tensor', 'tensor', (['input'], {}), '(input)\n', (5656, 5663), False, 'from megengine import tensor\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
from io import BytesIO
import numpy as np
from helpers import MLP, graph_mode
import megengine.functional as F
from megengine import load, optimizer, save
from megengine.core import TensorDict, tensor
from megengine.jit import trace
from megengine.test import assertTensorClose
def get_input():
batch_size, input_dim = 2, 28
data_shape, label_shape = (batch_size, input_dim), (batch_size,)
data, label = tensor(dtype=np.float32), tensor(dtype=np.int32)
data.set_value(np.random.random(data_shape).astype(np.float32))
label.set_value(np.random.randint(0, 10, label_shape))
return data, data_shape, label, label_shape
@graph_mode("eager", "static")
def test_optimizer_serialization():
data, data_shape, label, label_shape = get_input()
mlp = MLP()
opt = optimizer.SGD(mlp.parameters(), lr=0.01, momentum=0.9)
slots = TensorDict()
for param in mlp.parameters():
slots[param] = np.zeros(param.shape).astype(np.float32)
pred = mlp(data)
loss = F.square_loss(pred, label.reshape(-1, 1))
opt.zero_grad()
opt.backward(loss)
opt.step()
for param in mlp.parameters():
slots[param] = slots[param] * 0.9 + param.grad.numpy()
with BytesIO() as fout:
save(opt.state_dict(), fout)
fout.seek(0)
state_dict = load(fout)
opt1 = optimizer.SGD(mlp.parameters(), lr=0.02, momentum=0.8)
opt1.load_state_dict(state_dict)
data.set_value(np.random.random(data_shape).astype(np.float32))
label.set_value(np.random.randint(0, 10, label_shape))
pred = mlp(data)
loss = F.square_loss(pred, label.reshape(-1, 1))
opt1.zero_grad()
opt1.backward(loss)
orig_params = TensorDict()
for param in mlp.parameters():
orig_params[param] = np.copy(param.numpy())
opt1.step()
for param in mlp.parameters():
orig_param = orig_params[param]
slots[param] = slots[param] * 0.9 + param.grad.numpy()
assertTensorClose(param.numpy(), orig_param - 0.01 * slots[param])
def _test_optimizer(opt_str, test_case, check_class, update_lr=False):
iter_num = 3
data, data_shape, label, label_shape = get_input()
net = MLP()
opt = getattr(optimizer, opt_str)(net.parameters(), **test_case)
check_func = check_class(net, **test_case)
step = 0
# eager graph
for i in range(iter_num):
if update_lr and i == 1: # change learning rate
for group in opt.param_groups:
group["lr"] += 0.01
check_func.lr += 0.01
data.set_value(np.random.random(data_shape).astype(np.float32))
label.set_value(np.random.randint(0, 10, label_shape))
pred = net(data)
loss = F.square_loss(pred, label.reshape(-1, 1))
opt.zero_grad()
opt.backward(loss)
ori_params = TensorDict()
for param in net.parameters():
ori_params[param] = np.copy(param.numpy())
opt.step()
step += 1
check_func(ori_params, net.parameters(), step)
# static graph
@trace
def train_func(data, label):
pred = net(data)
loss = F.square_loss(pred, label.reshape(-1, 1))
opt.backward(loss)
for i in range(iter_num):
if update_lr and i == 1: # change learning rate
for group in opt.param_groups:
group["lr"] += 0.01
check_func.lr += 0.01
opt.zero_grad()
ori_params = TensorDict()
for param in net.parameters():
ori_params[param] = np.copy(param.numpy())
train_func(
np.random.random(data_shape).astype(np.float32),
np.random.randint(0, 10, label_shape).astype(np.int32),
)
opt.step()
step += 1
check_func(ori_params, net.parameters(), step)
def test_sgd():
class CheckValue:
def __init__(self, net, **kwarg):
self.slots = TensorDict()
for param in net.parameters():
self.slots[param] = np.zeros(param.shape).astype(np.float32)
for k, v in kwarg.items():
setattr(self, k, v)
def __call__(self, ori_params, new_params, step):
for param in new_params:
grad = param.grad.numpy()
if hasattr(self, "momentum"):
self.slots[param] = grad + self.slots[param] * self.momentum
delta = -self.lr * self.slots[param]
else:
delta = -self.lr * grad
assertTensorClose(param.numpy(), ori_params[param] + delta)
cases = [
{"momentum": 0.9, "lr": 0.01}, # SGD with momentum
{"lr": 0.01}, # simple SGD
{"weight_decay": 0.1, "lr": 0.01}, # with weight_decay
]
for case in cases:
_test_optimizer("SGD", case, CheckValue)
_test_optimizer("SGD", case, CheckValue, update_lr=True)
def test_adam():
class CheckValue:
def __init__(self, net, **kwarg):
self.m_slots = TensorDict()
self.v_slots = TensorDict()
for param in net.parameters():
self.m_slots[param] = np.zeros(param.shape).astype(np.float32)
self.v_slots[param] = np.zeros(param.shape).astype(np.float32)
for k, v in kwarg.items():
setattr(self, k, v)
def __call__(self, ori_params, new_params, step):
for param in new_params:
grad = param.grad.numpy()
m = self.m_slots[param]
v = self.v_slots[param]
m *= self.betas[0]
m += (1 - self.betas[0]) * grad
v *= self.betas[1]
v += (1 - self.betas[1]) * grad * grad
delta = (m / (1 - self.betas[0] ** step)) / (
np.sqrt(v / (1 - self.betas[1] ** step)) + self.eps
)
assertTensorClose(param.numpy(), ori_params[param] - self.lr * delta)
cases = [
{"betas": (0.8, 0.9), "eps": 1e-04, "lr": 0.01},
{
"betas": (0.8, 0.9),
"eps": 1e-04,
"lr": 0.01,
"weight_decay": 0.1,
}, # with weight_decay
]
for case in cases:
_test_optimizer("Adam", case, CheckValue)
_test_optimizer("Adam", case, CheckValue, update_lr=True)
def test_adagrad():
class CheckValue:
def __init__(self, net, **kwarg):
self.s_slots = TensorDict()
for param in net.parameters():
self.s_slots[param] = np.zeros(param.shape).astype(np.float32)
for k, v in kwarg.items():
setattr(self, k, v)
def __call__(self, ori_params, new_params, step):
for param in new_params:
grad = param.grad.numpy()
self.s_slots[param] += grad ** 2
delta = grad / (self.s_slots[param] + self.eps) ** 0.5
delta *= -(self.lr / (1 + (step - 1) * self.lr_decay))
assertTensorClose(param.numpy(), ori_params[param] + delta)
cases = [
{"lr": 0.01, "eps": 1e-06, "lr_decay": 0.01},
{"lr": 0.01, "eps": 1e-06, "lr_decay": 0.0}, # without lr_decay
{
"lr": 0.01,
"eps": 1e-06,
"lr_decay": 0.01,
"weight_decay": 0.1,
}, # with weight_decay
]
for case in cases:
_test_optimizer("Adagrad", case, CheckValue)
_test_optimizer("Adagrad", case, CheckValue, update_lr=True)
def test_adadelta():
class CheckValue:
def __init__(self, net, **kwarg):
self.s_slots = TensorDict()
self.a_slots = TensorDict()
for param in net.parameters():
self.s_slots[param] = np.zeros(param.shape).astype(np.float32)
self.a_slots[param] = np.zeros(param.shape).astype(np.float32)
for k, v in kwarg.items():
setattr(self, k, v)
def __call__(self, ori_params, new_params, step):
for param in new_params:
grad = param.grad.numpy()
self.s_slots[param] = self.s_slots[param] * self.rho + grad ** 2 * (
1 - self.rho
)
delta = (
grad
* ((self.a_slots[param] + self.eps) ** 0.5)
/ (self.s_slots[param] + self.eps) ** 0.5
)
self.a_slots[param] = self.a_slots[param] * self.rho + delta ** 2 * (
1 - self.rho
)
delta *= -self.lr
assertTensorClose(param.numpy(), ori_params[param] + delta)
cases = [
{"lr": 1.0, "eps": 1e-06, "rho": 0.9},
{"lr": 1.0, "eps": 1e-06, "rho": 0.9, "weight_decay": 0.9}, # with weight_decay
]
for case in cases:
_test_optimizer("Adadelta", case, CheckValue)
_test_optimizer("Adadelta", case, CheckValue, update_lr=True)
|
[
"megengine.core.TensorDict",
"megengine.load",
"megengine.core.tensor"
] |
[((1024, 1053), 'helpers.graph_mode', 'graph_mode', (['"""eager"""', '"""static"""'], {}), "('eager', 'static')\n", (1034, 1053), False, 'from helpers import MLP, graph_mode\n'), ((1155, 1160), 'helpers.MLP', 'MLP', ([], {}), '()\n', (1158, 1160), False, 'from helpers import MLP, graph_mode\n'), ((1238, 1250), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (1248, 1250), False, 'from megengine.core import TensorDict, tensor\n'), ((2617, 2622), 'helpers.MLP', 'MLP', ([], {}), '()\n', (2620, 2622), False, 'from helpers import MLP, graph_mode\n'), ((797, 821), 'megengine.core.tensor', 'tensor', ([], {'dtype': 'np.float32'}), '(dtype=np.float32)\n', (803, 821), False, 'from megengine.core import TensorDict, tensor\n'), ((823, 845), 'megengine.core.tensor', 'tensor', ([], {'dtype': 'np.int32'}), '(dtype=np.int32)\n', (829, 845), False, 'from megengine.core import TensorDict, tensor\n'), ((934, 971), 'numpy.random.randint', 'np.random.randint', (['(0)', '(10)', 'label_shape'], {}), '(0, 10, label_shape)\n', (951, 971), True, 'import numpy as np\n'), ((1591, 1600), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (1598, 1600), False, 'from io import BytesIO\n'), ((1689, 1699), 'megengine.load', 'load', (['fout'], {}), '(fout)\n', (1693, 1699), False, 'from megengine import load, optimizer, save\n'), ((2104, 2116), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (2114, 2116), False, 'from megengine.core import TensorDict, tensor\n'), ((3261, 3273), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (3271, 3273), False, 'from megengine.core import TensorDict, tensor\n'), ((3879, 3891), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (3889, 3891), False, 'from megengine.core import TensorDict, tensor\n'), ((1908, 1945), 'numpy.random.randint', 'np.random.randint', (['(0)', '(10)', 'label_shape'], {}), '(0, 10, label_shape)\n', (1925, 1945), True, 'import numpy as np\n'), ((3068, 3105), 'numpy.random.randint', 'np.random.randint', (['(0)', '(10)', 'label_shape'], {}), '(0, 10, label_shape)\n', (3085, 3105), True, 'import numpy as np\n'), ((4344, 4356), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (4354, 4356), False, 'from megengine.core import TensorDict, tensor\n'), ((5444, 5456), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (5454, 5456), False, 'from megengine.core import TensorDict, tensor\n'), ((5484, 5496), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (5494, 5496), False, 'from megengine.core import TensorDict, tensor\n'), ((6890, 6902), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (6900, 6902), False, 'from megengine.core import TensorDict, tensor\n'), ((8067, 8079), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (8077, 8079), False, 'from megengine.core import TensorDict, tensor\n'), ((8107, 8119), 'megengine.core.TensorDict', 'TensorDict', ([], {}), '()\n', (8117, 8119), False, 'from megengine.core import TensorDict, tensor\n'), ((865, 893), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (881, 893), True, 'import numpy as np\n'), ((1309, 1330), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (1317, 1330), True, 'import numpy as np\n'), ((1835, 1863), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (1851, 1863), True, 'import numpy as np\n'), ((2995, 3023), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (3011, 3023), True, 'import numpy as np\n'), ((4018, 4046), 'numpy.random.random', 'np.random.random', (['data_shape'], {}), '(data_shape)\n', (4034, 4046), True, 'import numpy as np\n'), ((4079, 4116), 'numpy.random.randint', 'np.random.randint', (['(0)', '(10)', 'label_shape'], {}), '(0, 10, label_shape)\n', (4096, 4116), True, 'import numpy as np\n'), ((4436, 4457), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (4444, 4457), True, 'import numpy as np\n'), ((5578, 5599), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (5586, 5599), True, 'import numpy as np\n'), ((5657, 5678), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (5665, 5678), True, 'import numpy as np\n'), ((6246, 6286), 'numpy.sqrt', 'np.sqrt', (['(v / (1 - self.betas[1] ** step))'], {}), '(v / (1 - self.betas[1] ** step))\n', (6253, 6286), True, 'import numpy as np\n'), ((6984, 7005), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (6992, 7005), True, 'import numpy as np\n'), ((8201, 8222), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (8209, 8222), True, 'import numpy as np\n'), ((8280, 8301), 'numpy.zeros', 'np.zeros', (['param.shape'], {}), '(param.shape)\n', (8288, 8301), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
import json
import os
import pytest
from megengine import Parameter, tensor
from megengine.core import option
from megengine.module import Module
from megengine.utils.profiler import Profiler, scope
class Simple(Module):
def __init__(self):
super().__init__()
self.a = Parameter([1.23], dtype="float32")
def forward(self, x):
x = x * self.a
return x
def test_profiler():
profile_prefix = "pytest_profile"
profile_format = "chrome_timeline.json"
profile_path = "{}.{}".format(profile_prefix, profile_format)
with Profiler(profile_prefix, format=profile_format):
with scope("my_scope"):
oup = Simple()(tensor([1.23], dtype="float32"))
with open(profile_path, "r") as f:
events = json.load(f)
os.remove(profile_path)
prev_ts = {}
scope_count = 0
for event in events:
if "dur" in event:
assert event["dur"] >= 0
elif "ts" in event and "tid" in event:
ts = event["ts"]
tid = event["tid"]
if ts == 0:
continue
assert (tid not in prev_ts) or prev_ts[tid] <= ts
prev_ts[tid] = ts
if "name" in event and event["name"] == "my_scope":
scope_count += 1
assert scope_count > 0 and scope_count % 2 == 0
|
[
"megengine.tensor",
"megengine.utils.profiler.scope",
"megengine.Parameter",
"megengine.utils.profiler.Profiler"
] |
[((1165, 1188), 'os.remove', 'os.remove', (['profile_path'], {}), '(profile_path)\n', (1174, 1188), False, 'import os\n'), ((669, 703), 'megengine.Parameter', 'Parameter', (['[1.23]'], {'dtype': '"""float32"""'}), "([1.23], dtype='float32')\n", (678, 703), False, 'from megengine import Parameter, tensor\n'), ((951, 998), 'megengine.utils.profiler.Profiler', 'Profiler', (['profile_prefix'], {'format': 'profile_format'}), '(profile_prefix, format=profile_format)\n', (959, 998), False, 'from megengine.utils.profiler import Profiler, scope\n'), ((1148, 1160), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1157, 1160), False, 'import json\n'), ((1013, 1030), 'megengine.utils.profiler.scope', 'scope', (['"""my_scope"""'], {}), "('my_scope')\n", (1018, 1030), False, 'from megengine.utils.profiler import Profiler, scope\n'), ((1059, 1090), 'megengine.tensor', 'tensor', (['[1.23]'], {'dtype': '"""float32"""'}), "([1.23], dtype='float32')\n", (1065, 1090), False, 'from megengine import Parameter, tensor\n')]
|
#! /usr/bin/env python3
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import getopt
import os
import runpy
import sys
from megengine.logger import get_logger
from megengine.utils.profiler import Profiler, merge_trace_events
def main():
parser = argparse.ArgumentParser(
prog="megengine.tools.profiler", description="Profiling megengine program"
)
parser.add_argument(
"-m", "--module", action="store_true", help="whether launch program as module"
)
parser.add_argument("-o", "--output", type=str, help="output file location")
parser.add_argument(
"-f",
"--format",
action="append",
type=str,
help="output file format",
choices=Profiler.valid_formats,
)
parser.add_argument(
"--merge_trace_events", action="store_true",
)
parser.add_argument(
"--clean", action="store_true",
)
for opt in Profiler.valid_options:
parser.add_argument("--" + opt, type=int, default=None)
args, extras = parser.parse_known_args(sys.argv[1:])
prof_args = {}
for opt in Profiler.valid_options:
optval = getattr(args, opt, None)
if optval is not None:
prof_args[opt] = optval
if args.output is not None:
prof_args["path"] = args.output
if args.format:
prof_args["formats"] = args.format
if args.clean:
for file in os.listdir(profiler.directory):
os.remove(os.path.join(profiler.directory, file))
if len(extras) == 0:
if not args.merge_trace_events:
parser.print_usage()
exit(1)
else:
filename = extras[0]
if not args.module:
if not os.path.exists(filename):
get_logger().fatal("cannot find file {}".format(filename))
exit(1)
filename = os.path.realpath(filename)
# Replace profiler's dir with script's dir in front of module search path.
sys.path[0] = os.path.dirname(filename)
sys.argv[:] = [filename, *extras[1:]]
profiler = Profiler(**prof_args)
with profiler:
if args.module:
runpy.run_module(filename)
else:
run_script(filename)
profiler.dump()
if args.merge_trace_events:
merge_trace_events(profiler.directory)
def run_module(modulename):
runpy.run_module(modulename, None, "__main__", True)
def run_script(filename):
runpy.run_path(filename, None, "__main__")
if __name__ == "__main__":
main()
|
[
"megengine.utils.profiler.merge_trace_events",
"megengine.logger.get_logger",
"megengine.utils.profiler.Profiler"
] |
[((575, 679), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""megengine.tools.profiler"""', 'description': '"""Profiling megengine program"""'}), "(prog='megengine.tools.profiler', description=\n 'Profiling megengine program')\n", (598, 679), False, 'import argparse\n'), ((2719, 2771), 'runpy.run_module', 'runpy.run_module', (['modulename', 'None', '"""__main__"""', '(True)'], {}), "(modulename, None, '__main__', True)\n", (2735, 2771), False, 'import runpy\n'), ((2804, 2846), 'runpy.run_path', 'runpy.run_path', (['filename', 'None', '"""__main__"""'], {}), "(filename, None, '__main__')\n", (2818, 2846), False, 'import runpy\n'), ((1730, 1760), 'os.listdir', 'os.listdir', (['profiler.directory'], {}), '(profiler.directory)\n', (1740, 1760), False, 'import os\n'), ((2410, 2431), 'megengine.utils.profiler.Profiler', 'Profiler', ([], {}), '(**prof_args)\n', (2418, 2431), False, 'from megengine.utils.profiler import Profiler, merge_trace_events\n'), ((2646, 2684), 'megengine.utils.profiler.merge_trace_events', 'merge_trace_events', (['profiler.directory'], {}), '(profiler.directory)\n', (2664, 2684), False, 'from megengine.utils.profiler import Profiler, merge_trace_events\n'), ((2177, 2203), 'os.path.realpath', 'os.path.realpath', (['filename'], {}), '(filename)\n', (2193, 2203), False, 'import os\n'), ((2317, 2342), 'os.path.dirname', 'os.path.dirname', (['filename'], {}), '(filename)\n', (2332, 2342), False, 'import os\n'), ((1784, 1822), 'os.path.join', 'os.path.join', (['profiler.directory', 'file'], {}), '(profiler.directory, file)\n', (1796, 1822), False, 'import os\n'), ((2029, 2053), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (2043, 2053), False, 'import os\n'), ((2499, 2525), 'runpy.run_module', 'runpy.run_module', (['filename'], {}), '(filename)\n', (2515, 2525), False, 'import runpy\n'), ((2071, 2083), 'megengine.logger.get_logger', 'get_logger', ([], {}), '()\n', (2081, 2083), False, 'from megengine.logger import get_logger\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import cv2
import megengine as mge
import megengine.data.dataset as dataset
import megengine.jit as jit
import numpy as np
from megengine.utils.http_download import download_from_url
from official.vision.segmentation.deeplabv3plus import DeepLabV3Plus
class Config:
NUM_CLASSES = 21
IMG_SIZE = 512
IMG_MEAN = [103.530, 116.280, 123.675]
IMG_STD = [57.375, 57.120, 58.395]
cfg = Config()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--image_path", type=str, default=None, help="inference image")
parser.add_argument("--model_path", type=str, default=None, help="inference model")
args = parser.parse_args()
net = load_model(args.model_path)
if args.image_path is None:
download_from_url("https://data.megengine.org.cn/images/cat.jpg", "test.jpg")
img = cv2.imread("test.jpg")
else:
img = cv2.imread(args.image_path)
pred = inference(img, net)
cv2.imwrite("out.jpg", pred)
def load_model(model_path):
model_dict = mge.load(model_path)
net = DeepLabV3Plus(class_num=cfg.NUM_CLASSES)
net.load_state_dict(model_dict["state_dict"])
print("load model %s" % (model_path))
net.eval()
return net
def inference(img, net):
@jit.trace(symbolic=True, opt_level=2)
def pred_fun(data, net=None):
net.eval()
pred = net(data)
return pred
img = (img.astype("float32") - np.array(cfg.IMG_MEAN)) / np.array(cfg.IMG_STD)
orih, oriw = img.shape[:2]
img = cv2.resize(img, (cfg.IMG_SIZE, cfg.IMG_SIZE))
img = img.transpose(2, 0, 1)[np.newaxis]
data = mge.tensor()
data.set_value(img)
pred = pred_fun(data, net=net)
pred = pred.numpy().squeeze().argmax(0)
pred = cv2.resize(
pred.astype("uint8"), (oriw, orih), interpolation=cv2.INTER_NEAREST
)
class_colors = dataset.PascalVOC.class_colors
out = np.zeros((orih, oriw, 3))
nids = np.unique(pred)
for t in nids:
out[pred == t] = class_colors[t]
return out
if __name__ == "__main__":
main()
|
[
"megengine.jit.trace",
"megengine.tensor",
"megengine.load",
"megengine.utils.http_download.download_from_url"
] |
[((829, 854), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (852, 854), False, 'import argparse\n'), ((1343, 1371), 'cv2.imwrite', 'cv2.imwrite', (['"""out.jpg"""', 'pred'], {}), "('out.jpg', pred)\n", (1354, 1371), False, 'import cv2\n'), ((1419, 1439), 'megengine.load', 'mge.load', (['model_path'], {}), '(model_path)\n', (1427, 1439), True, 'import megengine as mge\n'), ((1450, 1490), 'official.vision.segmentation.deeplabv3plus.DeepLabV3Plus', 'DeepLabV3Plus', ([], {'class_num': 'cfg.NUM_CLASSES'}), '(class_num=cfg.NUM_CLASSES)\n', (1463, 1490), False, 'from official.vision.segmentation.deeplabv3plus import DeepLabV3Plus\n'), ((1645, 1682), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)', 'opt_level': '(2)'}), '(symbolic=True, opt_level=2)\n', (1654, 1682), True, 'import megengine.jit as jit\n'), ((1906, 1951), 'cv2.resize', 'cv2.resize', (['img', '(cfg.IMG_SIZE, cfg.IMG_SIZE)'], {}), '(img, (cfg.IMG_SIZE, cfg.IMG_SIZE))\n', (1916, 1951), False, 'import cv2\n'), ((2009, 2021), 'megengine.tensor', 'mge.tensor', ([], {}), '()\n', (2019, 2021), True, 'import megengine as mge\n'), ((2291, 2316), 'numpy.zeros', 'np.zeros', (['(orih, oriw, 3)'], {}), '((orih, oriw, 3))\n', (2299, 2316), True, 'import numpy as np\n'), ((2328, 2343), 'numpy.unique', 'np.unique', (['pred'], {}), '(pred)\n', (2337, 2343), True, 'import numpy as np\n'), ((1141, 1218), 'megengine.utils.http_download.download_from_url', 'download_from_url', (['"""https://data.megengine.org.cn/images/cat.jpg"""', '"""test.jpg"""'], {}), "('https://data.megengine.org.cn/images/cat.jpg', 'test.jpg')\n", (1158, 1218), False, 'from megengine.utils.http_download import download_from_url\n'), ((1233, 1255), 'cv2.imread', 'cv2.imread', (['"""test.jpg"""'], {}), "('test.jpg')\n", (1243, 1255), False, 'import cv2\n'), ((1280, 1307), 'cv2.imread', 'cv2.imread', (['args.image_path'], {}), '(args.image_path)\n', (1290, 1307), False, 'import cv2\n'), ((1843, 1864), 'numpy.array', 'np.array', (['cfg.IMG_STD'], {}), '(cfg.IMG_STD)\n', (1851, 1864), True, 'import numpy as np\n'), ((1817, 1839), 'numpy.array', 'np.array', (['cfg.IMG_MEAN'], {}), '(cfg.IMG_MEAN)\n', (1825, 1839), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import time
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as TF
from tabulate import tabulate
import megengine as mge
import megengine.functional as MF
import megengine.module as MM
module_cache = {
"conv2d": (MM.Conv2d(32, 32, 3, 1, 0), nn.Conv2d(32, 32, 3, 1, 0).cuda()),
"dw_conv2d": (
MM.Conv2d(32, 32, 3, 1, 0, groups=32),
nn.Conv2d(32, 32, 3, 1, 0, groups=32).cuda(),
),
"conv3d": (MM.Conv3d(32, 32, 3, 1, 0), nn.Conv3d(32, 32, 3, 1, 0).cuda()),
"ConvTranspose2d": (
MM.ConvTranspose2d(32, 32, 3, 1, 0),
nn.ConvTranspose2d(32, 32, 3, 1, 0).cuda(),
),
"BatchNorm2d": (MM.BatchNorm2d(64), nn.BatchNorm2d(64).cuda()),
"Linear": (MM.Linear(1000, 1000), nn.Linear(1000, 1000).cuda()),
}
test_cases = [
# (mge op, torch op, small inps, large inps, unpack_inps, rep)
(
"adaptive_avg_pool2d",
lambda x: MF.adaptive_avg_pool2d(x, (7, 7)),
lambda x: TF.adaptive_avg_pool2d(x, (7, 7)),
[(2, 32, 16, 16)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"adaptive_max_pool2d",
lambda x: MF.adaptive_max_pool2d(x, (7, 7)),
lambda x: TF.adaptive_max_pool2d(x, (7, 7)),
[(2, 32, 16, 16)],
[(64, 512, 16, 16)],
True,
1000,
),
("argsort", MF.argsort, torch.argsort, [(1000,)], [(1000, 1000),], True, 1000),
(
"avg_pool2d",
lambda x: MF.avg_pool2d(x, 2),
lambda x: TF.avg_pool2d(x, 2),
[(2, 32, 16, 16)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"broadcast",
lambda x: MF.broadcast_to(x, (5,) + x.shape),
lambda x: torch.broadcast_to(x, (5,) + x.shape),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"batchedmatmul",
MF.matmul,
torch.matmul,
[(8, 64, 32), (8, 32, 64)],
[(8, 2048, 512), (8, 512, 2048)],
True,
1000,
),
(
"batchnrom2d",
lambda x: module_cache["BatchNorm2d"][0](x),
lambda x: module_cache["BatchNorm2d"][1](x),
[(2, 64, 16, 16)],
[(64, 64, 128, 128)],
True,
1000,
),
(
"concat",
MF.concat,
torch.cat,
[(20, 100), (50, 100), (30, 100)],
[(64, 512, 16, 16), (64, 512, 16, 16), (64, 512, 16, 16)],
False,
1000,
),
(
"conv2d",
lambda x: module_cache["conv2d"][0](x),
lambda x: module_cache["conv2d"][1](x),
[(2, 32, 16, 16)],
[(32, 32, 128, 128)],
True,
1000,
),
(
"conv3d",
lambda x: module_cache["conv3d"][0](x),
lambda x: module_cache["conv3d"][1](x),
[(2, 32, 8, 8, 8)],
[(32, 32, 16, 16, 16)],
True,
1000,
),
(
"convTranspose2d",
lambda x: module_cache["ConvTranspose2d"][0](x),
lambda x: module_cache["ConvTranspose2d"][1](x),
[(2, 32, 16, 16)],
[(32, 32, 128, 128)],
True,
1000,
),
(
"dropout",
lambda x: MF.dropout(x, 0.5),
TF.dropout,
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"dw_conv2d",
lambda x: module_cache["dw_conv2d"][0](x),
lambda x: module_cache["dw_conv2d"][1](x),
[(2, 32, 16, 16)],
[(32, 32, 128, 128)],
True,
1000,
),
(
"elemwise.unary",
MF.log,
torch.log,
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"elemwise.binary",
MF.add,
torch.add,
[(100, 100), (100, 100)],
[(64, 512, 16, 16), (64, 512, 16, 16)],
True,
1000,
),
(
"expand_dims",
lambda x: MF.expand_dims(x, 0),
lambda x: torch.unsqueeze(x, 0),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
("gelu", MF.gelu, TF.gelu, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
("hswish", MF.hswish, TF.hardswish, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
(
"hsigmoid",
MF.hsigmoid,
TF.hardsigmoid,
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
("isinf", MF.isinf, torch.isinf, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
(
"indeixngMultiAxisVec",
lambda x: x[[1, 3, 5], [1, 3, 5], [1, 3, 5], [1, 3, 5]],
lambda x: x[[1, 3, 5], [1, 3, 5], [1, 3, 5], [1, 3, 5]],
[(10, 10, 10, 10)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"logsigmoid",
MF.logsigmoid,
TF.logsigmoid,
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"leaky_relu",
lambda x: MF.leaky_relu(x, 0.5),
lambda x: TF.leaky_relu(x, 0.5),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"linear",
lambda x: module_cache["Linear"][0](x),
lambda x: module_cache["Linear"][1](x),
[(10, 1000)],
[(64, 128, 1000)],
True,
1000,
),
("matinv", MF.matinv, torch.inverse, [(10, 10)], [(30, 30)], True, 1000),
(
"matmul",
MF.matmul,
torch.matmul,
[(64, 32), (32, 64)],
[(2048, 1024), (1024, 2048)],
True,
1000,
),
(
"max_pool2d",
lambda x: MF.max_pool2d(x, 2),
lambda x: TF.max_pool2d(x, 2),
[(2, 32, 16, 16)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"normal",
lambda x: mge.random.normal(0, 1, x.shape),
lambda x: torch.randn(x.shape, device="cuda"),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"prelu",
MF.prelu,
TF.prelu,
[(100, 100), (1,)],
[(64, 512, 16, 16), (1,)],
True,
1000,
),
(
"reduce.max",
lambda x: MF.max(x, 0),
lambda x: torch.max(x, 0),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"reduce.mean",
lambda x: MF.mean(x, 0),
lambda x: torch.mean(x, 0),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"reduce.mean",
lambda x: MF.mean(x, 0),
lambda x: torch.mean(x, 0),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
("relu", MF.relu, TF.relu, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
("relu6", MF.relu6, TF.relu6, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
(
"repeat",
lambda x: MF.repeat(x, 5),
lambda x: torch.repeat_interleave(x, 5),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
("silu", MF.silu, TF.silu, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
(
"split",
lambda x: MF.split(x, 5),
lambda x: torch.split(x, 5),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
("sigmoid", MF.sigmoid, TF.sigmoid, [(100, 100)], [(64, 512, 16, 16)], True, 1000),
(
"softmax",
lambda x: MF.softmax(x, axis=1),
lambda x: TF.softmax(x, dim=1),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"softplus",
MF.softplus,
TF.softplus,
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"squeeze",
lambda x: MF.squeeze(x, 0),
lambda x: torch.squeeze(x, 0),
[(1, 100, 100)],
[(1, 64, 512, 16, 16)],
True,
1000,
),
(
"stack",
MF.stack,
torch.stack,
[(100, 100), (100, 100)],
[(64, 512, 16, 16), (64, 512, 16, 16)],
False,
10000,
),
(
"subtensor",
lambda x: x[0:20, 10:60],
lambda x: x[0:20, 10:60],
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"topk",
lambda x: MF.topk(x, 10),
lambda x: torch.topk(x, 10),
[(100, 100)],
[(1000, 1000)],
True,
1000,
),
(
"tile",
lambda x: MF.tile(x, (2,) * len(x.shape)),
lambda x: torch.tile(x, (2,) * len(x.shape)),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"transpose",
lambda x: MF.transpose(x, list(range(len(x.shape)))[::-1]),
lambda x: torch.permute(x, list(range(len(x.shape)))[::-1]),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"where",
lambda x: MF.where(x > 0.5, x, x),
lambda x: torch.where(x > 0.5, x, x),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
(
"uniform",
lambda x: mge.random.uniform(0, 1, x.shape),
lambda x: torch.rand(x.shape, device="cuda"),
[(100, 100)],
[(64, 512, 16, 16)],
True,
1000,
),
]
def perf_func(func, inps, reps, unpack_inps, is_mge):
if is_mge:
mge._full_sync()
tik = time.time()
for _ in range(reps):
if unpack_inps:
out = func(*inps)
else:
out = func(inps)
mge._full_sync()
else:
torch.cuda.synchronize()
with torch.no_grad():
tik = time.time()
for _ in range(reps):
if unpack_inps:
out = func(*inps)
else:
out = func(inps)
torch.cuda.synchronize()
return time.time() - tik
def get_avg_time(func, inps, reps, unpack_inps, is_mge):
# warm up
for _ in range(2):
t = perf_func(func, inps, reps, unpack_inps, is_mge)
times = []
for _ in range(5):
t = perf_func(func, inps, reps, unpack_inps, is_mge)
times.append(t)
return np.mean(times)
def get_perf_results(mge_func, torch_func, shapes, unpack_inps, reps):
inps = [np.random.randn(*shape) for shape in shapes]
inps_mge = [mge.tensor(inp, dtype="float32") for inp in inps]
avg_time_mge = get_avg_time(mge_func, inps_mge, reps, unpack_inps, True)
inps_torch = [torch.Tensor(inp).type(torch.float).cuda() for inp in inps]
avg_time_torch = get_avg_time(torch_func, inps_torch, reps, unpack_inps, False)
return avg_time_mge, avg_time_torch
if __name__ == "__main__":
header = [
"opr_name",
"time(mge/pytorch; small input)",
"time(mge/pytorch; large input)",
]
table = []
for case in test_cases:
assert len(case) == 7
name, mge_func, torch_func, small_shapes, large_shapes, unpack_inps, reps = case
data = []
data.append(name)
print("========== op: {}".format(name))
avg_time_mge, avg_time_torch = get_perf_results(
mge_func, torch_func, small_shapes, unpack_inps, reps
)
print("mge time: {}".format(avg_time_mge))
print("torch time: {}".format(avg_time_torch))
data.append("{:.2f}".format(avg_time_mge / avg_time_torch))
avg_time_mge, avg_time_torch = get_perf_results(
mge_func, torch_func, large_shapes, unpack_inps, reps
)
print("mge time: {}".format(avg_time_mge))
print("torch time: {}".format(avg_time_torch))
data.append("{:.2f}".format(avg_time_mge / avg_time_torch))
table.append(data)
print(tabulate(table, header, tablefmt="github"))
|
[
"megengine.random.normal",
"megengine.functional.adaptive_max_pool2d",
"megengine.functional.avg_pool2d",
"megengine.module.Conv2d",
"megengine.functional.repeat",
"megengine.functional.max_pool2d",
"megengine.functional.squeeze",
"megengine.module.BatchNorm2d",
"megengine.functional.leaky_relu",
"megengine.functional.broadcast_to",
"megengine.functional.split",
"megengine.tensor",
"megengine.functional.dropout",
"megengine.functional.adaptive_avg_pool2d",
"megengine.module.ConvTranspose2d",
"megengine.functional.max",
"megengine._full_sync",
"megengine.module.Linear",
"megengine.module.Conv3d",
"megengine.functional.expand_dims",
"megengine.functional.softmax",
"megengine.functional.topk",
"megengine.random.uniform",
"megengine.functional.mean",
"megengine.functional.where"
] |
[((10595, 10609), 'numpy.mean', 'np.mean', (['times'], {}), '(times)\n', (10602, 10609), True, 'import numpy as np\n'), ((629, 655), 'megengine.module.Conv2d', 'MM.Conv2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (638, 655), True, 'import megengine.module as MM\n'), ((720, 757), 'megengine.module.Conv2d', 'MM.Conv2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {'groups': '(32)'}), '(32, 32, 3, 1, 0, groups=32)\n', (729, 757), True, 'import megengine.module as MM\n'), ((835, 861), 'megengine.module.Conv3d', 'MM.Conv3d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (844, 861), True, 'import megengine.module as MM\n'), ((932, 967), 'megengine.module.ConvTranspose2d', 'MM.ConvTranspose2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (950, 967), True, 'import megengine.module as MM\n'), ((1048, 1066), 'megengine.module.BatchNorm2d', 'MM.BatchNorm2d', (['(64)'], {}), '(64)\n', (1062, 1066), True, 'import megengine.module as MM\n'), ((1111, 1132), 'megengine.module.Linear', 'MM.Linear', (['(1000)', '(1000)'], {}), '(1000, 1000)\n', (1120, 1132), True, 'import megengine.module as MM\n'), ((9764, 9780), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (9778, 9780), True, 'import megengine as mge\n'), ((9795, 9806), 'time.time', 'time.time', ([], {}), '()\n', (9804, 9806), False, 'import time\n'), ((9958, 9974), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (9972, 9974), True, 'import megengine as mge\n'), ((9993, 10017), 'torch.cuda.synchronize', 'torch.cuda.synchronize', ([], {}), '()\n', (10015, 10017), False, 'import torch\n'), ((10249, 10273), 'torch.cuda.synchronize', 'torch.cuda.synchronize', ([], {}), '()\n', (10271, 10273), False, 'import torch\n'), ((10285, 10296), 'time.time', 'time.time', ([], {}), '()\n', (10294, 10296), False, 'import time\n'), ((10695, 10718), 'numpy.random.randn', 'np.random.randn', (['*shape'], {}), '(*shape)\n', (10710, 10718), True, 'import numpy as np\n'), ((10757, 10789), 'megengine.tensor', 'mge.tensor', (['inp'], {'dtype': '"""float32"""'}), "(inp, dtype='float32')\n", (10767, 10789), True, 'import megengine as mge\n'), ((12149, 12191), 'tabulate.tabulate', 'tabulate', (['table', 'header'], {'tablefmt': '"""github"""'}), "(table, header, tablefmt='github')\n", (12157, 12191), False, 'from tabulate import tabulate\n'), ((1305, 1338), 'megengine.functional.adaptive_avg_pool2d', 'MF.adaptive_avg_pool2d', (['x', '(7, 7)'], {}), '(x, (7, 7))\n', (1327, 1338), True, 'import megengine.functional as MF\n'), ((1358, 1391), 'torch.nn.functional.adaptive_avg_pool2d', 'TF.adaptive_avg_pool2d', (['x', '(7, 7)'], {}), '(x, (7, 7))\n', (1380, 1391), True, 'import torch.nn.functional as TF\n'), ((1539, 1572), 'megengine.functional.adaptive_max_pool2d', 'MF.adaptive_max_pool2d', (['x', '(7, 7)'], {}), '(x, (7, 7))\n', (1561, 1572), True, 'import megengine.functional as MF\n'), ((1592, 1625), 'torch.nn.functional.adaptive_max_pool2d', 'TF.adaptive_max_pool2d', (['x', '(7, 7)'], {}), '(x, (7, 7))\n', (1614, 1625), True, 'import torch.nn.functional as TF\n'), ((1848, 1867), 'megengine.functional.avg_pool2d', 'MF.avg_pool2d', (['x', '(2)'], {}), '(x, 2)\n', (1861, 1867), True, 'import megengine.functional as MF\n'), ((1887, 1906), 'torch.nn.functional.avg_pool2d', 'TF.avg_pool2d', (['x', '(2)'], {}), '(x, 2)\n', (1900, 1906), True, 'import torch.nn.functional as TF\n'), ((2044, 2078), 'megengine.functional.broadcast_to', 'MF.broadcast_to', (['x', '((5,) + x.shape)'], {}), '(x, (5,) + x.shape)\n', (2059, 2078), True, 'import megengine.functional as MF\n'), ((2098, 2135), 'torch.broadcast_to', 'torch.broadcast_to', (['x', '((5,) + x.shape)'], {}), '(x, (5,) + x.shape)\n', (2116, 2135), False, 'import torch\n'), ((3552, 3570), 'megengine.functional.dropout', 'MF.dropout', (['x', '(0.5)'], {}), '(x, 0.5)\n', (3562, 3570), True, 'import megengine.functional as MF\n'), ((4284, 4304), 'megengine.functional.expand_dims', 'MF.expand_dims', (['x', '(0)'], {}), '(x, 0)\n', (4298, 4304), True, 'import megengine.functional as MF\n'), ((4324, 4345), 'torch.unsqueeze', 'torch.unsqueeze', (['x', '(0)'], {}), '(x, 0)\n', (4339, 4345), False, 'import torch\n'), ((5308, 5329), 'megengine.functional.leaky_relu', 'MF.leaky_relu', (['x', '(0.5)'], {}), '(x, 0.5)\n', (5321, 5329), True, 'import megengine.functional as MF\n'), ((5349, 5370), 'torch.nn.functional.leaky_relu', 'TF.leaky_relu', (['x', '(0.5)'], {}), '(x, 0.5)\n', (5362, 5370), True, 'import torch.nn.functional as TF\n'), ((5954, 5973), 'megengine.functional.max_pool2d', 'MF.max_pool2d', (['x', '(2)'], {}), '(x, 2)\n', (5967, 5973), True, 'import megengine.functional as MF\n'), ((5993, 6012), 'torch.nn.functional.max_pool2d', 'TF.max_pool2d', (['x', '(2)'], {}), '(x, 2)\n', (6006, 6012), True, 'import torch.nn.functional as TF\n'), ((6147, 6179), 'megengine.random.normal', 'mge.random.normal', (['(0)', '(1)', 'x.shape'], {}), '(0, 1, x.shape)\n', (6164, 6179), True, 'import megengine as mge\n'), ((6199, 6234), 'torch.randn', 'torch.randn', (['x.shape'], {'device': '"""cuda"""'}), "(x.shape, device='cuda')\n", (6210, 6234), False, 'import torch\n'), ((6525, 6537), 'megengine.functional.max', 'MF.max', (['x', '(0)'], {}), '(x, 0)\n', (6531, 6537), True, 'import megengine.functional as MF\n'), ((6557, 6572), 'torch.max', 'torch.max', (['x', '(0)'], {}), '(x, 0)\n', (6566, 6572), False, 'import torch\n'), ((6707, 6720), 'megengine.functional.mean', 'MF.mean', (['x', '(0)'], {}), '(x, 0)\n', (6714, 6720), True, 'import megengine.functional as MF\n'), ((6740, 6756), 'torch.mean', 'torch.mean', (['x', '(0)'], {}), '(x, 0)\n', (6750, 6756), False, 'import torch\n'), ((6891, 6904), 'megengine.functional.mean', 'MF.mean', (['x', '(0)'], {}), '(x, 0)\n', (6898, 6904), True, 'import megengine.functional as MF\n'), ((6924, 6940), 'torch.mean', 'torch.mean', (['x', '(0)'], {}), '(x, 0)\n', (6934, 6940), False, 'import torch\n'), ((7231, 7246), 'megengine.functional.repeat', 'MF.repeat', (['x', '(5)'], {}), '(x, 5)\n', (7240, 7246), True, 'import megengine.functional as MF\n'), ((7266, 7295), 'torch.repeat_interleave', 'torch.repeat_interleave', (['x', '(5)'], {}), '(x, 5)\n', (7289, 7295), False, 'import torch\n'), ((7503, 7517), 'megengine.functional.split', 'MF.split', (['x', '(5)'], {}), '(x, 5)\n', (7511, 7517), True, 'import megengine.functional as MF\n'), ((7537, 7554), 'torch.split', 'torch.split', (['x', '(5)'], {}), '(x, 5)\n', (7548, 7554), False, 'import torch\n'), ((7773, 7794), 'megengine.functional.softmax', 'MF.softmax', (['x'], {'axis': '(1)'}), '(x, axis=1)\n', (7783, 7794), True, 'import megengine.functional as MF\n'), ((7814, 7834), 'torch.nn.functional.softmax', 'TF.softmax', (['x'], {'dim': '(1)'}), '(x, dim=1)\n', (7824, 7834), True, 'import torch.nn.functional as TF\n'), ((8119, 8135), 'megengine.functional.squeeze', 'MF.squeeze', (['x', '(0)'], {}), '(x, 0)\n', (8129, 8135), True, 'import megengine.functional as MF\n'), ((8155, 8174), 'torch.squeeze', 'torch.squeeze', (['x', '(0)'], {}), '(x, 0)\n', (8168, 8174), False, 'import torch\n'), ((8670, 8684), 'megengine.functional.topk', 'MF.topk', (['x', '(10)'], {}), '(x, 10)\n', (8677, 8684), True, 'import megengine.functional as MF\n'), ((8704, 8721), 'torch.topk', 'torch.topk', (['x', '(10)'], {}), '(x, 10)\n', (8714, 8721), False, 'import torch\n'), ((9308, 9331), 'megengine.functional.where', 'MF.where', (['(x > 0.5)', 'x', 'x'], {}), '(x > 0.5, x, x)\n', (9316, 9331), True, 'import megengine.functional as MF\n'), ((9351, 9377), 'torch.where', 'torch.where', (['(x > 0.5)', 'x', 'x'], {}), '(x > 0.5, x, x)\n', (9362, 9377), False, 'import torch\n'), ((9508, 9541), 'megengine.random.uniform', 'mge.random.uniform', (['(0)', '(1)', 'x.shape'], {}), '(0, 1, x.shape)\n', (9526, 9541), True, 'import megengine as mge\n'), ((9561, 9595), 'torch.rand', 'torch.rand', (['x.shape'], {'device': '"""cuda"""'}), "(x.shape, device='cuda')\n", (9571, 9595), False, 'import torch\n'), ((10031, 10046), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (10044, 10046), False, 'import torch\n'), ((10066, 10077), 'time.time', 'time.time', ([], {}), '()\n', (10075, 10077), False, 'import time\n'), ((657, 683), 'torch.nn.Conv2d', 'nn.Conv2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (666, 683), True, 'import torch.nn as nn\n'), ((767, 804), 'torch.nn.Conv2d', 'nn.Conv2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {'groups': '(32)'}), '(32, 32, 3, 1, 0, groups=32)\n', (776, 804), True, 'import torch.nn as nn\n'), ((863, 889), 'torch.nn.Conv3d', 'nn.Conv3d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (872, 889), True, 'import torch.nn as nn\n'), ((977, 1012), 'torch.nn.ConvTranspose2d', 'nn.ConvTranspose2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (995, 1012), True, 'import torch.nn as nn\n'), ((1068, 1086), 'torch.nn.BatchNorm2d', 'nn.BatchNorm2d', (['(64)'], {}), '(64)\n', (1082, 1086), True, 'import torch.nn as nn\n'), ((1134, 1155), 'torch.nn.Linear', 'nn.Linear', (['(1000)', '(1000)'], {}), '(1000, 1000)\n', (1143, 1155), True, 'import torch.nn as nn\n'), ((10903, 10920), 'torch.Tensor', 'torch.Tensor', (['inp'], {}), '(inp)\n', (10915, 10920), False, 'import torch\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import platform
import numpy as np
import pytest
import megengine as mge
import megengine.distributed as dist
from megengine import Parameter, tensor
from megengine.core._imperative_rt.core2 import sync
from megengine.device import get_default_device, set_default_device
from megengine.functional.distributed import (
all_gather,
all_reduce_max,
all_reduce_min,
all_reduce_sum,
all_to_all,
broadcast,
gather,
reduce_scatter_sum,
reduce_sum,
remote_recv,
remote_send,
scatter,
)
def run_reduce_sum(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = reduce_sum(inp)
if rank == 0:
assert np.allclose(output.numpy(), expect[rank])
else:
assert output is None
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = x + y
data = (x, y)
expect = (z, None)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_reduce_sum_multishape(shape):
run_reduce_sum(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_reduce_sum_multidtype(dtype):
run_reduce_sum((8, 10), dtype)
def run_broadcast(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = broadcast(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = x + 1
data = (x, y)
expect = (x, x)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_broadcast_multishape(shape):
run_broadcast(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_broadcast_multidtype(dtype):
run_broadcast((8, 10), dtype)
def run_all_gather(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = all_gather(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = np.concatenate((x, y))
data = (x, y)
expect = (z, z)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(1,), (2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_all_gather_multishape(shape):
run_all_gather(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_all_gather_multidtype(dtype):
run_all_gather((8, 10), dtype)
def run_reduce_scatter_sum(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = reduce_scatter_sum(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = x + y
data = (x, y)
expect = (z[: shape[0] // 2], z[shape[0] // 2 :])
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(2, 3), (8, 10), (88, 44)], ids=str)
@pytest.mark.isolated_distributed
def test_reduce_scatter_sum_multishape(shape):
run_reduce_scatter_sum(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_reduce_scatter_sum_multidtype(dtype):
run_reduce_scatter_sum((8, 10), dtype)
def run_all_reduce_sum(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = all_reduce_sum(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = x + y
data = (x, y)
expect = (z, z)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_all_reduce_sum_multishape(shape):
run_all_reduce_sum(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_all_reduce_sum_multidtype(dtype):
run_all_reduce_sum((8, 10), dtype)
def run_all_reduce_max(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = all_reduce_max(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = np.maximum(x, y)
data = (x, y)
expect = (z, z)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_all_reduce_max_multishape(shape):
run_all_reduce_max(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_all_reduce_max_multidtype(dtype):
run_all_reduce_max((8, 10), dtype)
def run_all_reduce_min(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = all_reduce_min(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = np.minimum(x, y)
data = (x, y)
expect = (z, z)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_all_reduce_min_multishape(shape):
run_all_reduce_min(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_all_reduce_min_multidtype(dtype):
run_all_reduce_min((8, 10), dtype)
def run_gather(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = gather(inp)
if rank == 0:
assert np.allclose(output.numpy(), expect[rank])
else:
assert output is None
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
z = np.concatenate((x, y))
data = (x, y)
expect = (z, None)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(2, 3), (8, 10), (99, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_gather_multishape(shape):
run_gather(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_gather_multidtype(dtype):
run_gather((8, 10), dtype)
def run_scatter(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = scatter(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = x + 1
data = (x, y)
expect = (x[: shape[0] // 2], x[shape[0] // 2 :])
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(2, 3), (8, 10), (100, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_scatter_multishape(shape):
run_scatter(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_scatter_multidtype(dtype):
run_scatter((8, 10), dtype)
def run_all_to_all(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(data, expect):
rank = dist.get_rank()
inp = tensor(data[rank])
output = all_to_all(inp)
assert np.allclose(output.numpy(), expect[rank])
x = np.random.random_sample(shape).astype(dtype)
y = np.random.random_sample(shape).astype(dtype)
a = np.concatenate((x[: shape[0] // 2], y[: shape[0] // 2]))
b = np.concatenate((x[shape[0] // 2 :], y[shape[0] // 2 :]))
data = (x, y)
expect = (a, b)
worker(data, expect)
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("shape", [(2, 3), (8, 10), (100, 77)], ids=str)
@pytest.mark.isolated_distributed
def test_all_to_all_multishape(shape):
run_all_to_all(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
@pytest.mark.isolated_distributed
def test_all_to_all_multidtype(dtype):
run_all_to_all((8, 10), dtype)
def run_io_remote(shape, dtype):
@dist.launcher(n_gpus=2)
def worker(val, shape):
rank = dist.get_rank()
if rank == 0: # remote send
x = tensor(val, device="xpu0")
remote_send(x, 1)
sync()
else: # remote recv
y = remote_recv(0)
assert y.device == get_default_device()
np.testing.assert_almost_equal(val, y.numpy())
val = np.random.random_sample(shape).astype(dtype)
worker(val, shape)
@pytest.mark.require_ngpu(2)
@pytest.mark.isolated_distributed
@pytest.mark.parametrize("shape", [(), (1,), (4, 5)], ids=str)
def test_io_remote_multishape(shape):
run_io_remote(shape, "float32")
@pytest.mark.require_ngpu(2)
@pytest.mark.isolated_distributed
@pytest.mark.parametrize("dtype", ["float32", "int32", "int8", "uint8"], ids=str)
def test_io_remote_multidtype(dtype):
run_io_remote((8, 10), dtype)
@pytest.mark.require_ngpu(2)
def test_cuda_init_before_fork():
a = mge.tensor(1, device="gpu0")
@dist.launcher(n_gpus=2)
def worker():
a += 1
b = mge.tensor(2)
with pytest.raises(AssertionError):
worker()
|
[
"megengine.functional.distributed.all_reduce_sum",
"megengine.functional.distributed.all_reduce_max",
"megengine.functional.distributed.broadcast",
"megengine.distributed.get_rank",
"megengine.device.get_default_device",
"megengine.functional.distributed.gather",
"megengine.functional.distributed.all_to_all",
"megengine.functional.distributed.remote_send",
"megengine.tensor",
"megengine.core._imperative_rt.core2.sync",
"megengine.functional.distributed.all_reduce_min",
"megengine.functional.distributed.remote_recv",
"megengine.functional.distributed.all_gather",
"megengine.functional.distributed.reduce_scatter_sum",
"megengine.functional.distributed.scatter",
"megengine.distributed.launcher",
"megengine.functional.distributed.reduce_sum"
] |
[((1418, 1445), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (1442, 1445), False, 'import pytest\n'), ((1447, 1532), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(), (1,), (2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str\n )\n", (1470, 1532), False, 'import pytest\n'), ((1641, 1668), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (1665, 1668), False, 'import pytest\n'), ((1670, 1755), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (1693, 1755), False, 'import pytest\n'), ((2240, 2267), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (2264, 2267), False, 'import pytest\n'), ((2269, 2354), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(), (1,), (2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str\n )\n", (2292, 2354), False, 'import pytest\n'), ((2461, 2488), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (2485, 2488), False, 'import pytest\n'), ((2490, 2575), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (2513, 2575), False, 'import pytest\n'), ((3130, 3157), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (3154, 3157), False, 'import pytest\n'), ((3159, 3235), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(1,), (2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(1,), (2, 3), (8, 10), (99, 77)], ids=str)\n", (3182, 3235), False, 'import pytest\n'), ((3349, 3376), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (3373, 3376), False, 'import pytest\n'), ((3378, 3463), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (3401, 3463), False, 'import pytest\n'), ((4053, 4080), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (4077, 4080), False, 'import pytest\n'), ((4082, 4152), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(2, 3), (8, 10), (88, 44)]'], {'ids': 'str'}), "('shape', [(2, 3), (8, 10), (88, 44)], ids=str)\n", (4105, 4152), False, 'import pytest\n'), ((4282, 4309), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (4306, 4309), False, 'import pytest\n'), ((4311, 4396), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (4334, 4396), False, 'import pytest\n'), ((4960, 4987), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (4984, 4987), False, 'import pytest\n'), ((4989, 5074), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(), (1,), (2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str\n )\n", (5012, 5074), False, 'import pytest\n'), ((5191, 5218), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (5215, 5218), False, 'import pytest\n'), ((5220, 5305), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (5243, 5305), False, 'import pytest\n'), ((5872, 5899), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (5896, 5899), False, 'import pytest\n'), ((5901, 5986), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(), (1,), (2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str\n )\n", (5924, 5986), False, 'import pytest\n'), ((6103, 6130), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (6127, 6130), False, 'import pytest\n'), ((6132, 6217), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (6155, 6217), False, 'import pytest\n'), ((6784, 6811), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (6808, 6811), False, 'import pytest\n'), ((6813, 6898), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(), (1,), (2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(), (1,), (2, 3), (8, 10), (99, 77)], ids=str\n )\n", (6836, 6898), False, 'import pytest\n'), ((7015, 7042), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (7039, 7042), False, 'import pytest\n'), ((7044, 7129), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (7067, 7129), False, 'import pytest\n'), ((7763, 7790), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (7787, 7790), False, 'import pytest\n'), ((7792, 7862), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(2, 3), (8, 10), (99, 77)]'], {'ids': 'str'}), "('shape', [(2, 3), (8, 10), (99, 77)], ids=str)\n", (7815, 7862), False, 'import pytest\n'), ((7968, 7995), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (7992, 7995), False, 'import pytest\n'), ((7997, 8082), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (8020, 8082), False, 'import pytest\n'), ((8589, 8616), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (8613, 8616), False, 'import pytest\n'), ((8618, 8689), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(2, 3), (8, 10), (100, 77)]'], {'ids': 'str'}), "('shape', [(2, 3), (8, 10), (100, 77)], ids=str)\n", (8641, 8689), False, 'import pytest\n'), ((8797, 8824), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (8821, 8824), False, 'import pytest\n'), ((8826, 8911), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (8849, 8911), False, 'import pytest\n'), ((9561, 9588), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (9585, 9588), False, 'import pytest\n'), ((9590, 9661), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(2, 3), (8, 10), (100, 77)]'], {'ids': 'str'}), "('shape', [(2, 3), (8, 10), (100, 77)], ids=str)\n", (9613, 9661), False, 'import pytest\n'), ((9775, 9802), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (9799, 9802), False, 'import pytest\n'), ((9804, 9889), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (9827, 9889), False, 'import pytest\n'), ((10498, 10525), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (10522, 10525), False, 'import pytest\n'), ((10561, 10622), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[(), (1,), (4, 5)]'], {'ids': 'str'}), "('shape', [(), (1,), (4, 5)], ids=str)\n", (10584, 10622), False, 'import pytest\n'), ((10700, 10727), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (10724, 10727), False, 'import pytest\n'), ((10763, 10848), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32', 'int32', 'int8', 'uint8']"], {'ids': 'str'}), "('dtype', ['float32', 'int32', 'int8', 'uint8'], ids=str\n )\n", (10786, 10848), False, 'import pytest\n'), ((10919, 10946), 'pytest.mark.require_ngpu', 'pytest.mark.require_ngpu', (['(2)'], {}), '(2)\n', (10943, 10946), False, 'import pytest\n'), ((946, 969), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (959, 969), True, 'import megengine.distributed as dist\n'), ((1899, 1922), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (1912, 1922), True, 'import megengine.distributed as dist\n'), ((2718, 2741), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (2731, 2741), True, 'import megengine.distributed as dist\n'), ((3041, 3063), 'numpy.concatenate', 'np.concatenate', (['(x, y)'], {}), '((x, y))\n', (3055, 3063), True, 'import numpy as np\n'), ((3616, 3639), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (3629, 3639), True, 'import megengine.distributed as dist\n'), ((4561, 4584), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (4574, 4584), True, 'import megengine.distributed as dist\n'), ((5462, 5485), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (5475, 5485), True, 'import megengine.distributed as dist\n'), ((5789, 5805), 'numpy.maximum', 'np.maximum', (['x', 'y'], {}), '(x, y)\n', (5799, 5805), True, 'import numpy as np\n'), ((6374, 6397), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (6387, 6397), True, 'import megengine.distributed as dist\n'), ((6701, 6717), 'numpy.minimum', 'np.minimum', (['x', 'y'], {}), '(x, y)\n', (6711, 6717), True, 'import numpy as np\n'), ((7278, 7301), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (7291, 7301), True, 'import megengine.distributed as dist\n'), ((7671, 7693), 'numpy.concatenate', 'np.concatenate', (['(x, y)'], {}), '((x, y))\n', (7685, 7693), True, 'import numpy as np\n'), ((8216, 8239), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (8229, 8239), True, 'import megengine.distributed as dist\n'), ((9050, 9073), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (9063, 9073), True, 'import megengine.distributed as dist\n'), ((9373, 9427), 'numpy.concatenate', 'np.concatenate', (['(x[:shape[0] // 2], y[:shape[0] // 2])'], {}), '((x[:shape[0] // 2], y[:shape[0] // 2]))\n', (9387, 9427), True, 'import numpy as np\n'), ((9438, 9492), 'numpy.concatenate', 'np.concatenate', (['(x[shape[0] // 2:], y[shape[0] // 2:])'], {}), '((x[shape[0] // 2:], y[shape[0] // 2:]))\n', (9452, 9492), True, 'import numpy as np\n'), ((10033, 10056), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (10046, 10056), True, 'import megengine.distributed as dist\n'), ((10989, 11017), 'megengine.tensor', 'mge.tensor', (['(1)'], {'device': '"""gpu0"""'}), "(1, device='gpu0')\n", (10999, 11017), True, 'import megengine as mge\n'), ((11024, 11047), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': '(2)'}), '(n_gpus=2)\n', (11037, 11047), True, 'import megengine.distributed as dist\n'), ((1015, 1030), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1028, 1030), True, 'import megengine.distributed as dist\n'), ((1045, 1063), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (1051, 1063), False, 'from megengine import Parameter, tensor\n'), ((1081, 1096), 'megengine.functional.distributed.reduce_sum', 'reduce_sum', (['inp'], {}), '(inp)\n', (1091, 1096), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((1968, 1983), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1981, 1983), True, 'import megengine.distributed as dist\n'), ((1998, 2016), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (2004, 2016), False, 'from megengine import Parameter, tensor\n'), ((2034, 2048), 'megengine.functional.distributed.broadcast', 'broadcast', (['inp'], {}), '(inp)\n', (2043, 2048), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((2787, 2802), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2800, 2802), True, 'import megengine.distributed as dist\n'), ((2817, 2835), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (2823, 2835), False, 'from megengine import Parameter, tensor\n'), ((2853, 2868), 'megengine.functional.distributed.all_gather', 'all_gather', (['inp'], {}), '(inp)\n', (2863, 2868), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((3685, 3700), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (3698, 3700), True, 'import megengine.distributed as dist\n'), ((3715, 3733), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (3721, 3733), False, 'from megengine import Parameter, tensor\n'), ((3751, 3774), 'megengine.functional.distributed.reduce_scatter_sum', 'reduce_scatter_sum', (['inp'], {}), '(inp)\n', (3769, 3774), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((4630, 4645), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (4643, 4645), True, 'import megengine.distributed as dist\n'), ((4660, 4678), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (4666, 4678), False, 'from megengine import Parameter, tensor\n'), ((4696, 4715), 'megengine.functional.distributed.all_reduce_sum', 'all_reduce_sum', (['inp'], {}), '(inp)\n', (4710, 4715), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((5531, 5546), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (5544, 5546), True, 'import megengine.distributed as dist\n'), ((5561, 5579), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (5567, 5579), False, 'from megengine import Parameter, tensor\n'), ((5597, 5616), 'megengine.functional.distributed.all_reduce_max', 'all_reduce_max', (['inp'], {}), '(inp)\n', (5611, 5616), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((6443, 6458), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (6456, 6458), True, 'import megengine.distributed as dist\n'), ((6473, 6491), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (6479, 6491), False, 'from megengine import Parameter, tensor\n'), ((6509, 6528), 'megengine.functional.distributed.all_reduce_min', 'all_reduce_min', (['inp'], {}), '(inp)\n', (6523, 6528), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((7347, 7362), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (7360, 7362), True, 'import megengine.distributed as dist\n'), ((7377, 7395), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (7383, 7395), False, 'from megengine import Parameter, tensor\n'), ((7413, 7424), 'megengine.functional.distributed.gather', 'gather', (['inp'], {}), '(inp)\n', (7419, 7424), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((8285, 8300), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (8298, 8300), True, 'import megengine.distributed as dist\n'), ((8315, 8333), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (8321, 8333), False, 'from megengine import Parameter, tensor\n'), ((8351, 8363), 'megengine.functional.distributed.scatter', 'scatter', (['inp'], {}), '(inp)\n', (8358, 8363), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((9119, 9134), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (9132, 9134), True, 'import megengine.distributed as dist\n'), ((9149, 9167), 'megengine.tensor', 'tensor', (['data[rank]'], {}), '(data[rank])\n', (9155, 9167), False, 'from megengine import Parameter, tensor\n'), ((9185, 9200), 'megengine.functional.distributed.all_to_all', 'all_to_all', (['inp'], {}), '(inp)\n', (9195, 9200), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((10100, 10115), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (10113, 10115), True, 'import megengine.distributed as dist\n'), ((11093, 11106), 'megengine.tensor', 'mge.tensor', (['(2)'], {}), '(2)\n', (11103, 11106), True, 'import megengine as mge\n'), ((11117, 11146), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (11130, 11146), False, 'import pytest\n'), ((1237, 1267), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (1260, 1267), True, 'import numpy as np\n'), ((1290, 1320), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (1313, 1320), True, 'import numpy as np\n'), ((2115, 2145), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (2138, 2145), True, 'import numpy as np\n'), ((2935, 2965), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (2958, 2965), True, 'import numpy as np\n'), ((2988, 3018), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (3011, 3018), True, 'import numpy as np\n'), ((3841, 3871), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (3864, 3871), True, 'import numpy as np\n'), ((3894, 3924), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (3917, 3924), True, 'import numpy as np\n'), ((4782, 4812), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (4805, 4812), True, 'import numpy as np\n'), ((4835, 4865), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (4858, 4865), True, 'import numpy as np\n'), ((5683, 5713), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (5706, 5713), True, 'import numpy as np\n'), ((5736, 5766), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (5759, 5766), True, 'import numpy as np\n'), ((6595, 6625), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (6618, 6625), True, 'import numpy as np\n'), ((6648, 6678), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (6671, 6678), True, 'import numpy as np\n'), ((7565, 7595), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (7588, 7595), True, 'import numpy as np\n'), ((7618, 7648), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (7641, 7648), True, 'import numpy as np\n'), ((8430, 8460), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (8453, 8460), True, 'import numpy as np\n'), ((9267, 9297), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (9290, 9297), True, 'import numpy as np\n'), ((9320, 9350), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (9343, 9350), True, 'import numpy as np\n'), ((10169, 10195), 'megengine.tensor', 'tensor', (['val'], {'device': '"""xpu0"""'}), "(val, device='xpu0')\n", (10175, 10195), False, 'from megengine import Parameter, tensor\n'), ((10208, 10225), 'megengine.functional.distributed.remote_send', 'remote_send', (['x', '(1)'], {}), '(x, 1)\n', (10219, 10225), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((10238, 10244), 'megengine.core._imperative_rt.core2.sync', 'sync', ([], {}), '()\n', (10242, 10244), False, 'from megengine.core._imperative_rt.core2 import sync\n'), ((10290, 10304), 'megengine.functional.distributed.remote_recv', 'remote_recv', (['(0)'], {}), '(0)\n', (10301, 10304), False, 'from megengine.functional.distributed import all_gather, all_reduce_max, all_reduce_min, all_reduce_sum, all_to_all, broadcast, gather, reduce_scatter_sum, reduce_sum, remote_recv, remote_send, scatter\n'), ((10427, 10457), 'numpy.random.random_sample', 'np.random.random_sample', (['shape'], {}), '(shape)\n', (10450, 10457), True, 'import numpy as np\n'), ((10336, 10356), 'megengine.device.get_default_device', 'get_default_device', ([], {}), '()\n', (10354, 10356), False, 'from megengine.device import get_default_device, set_default_device\n')]
|
import math
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
def bias_act(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None):
assert clamp is None or clamp >= 0
def_gain = 1.0
if act in ['relu', 'lrelu', 'swish']: # 除了这些激活函数的def_gain = np.sqrt(2)，其余激活函数的def_gain = 1.0
def_gain = np.sqrt(2)
def_alpha = 0.0
if act in ['lrelu']: # 除了这些激活函数的def_alpha = 0.2，其余激活函数的def_alpha = 0.0
def_alpha = 0.2
alpha = float(alpha if alpha is not None else def_alpha)
gain = float(gain if gain is not None else def_gain)
clamp = float(clamp if clamp is not None else -1)
# 加上偏移
if b is not None:
new_shape = [-1 if i == dim else 1 for i in range(x.ndim)]
b_ = F.reshape(b, new_shape)
x = x + b_
x_add_b = x
# 经过激活函数
alpha = float(alpha) # 只有leaky_relu需要
if act == 'linear':
pass
elif act == 'relu':
x = F.relu(x)
elif act == 'lrelu':
x = F.leaky_relu(x, alpha)
elif act == 'tanh':
x = F.tanh(x)
elif act == 'sigmoid':
x = F.sigmoid(x)
elif act == 'elu':
x = F.elu(x)
elif act == 'selu':
x = F.selu(x)
elif act == 'softplus':
x = F.softplus(x)
elif act == 'swish':
x = F.sigmoid(x) * x
else:
raise NotImplementedError("activation \'{}\' is not implemented.".format(act))
act_x = x
# 乘以缩放因子
gain = float(gain)
if gain != 1:
x = x * gain
gain_x = x
# 限制范围
if clamp >= 0:
x = F.clip(x, -clamp, clamp)
clamp_x = x
return clamp_x
class FullyConnectedLayer(M.Module):
def __init__(self,
in_features, # Number of input features.
out_features, # Number of output features.
bias = True, # Apply additive bias before the activation function?
activation = 'linear', # Activation function: 'relu', 'lrelu', etc.
lr_multiplier = 1, # Learning rate multiplier.
bias_init = 0, # Initial value for the additive bias.
):
super().__init__()
self.activation = activation
self.weight = mge.Parameter(mge.tensor(np.random.randn(out_features, in_features).astype(np.float32)) / lr_multiplier)
self.bias = mge.Parameter(mge.tensor(np.ones(out_features, ).astype(np.float32) * bias_init)) if bias else None
self.weight_gain = lr_multiplier / np.sqrt(in_features)
self.weight_gain = float(self.weight_gain)
self.bias_gain = lr_multiplier
def forward(self, x):
# w = self.weight.to(x.dtype) * self.weight_gain
w = self.weight * self.weight_gain
b = self.bias
if b is not None:
# b = b.to(x.dtype)
if self.bias_gain != 1:
b = b * self.bias_gain
if self.activation == 'linear' and b is not None:
out = F.matmul(x, w, transpose_b=True) + F.expand_dims(b, 0)
else:
# r = x.matmul(w.t())
r = F.matmul(x, w, transpose_b=True)
out = bias_act(r, b, act=self.activation)
return out
|
[
"megengine.functional.sigmoid",
"megengine.functional.softplus",
"megengine.functional.matmul",
"megengine.functional.expand_dims",
"megengine.functional.relu",
"megengine.functional.leaky_relu",
"megengine.functional.elu",
"megengine.functional.clip",
"megengine.functional.selu",
"megengine.functional.reshape",
"megengine.functional.tanh"
] |
[((379, 389), 'numpy.sqrt', 'np.sqrt', (['(2)'], {}), '(2)\n', (386, 389), True, 'import numpy as np\n'), ((797, 820), 'megengine.functional.reshape', 'F.reshape', (['b', 'new_shape'], {}), '(b, new_shape)\n', (806, 820), True, 'import megengine.functional as F\n'), ((1597, 1621), 'megengine.functional.clip', 'F.clip', (['x', '(-clamp)', 'clamp'], {}), '(x, -clamp, clamp)\n', (1603, 1621), True, 'import megengine.functional as F\n'), ((986, 995), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (992, 995), True, 'import megengine.functional as F\n'), ((2521, 2541), 'numpy.sqrt', 'np.sqrt', (['in_features'], {}), '(in_features)\n', (2528, 2541), True, 'import numpy as np\n'), ((3110, 3142), 'megengine.functional.matmul', 'F.matmul', (['x', 'w'], {'transpose_b': '(True)'}), '(x, w, transpose_b=True)\n', (3118, 3142), True, 'import megengine.functional as F\n'), ((1033, 1055), 'megengine.functional.leaky_relu', 'F.leaky_relu', (['x', 'alpha'], {}), '(x, alpha)\n', (1045, 1055), True, 'import megengine.functional as F\n'), ((2991, 3023), 'megengine.functional.matmul', 'F.matmul', (['x', 'w'], {'transpose_b': '(True)'}), '(x, w, transpose_b=True)\n', (2999, 3023), True, 'import megengine.functional as F\n'), ((3026, 3045), 'megengine.functional.expand_dims', 'F.expand_dims', (['b', '(0)'], {}), '(b, 0)\n', (3039, 3045), True, 'import megengine.functional as F\n'), ((1092, 1101), 'megengine.functional.tanh', 'F.tanh', (['x'], {}), '(x)\n', (1098, 1101), True, 'import megengine.functional as F\n'), ((1141, 1153), 'megengine.functional.sigmoid', 'F.sigmoid', (['x'], {}), '(x)\n', (1150, 1153), True, 'import megengine.functional as F\n'), ((1189, 1197), 'megengine.functional.elu', 'F.elu', (['x'], {}), '(x)\n', (1194, 1197), True, 'import megengine.functional as F\n'), ((2278, 2320), 'numpy.random.randn', 'np.random.randn', (['out_features', 'in_features'], {}), '(out_features, in_features)\n', (2293, 2320), True, 'import numpy as np\n'), ((1234, 1243), 'megengine.functional.selu', 'F.selu', (['x'], {}), '(x)\n', (1240, 1243), True, 'import megengine.functional as F\n'), ((2403, 2424), 'numpy.ones', 'np.ones', (['out_features'], {}), '(out_features)\n', (2410, 2424), True, 'import numpy as np\n'), ((1284, 1297), 'megengine.functional.softplus', 'F.softplus', (['x'], {}), '(x)\n', (1294, 1297), True, 'import megengine.functional as F\n'), ((1335, 1347), 'megengine.functional.sigmoid', 'F.sigmoid', (['x'], {}), '(x)\n', (1344, 1347), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
"""Test int8 quantizated model on ImageNet.
Note:
* QAT simulate int8 with fp32, gpu only.
* Quantized use real int8, cpu only, a bit slow.
* Results may be slightly different between qat and quantized mode.
"""
import argparse
import time
# pylint: disable=import-error
import models
import megengine as mge
import megengine.data as data
import megengine.data.transform as T
import megengine.distributed as dist
import megengine.functional as F
import megengine.quantization as Q
from megengine.quantization.quantize import quantize, quantize_qat
logger = mge.get_logger(__name__)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-a", "--arch", default="resnet18", type=str)
parser.add_argument("-d", "--data", default=None, type=str)
parser.add_argument("-s", "--save", default="/data/models", type=str)
parser.add_argument(
"-c",
"--checkpoint",
default=None,
type=str,
help="pretrained model to finetune",
)
parser.add_argument(
"-m",
"--mode",
default="qat",
type=str,
choices=["normal", "qat", "quantized"],
help="Quantization Mode\n"
"normal: no quantization, using float32\n"
"qat: quantization aware training, simulate int8\n"
"quantized: convert mode to int8 quantized, inference only",
)
parser.add_argument("-n", "--ngpus", default=None, type=int)
parser.add_argument("-w", "--workers", default=4, type=int)
parser.add_argument("--report-freq", default=50, type=int)
args = parser.parse_args()
world_size = (
dist.helper.get_device_count_by_fork("gpu")
if args.ngpus is None
else args.ngpus
)
world_size = 1 if world_size == 0 else world_size
test_proc = dist.launcher(worker) if world_size > 1 else worker
test_proc(world_size, args)
def worker(world_size, args):
# pylint: disable=too-many-statements
rank = dist.get_rank()
if world_size > 1:
# Initialize distributed process group
logger.info("init distributed process group {} / {}".format(rank, world_size))
model = models.__dict__[args.arch]()
if args.mode != "normal":
quantize_qat(model, qconfig=Q.ema_fakequant_qconfig)
if args.checkpoint:
logger.info("Load pretrained weights from %s", args.checkpoint)
ckpt = mge.load(args.checkpoint)
ckpt = ckpt["state_dict"] if "state_dict" in ckpt else ckpt
model.load_state_dict(ckpt, strict=False)
if args.mode == "quantized":
quantize(model)
# Define valid graph
def valid_func(image, label):
model.eval()
logits = model(image)
loss = F.loss.cross_entropy(logits, label, label_smooth=0.1)
acc1, acc5 = F.topk_accuracy(logits, label, (1, 5))
if dist.is_distributed(): # all_reduce_mean
loss = dist.functional.all_reduce_sum(loss) / dist.get_world_size()
acc1 = dist.functional.all_reduce_sum(acc1) / dist.get_world_size()
acc5 = dist.functional.all_reduce_sum(acc5) / dist.get_world_size()
return loss, acc1, acc5
# Build valid datasets
logger.info("preparing dataset..")
valid_dataset = data.dataset.ImageNet(args.data, train=False)
valid_sampler = data.SequentialSampler(
valid_dataset, batch_size=100, drop_last=False
)
valid_queue = data.DataLoader(
valid_dataset,
sampler=valid_sampler,
transform=T.Compose(
[T.Resize(256), T.CenterCrop(224), T.Normalize(mean=128), T.ToMode("CHW")]
),
num_workers=args.workers,
)
_, valid_acc, valid_acc5 = infer(valid_func, valid_queue, args)
if rank == 0:
logger.info("TEST %f, %f", valid_acc, valid_acc5)
def infer(model, data_queue, args):
objs = AverageMeter("Loss")
top1 = AverageMeter("Acc@1")
top5 = AverageMeter("Acc@5")
total_time = AverageMeter("Time")
t = time.time()
for step, (image, label) in enumerate(data_queue):
n = image.shape[0]
image = mge.tensor(image, dtype="float32")
label = mge.tensor(label, dtype="int32")
loss, acc1, acc5 = model(image, label)
objs.update(loss.numpy()[0], n)
top1.update(100 * acc1.numpy()[0], n)
top5.update(100 * acc5.numpy()[0], n)
total_time.update(time.time() - t)
t = time.time()
if step % args.report_freq == 0 and dist.get_rank() == 0:
logger.info("Step %d, %s %s %s %s", step, objs, top1, top5, total_time)
return objs.avg, top1.avg, top5.avg
class AverageMeter:
"""Computes and stores the average and current value"""
def __init__(self, name, fmt=":.3f"):
self.name = name
self.fmt = fmt
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def __str__(self):
fmtstr = "{name} {val" + self.fmt + "} ({avg" + self.fmt + "})"
return fmtstr.format(**self.__dict__)
if __name__ == "__main__":
main()
|
[
"megengine.distributed.is_distributed",
"megengine.data.transform.ToMode",
"megengine.data.transform.CenterCrop",
"megengine.data.transform.Normalize",
"megengine.data.SequentialSampler",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.data.dataset.ImageNet",
"megengine.data.transform.Resize",
"megengine.tensor",
"megengine.distributed.helper.get_device_count_by_fork",
"megengine.functional.loss.cross_entropy",
"megengine.quantization.quantize.quantize",
"megengine.quantization.quantize.quantize_qat",
"megengine.distributed.functional.all_reduce_sum",
"megengine.functional.topk_accuracy",
"megengine.load",
"megengine.distributed.launcher"
] |
[((950, 974), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (964, 974), True, 'import megengine as mge\n'), ((1002, 1027), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1025, 1027), False, 'import argparse\n'), ((2354, 2369), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2367, 2369), True, 'import megengine.distributed as dist\n'), ((3627, 3672), 'megengine.data.dataset.ImageNet', 'data.dataset.ImageNet', (['args.data'], {'train': '(False)'}), '(args.data, train=False)\n', (3648, 3672), True, 'import megengine.data as data\n'), ((3693, 3763), 'megengine.data.SequentialSampler', 'data.SequentialSampler', (['valid_dataset'], {'batch_size': '(100)', 'drop_last': '(False)'}), '(valid_dataset, batch_size=100, drop_last=False)\n', (3715, 3763), True, 'import megengine.data as data\n'), ((4362, 4373), 'time.time', 'time.time', ([], {}), '()\n', (4371, 4373), False, 'import time\n'), ((2010, 2053), 'megengine.distributed.helper.get_device_count_by_fork', 'dist.helper.get_device_count_by_fork', (['"""gpu"""'], {}), "('gpu')\n", (2046, 2053), True, 'import megengine.distributed as dist\n'), ((2184, 2205), 'megengine.distributed.launcher', 'dist.launcher', (['worker'], {}), '(worker)\n', (2197, 2205), True, 'import megengine.distributed as dist\n'), ((2608, 2660), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['model'], {'qconfig': 'Q.ema_fakequant_qconfig'}), '(model, qconfig=Q.ema_fakequant_qconfig)\n', (2620, 2660), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((2773, 2798), 'megengine.load', 'mge.load', (['args.checkpoint'], {}), '(args.checkpoint)\n', (2781, 2798), True, 'import megengine as mge\n'), ((2959, 2974), 'megengine.quantization.quantize.quantize', 'quantize', (['model'], {}), '(model)\n', (2967, 2974), False, 'from megengine.quantization.quantize import quantize, quantize_qat\n'), ((3101, 3154), 'megengine.functional.loss.cross_entropy', 'F.loss.cross_entropy', (['logits', 'label'], {'label_smooth': '(0.1)'}), '(logits, label, label_smooth=0.1)\n', (3121, 3154), True, 'import megengine.functional as F\n'), ((3176, 3214), 'megengine.functional.topk_accuracy', 'F.topk_accuracy', (['logits', 'label', '(1, 5)'], {}), '(logits, label, (1, 5))\n', (3191, 3214), True, 'import megengine.functional as F\n'), ((3226, 3247), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (3245, 3247), True, 'import megengine.distributed as dist\n'), ((4472, 4506), 'megengine.tensor', 'mge.tensor', (['image'], {'dtype': '"""float32"""'}), "(image, dtype='float32')\n", (4482, 4506), True, 'import megengine as mge\n'), ((4523, 4555), 'megengine.tensor', 'mge.tensor', (['label'], {'dtype': '"""int32"""'}), "(label, dtype='int32')\n", (4533, 4555), True, 'import megengine as mge\n'), ((4792, 4803), 'time.time', 'time.time', ([], {}), '()\n', (4801, 4803), False, 'import time\n'), ((3287, 3323), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['loss'], {}), '(loss)\n', (3317, 3323), True, 'import megengine.distributed as dist\n'), ((3326, 3347), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (3345, 3347), True, 'import megengine.distributed as dist\n'), ((3367, 3403), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['acc1'], {}), '(acc1)\n', (3397, 3403), True, 'import megengine.distributed as dist\n'), ((3406, 3427), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (3425, 3427), True, 'import megengine.distributed as dist\n'), ((3447, 3483), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['acc5'], {}), '(acc5)\n', (3477, 3483), True, 'import megengine.distributed as dist\n'), ((3486, 3507), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (3505, 3507), True, 'import megengine.distributed as dist\n'), ((4763, 4774), 'time.time', 'time.time', ([], {}), '()\n', (4772, 4774), False, 'import time\n'), ((4849, 4864), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (4862, 4864), True, 'import megengine.distributed as dist\n'), ((3909, 3922), 'megengine.data.transform.Resize', 'T.Resize', (['(256)'], {}), '(256)\n', (3917, 3922), True, 'import megengine.data.transform as T\n'), ((3924, 3941), 'megengine.data.transform.CenterCrop', 'T.CenterCrop', (['(224)'], {}), '(224)\n', (3936, 3941), True, 'import megengine.data.transform as T\n'), ((3943, 3964), 'megengine.data.transform.Normalize', 'T.Normalize', ([], {'mean': '(128)'}), '(mean=128)\n', (3954, 3964), True, 'import megengine.data.transform as T\n'), ((3966, 3981), 'megengine.data.transform.ToMode', 'T.ToMode', (['"""CHW"""'], {}), "('CHW')\n", (3974, 3981), True, 'import megengine.data.transform as T\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import multiprocessing as mp
import os
import cv2
import megengine as mge
import megengine.data as data
import megengine.data.dataset as dataset
import megengine.data.transform as T
import megengine.jit as jit
import numpy as np
from tqdm import tqdm
from official.vision.segmentation.deeplabv3plus import DeepLabV3Plus
class Config:
DATA_WORKERS = 4
NUM_CLASSES = 21
IMG_SIZE = 512
IMG_MEAN = [103.530, 116.280, 123.675]
IMG_STD = [57.375, 57.120, 58.395]
VAL_BATCHES = 1
VAL_MULTISCALE = [1.0] # [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
VAL_FLIP = False
VAL_SLIP = False
VAL_SAVE = None
cfg = Config()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-d", "--dataset_dir", type=str, default="/data/datasets/VOC2012",
)
parser.add_argument(
"-m", "--model_path", type=str, default=None, help="eval model file"
)
args = parser.parse_args()
test_loader, test_size = build_dataloader(args.dataset_dir)
print("number of test images: %d" % (test_size))
net = DeepLabV3Plus(class_num=cfg.NUM_CLASSES)
model_dict = mge.load(args.model_path)
net.load_state_dict(model_dict["state_dict"])
print("load model %s" % (args.model_path))
net.eval()
result_list = []
for sample_batched in tqdm(test_loader):
img = sample_batched[0].squeeze()
label = sample_batched[1].squeeze()
pred = evaluate(net, img)
result_list.append({"pred": pred, "gt": label})
if cfg.VAL_SAVE:
save_results(result_list, cfg.VAL_SAVE)
compute_metric(result_list)
def pad_image_to_shape(img, shape, border_mode, value):
margin = np.zeros(4, np.uint32)
pad_height = shape[0] - img.shape[0] if shape[0] - img.shape[0] > 0 else 0
pad_width = shape[1] - img.shape[1] if shape[1] - img.shape[1] > 0 else 0
margin[0] = pad_height // 2
margin[1] = pad_height // 2 + pad_height % 2
margin[2] = pad_width // 2
margin[3] = pad_width // 2 + pad_width % 2
img = cv2.copyMakeBorder(
img, margin[0], margin[1], margin[2], margin[3], border_mode, value=value
)
return img, margin
def eval_single(net, img, is_flip):
@jit.trace(symbolic=True, opt_level=2)
def pred_fun(data, net=None):
net.eval()
pred = net(data)
return pred
data = mge.tensor()
data.set_value(img.transpose(2, 0, 1)[np.newaxis])
pred = pred_fun(data, net=net)
if is_flip:
img_flip = img[:, ::-1, :]
data.set_value(img_flip.transpose(2, 0, 1)[np.newaxis])
pred_flip = pred_fun(data, net=net)
pred = (pred + pred_flip[:, :, :, ::-1]) / 2.0
del pred_flip
pred = pred.numpy().squeeze().transpose(1, 2, 0)
del data
return pred
def evaluate(net, img):
ori_h, ori_w, _ = img.shape
pred_all = np.zeros((ori_h, ori_w, cfg.NUM_CLASSES))
for rate in cfg.VAL_MULTISCALE:
if cfg.VAL_SLIP:
img_scale = cv2.resize(
img, None, fx=rate, fy=rate, interpolation=cv2.INTER_LINEAR
)
val_size = (cfg.IMG_SIZE, cfg.IMG_SIZE)
else:
out_h, out_w = int(cfg.IMG_SIZE * rate), int(cfg.IMG_SIZE * rate)
img_scale = cv2.resize(img, (out_w, out_h), interpolation=cv2.INTER_LINEAR)
val_size = (out_h, out_w)
new_h, new_w, _ = img_scale.shape
if (new_h <= val_size[0]) and (new_h <= val_size[1]):
img_pad, margin = pad_image_to_shape(
img_scale, val_size, cv2.BORDER_CONSTANT, value=0
)
pred = eval_single(net, img_pad, cfg.VAL_FLIP)
pred = pred[
margin[0] : (pred.shape[0] - margin[1]),
margin[2] : (pred.shape[1] - margin[3]),
:,
]
else:
stride_rate = 2 / 3
stride = [int(np.ceil(i * stride_rate)) for i in val_size]
print(img_scale.shape, stride, val_size)
img_pad, margin = pad_image_to_shape(
img_scale, val_size, cv2.BORDER_CONSTANT, value=0
)
pad_h, pad_w = img_pad.shape[:2]
r_grid, c_grid = [
int(np.ceil((ps - cs) / stride)) + 1
for ps, cs, stride in zip(img_pad.shape, val_size, stride)
]
pred_scale = np.zeros((pad_h, pad_w, cfg.NUM_CLASSES))
count_scale = np.zeros((pad_h, pad_w, cfg.NUM_CLASSES))
for grid_yidx in range(r_grid):
for grid_xidx in range(c_grid):
s_x = grid_xidx * stride[1]
s_y = grid_yidx * stride[0]
e_x = min(s_x + val_size[1], pad_w)
e_y = min(s_y + val_size[0], pad_h)
s_x = e_x - val_size[1]
s_y = e_y - val_size[0]
img_sub = img_pad[s_y:e_y, s_x:e_x, :]
timg_pad, tmargin = pad_image_to_shape(
img_sub, val_size, cv2.BORDER_CONSTANT, value=0
)
print(tmargin, timg_pad.shape)
tpred = eval_single(net, timg_pad, cfg.VAL_FLIP)
tpred = tpred[
margin[0] : (tpred.shape[0] - margin[1]),
margin[2] : (tpred.shape[1] - margin[3]),
:,
]
count_scale[s_y:e_y, s_x:e_x, :] += 1
pred_scale[s_y:e_y, s_x:e_x, :] += tpred
pred_scale = pred_scale / count_scale
pred = pred_scale[
margin[0] : (pred_scale.shape[0] - margin[1]),
margin[2] : (pred_scale.shape[1] - margin[3]),
:,
]
pred = cv2.resize(pred, (ori_w, ori_h), interpolation=cv2.INTER_LINEAR)
pred_all = pred_all + pred
pred_all = pred_all / len(cfg.VAL_MULTISCALE)
result = np.argmax(pred_all, axis=2).astype(np.uint8)
return result
def save_results(result_list, save_dir):
if not os.path.exists(save_dir):
os.makedirs(save_dir)
for idx, sample in enumerate(result_list):
file_path = os.path.join(save_dir, "%d.png" % idx)
cv2.imwrite(file_path, sample["pred"])
file_path = os.path.join(save_dir, "%d.gt.png" % idx)
cv2.imwrite(file_path, sample["gt"])
def compute_metric(result_list):
"""
modified from https://github.com/YudeWang/deeplabv3plus-pytorch
"""
TP, P, T = [], [], []
for i in range(cfg.NUM_CLASSES):
TP.append(mp.Value("i", 0, lock=True))
P.append(mp.Value("i", 0, lock=True))
T.append(mp.Value("i", 0, lock=True))
def compare(start, step, TP, P, T):
for idx in tqdm(range(start, len(result_list), step)):
pred = result_list[idx]["pred"]
gt = result_list[idx]["gt"]
cal = gt < 255
mask = (pred == gt) * cal
for i in range(cfg.NUM_CLASSES):
P[i].acquire()
P[i].value += np.sum((pred == i) * cal)
P[i].release()
T[i].acquire()
T[i].value += np.sum((gt == i) * cal)
T[i].release()
TP[i].acquire()
TP[i].value += np.sum((gt == i) * mask)
TP[i].release()
p_list = []
for i in range(8):
p = mp.Process(target=compare, args=(i, 8, TP, P, T))
p.start()
p_list.append(p)
for p in p_list:
p.join()
class_names = dataset.PascalVOC.class_names
IoU = []
for i in range(cfg.NUM_CLASSES):
IoU.append(TP[i].value / (T[i].value + P[i].value - TP[i].value + 1e-10))
for i in range(cfg.NUM_CLASSES):
if i == 0:
print("%11s:%7.3f%%" % ("backbound", IoU[i] * 100), end="\t")
else:
if i % 2 != 1:
print("%11s:%7.3f%%" % (class_names[i - 1], IoU[i] * 100), end="\t")
else:
print("%11s:%7.3f%%" % (class_names[i - 1], IoU[i] * 100))
miou = np.mean(np.array(IoU))
print("\n======================================================")
print("%11s:%7.3f%%" % ("mIoU", miou * 100))
return miou
def build_dataloader(dataset_dir):
val_dataset = dataset.PascalVOC(dataset_dir, "val", order=["image", "mask"])
val_sampler = data.SequentialSampler(val_dataset, cfg.VAL_BATCHES)
val_dataloader = data.DataLoader(
val_dataset,
sampler=val_sampler,
transform=T.Normalize(
mean=cfg.IMG_MEAN, std=cfg.IMG_STD, order=["image", "mask"]
),
num_workers=cfg.DATA_WORKERS,
)
return val_dataloader, val_dataset.__len__()
if __name__ == "__main__":
main()
|
[
"megengine.data.transform.Normalize",
"megengine.data.SequentialSampler",
"megengine.jit.trace",
"megengine.tensor",
"megengine.load",
"megengine.data.dataset.PascalVOC"
] |
[((1066, 1091), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1089, 1091), False, 'import argparse\n'), ((1465, 1505), 'official.vision.segmentation.deeplabv3plus.DeepLabV3Plus', 'DeepLabV3Plus', ([], {'class_num': 'cfg.NUM_CLASSES'}), '(class_num=cfg.NUM_CLASSES)\n', (1478, 1505), False, 'from official.vision.segmentation.deeplabv3plus import DeepLabV3Plus\n'), ((1523, 1548), 'megengine.load', 'mge.load', (['args.model_path'], {}), '(args.model_path)\n', (1531, 1548), True, 'import megengine as mge\n'), ((1710, 1727), 'tqdm.tqdm', 'tqdm', (['test_loader'], {}), '(test_loader)\n', (1714, 1727), False, 'from tqdm import tqdm\n'), ((2077, 2099), 'numpy.zeros', 'np.zeros', (['(4)', 'np.uint32'], {}), '(4, np.uint32)\n', (2085, 2099), True, 'import numpy as np\n'), ((2426, 2523), 'cv2.copyMakeBorder', 'cv2.copyMakeBorder', (['img', 'margin[0]', 'margin[1]', 'margin[2]', 'margin[3]', 'border_mode'], {'value': 'value'}), '(img, margin[0], margin[1], margin[2], margin[3],\n border_mode, value=value)\n', (2444, 2523), False, 'import cv2\n'), ((2600, 2637), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)', 'opt_level': '(2)'}), '(symbolic=True, opt_level=2)\n', (2609, 2637), True, 'import megengine.jit as jit\n'), ((2748, 2760), 'megengine.tensor', 'mge.tensor', ([], {}), '()\n', (2758, 2760), True, 'import megengine as mge\n'), ((3242, 3283), 'numpy.zeros', 'np.zeros', (['(ori_h, ori_w, cfg.NUM_CLASSES)'], {}), '((ori_h, ori_w, cfg.NUM_CLASSES))\n', (3250, 3283), True, 'import numpy as np\n'), ((8680, 8742), 'megengine.data.dataset.PascalVOC', 'dataset.PascalVOC', (['dataset_dir', '"""val"""'], {'order': "['image', 'mask']"}), "(dataset_dir, 'val', order=['image', 'mask'])\n", (8697, 8742), True, 'import megengine.data.dataset as dataset\n'), ((8761, 8813), 'megengine.data.SequentialSampler', 'data.SequentialSampler', (['val_dataset', 'cfg.VAL_BATCHES'], {}), '(val_dataset, cfg.VAL_BATCHES)\n', (8783, 8813), True, 'import megengine.data as data\n'), ((6173, 6237), 'cv2.resize', 'cv2.resize', (['pred', '(ori_w, ori_h)'], {'interpolation': 'cv2.INTER_LINEAR'}), '(pred, (ori_w, ori_h), interpolation=cv2.INTER_LINEAR)\n', (6183, 6237), False, 'import cv2\n'), ((6454, 6478), 'os.path.exists', 'os.path.exists', (['save_dir'], {}), '(save_dir)\n', (6468, 6478), False, 'import os\n'), ((6488, 6509), 'os.makedirs', 'os.makedirs', (['save_dir'], {}), '(save_dir)\n', (6499, 6509), False, 'import os\n'), ((6577, 6615), 'os.path.join', 'os.path.join', (['save_dir', "('%d.png' % idx)"], {}), "(save_dir, '%d.png' % idx)\n", (6589, 6615), False, 'import os\n'), ((6624, 6662), 'cv2.imwrite', 'cv2.imwrite', (['file_path', "sample['pred']"], {}), "(file_path, sample['pred'])\n", (6635, 6662), False, 'import cv2\n'), ((6683, 6724), 'os.path.join', 'os.path.join', (['save_dir', "('%d.gt.png' % idx)"], {}), "(save_dir, '%d.gt.png' % idx)\n", (6695, 6724), False, 'import os\n'), ((6733, 6769), 'cv2.imwrite', 'cv2.imwrite', (['file_path', "sample['gt']"], {}), "(file_path, sample['gt'])\n", (6744, 6769), False, 'import cv2\n'), ((7795, 7844), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'compare', 'args': '(i, 8, TP, P, T)'}), '(target=compare, args=(i, 8, TP, P, T))\n', (7805, 7844), True, 'import multiprocessing as mp\n'), ((8475, 8488), 'numpy.array', 'np.array', (['IoU'], {}), '(IoU)\n', (8483, 8488), True, 'import numpy as np\n'), ((3369, 3440), 'cv2.resize', 'cv2.resize', (['img', 'None'], {'fx': 'rate', 'fy': 'rate', 'interpolation': 'cv2.INTER_LINEAR'}), '(img, None, fx=rate, fy=rate, interpolation=cv2.INTER_LINEAR)\n', (3379, 3440), False, 'import cv2\n'), ((3639, 3702), 'cv2.resize', 'cv2.resize', (['img', '(out_w, out_h)'], {'interpolation': 'cv2.INTER_LINEAR'}), '(img, (out_w, out_h), interpolation=cv2.INTER_LINEAR)\n', (3649, 3702), False, 'import cv2\n'), ((4751, 4792), 'numpy.zeros', 'np.zeros', (['(pad_h, pad_w, cfg.NUM_CLASSES)'], {}), '((pad_h, pad_w, cfg.NUM_CLASSES))\n', (4759, 4792), True, 'import numpy as np\n'), ((4819, 4860), 'numpy.zeros', 'np.zeros', (['(pad_h, pad_w, cfg.NUM_CLASSES)'], {}), '((pad_h, pad_w, cfg.NUM_CLASSES))\n', (4827, 4860), True, 'import numpy as np\n'), ((6337, 6364), 'numpy.argmax', 'np.argmax', (['pred_all'], {'axis': '(2)'}), '(pred_all, axis=2)\n', (6346, 6364), True, 'import numpy as np\n'), ((6970, 6997), 'multiprocessing.Value', 'mp.Value', (['"""i"""', '(0)'], {'lock': '(True)'}), "('i', 0, lock=True)\n", (6978, 6997), True, 'import multiprocessing as mp\n'), ((7016, 7043), 'multiprocessing.Value', 'mp.Value', (['"""i"""', '(0)'], {'lock': '(True)'}), "('i', 0, lock=True)\n", (7024, 7043), True, 'import multiprocessing as mp\n'), ((7062, 7089), 'multiprocessing.Value', 'mp.Value', (['"""i"""', '(0)'], {'lock': '(True)'}), "('i', 0, lock=True)\n", (7070, 7089), True, 'import multiprocessing as mp\n'), ((8920, 8992), 'megengine.data.transform.Normalize', 'T.Normalize', ([], {'mean': 'cfg.IMG_MEAN', 'std': 'cfg.IMG_STD', 'order': "['image', 'mask']"}), "(mean=cfg.IMG_MEAN, std=cfg.IMG_STD, order=['image', 'mask'])\n", (8931, 8992), True, 'import megengine.data.transform as T\n'), ((7450, 7475), 'numpy.sum', 'np.sum', (['((pred == i) * cal)'], {}), '((pred == i) * cal)\n', (7456, 7475), True, 'import numpy as np\n'), ((7568, 7591), 'numpy.sum', 'np.sum', (['((gt == i) * cal)'], {}), '((gt == i) * cal)\n', (7574, 7591), True, 'import numpy as np\n'), ((7686, 7710), 'numpy.sum', 'np.sum', (['((gt == i) * mask)'], {}), '((gt == i) * mask)\n', (7692, 7710), True, 'import numpy as np\n'), ((4279, 4303), 'numpy.ceil', 'np.ceil', (['(i * stride_rate)'], {}), '(i * stride_rate)\n', (4286, 4303), True, 'import numpy as np\n'), ((4603, 4630), 'numpy.ceil', 'np.ceil', (['((ps - cs) / stride)'], {}), '((ps - cs) / stride)\n', (4610, 4630), True, 'import numpy as np\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
from functools import partial
import numpy as np
import pytest
import megengine as mge
import megengine.functional as F
import megengine.module as Float
import megengine.module.qat as QAT
import megengine.module.quantized as Q
from megengine import Parameter, Tensor
from megengine.core.tensor import dtype
from megengine.quantization import (
FakeQuantize,
MinMaxObserver,
QConfig,
QuantMode,
create_qparams,
)
from megengine.quantization.quantize import (
disable_fake_quant,
disable_observer,
propagate_qconfig,
)
min_max_fakequant_qconfig = QConfig(
weight_observer=partial(MinMaxObserver, dtype="qint8_narrow"),
act_observer=partial(MinMaxObserver, dtype="qint8"),
weight_fake_quant=partial(FakeQuantize, dtype="qint8_narrow"),
act_fake_quant=partial(FakeQuantize, dtype="qint8"),
)
def gen_inp_scale():
return np.float32(np.random.rand() + 1)
min_val = np.random.randint(-127, 0, size=(2,)).astype("float32")
max_val = np.random.randint(1, 127, size=(2,)).astype("float32")
weight_scale = np.float32(np.max([-min_val[0], max_val[0]]) / 254 * 2)
act_scale = np.float32(np.max([-min_val[1], max_val[1]]) / 255 * 2)
def quant(x, scale):
inp_dtype = dtype.qint8(scale)
return x.astype(inp_dtype)
def fake_quant(x, scale, qmin, qmax):
x = x / scale
x = F.round(x)
x = F.clip(x, qmin, qmax)
x = x * scale
return x
fake_quant_act = partial(fake_quant, qmin=-128, qmax=127)
fake_quant_weight = partial(fake_quant, qmin=-127, qmax=127)
fake_quant_bias = partial(fake_quant, qmin=-(2 ** 31), qmax=2 ** 31 - 1)
def init_qat_net(net):
if net.with_weight:
net.weight_observer.min_val[...] = Tensor(min_val[0])
net.weight_observer.max_val[...] = Tensor(max_val[0])
if net.with_act:
net.act_observer.min_val[...] = Tensor(min_val[1])
net.act_observer.max_val[...] = Tensor(max_val[1])
def test_quant_stub():
normal_net = Float.QuantStub()
normal_net.eval()
qat_from_float = QAT.QuantStub.from_float_module(normal_net)
qat_from_float.eval()
disable_observer(qat_from_float)
disable_fake_quant(qat_from_float)
qat_net = QAT.QuantStub()
qat_net.eval()
disable_observer(qat_net)
propagate_qconfig(qat_net, min_max_fakequant_qconfig)
init_qat_net(qat_net)
q_net = Q.QuantStub.from_qat_module(qat_net)
q_net.eval()
x = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
normal = normal_net(x)
qat_without_fakequant = qat_from_float(x)
fake_quant_normal = fake_quant_act(normal_net(x), act_scale)
qat = qat_net(x)
q = q_net(x).numpy() * act_scale
np.testing.assert_allclose(qat_without_fakequant, normal)
np.testing.assert_allclose(qat, fake_quant_normal)
np.testing.assert_allclose(q, fake_quant_normal.numpy())
def test_dequant_stub():
normal_net = Float.DequantStub()
normal_net.eval()
qat_from_float = QAT.DequantStub.from_float_module(normal_net)
qat_from_float.eval()
disable_fake_quant(qat_from_float)
disable_observer(qat_from_float)
qat_net = QAT.DequantStub()
qat_net.eval()
disable_observer(qat_net)
propagate_qconfig(qat_net, min_max_fakequant_qconfig)
init_qat_net(qat_net)
q_net = Q.DequantStub.from_qat_module(qat_net)
q_net.eval()
x = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
inp_scale = gen_inp_scale()
x = fake_quant_act(x, inp_scale)
x.qparams.scale = inp_scale
normal = normal_net(x)
qat_without_fakequant = qat_from_float(x)
fake_quant_normal = normal_net(x)
qat = qat_net(x)
q = q_net(quant(x, inp_scale)).numpy()
np.testing.assert_allclose(qat_without_fakequant, normal)
np.testing.assert_allclose(qat, fake_quant_normal)
np.testing.assert_allclose(q, fake_quant_normal.numpy())
@pytest.mark.parametrize("kind", ["cos", "relu", "add", "mul", "fuse_add_relu"])
def test_elemwise(kind):
normal_net = Float.Elemwise(kind)
normal_net.eval()
qat_from_float = QAT.Elemwise.from_float_module(normal_net)
qat_from_float.eval()
disable_observer(qat_from_float)
disable_fake_quant(qat_from_float)
qat_net = QAT.Elemwise(kind)
qat_net.eval()
disable_observer(qat_net)
propagate_qconfig(qat_net, min_max_fakequant_qconfig)
init_qat_net(qat_net)
q_net = Q.Elemwise.from_qat_module(qat_net)
q_net.eval()
x1_scale = np.float32(np.random.rand() + 1)
x1 = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
x1 = fake_quant_act(x1, x1_scale)
x1.qparams.scale = x1_scale
x2_scale = np.float32(np.random.rand() + 1)
x2 = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
x2 = fake_quant_act(x2, x2_scale)
x2.qparams.scale = x2_scale
x1_int8 = quant(x1, x1_scale)
x2_int8 = quant(x2, x2_scale)
# test correctness of `Float`, `QAT` and `Quantized`
if kind in ("add", "mul", "fuse_add_relu"):
normal = normal_net(x1, x2)
qat_without_fakequant = qat_from_float(x1, x2)
fake_quant_normal = fake_quant_act(normal_net(x1, x2), act_scale)
qat = qat_net(x1, x2)
q = q_net(x1_int8, x2_int8).numpy() * act_scale
else:
normal = normal_net(x1)
qat_without_fakequant = qat_from_float(x1)
fake_quant_normal = fake_quant_act(normal_net(x1), act_scale)
qat = qat_net(x1)
q = q_net(x1_int8).numpy() * act_scale
np.testing.assert_allclose(qat_without_fakequant, normal)
np.testing.assert_allclose(qat, fake_quant_normal)
np.testing.assert_allclose(q, fake_quant_normal.numpy())
def test_linear():
normal_net = Float.Linear(3, 3, bias=True)
normal_net.eval()
qat_net = QAT.Linear(3, 3, bias=True)
qat_net.eval()
disable_observer(qat_net)
propagate_qconfig(qat_net, min_max_fakequant_qconfig)
init_qat_net(qat_net)
x = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
inp_scale = gen_inp_scale()
x = fake_quant_act(x, inp_scale)
x.qparams.update(create_qparams(QuantMode.SYMMERTIC, "qint8", inp_scale))
x_int8 = quant(x, inp_scale)
weight = np.random.normal(size=(3, 3)).astype("float32")
bias = np.random.normal(size=(3,)).astype("float32")
normal_net.weight[...] = fake_quant_weight(weight, weight_scale)
normal_net.bias[...] = fake_quant_bias(bias, inp_scale * weight_scale)
qat_net.weight[...] = Parameter(weight)
qat_net.bias[...] = Parameter(bias)
qat_from_float = QAT.Linear.from_float_module(normal_net)
qat_from_float.eval()
disable_fake_quant(qat_from_float)
disable_observer(qat_from_float)
q_net = Q.Linear.from_qat_module(qat_net)
q_net.eval()
normal = normal_net(x)
qat_without_fakequant = qat_from_float(x)
fake_quant_normal = fake_quant_act(normal_net(x), act_scale)
qat = qat_net(x)
q = q_net(x_int8).numpy() * act_scale
np.testing.assert_allclose(qat_without_fakequant, normal)
np.testing.assert_allclose(qat, fake_quant_normal.numpy())
np.testing.assert_allclose(q, fake_quant_normal.numpy())
@pytest.mark.parametrize("module", ["Conv2d", "ConvBn2d", "ConvBnRelu2d"])
def test_conv(module):
normal_net = getattr(Float, module)(3, 3, 3, 1, 1, 1, bias=True)
normal_net.eval()
qat_net = getattr(QAT, module)(3, 3, 3, 1, 1, 1, bias=True)
qat_net.eval()
disable_observer(qat_net)
propagate_qconfig(qat_net, min_max_fakequant_qconfig)
init_qat_net(qat_net)
x = mge.tensor(np.random.normal(size=(1, 3, 3, 3)).astype("float32"))
inp_scale = gen_inp_scale()
x = fake_quant_act(x, inp_scale)
x.qparams.update(create_qparams(QuantMode.SYMMERTIC, "qint8", inp_scale))
x_int8 = quant(x, inp_scale)
weight = np.random.normal(size=(3, 3, 3, 3)).astype("float32")
bias = np.random.normal(size=(1, 3, 1, 1)).astype("float32")
if module in ("ConvBn2d", "ConvBnRelu2d"):
normal_net.conv.weight[...] = fake_quant_weight(weight, weight_scale)
normal_net.conv.bias[...] = fake_quant_bias(bias, inp_scale * weight_scale)
qat_net.conv.weight[...] = Parameter(weight)
qat_net.conv.bias[...] = Parameter(bias)
else:
normal_net.weight[...] = fake_quant_weight(weight, weight_scale)
normal_net.bias[...] = fake_quant_bias(bias, inp_scale * weight_scale)
qat_net.weight[...] = Parameter(weight)
qat_net.bias[...] = Parameter(bias)
qat_from_float = getattr(QAT, module).from_float_module(normal_net)
qat_from_float.eval()
disable_observer(qat_from_float)
disable_fake_quant(qat_from_float)
q_net = getattr(Q, module).from_qat_module(qat_net)
q_net.eval()
normal = normal_net(x)
qat_without_fakequant = qat_from_float(x)
fake_quant_normal = fake_quant_act(normal_net(x), act_scale)
qat = qat_net(x)
q = q_net(x_int8).numpy() * act_scale
np.testing.assert_allclose(qat_without_fakequant, normal, atol=1e-5)
np.testing.assert_allclose(qat, fake_quant_normal, atol=act_scale)
np.testing.assert_allclose(q, fake_quant_normal.numpy(), atol=act_scale)
def test_concat():
normal_net = Float.Concat()
normal_net.eval()
qat_net = QAT.Concat()
qat_net.eval()
disable_observer(qat_net)
propagate_qconfig(qat_net, min_max_fakequant_qconfig)
init_qat_net(qat_net)
inps = []
inps_int8 = []
for i in range(3):
inp_scale = gen_inp_scale()
inps.append(mge.tensor(np.random.normal(size=(3, 3)).astype("float32")))
inps[i] = fake_quant_act(inps[i], inp_scale)
inps[i].qparams.update(create_qparams(QuantMode.SYMMERTIC, "qint8", inp_scale))
inps_int8.append(quant(inps[i], inp_scale))
qat_from_float = QAT.Concat.from_float_module(normal_net)
qat_from_float.eval()
disable_fake_quant(qat_from_float)
disable_observer(qat_from_float)
q_net = Q.Concat.from_qat_module(qat_net)
q_net.eval()
normal = normal_net(inps)
qat_without_fakequant = qat_from_float(inps)
fake_quant_normal = fake_quant_act(normal_net(inps), act_scale)
qat = qat_net(inps)
q = q_net(inps_int8).numpy() * act_scale
np.testing.assert_allclose(qat_without_fakequant, normal)
np.testing.assert_allclose(qat, fake_quant_normal.numpy())
np.testing.assert_allclose(q, fake_quant_normal.numpy())
|
[
"megengine.quantization.quantize.propagate_qconfig",
"megengine.module.Elemwise",
"megengine.module.quantized.Elemwise.from_qat_module",
"megengine.module.qat.Linear",
"megengine.core.tensor.dtype.qint8",
"megengine.module.DequantStub",
"megengine.module.qat.Linear.from_float_module",
"megengine.module.qat.Elemwise",
"megengine.module.quantized.QuantStub.from_qat_module",
"megengine.module.qat.QuantStub",
"megengine.module.quantized.Linear.from_qat_module",
"megengine.module.quantized.DequantStub.from_qat_module",
"megengine.module.qat.Concat",
"megengine.module.qat.Elemwise.from_float_module",
"megengine.Parameter",
"megengine.module.qat.Concat.from_float_module",
"megengine.module.QuantStub",
"megengine.module.qat.DequantStub",
"megengine.module.quantized.Concat.from_qat_module",
"megengine.quantization.quantize.disable_observer",
"megengine.functional.round",
"megengine.module.Linear",
"megengine.module.Concat",
"megengine.module.qat.QuantStub.from_float_module",
"megengine.functional.clip",
"megengine.quantization.quantize.disable_fake_quant",
"megengine.module.qat.DequantStub.from_float_module",
"megengine.Tensor",
"megengine.quantization.create_qparams"
] |
[((1778, 1818), 'functools.partial', 'partial', (['fake_quant'], {'qmin': '(-128)', 'qmax': '(127)'}), '(fake_quant, qmin=-128, qmax=127)\n', (1785, 1818), False, 'from functools import partial\n'), ((1839, 1879), 'functools.partial', 'partial', (['fake_quant'], {'qmin': '(-127)', 'qmax': '(127)'}), '(fake_quant, qmin=-127, qmax=127)\n', (1846, 1879), False, 'from functools import partial\n'), ((1898, 1950), 'functools.partial', 'partial', (['fake_quant'], {'qmin': '(-2 ** 31)', 'qmax': '(2 ** 31 - 1)'}), '(fake_quant, qmin=-2 ** 31, qmax=2 ** 31 - 1)\n', (1905, 1950), False, 'from functools import partial\n'), ((4210, 4289), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""kind"""', "['cos', 'relu', 'add', 'mul', 'fuse_add_relu']"], {}), "('kind', ['cos', 'relu', 'add', 'mul', 'fuse_add_relu'])\n", (4233, 4289), False, 'import pytest\n'), ((7476, 7549), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""module"""', "['Conv2d', 'ConvBn2d', 'ConvBnRelu2d']"], {}), "('module', ['Conv2d', 'ConvBn2d', 'ConvBnRelu2d'])\n", (7499, 7549), False, 'import pytest\n'), ((1571, 1589), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['scale'], {}), '(scale)\n', (1582, 1589), False, 'from megengine.core.tensor import dtype\n'), ((1687, 1697), 'megengine.functional.round', 'F.round', (['x'], {}), '(x)\n', (1694, 1697), True, 'import megengine.functional as F\n'), ((1706, 1727), 'megengine.functional.clip', 'F.clip', (['x', 'qmin', 'qmax'], {}), '(x, qmin, qmax)\n', (1712, 1727), True, 'import megengine.functional as F\n'), ((2307, 2324), 'megengine.module.QuantStub', 'Float.QuantStub', ([], {}), '()\n', (2322, 2324), True, 'import megengine.module as Float\n'), ((2369, 2412), 'megengine.module.qat.QuantStub.from_float_module', 'QAT.QuantStub.from_float_module', (['normal_net'], {}), '(normal_net)\n', (2400, 2412), True, 'import megengine.module.qat as QAT\n'), ((2443, 2475), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_from_float'], {}), '(qat_from_float)\n', (2459, 2475), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((2480, 2514), 'megengine.quantization.quantize.disable_fake_quant', 'disable_fake_quant', (['qat_from_float'], {}), '(qat_from_float)\n', (2498, 2514), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((2530, 2545), 'megengine.module.qat.QuantStub', 'QAT.QuantStub', ([], {}), '()\n', (2543, 2545), True, 'import megengine.module.qat as QAT\n'), ((2569, 2594), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_net'], {}), '(qat_net)\n', (2585, 2594), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((2600, 2653), 'megengine.quantization.quantize.propagate_qconfig', 'propagate_qconfig', (['qat_net', 'min_max_fakequant_qconfig'], {}), '(qat_net, min_max_fakequant_qconfig)\n', (2617, 2653), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((2693, 2729), 'megengine.module.quantized.QuantStub.from_qat_module', 'Q.QuantStub.from_qat_module', (['qat_net'], {}), '(qat_net)\n', (2720, 2729), True, 'import megengine.module.quantized as Q\n'), ((3017, 3074), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat_without_fakequant', 'normal'], {}), '(qat_without_fakequant, normal)\n', (3043, 3074), True, 'import numpy as np\n'), ((3079, 3129), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat', 'fake_quant_normal'], {}), '(qat, fake_quant_normal)\n', (3105, 3129), True, 'import numpy as np\n'), ((3235, 3254), 'megengine.module.DequantStub', 'Float.DequantStub', ([], {}), '()\n', (3252, 3254), True, 'import megengine.module as Float\n'), ((3299, 3344), 'megengine.module.qat.DequantStub.from_float_module', 'QAT.DequantStub.from_float_module', (['normal_net'], {}), '(normal_net)\n', (3332, 3344), True, 'import megengine.module.qat as QAT\n'), ((3375, 3409), 'megengine.quantization.quantize.disable_fake_quant', 'disable_fake_quant', (['qat_from_float'], {}), '(qat_from_float)\n', (3393, 3409), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((3414, 3446), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_from_float'], {}), '(qat_from_float)\n', (3430, 3446), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((3462, 3479), 'megengine.module.qat.DequantStub', 'QAT.DequantStub', ([], {}), '()\n', (3477, 3479), True, 'import megengine.module.qat as QAT\n'), ((3503, 3528), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_net'], {}), '(qat_net)\n', (3519, 3528), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((3534, 3587), 'megengine.quantization.quantize.propagate_qconfig', 'propagate_qconfig', (['qat_net', 'min_max_fakequant_qconfig'], {}), '(qat_net, min_max_fakequant_qconfig)\n', (3551, 3587), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((3627, 3665), 'megengine.module.quantized.DequantStub.from_qat_module', 'Q.DequantStub.from_qat_module', (['qat_net'], {}), '(qat_net)\n', (3656, 3665), True, 'import megengine.module.quantized as Q\n'), ((4033, 4090), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat_without_fakequant', 'normal'], {}), '(qat_without_fakequant, normal)\n', (4059, 4090), True, 'import numpy as np\n'), ((4095, 4145), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat', 'fake_quant_normal'], {}), '(qat, fake_quant_normal)\n', (4121, 4145), True, 'import numpy as np\n'), ((4332, 4352), 'megengine.module.Elemwise', 'Float.Elemwise', (['kind'], {}), '(kind)\n', (4346, 4352), True, 'import megengine.module as Float\n'), ((4397, 4439), 'megengine.module.qat.Elemwise.from_float_module', 'QAT.Elemwise.from_float_module', (['normal_net'], {}), '(normal_net)\n', (4427, 4439), True, 'import megengine.module.qat as QAT\n'), ((4470, 4502), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_from_float'], {}), '(qat_from_float)\n', (4486, 4502), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((4507, 4541), 'megengine.quantization.quantize.disable_fake_quant', 'disable_fake_quant', (['qat_from_float'], {}), '(qat_from_float)\n', (4525, 4541), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((4557, 4575), 'megengine.module.qat.Elemwise', 'QAT.Elemwise', (['kind'], {}), '(kind)\n', (4569, 4575), True, 'import megengine.module.qat as QAT\n'), ((4599, 4624), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_net'], {}), '(qat_net)\n', (4615, 4624), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((4630, 4683), 'megengine.quantization.quantize.propagate_qconfig', 'propagate_qconfig', (['qat_net', 'min_max_fakequant_qconfig'], {}), '(qat_net, min_max_fakequant_qconfig)\n', (4647, 4683), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((4723, 4758), 'megengine.module.quantized.Elemwise.from_qat_module', 'Q.Elemwise.from_qat_module', (['qat_net'], {}), '(qat_net)\n', (4749, 4758), True, 'import megengine.module.quantized as Q\n'), ((5818, 5875), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat_without_fakequant', 'normal'], {}), '(qat_without_fakequant, normal)\n', (5844, 5875), True, 'import numpy as np\n'), ((5880, 5930), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat', 'fake_quant_normal'], {}), '(qat, fake_quant_normal)\n', (5906, 5930), True, 'import numpy as np\n'), ((6030, 6059), 'megengine.module.Linear', 'Float.Linear', (['(3)', '(3)'], {'bias': '(True)'}), '(3, 3, bias=True)\n', (6042, 6059), True, 'import megengine.module as Float\n'), ((6097, 6124), 'megengine.module.qat.Linear', 'QAT.Linear', (['(3)', '(3)'], {'bias': '(True)'}), '(3, 3, bias=True)\n', (6107, 6124), True, 'import megengine.module.qat as QAT\n'), ((6148, 6173), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_net'], {}), '(qat_net)\n', (6164, 6173), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((6179, 6232), 'megengine.quantization.quantize.propagate_qconfig', 'propagate_qconfig', (['qat_net', 'min_max_fakequant_qconfig'], {}), '(qat_net, min_max_fakequant_qconfig)\n', (6196, 6232), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((6798, 6815), 'megengine.Parameter', 'Parameter', (['weight'], {}), '(weight)\n', (6807, 6815), False, 'from megengine import Parameter, Tensor\n'), ((6840, 6855), 'megengine.Parameter', 'Parameter', (['bias'], {}), '(bias)\n', (6849, 6855), False, 'from megengine import Parameter, Tensor\n'), ((6878, 6918), 'megengine.module.qat.Linear.from_float_module', 'QAT.Linear.from_float_module', (['normal_net'], {}), '(normal_net)\n', (6906, 6918), True, 'import megengine.module.qat as QAT\n'), ((6949, 6983), 'megengine.quantization.quantize.disable_fake_quant', 'disable_fake_quant', (['qat_from_float'], {}), '(qat_from_float)\n', (6967, 6983), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((6988, 7020), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_from_float'], {}), '(qat_from_float)\n', (7004, 7020), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((7034, 7067), 'megengine.module.quantized.Linear.from_qat_module', 'Q.Linear.from_qat_module', (['qat_net'], {}), '(qat_net)\n', (7058, 7067), True, 'import megengine.module.quantized as Q\n'), ((7291, 7348), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat_without_fakequant', 'normal'], {}), '(qat_without_fakequant, normal)\n', (7317, 7348), True, 'import numpy as np\n'), ((7752, 7777), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_net'], {}), '(qat_net)\n', (7768, 7777), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((7783, 7836), 'megengine.quantization.quantize.propagate_qconfig', 'propagate_qconfig', (['qat_net', 'min_max_fakequant_qconfig'], {}), '(qat_net, min_max_fakequant_qconfig)\n', (7800, 7836), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((8920, 8952), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_from_float'], {}), '(qat_from_float)\n', (8936, 8952), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((8957, 8991), 'megengine.quantization.quantize.disable_fake_quant', 'disable_fake_quant', (['qat_from_float'], {}), '(qat_from_float)\n', (8975, 8991), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((9272, 9341), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat_without_fakequant', 'normal'], {'atol': '(1e-05)'}), '(qat_without_fakequant, normal, atol=1e-05)\n', (9298, 9341), True, 'import numpy as np\n'), ((9345, 9411), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat', 'fake_quant_normal'], {'atol': 'act_scale'}), '(qat, fake_quant_normal, atol=act_scale)\n', (9371, 9411), True, 'import numpy as np\n'), ((9527, 9541), 'megengine.module.Concat', 'Float.Concat', ([], {}), '()\n', (9539, 9541), True, 'import megengine.module as Float\n'), ((9579, 9591), 'megengine.module.qat.Concat', 'QAT.Concat', ([], {}), '()\n', (9589, 9591), True, 'import megengine.module.qat as QAT\n'), ((9615, 9640), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_net'], {}), '(qat_net)\n', (9631, 9640), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((9646, 9699), 'megengine.quantization.quantize.propagate_qconfig', 'propagate_qconfig', (['qat_net', 'min_max_fakequant_qconfig'], {}), '(qat_net, min_max_fakequant_qconfig)\n', (9663, 9699), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((10115, 10155), 'megengine.module.qat.Concat.from_float_module', 'QAT.Concat.from_float_module', (['normal_net'], {}), '(normal_net)\n', (10143, 10155), True, 'import megengine.module.qat as QAT\n'), ((10186, 10220), 'megengine.quantization.quantize.disable_fake_quant', 'disable_fake_quant', (['qat_from_float'], {}), '(qat_from_float)\n', (10204, 10220), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((10225, 10257), 'megengine.quantization.quantize.disable_observer', 'disable_observer', (['qat_from_float'], {}), '(qat_from_float)\n', (10241, 10257), False, 'from megengine.quantization.quantize import disable_fake_quant, disable_observer, propagate_qconfig\n'), ((10271, 10304), 'megengine.module.quantized.Concat.from_qat_module', 'Q.Concat.from_qat_module', (['qat_net'], {}), '(qat_net)\n', (10295, 10304), True, 'import megengine.module.quantized as Q\n'), ((10543, 10600), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['qat_without_fakequant', 'normal'], {}), '(qat_without_fakequant, normal)\n', (10569, 10600), True, 'import numpy as np\n'), ((963, 1008), 'functools.partial', 'partial', (['MinMaxObserver'], {'dtype': '"""qint8_narrow"""'}), "(MinMaxObserver, dtype='qint8_narrow')\n", (970, 1008), False, 'from functools import partial\n'), ((1027, 1065), 'functools.partial', 'partial', (['MinMaxObserver'], {'dtype': '"""qint8"""'}), "(MinMaxObserver, dtype='qint8')\n", (1034, 1065), False, 'from functools import partial\n'), ((1089, 1132), 'functools.partial', 'partial', (['FakeQuantize'], {'dtype': '"""qint8_narrow"""'}), "(FakeQuantize, dtype='qint8_narrow')\n", (1096, 1132), False, 'from functools import partial\n'), ((1153, 1189), 'functools.partial', 'partial', (['FakeQuantize'], {'dtype': '"""qint8"""'}), "(FakeQuantize, dtype='qint8')\n", (1160, 1189), False, 'from functools import partial\n'), ((1272, 1309), 'numpy.random.randint', 'np.random.randint', (['(-127)', '(0)'], {'size': '(2,)'}), '(-127, 0, size=(2,))\n', (1289, 1309), True, 'import numpy as np\n'), ((1338, 1374), 'numpy.random.randint', 'np.random.randint', (['(1)', '(127)'], {'size': '(2,)'}), '(1, 127, size=(2,))\n', (1355, 1374), True, 'import numpy as np\n'), ((2045, 2063), 'megengine.Tensor', 'Tensor', (['min_val[0]'], {}), '(min_val[0])\n', (2051, 2063), False, 'from megengine import Parameter, Tensor\n'), ((2107, 2125), 'megengine.Tensor', 'Tensor', (['max_val[0]'], {}), '(max_val[0])\n', (2113, 2125), False, 'from megengine import Parameter, Tensor\n'), ((2187, 2205), 'megengine.Tensor', 'Tensor', (['min_val[1]'], {}), '(min_val[1])\n', (2193, 2205), False, 'from megengine import Parameter, Tensor\n'), ((2246, 2264), 'megengine.Tensor', 'Tensor', (['max_val[1]'], {}), '(max_val[1])\n', (2252, 2264), False, 'from megengine import Parameter, Tensor\n'), ((6418, 6473), 'megengine.quantization.create_qparams', 'create_qparams', (['QuantMode.SYMMERTIC', '"""qint8"""', 'inp_scale'], {}), "(QuantMode.SYMMERTIC, 'qint8', inp_scale)\n", (6432, 6473), False, 'from megengine.quantization import FakeQuantize, MinMaxObserver, QConfig, QuantMode, create_qparams\n'), ((8028, 8083), 'megengine.quantization.create_qparams', 'create_qparams', (['QuantMode.SYMMERTIC', '"""qint8"""', 'inp_scale'], {}), "(QuantMode.SYMMERTIC, 'qint8', inp_scale)\n", (8042, 8083), False, 'from megengine.quantization import FakeQuantize, MinMaxObserver, QConfig, QuantMode, create_qparams\n'), ((8496, 8513), 'megengine.Parameter', 'Parameter', (['weight'], {}), '(weight)\n', (8505, 8513), False, 'from megengine import Parameter, Tensor\n'), ((8547, 8562), 'megengine.Parameter', 'Parameter', (['bias'], {}), '(bias)\n', (8556, 8562), False, 'from megengine import Parameter, Tensor\n'), ((8755, 8772), 'megengine.Parameter', 'Parameter', (['weight'], {}), '(weight)\n', (8764, 8772), False, 'from megengine import Parameter, Tensor\n'), ((8801, 8816), 'megengine.Parameter', 'Parameter', (['bias'], {}), '(bias)\n', (8810, 8816), False, 'from megengine import Parameter, Tensor\n'), ((1238, 1254), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (1252, 1254), True, 'import numpy as np\n'), ((1419, 1452), 'numpy.max', 'np.max', (['[-min_val[0], max_val[0]]'], {}), '([-min_val[0], max_val[0]])\n', (1425, 1452), True, 'import numpy as np\n'), ((1487, 1520), 'numpy.max', 'np.max', (['[-min_val[1], max_val[1]]'], {}), '([-min_val[1], max_val[1]])\n', (1493, 1520), True, 'import numpy as np\n'), ((4803, 4819), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (4817, 4819), True, 'import numpy as np\n'), ((4991, 5007), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (5005, 5007), True, 'import numpy as np\n'), ((6523, 6552), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (6539, 6552), True, 'import numpy as np\n'), ((6582, 6609), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3,)'}), '(size=(3,))\n', (6598, 6609), True, 'import numpy as np\n'), ((8133, 8168), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3, 3, 3)'}), '(size=(3, 3, 3, 3))\n', (8149, 8168), True, 'import numpy as np\n'), ((8198, 8233), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(1, 3, 1, 1)'}), '(size=(1, 3, 1, 1))\n', (8214, 8233), True, 'import numpy as np\n'), ((9984, 10039), 'megengine.quantization.create_qparams', 'create_qparams', (['QuantMode.SYMMERTIC', '"""qint8"""', 'inp_scale'], {}), "(QuantMode.SYMMERTIC, 'qint8', inp_scale)\n", (9998, 10039), False, 'from megengine.quantization import FakeQuantize, MinMaxObserver, QConfig, QuantMode, create_qparams\n'), ((2767, 2796), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (2783, 2796), True, 'import numpy as np\n'), ((3703, 3732), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (3719, 3732), True, 'import numpy as np\n'), ((4845, 4874), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (4861, 4874), True, 'import numpy as np\n'), ((5033, 5062), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (5049, 5062), True, 'import numpy as np\n'), ((6279, 6308), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (6295, 6308), True, 'import numpy as np\n'), ((7883, 7918), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(1, 3, 3, 3)'}), '(size=(1, 3, 3, 3))\n', (7899, 7918), True, 'import numpy as np\n'), ((9850, 9879), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (9866, 9879), True, 'import numpy as np\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import argparse
import importlib
import multiprocessing as mp
import os
import sys
import megengine as mge
import megengine.distributed as dist
from basecore.config import ConfigDict
from loguru import logger
from basecls.engine import ClsTester
from basecls.models import build_model, load_model
from basecls.utils import default_logging, registers, set_nccl_env, set_num_threads, setup_logger
def make_parser() -> argparse.ArgumentParser:
"""Build args parser for testing script.
Returns:
The args parser.
"""
parser = argparse.ArgumentParser()
parser.add_argument("-f", "--file", type=str, help="testing process description file")
parser.add_argument("-w", "--weight_file", default=None, type=str, help="weight file")
return parser
@logger.catch
def worker(args: argparse.Namespace):
"""Worker function for testing script.
Args:
args: args for testing script.
"""
logger.info(f"Init process group for gpu{dist.get_rank()} done")
sys.path.append(os.path.dirname(args.file))
module_name = os.path.splitext(os.path.basename(args.file))[0]
current_network = importlib.import_module(module_name)
cfg = current_network.Cfg()
if cfg.output_dir is None:
cfg.output_dir = f"./logs_{module_name}"
cfg.output_dir = os.path.abspath(cfg.output_dir)
if args.weight_file:
cfg.weights = args.weight_file
else:
cfg.weights = os.path.join(cfg.output_dir, "latest.pkl")
cfg.set_mode("freeze")
if dist.get_rank() == 0 and not os.path.exists(cfg.output_dir):
os.makedirs(cfg.output_dir)
dist.group_barrier()
setup_logger(cfg.output_dir, "test_log.txt", to_loguru=True)
logger.info(f"args: {args}")
if cfg.fastrun:
logger.info("Using fastrun mode...")
mge.functional.debug_param.set_execution_strategy("PROFILE")
tester = build(cfg)
tester.test()
def build(cfg: ConfigDict):
"""Build function for testing script.
Args:
cfg: config for testing.
Returns:
A tester.
"""
model = build_model(cfg)
load_model(model, cfg.weights)
model.eval()
default_logging(cfg, model)
dataloader = registers.dataloaders.get(cfg.data.name).build(cfg, False)
# FIXME: need atomic user_pop, maybe in MegEngine 1.5?
# tester = BaseTester(model, dataloader, AccEvaluator())
return ClsTester(cfg, model, dataloader)
def main():
"""Main function for testing script."""
parser = make_parser()
args = parser.parse_args()
mp.set_start_method("spawn")
set_nccl_env()
set_num_threads()
if not os.path.exists(args.file):
raise ValueError("Description file does not exist")
device_count = mge.device.get_device_count("gpu")
if device_count == 0:
logger.warning("No GPU was found, testing on CPU")
worker(args)
elif device_count > 1:
mp_worker = dist.launcher(worker)
mp_worker(args)
else:
worker(args)
if __name__ == "__main__":
main()
|
[
"megengine.distributed.get_rank",
"megengine.functional.debug_param.set_execution_strategy",
"megengine.device.get_device_count",
"megengine.distributed.group_barrier",
"megengine.distributed.launcher"
] |
[((632, 657), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (655, 657), False, 'import argparse\n'), ((1220, 1256), 'importlib.import_module', 'importlib.import_module', (['module_name'], {}), '(module_name)\n', (1243, 1256), False, 'import importlib\n'), ((1390, 1421), 'os.path.abspath', 'os.path.abspath', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (1405, 1421), False, 'import os\n'), ((1699, 1719), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (1717, 1719), True, 'import megengine.distributed as dist\n'), ((1725, 1785), 'basecls.utils.setup_logger', 'setup_logger', (['cfg.output_dir', '"""test_log.txt"""'], {'to_loguru': '(True)'}), "(cfg.output_dir, 'test_log.txt', to_loguru=True)\n", (1737, 1785), False, 'from basecls.utils import default_logging, registers, set_nccl_env, set_num_threads, setup_logger\n'), ((1790, 1818), 'loguru.logger.info', 'logger.info', (['f"""args: {args}"""'], {}), "(f'args: {args}')\n", (1801, 1818), False, 'from loguru import logger\n'), ((2165, 2181), 'basecls.models.build_model', 'build_model', (['cfg'], {}), '(cfg)\n', (2176, 2181), False, 'from basecls.models import build_model, load_model\n'), ((2186, 2216), 'basecls.models.load_model', 'load_model', (['model', 'cfg.weights'], {}), '(model, cfg.weights)\n', (2196, 2216), False, 'from basecls.models import build_model, load_model\n'), ((2239, 2266), 'basecls.utils.default_logging', 'default_logging', (['cfg', 'model'], {}), '(cfg, model)\n', (2254, 2266), False, 'from basecls.utils import default_logging, registers, set_nccl_env, set_num_threads, setup_logger\n'), ((2475, 2508), 'basecls.engine.ClsTester', 'ClsTester', (['cfg', 'model', 'dataloader'], {}), '(cfg, model, dataloader)\n', (2484, 2508), False, 'from basecls.engine import ClsTester\n'), ((2630, 2658), 'multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (2649, 2658), True, 'import multiprocessing as mp\n'), ((2664, 2678), 'basecls.utils.set_nccl_env', 'set_nccl_env', ([], {}), '()\n', (2676, 2678), False, 'from basecls.utils import default_logging, registers, set_nccl_env, set_num_threads, setup_logger\n'), ((2683, 2700), 'basecls.utils.set_num_threads', 'set_num_threads', ([], {}), '()\n', (2698, 2700), False, 'from basecls.utils import default_logging, registers, set_nccl_env, set_num_threads, setup_logger\n'), ((2820, 2854), 'megengine.device.get_device_count', 'mge.device.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (2847, 2854), True, 'import megengine as mge\n'), ((1103, 1129), 'os.path.dirname', 'os.path.dirname', (['args.file'], {}), '(args.file)\n', (1118, 1129), False, 'import os\n'), ((1519, 1561), 'os.path.join', 'os.path.join', (['cfg.output_dir', '"""latest.pkl"""'], {}), "(cfg.output_dir, 'latest.pkl')\n", (1531, 1561), False, 'import os\n'), ((1667, 1694), 'os.makedirs', 'os.makedirs', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (1678, 1694), False, 'import os\n'), ((1848, 1884), 'loguru.logger.info', 'logger.info', (['"""Using fastrun mode..."""'], {}), "('Using fastrun mode...')\n", (1859, 1884), False, 'from loguru import logger\n'), ((1893, 1953), 'megengine.functional.debug_param.set_execution_strategy', 'mge.functional.debug_param.set_execution_strategy', (['"""PROFILE"""'], {}), "('PROFILE')\n", (1942, 1953), True, 'import megengine as mge\n'), ((2713, 2738), 'os.path.exists', 'os.path.exists', (['args.file'], {}), '(args.file)\n', (2727, 2738), False, 'import os\n'), ((2890, 2940), 'loguru.logger.warning', 'logger.warning', (['"""No GPU was found, testing on CPU"""'], {}), "('No GPU was found, testing on CPU')\n", (2904, 2940), False, 'from loguru import logger\n'), ((1166, 1193), 'os.path.basename', 'os.path.basename', (['args.file'], {}), '(args.file)\n', (1182, 1193), False, 'import os\n'), ((1598, 1613), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1611, 1613), True, 'import megengine.distributed as dist\n'), ((1627, 1657), 'os.path.exists', 'os.path.exists', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (1641, 1657), False, 'import os\n'), ((2285, 2325), 'basecls.utils.registers.dataloaders.get', 'registers.dataloaders.get', (['cfg.data.name'], {}), '(cfg.data.name)\n', (2310, 2325), False, 'from basecls.utils import default_logging, registers, set_nccl_env, set_num_threads, setup_logger\n'), ((3009, 3030), 'megengine.distributed.launcher', 'dist.launcher', (['worker'], {}), '(worker)\n', (3022, 3030), True, 'import megengine.distributed as dist\n'), ((1058, 1073), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1071, 1073), True, 'import megengine.distributed as dist\n')]
|
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.functional as F
import megengine.module as M
__all__ = ["fuse_conv_and_bn", "fuse_model", "replace_module"]
def fuse_conv_and_bn(conv, bn):
# Fuse convolution and batchnorm layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
fusedconv = M.Conv2d(
conv.in_channels,
conv.out_channels,
kernel_size=conv.kernel_size,
stride=conv.stride,
padding=conv.padding,
groups=conv.groups,
bias=True,
)
# fused_conv.weight = bn.weight / running_var * conv.weight
w_conv = conv.weight.reshape(conv.out_channels, -1)
factor = (bn.weight / F.sqrt(bn.eps + bn.running_var)).reshape(-1)
# diag_factor = diag(factor)
fusedconv.weight = mge.Parameter(
(factor.reshape(-1, 1) * w_conv).reshape(fusedconv.weight.shape)
)
# fused_conv.bias = bn.bias + (conv.bias - running_mean) * bn.weight / runing_var
conv_bias = F.zeros(bn.running_mean.shape) if conv.bias is None else conv.bias
fuse_bias = bn.bias + (conv_bias - bn.running_mean) * factor.reshape(1, -1, 1, 1)
fusedconv.bias = mge.Parameter(fuse_bias)
return fusedconv
def fuse_model(model):
from yolox.models.network_blocks import BaseConv
for m in model.modules():
if type(m) is BaseConv and hasattr(m, "bn"):
m.conv = fuse_conv_and_bn(m.conv, m.bn) # update conv
delattr(m, "bn") # remove batchnorm
m.forward = m.fuseforward # update forward
return model
def replace_module(module, replaced_module_type, new_module_type, replace_func=None):
"""
Replace given type in module to a new type. mostly used in deploy.
Args:
module (nn.Module): model to apply replace operation.
replaced_module_type (Type): module type to be replaced.
new_module_type (Type)
replace_func (function): python function to describe replace logic. Defalut value None.
Returns:
model (nn.Module): module that already been replaced.
"""
def default_replace_func(replaced_module_type, new_module_type):
return new_module_type()
if replace_func is None:
replace_func = default_replace_func
model = module
if isinstance(module, replaced_module_type):
model = replace_func(replaced_module_type, new_module_type)
else: # recurrsively replace
for name, child in module.named_children():
new_child = replace_module(child, replaced_module_type, new_module_type)
if new_child is not child: # child is already replaced
model.add_module(name, new_child)
return model
|
[
"megengine.functional.zeros",
"megengine.Parameter",
"megengine.functional.sqrt",
"megengine.module.Conv2d"
] |
[((403, 555), 'megengine.module.Conv2d', 'M.Conv2d', (['conv.in_channels', 'conv.out_channels'], {'kernel_size': 'conv.kernel_size', 'stride': 'conv.stride', 'padding': 'conv.padding', 'groups': 'conv.groups', 'bias': '(True)'}), '(conv.in_channels, conv.out_channels, kernel_size=conv.kernel_size,\n stride=conv.stride, padding=conv.padding, groups=conv.groups, bias=True)\n', (411, 555), True, 'import megengine.module as M\n'), ((1234, 1258), 'megengine.Parameter', 'mge.Parameter', (['fuse_bias'], {}), '(fuse_bias)\n', (1247, 1258), True, 'import megengine as mge\n'), ((1060, 1090), 'megengine.functional.zeros', 'F.zeros', (['bn.running_mean.shape'], {}), '(bn.running_mean.shape)\n', (1067, 1090), True, 'import megengine.functional as F\n'), ((762, 793), 'megengine.functional.sqrt', 'F.sqrt', (['(bn.eps + bn.running_var)'], {}), '(bn.eps + bn.running_var)\n', (768, 793), True, 'import megengine.functional as F\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.module as M
import numpy as np
import pytest
from basecls.layers import ClsHead, MBV3Head, VGGHead, build_head
@pytest.mark.parametrize("w_in", [4])
@pytest.mark.parametrize(
"head_args",
[
None,
dict(name=None),
dict(name="ClsHead", w_out=8),
dict(name="ClsHead", w_out=8, width=8, norm_name="BN", act_name="relu"),
dict(name="ClsHead", w_out=8, width=8, norm_name="BN", act_name="relu", bias=False),
dict(name="VGGHead", w_out=8, width=8),
dict(name="VGGHead", w_out=8, width=8, dropout_prob=0.5, act_name="relu"),
dict(name="MBV3Head", w_out=8, width=8, w_h=16, norm_name="BN", act_name="relu"),
dict(name="MBV3Head", w_out=8, width=8, w_h=16, norm_name="BN", act_name="relu", se_r=0.25),
dict(
name="MBV3Head",
w_out=8,
width=8,
w_h=16,
norm_name="BN",
act_name="relu",
se_r=0.25,
bias=False,
),
],
)
@pytest.mark.parametrize("norm_name", ["BN"])
@pytest.mark.parametrize("act_name", ["relu"])
def test_build_head(w_in, head_args, norm_name, act_name):
m = build_head(w_in, head_args, norm_name, act_name)
if head_args is None or head_args.get("name") is None:
assert m is None
else:
assert isinstance(m, M.Module)
def test_cls_head():
C = 4
K = 8
x = np.random.rand(2, C, 8, 8).astype("float32")
y = ClsHead(C, K)(mge.Tensor(x)).numpy()
assert len(y.shape) == 2 and y.shape[1] == K
def test_mbv3_head():
C = 4
K = 8
x = np.random.rand(2, C, 8, 8).astype("float32")
y = MBV3Head(C, K, 8, 16)(mge.Tensor(x)).numpy()
assert len(y.shape) == 2 and y.shape[1] == K
def test_vgg_head():
C = 4
K = 8
x = np.random.rand(2, C, 8, 8).astype("float32")
y = VGGHead(C, K, 8)(mge.Tensor(x)).numpy()
assert len(y.shape) == 2 and y.shape[1] == K
|
[
"megengine.Tensor"
] |
[((238, 274), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[4]'], {}), "('w_in', [4])\n", (261, 274), False, 'import pytest\n'), ((1128, 1172), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""norm_name"""', "['BN']"], {}), "('norm_name', ['BN'])\n", (1151, 1172), False, 'import pytest\n'), ((1174, 1219), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""act_name"""', "['relu']"], {}), "('act_name', ['relu'])\n", (1197, 1219), False, 'import pytest\n'), ((1287, 1335), 'basecls.layers.build_head', 'build_head', (['w_in', 'head_args', 'norm_name', 'act_name'], {}), '(w_in, head_args, norm_name, act_name)\n', (1297, 1335), False, 'from basecls.layers import ClsHead, MBV3Head, VGGHead, build_head\n'), ((1521, 1547), 'numpy.random.rand', 'np.random.rand', (['(2)', 'C', '(8)', '(8)'], {}), '(2, C, 8, 8)\n', (1535, 1547), True, 'import numpy as np\n'), ((1713, 1739), 'numpy.random.rand', 'np.random.rand', (['(2)', 'C', '(8)', '(8)'], {}), '(2, C, 8, 8)\n', (1727, 1739), True, 'import numpy as np\n'), ((1912, 1938), 'numpy.random.rand', 'np.random.rand', (['(2)', 'C', '(8)', '(8)'], {}), '(2, C, 8, 8)\n', (1926, 1938), True, 'import numpy as np\n'), ((1574, 1587), 'basecls.layers.ClsHead', 'ClsHead', (['C', 'K'], {}), '(C, K)\n', (1581, 1587), False, 'from basecls.layers import ClsHead, MBV3Head, VGGHead, build_head\n'), ((1588, 1601), 'megengine.Tensor', 'mge.Tensor', (['x'], {}), '(x)\n', (1598, 1601), True, 'import megengine as mge\n'), ((1766, 1787), 'basecls.layers.MBV3Head', 'MBV3Head', (['C', 'K', '(8)', '(16)'], {}), '(C, K, 8, 16)\n', (1774, 1787), False, 'from basecls.layers import ClsHead, MBV3Head, VGGHead, build_head\n'), ((1788, 1801), 'megengine.Tensor', 'mge.Tensor', (['x'], {}), '(x)\n', (1798, 1801), True, 'import megengine as mge\n'), ((1965, 1981), 'basecls.layers.VGGHead', 'VGGHead', (['C', 'K', '(8)'], {}), '(C, K, 8)\n', (1972, 1981), False, 'from basecls.layers import ClsHead, MBV3Head, VGGHead, build_head\n'), ((1982, 1995), 'megengine.Tensor', 'mge.Tensor', (['x'], {}), '(x)\n', (1992, 1995), True, 'import megengine as mge\n')]
|
import os
import os.path as osp
import bisect
import argparse
import multiprocessing as mp
import numpy as np
from tqdm import tqdm
import megengine as mge
from megengine import distributed as dist
from megengine import optimizer as optim
import megengine.autodiff as autodiff
from megengine import jit
import dataset, network
from config import config as cfg
from misc_utils import ensure_dir
import socket
import pdb
ensure_dir(cfg.output_dir)
logger = mge.get_logger(__name__)
log_path = osp.join(cfg.output_dir, 'logger.log')
mge.set_log_file(log_path, mode='a')
def find_free_port():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("", 0))
port = sock.getsockname()[1]
sock.close()
return port
def allreduce_cb(param, grad, group=dist.WORLD):
return dist.functional.all_reduce_sum(grad, group) / group.size
def train_one_epoch(model, gm, data_iter, opt, max_steps, rank, epoch_id, gpu_num):
# @jit.trace(symbolic=False,)
def propagate():
with gm:
loss_dict = model(model.inputs)
total_loss = sum([loss_dict[key].mean() for key in loss_dict.keys()])
gm.backward(total_loss)
opt.step().clear_grad()
loss_dict['total_loss'] = total_loss
return loss_dict
for step in range(max_steps):
# learing rate
if epoch_id == 0 and step < cfg.warm_iters:
base_lr = (
cfg.basic_lr * gpu_num * cfg.batch_per_gpu
* (cfg.lr_decay_rate ** bisect.bisect_right(cfg.lr_decay_sates, epoch_id)
)
)
lr_factor = (step + 1.0) / cfg.warm_iters
for param_group in opt.param_groups:
param_group['lr'] = (0.33 + 0.67 * lr_factor) * base_lr
mini_batch = next(data_iter)
im_info = mini_batch["im_info"]
image = mini_batch["data"][:, :, :int(im_info[0, 0]), :int(im_info[0, 1])]
model.inputs["image"].set_value(image)
model.inputs["gt_boxes"].set_value(mini_batch["boxes"])
model.inputs["im_info"].set_value(mini_batch["im_info"])
del mini_batch
losses = propagate()
print_str = ' '
for loss_name, loss_value in losses.items():
print_str += ', {}: {:.4f}'.format(loss_name, loss_value.numpy())
if rank == 0:
if step % cfg.log_dump_interval == 0:
logger.info(
"epoch-{}, {}/{}, lr: {:.4f}{}.\n{}".format(
epoch_id,
step,
max_steps,
opt.param_groups[0]["lr"],
print_str,
cfg.workspace,
)
)
def worker(rank, gpu_num, args):
# using sublinear
os.environ["MGB_COMP_GRAPH_OPT"] = "enable_sublinear_memory_opt=1;seq_opt.enable_seq_comp_node_opt=0"
os.environ["MGB_SUBLINEAR_MEMORY_GENETIC_NR_ITER"] = '10'
os.environ['MGB_CUDA_RESERVE_MEMORY'] = '1'
# establish the server if is the master
dist_port = args.port
if rank == 0:
dist.Server(port=dist_port)
if gpu_num> 1:
dist.init_process_group(
master_ip="localhost",
port=dist_port,
world_size=gpu_num,
rank=rank,
device=rank,
)
logger.info("Init process group for gpu%d done", rank)
model = network.Network()
params = model.parameters(requires_grad=True)
model.train()
# Autodiff gradient manager
gm = autodiff.GradManager().attach(
model.parameters(),
callbacks=allreduce_cb,
)
opt = optim.SGD(
params,
lr=cfg.basic_lr * gpu_num * cfg.batch_per_gpu,
momentum=cfg.momentum,
weight_decay=cfg.weight_decay,
)
if cfg.pretrain_weight is not None:
weights = mge.load(cfg.pretrain_weight)
del weights['fc.weight']
del weights['fc.bias']
model.resnet50.load_state_dict(weights)
start_epoch = 0
if args.resume_weights is not None:
assert osp.exists(args.resume_weights)
model_file = args.resume_weights
model_dict = mge.load(model_file)
start_epoch, weights = model_dict['epoch'] + 1, model_dict['state_dict']
model.load_state_dict(weights, strict=False)
logger.info("Prepare dataset")
train_loader = dataset.train_dataset(rank)
logger.info("Training...")
for epoch_id in range(start_epoch, cfg.max_epoch):
for param_group in opt.param_groups:
param_group["lr"] = (
cfg.basic_lr * gpu_num * cfg.batch_per_gpu
* (cfg.lr_decay_rate ** bisect.bisect_right(cfg.lr_decay_sates, epoch_id))
)
max_steps = cfg.nr_images_epoch // (cfg.batch_per_gpu * gpu_num)
train_one_epoch(model, gm, train_loader, opt, max_steps, rank, epoch_id, gpu_num)
if rank == 0:
save_path = osp.join(cfg.model_dir, 'epoch-{}.pkl'.format(epoch_id + 1))
state_dict = model.state_dict()
names = [k for k, _ in state_dict.items()]
for name in names:
if name.startswith('inputs.'):
del state_dict[name]
mge.save(
{"epoch": epoch_id, "state_dict": state_dict}, save_path,
)
logger.info("dump weights to %s", save_path)
def train(args):
# ------------------------ begin training -------------------------- #
valid_nr_dev = mge.get_device_count("gpu")
gpu_num = min(valid_nr_dev, args.num_gpus)
assert gpu_num > 0
logger.info('Device Count: {}'.format(gpu_num))
ensure_dir(cfg.model_dir)
if not osp.exists('output'):
os.symlink(cfg.output_dir,'output')
if gpu_num > 1:
args.port =find_free_port()
mp.set_start_method("spawn")
processes = list()
for i in range(gpu_num):
process = mp.Process(target=worker, args=(i, gpu_num, args))
process.start()
processes.append(process)
for p in processes:
p.join()
else:
worker(0, 1, args)
def run_train():
parser = argparse.ArgumentParser()
parser.add_argument("--num_gpus", "-d", default=-1, type=int, help="total number of gpus for training")
parser.add_argument('--resume_weights', '-r', default=None, type=str)
parser.add_argument('--progressbar', '-p', action='store_true', default=False)
parser.add_argument('--port', '-pt', type=int, default=11123)
args = parser.parse_args()
train(args)
if __name__ == '__main__':
run_train()
|
[
"megengine.set_log_file",
"megengine.get_device_count",
"megengine.save",
"megengine.get_logger",
"megengine.optimizer.SGD",
"megengine.distributed.functional.all_reduce_sum",
"megengine.distributed.init_process_group",
"megengine.autodiff.GradManager",
"megengine.distributed.Server",
"megengine.load"
] |
[((420, 446), 'misc_utils.ensure_dir', 'ensure_dir', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (430, 446), False, 'from misc_utils import ensure_dir\n'), ((456, 480), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (470, 480), True, 'import megengine as mge\n'), ((492, 530), 'os.path.join', 'osp.join', (['cfg.output_dir', '"""logger.log"""'], {}), "(cfg.output_dir, 'logger.log')\n", (500, 530), True, 'import os.path as osp\n'), ((531, 567), 'megengine.set_log_file', 'mge.set_log_file', (['log_path'], {'mode': '"""a"""'}), "(log_path, mode='a')\n", (547, 567), True, 'import megengine as mge\n'), ((603, 652), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (616, 652), False, 'import socket\n'), ((3444, 3461), 'network.Network', 'network.Network', ([], {}), '()\n', (3459, 3461), False, 'import dataset, network\n'), ((3680, 3803), 'megengine.optimizer.SGD', 'optim.SGD', (['params'], {'lr': '(cfg.basic_lr * gpu_num * cfg.batch_per_gpu)', 'momentum': 'cfg.momentum', 'weight_decay': 'cfg.weight_decay'}), '(params, lr=cfg.basic_lr * gpu_num * cfg.batch_per_gpu, momentum=\n cfg.momentum, weight_decay=cfg.weight_decay)\n', (3689, 3803), True, 'from megengine import optimizer as optim\n'), ((4423, 4450), 'dataset.train_dataset', 'dataset.train_dataset', (['rank'], {}), '(rank)\n', (4444, 4450), False, 'import dataset, network\n'), ((5549, 5576), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (5569, 5576), True, 'import megengine as mge\n'), ((5704, 5729), 'misc_utils.ensure_dir', 'ensure_dir', (['cfg.model_dir'], {}), '(cfg.model_dir)\n', (5714, 5729), False, 'from misc_utils import ensure_dir\n'), ((6224, 6249), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (6247, 6249), False, 'import argparse\n'), ((803, 846), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['grad', 'group'], {}), '(grad, group)\n', (833, 846), True, 'from megengine import distributed as dist\n'), ((3134, 3161), 'megengine.distributed.Server', 'dist.Server', ([], {'port': 'dist_port'}), '(port=dist_port)\n', (3145, 3161), True, 'from megengine import distributed as dist\n'), ((3190, 3301), 'megengine.distributed.init_process_group', 'dist.init_process_group', ([], {'master_ip': '"""localhost"""', 'port': 'dist_port', 'world_size': 'gpu_num', 'rank': 'rank', 'device': 'rank'}), "(master_ip='localhost', port=dist_port, world_size=\n gpu_num, rank=rank, device=rank)\n", (3213, 3301), True, 'from megengine import distributed as dist\n'), ((3897, 3926), 'megengine.load', 'mge.load', (['cfg.pretrain_weight'], {}), '(cfg.pretrain_weight)\n', (3905, 3926), True, 'import megengine as mge\n'), ((4115, 4146), 'os.path.exists', 'osp.exists', (['args.resume_weights'], {}), '(args.resume_weights)\n', (4125, 4146), True, 'import os.path as osp\n'), ((4209, 4229), 'megengine.load', 'mge.load', (['model_file'], {}), '(model_file)\n', (4217, 4229), True, 'import megengine as mge\n'), ((5742, 5762), 'os.path.exists', 'osp.exists', (['"""output"""'], {}), "('output')\n", (5752, 5762), True, 'import os.path as osp\n'), ((5772, 5808), 'os.symlink', 'os.symlink', (['cfg.output_dir', '"""output"""'], {}), "(cfg.output_dir, 'output')\n", (5782, 5808), False, 'import os\n'), ((5873, 5901), 'multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (5892, 5901), True, 'import multiprocessing as mp\n'), ((3572, 3594), 'megengine.autodiff.GradManager', 'autodiff.GradManager', ([], {}), '()\n', (3592, 3594), True, 'import megengine.autodiff as autodiff\n'), ((5282, 5348), 'megengine.save', 'mge.save', (["{'epoch': epoch_id, 'state_dict': state_dict}", 'save_path'], {}), "({'epoch': epoch_id, 'state_dict': state_dict}, save_path)\n", (5290, 5348), True, 'import megengine as mge\n'), ((5984, 6034), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(i, gpu_num, args)'}), '(target=worker, args=(i, gpu_num, args))\n', (5994, 6034), True, 'import multiprocessing as mp\n'), ((1531, 1580), 'bisect.bisect_right', 'bisect.bisect_right', (['cfg.lr_decay_sates', 'epoch_id'], {}), '(cfg.lr_decay_sates, epoch_id)\n', (1550, 1580), False, 'import bisect\n'), ((4715, 4764), 'bisect.bisect_right', 'bisect.bisect_right', (['cfg.lr_decay_sates', 'epoch_id'], {}), '(cfg.lr_decay_sates, epoch_id)\n', (4734, 4764), False, 'import bisect\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
"""Finetune a pretrained fp32 with int8 post train quantization(calibration)"""
import argparse
import collections
import numbers
import os
import time
# pylint: disable=import-error
import models
import megengine as mge
import megengine.data as data
import megengine.data.transform as T
import megengine.distributed as dist
import megengine.functional as F
import megengine.quantization as Q
from megengine.quantization.quantize import enable_observer, quantize, quantize_qat
logger = mge.get_logger(__name__)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-a", "--arch", default="resnet18", type=str)
parser.add_argument("-d", "--data", default=None, type=str)
parser.add_argument("-s", "--save", default="/data/models", type=str)
parser.add_argument(
"-c",
"--checkpoint",
default=None,
type=str,
help="pretrained model to finetune",
)
parser.add_argument("-n", "--ngpus", default=None, type=int)
parser.add_argument("-w", "--workers", default=4, type=int)
parser.add_argument("--report-freq", default=50, type=int)
args = parser.parse_args()
world_size = (
dist.helper.get_device_count_by_fork("gpu")
if args.ngpus is None
else args.ngpus
)
world_size = 1 if world_size == 0 else world_size
if world_size != 1:
logger.warning(
"Calibration only supports single GPU now, %d provided", world_size
)
proc_func = dist.launcher(worker) if world_size > 1 else worker
proc_func(world_size, args)
def get_parameters(model, cfg):
if isinstance(cfg.WEIGHT_DECAY, numbers.Number):
return {
"params": model.parameters(requires_grad=True),
"weight_decay": cfg.WEIGHT_DECAY,
}
groups = collections.defaultdict(list) # weight_decay -> List[param]
for pname, p in model.named_parameters(requires_grad=True):
wd = cfg.WEIGHT_DECAY(pname, p)
groups[wd].append(p)
groups = [
{"params": params, "weight_decay": wd} for wd, params in groups.items()
] # List[{param, weight_decay}]
return groups
def worker(world_size, args):
# pylint: disable=too-many-statements
rank = dist.get_rank()
if world_size > 1:
# Initialize distributed process group
logger.info("init distributed process group {} / {}".format(rank, world_size))
save_dir = os.path.join(args.save, args.arch + "." + "calibration")
if not os.path.exists(save_dir):
os.makedirs(save_dir, exist_ok=True)
mge.set_log_file(os.path.join(save_dir, "log.txt"))
model = models.__dict__[args.arch]()
# load calibration model
assert args.checkpoint
logger.info("Load pretrained weights from %s", args.checkpoint)
ckpt = mge.load(args.checkpoint)
ckpt = ckpt["state_dict"] if "state_dict" in ckpt else ckpt
model.load_state_dict(ckpt, strict=False)
# Build valid datasets
valid_dataset = data.dataset.ImageNet(args.data, train=False)
valid_sampler = data.SequentialSampler(
valid_dataset, batch_size=100, drop_last=False
)
valid_queue = data.DataLoader(
valid_dataset,
sampler=valid_sampler,
transform=T.Compose(
[T.Resize(256), T.CenterCrop(224), T.Normalize(mean=128), T.ToMode("CHW")]
),
num_workers=args.workers,
)
# calibration
model.fc.disable_quantize()
model = quantize_qat(model, qconfig=Q.calibration_qconfig)
# calculate scale
def calculate_scale(image, label):
model.eval()
enable_observer(model)
logits = model(image)
loss = F.loss.cross_entropy(logits, label, label_smooth=0.1)
acc1, acc5 = F.topk_accuracy(logits, label, (1, 5))
if dist.is_distributed(): # all_reduce_mean
loss = dist.functional.all_reduce_sum(loss) / dist.get_world_size()
acc1 = dist.functional.all_reduce_sum(acc1) / dist.get_world_size()
acc5 = dist.functional.all_reduce_sum(acc5) / dist.get_world_size()
return loss, acc1, acc5
infer(calculate_scale, valid_queue, args)
# quantized
model = quantize(model)
# eval quantized model
def eval_func(image, label):
model.eval()
logits = model(image)
loss = F.loss.cross_entropy(logits, label, label_smooth=0.1)
acc1, acc5 = F.topk_accuracy(logits, label, (1, 5))
if dist.is_distributed(): # all_reduce_mean
loss = dist.functional.all_reduce_sum(loss) / dist.get_world_size()
acc1 = dist.functional.all_reduce_sum(acc1) / dist.get_world_size()
acc5 = dist.functional.all_reduce_sum(acc5) / dist.get_world_size()
return loss, acc1, acc5
_, valid_acc, valid_acc5 = infer(eval_func, valid_queue, args)
logger.info("TEST %f, %f", valid_acc, valid_acc5)
# save quantized model
mge.save(
{"step": -1, "state_dict": model.state_dict()},
os.path.join(save_dir, "checkpoint-calibration.pkl"),
)
logger.info(
"save in {}".format(os.path.join(save_dir, "checkpoint-calibration.pkl"))
)
def infer(model, data_queue, args):
objs = AverageMeter("Loss")
top1 = AverageMeter("Acc@1")
top5 = AverageMeter("Acc@5")
total_time = AverageMeter("Time")
t = time.time()
for step, (image, label) in enumerate(data_queue):
n = image.shape[0]
image = mge.tensor(image, dtype="float32")
label = mge.tensor(label, dtype="int32")
loss, acc1, acc5 = model(image, label)
objs.update(loss.numpy()[0], n)
top1.update(100 * acc1.numpy()[0], n)
top5.update(100 * acc5.numpy()[0], n)
total_time.update(time.time() - t)
t = time.time()
if step % args.report_freq == 0 and dist.get_rank() == 0:
logger.info("Step %d, %s %s %s %s", step, objs, top1, top5, total_time)
# break
if step == args.report_freq:
break
return objs.avg, top1.avg, top5.avg
class AverageMeter:
"""Computes and stores the average and current value"""
def __init__(self, name, fmt=":.3f"):
self.name = name
self.fmt = fmt
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def __str__(self):
fmtstr = "{name} {val" + self.fmt + "} ({avg" + self.fmt + "})"
return fmtstr.format(**self.__dict__)
if __name__ == "__main__":
main()
|
[
"megengine.distributed.is_distributed",
"megengine.data.transform.ToMode",
"megengine.data.transform.CenterCrop",
"megengine.data.transform.Normalize",
"megengine.data.SequentialSampler",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.data.dataset.ImageNet",
"megengine.data.transform.Resize",
"megengine.tensor",
"megengine.distributed.helper.get_device_count_by_fork",
"megengine.functional.loss.cross_entropy",
"megengine.quantization.quantize.quantize",
"megengine.quantization.quantize.quantize_qat",
"megengine.distributed.functional.all_reduce_sum",
"megengine.functional.topk_accuracy",
"megengine.quantization.quantize.enable_observer",
"megengine.load",
"megengine.distributed.launcher"
] |
[((866, 890), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (880, 890), True, 'import megengine as mge\n'), ((918, 943), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (941, 943), False, 'import argparse\n'), ((2188, 2217), 'collections.defaultdict', 'collections.defaultdict', (['list'], {}), '(list)\n', (2211, 2217), False, 'import collections\n'), ((2618, 2633), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2631, 2633), True, 'import megengine.distributed as dist\n'), ((2807, 2863), 'os.path.join', 'os.path.join', (['args.save', "(args.arch + '.' + 'calibration')"], {}), "(args.save, args.arch + '.' + 'calibration')\n", (2819, 2863), False, 'import os\n'), ((3180, 3205), 'megengine.load', 'mge.load', (['args.checkpoint'], {}), '(args.checkpoint)\n', (3188, 3205), True, 'import megengine as mge\n'), ((3364, 3409), 'megengine.data.dataset.ImageNet', 'data.dataset.ImageNet', (['args.data'], {'train': '(False)'}), '(args.data, train=False)\n', (3385, 3409), True, 'import megengine.data as data\n'), ((3430, 3500), 'megengine.data.SequentialSampler', 'data.SequentialSampler', (['valid_dataset'], {'batch_size': '(100)', 'drop_last': '(False)'}), '(valid_dataset, batch_size=100, drop_last=False)\n', (3452, 3500), True, 'import megengine.data as data\n'), ((3834, 3884), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['model'], {'qconfig': 'Q.calibration_qconfig'}), '(model, qconfig=Q.calibration_qconfig)\n', (3846, 3884), False, 'from megengine.quantization.quantize import enable_observer, quantize, quantize_qat\n'), ((4559, 4574), 'megengine.quantization.quantize.quantize', 'quantize', (['model'], {}), '(model)\n', (4567, 4574), False, 'from megengine.quantization.quantize import enable_observer, quantize, quantize_qat\n'), ((5717, 5728), 'time.time', 'time.time', ([], {}), '()\n', (5726, 5728), False, 'import time\n'), ((1558, 1601), 'megengine.distributed.helper.get_device_count_by_fork', 'dist.helper.get_device_count_by_fork', (['"""gpu"""'], {}), "('gpu')\n", (1594, 1601), True, 'import megengine.distributed as dist\n'), ((1870, 1891), 'megengine.distributed.launcher', 'dist.launcher', (['worker'], {}), '(worker)\n', (1883, 1891), True, 'import megengine.distributed as dist\n'), ((2875, 2899), 'os.path.exists', 'os.path.exists', (['save_dir'], {}), '(save_dir)\n', (2889, 2899), False, 'import os\n'), ((2909, 2945), 'os.makedirs', 'os.makedirs', (['save_dir'], {'exist_ok': '(True)'}), '(save_dir, exist_ok=True)\n', (2920, 2945), False, 'import os\n'), ((2967, 3000), 'os.path.join', 'os.path.join', (['save_dir', '"""log.txt"""'], {}), "(save_dir, 'log.txt')\n", (2979, 3000), False, 'import os\n'), ((3976, 3998), 'megengine.quantization.quantize.enable_observer', 'enable_observer', (['model'], {}), '(model)\n', (3991, 3998), False, 'from megengine.quantization.quantize import enable_observer, quantize, quantize_qat\n'), ((4044, 4097), 'megengine.functional.loss.cross_entropy', 'F.loss.cross_entropy', (['logits', 'label'], {'label_smooth': '(0.1)'}), '(logits, label, label_smooth=0.1)\n', (4064, 4097), True, 'import megengine.functional as F\n'), ((4119, 4157), 'megengine.functional.topk_accuracy', 'F.topk_accuracy', (['logits', 'label', '(1, 5)'], {}), '(logits, label, (1, 5))\n', (4134, 4157), True, 'import megengine.functional as F\n'), ((4169, 4190), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (4188, 4190), True, 'import megengine.distributed as dist\n'), ((4702, 4755), 'megengine.functional.loss.cross_entropy', 'F.loss.cross_entropy', (['logits', 'label'], {'label_smooth': '(0.1)'}), '(logits, label, label_smooth=0.1)\n', (4722, 4755), True, 'import megengine.functional as F\n'), ((4777, 4815), 'megengine.functional.topk_accuracy', 'F.topk_accuracy', (['logits', 'label', '(1, 5)'], {}), '(logits, label, (1, 5))\n', (4792, 4815), True, 'import megengine.functional as F\n'), ((4827, 4848), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (4846, 4848), True, 'import megengine.distributed as dist\n'), ((5369, 5421), 'os.path.join', 'os.path.join', (['save_dir', '"""checkpoint-calibration.pkl"""'], {}), "(save_dir, 'checkpoint-calibration.pkl')\n", (5381, 5421), False, 'import os\n'), ((5827, 5861), 'megengine.tensor', 'mge.tensor', (['image'], {'dtype': '"""float32"""'}), "(image, dtype='float32')\n", (5837, 5861), True, 'import megengine as mge\n'), ((5878, 5910), 'megengine.tensor', 'mge.tensor', (['label'], {'dtype': '"""int32"""'}), "(label, dtype='int32')\n", (5888, 5910), True, 'import megengine as mge\n'), ((6147, 6158), 'time.time', 'time.time', ([], {}), '()\n', (6156, 6158), False, 'import time\n'), ((5474, 5526), 'os.path.join', 'os.path.join', (['save_dir', '"""checkpoint-calibration.pkl"""'], {}), "(save_dir, 'checkpoint-calibration.pkl')\n", (5486, 5526), False, 'import os\n'), ((4230, 4266), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['loss'], {}), '(loss)\n', (4260, 4266), True, 'import megengine.distributed as dist\n'), ((4269, 4290), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4288, 4290), True, 'import megengine.distributed as dist\n'), ((4310, 4346), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['acc1'], {}), '(acc1)\n', (4340, 4346), True, 'import megengine.distributed as dist\n'), ((4349, 4370), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4368, 4370), True, 'import megengine.distributed as dist\n'), ((4390, 4426), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['acc5'], {}), '(acc5)\n', (4420, 4426), True, 'import megengine.distributed as dist\n'), ((4429, 4450), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4448, 4450), True, 'import megengine.distributed as dist\n'), ((4888, 4924), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['loss'], {}), '(loss)\n', (4918, 4924), True, 'import megengine.distributed as dist\n'), ((4927, 4948), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4946, 4948), True, 'import megengine.distributed as dist\n'), ((4968, 5004), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['acc1'], {}), '(acc1)\n', (4998, 5004), True, 'import megengine.distributed as dist\n'), ((5007, 5028), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (5026, 5028), True, 'import megengine.distributed as dist\n'), ((5048, 5084), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['acc5'], {}), '(acc5)\n', (5078, 5084), True, 'import megengine.distributed as dist\n'), ((5087, 5108), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (5106, 5108), True, 'import megengine.distributed as dist\n'), ((6118, 6129), 'time.time', 'time.time', ([], {}), '()\n', (6127, 6129), False, 'import time\n'), ((6204, 6219), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (6217, 6219), True, 'import megengine.distributed as dist\n'), ((3646, 3659), 'megengine.data.transform.Resize', 'T.Resize', (['(256)'], {}), '(256)\n', (3654, 3659), True, 'import megengine.data.transform as T\n'), ((3661, 3678), 'megengine.data.transform.CenterCrop', 'T.CenterCrop', (['(224)'], {}), '(224)\n', (3673, 3678), True, 'import megengine.data.transform as T\n'), ((3680, 3701), 'megengine.data.transform.Normalize', 'T.Normalize', ([], {'mean': '(128)'}), '(mean=128)\n', (3691, 3701), True, 'import megengine.data.transform as T\n'), ((3703, 3718), 'megengine.data.transform.ToMode', 'T.ToMode', (['"""CHW"""'], {}), "('CHW')\n", (3711, 3718), True, 'import megengine.data.transform as T\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import megengine as mge
import megengine.autodiff as ad
import megengine.functional as F
import megengine.module as M
import megengine.optimizer as optim
class Net(M.Module):
def __init__(self):
super().__init__()
self.conv1 = M.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = M.BatchNorm2d(64)
self.avgpool = M.AvgPool2d(kernel_size=5, stride=5, padding=0)
self.fc = M.Linear(64, 10)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = F.relu(x)
x = self.avgpool(x)
x = F.avg_pool2d(x, 22)
x = F.flatten(x, 1)
x = self.fc(x)
return x
def save_grad_value(net):
for param in net.parameters():
param.grad_backup = param.grad.numpy().copy()
def test_clip_grad_norm():
net = Net()
x = mge.tensor(np.random.randn(10, 3, 224, 224))
gm = ad.GradManager().attach(net.parameters())
opt = optim.SGD(net.parameters(), 1e-3, momentum=0.9)
with gm:
loss = net(x).sum()
gm.backward(loss)
save_grad_value(net)
max_norm = 1.0
original_norm = optim.clip_grad_norm(net.parameters(), max_norm=max_norm, ord=2)
scale = max_norm / original_norm
for param in net.parameters():
np.testing.assert_almost_equal(param.grad.numpy(), param.grad_backup * scale)
opt.step().clear_grad()
def test_clip_grad_value():
net = Net()
x = np.random.randn(10, 3, 224, 224).astype("float32")
gm = ad.GradManager().attach(net.parameters())
opt = optim.SGD(net.parameters(), 1e-3, momentum=0.9)
with gm:
y = net(mge.tensor(x))
y = y.mean()
gm.backward(y)
save_grad_value(net)
max_val = 5
min_val = -2
optim.clip_grad_value(net.parameters(), lower=min_val, upper=max_val)
for param in net.parameters():
np.testing.assert_almost_equal(
param.grad.numpy(),
np.maximum(np.minimum(param.grad_backup, max_val), min_val),
)
opt.step().clear_grad()
|
[
"megengine.module.Linear",
"megengine.tensor",
"megengine.module.AvgPool2d",
"megengine.module.BatchNorm2d",
"megengine.functional.avg_pool2d",
"megengine.functional.relu",
"megengine.autodiff.GradManager",
"megengine.module.Conv2d",
"megengine.functional.flatten"
] |
[((623, 686), 'megengine.module.Conv2d', 'M.Conv2d', (['(3)', '(64)'], {'kernel_size': '(7)', 'stride': '(2)', 'padding': '(3)', 'bias': '(False)'}), '(3, 64, kernel_size=7, stride=2, padding=3, bias=False)\n', (631, 686), True, 'import megengine.module as M\n'), ((706, 723), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(64)'], {}), '(64)\n', (719, 723), True, 'import megengine.module as M\n'), ((747, 794), 'megengine.module.AvgPool2d', 'M.AvgPool2d', ([], {'kernel_size': '(5)', 'stride': '(5)', 'padding': '(0)'}), '(kernel_size=5, stride=5, padding=0)\n', (758, 794), True, 'import megengine.module as M\n'), ((813, 829), 'megengine.module.Linear', 'M.Linear', (['(64)', '(10)'], {}), '(64, 10)\n', (821, 829), True, 'import megengine.module as M\n'), ((919, 928), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (925, 928), True, 'import megengine.functional as F\n'), ((969, 988), 'megengine.functional.avg_pool2d', 'F.avg_pool2d', (['x', '(22)'], {}), '(x, 22)\n', (981, 988), True, 'import megengine.functional as F\n'), ((1001, 1016), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (1010, 1016), True, 'import megengine.functional as F\n'), ((1238, 1270), 'numpy.random.randn', 'np.random.randn', (['(10)', '(3)', '(224)', '(224)'], {}), '(10, 3, 224, 224)\n', (1253, 1270), True, 'import numpy as np\n'), ((1281, 1297), 'megengine.autodiff.GradManager', 'ad.GradManager', ([], {}), '()\n', (1295, 1297), True, 'import megengine.autodiff as ad\n'), ((1817, 1849), 'numpy.random.randn', 'np.random.randn', (['(10)', '(3)', '(224)', '(224)'], {}), '(10, 3, 224, 224)\n', (1832, 1849), True, 'import numpy as np\n'), ((1877, 1893), 'megengine.autodiff.GradManager', 'ad.GradManager', ([], {}), '()\n', (1891, 1893), True, 'import megengine.autodiff as ad\n'), ((2006, 2019), 'megengine.tensor', 'mge.tensor', (['x'], {}), '(x)\n', (2016, 2019), True, 'import megengine as mge\n'), ((2327, 2365), 'numpy.minimum', 'np.minimum', (['param.grad_backup', 'max_val'], {}), '(param.grad_backup, max_val)\n', (2337, 2365), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
import megengine.module as M
import megengine.functional as F
class LeNet32x32(M.Module):
def __init__(self):
super().__init__()
# single channel image, two 5x5 Conv + ReLU + Pool
# Conv2d(1, 6, kernel_size=(5, 5))
self.conv1 = M.Conv2d(1, 6, 5)
self.relu1 = M.ReLU()
# MaxPool2d(kernel_size=2, stride=2, padding=0)
self.pool1 = M.MaxPool2d(2, 2)
self.conv2 = M.Conv2d(6, 16, 5)
self.relu2 = M.ReLU()
self.pool2 = M.MaxPool2d(2, 2)
# two FC + ReLU
self.fc1 = M.Linear(16 * 5 * 5, 120)
self.relu3 = M.ReLU()
self.fc2 = M.Linear(120, 84)
self.relu4 = M.ReLU()
# classifier
self.classifier = M.Linear(84, 10)
def forward(self, x):
x = self.pool1(self.relu1(self.conv1(x)))
x = self.pool2(self.relu2(self.conv2(x)))
# F.flatten reshape the tensor x with (N, C, H, W) into shape of (N, C*H*W)
# i.e., x = x.reshape(x.shape[0], -1)
# x.shape: (256, 16, 5, 5)
x = F.flatten(x, 1)
# x.shape: (256, 400)
x = self.relu3(self.fc1(x))
x = self.relu4(self.fc2(x))
x = self.classifier(x)
return x
class LeNet224x224(M.Module):
def __init__(self):
super().__init__()
# single channel image, two 5x5 Conv + ReLU + Pool
self.conv1 = M.Conv2d(1, 6, 5)
self.relu1 = M.ReLU()
self.pool1 = M.MaxPool2d(2, 2)
self.conv2 = M.Conv2d(6, 16, 5)
self.relu2 = M.ReLU()
self.pool2 = M.MaxPool2d(2, 2)
# two FC + ReLU
self.fc1 = M.Linear(16 * 53 * 53, 120)
self.relu3 = M.ReLU()
self.fc2 = M.Linear(120, 84)
self.relu4 = M.ReLU()
# classifier
self.classifier = M.Linear(84, 10)
def forward(self, x):
x = self.pool1(self.relu1(self.conv1(x)))
x = self.pool2(self.relu2(self.conv2(x)))
# F.flatten(x, 1) reshape the tensor x with (N, C, H, W) along
# the 1st dimension into shape of (N, C*H*W),
# i.e., x = x.reshape(x.shape[0], -1)
# x.shape: (256, 16, 53, 53)
x = F.flatten(x, 1)
# x.shape: (256, 16*53*53)
x = self.relu3(self.fc1(x))
x = self.relu4(self.fc2(x))
x = self.classifier(x)
return x
|
[
"megengine.module.MaxPool2d",
"megengine.module.Linear",
"megengine.module.ReLU",
"megengine.module.Conv2d",
"megengine.functional.flatten"
] |
[((289, 306), 'megengine.module.Conv2d', 'M.Conv2d', (['(1)', '(6)', '(5)'], {}), '(1, 6, 5)\n', (297, 306), True, 'import megengine.module as M\n'), ((328, 336), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (334, 336), True, 'import megengine.module as M\n'), ((414, 431), 'megengine.module.MaxPool2d', 'M.MaxPool2d', (['(2)', '(2)'], {}), '(2, 2)\n', (425, 431), True, 'import megengine.module as M\n'), ((453, 471), 'megengine.module.Conv2d', 'M.Conv2d', (['(6)', '(16)', '(5)'], {}), '(6, 16, 5)\n', (461, 471), True, 'import megengine.module as M\n'), ((493, 501), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (499, 501), True, 'import megengine.module as M\n'), ((523, 540), 'megengine.module.MaxPool2d', 'M.MaxPool2d', (['(2)', '(2)'], {}), '(2, 2)\n', (534, 540), True, 'import megengine.module as M\n'), ((584, 609), 'megengine.module.Linear', 'M.Linear', (['(16 * 5 * 5)', '(120)'], {}), '(16 * 5 * 5, 120)\n', (592, 609), True, 'import megengine.module as M\n'), ((631, 639), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (637, 639), True, 'import megengine.module as M\n'), ((659, 676), 'megengine.module.Linear', 'M.Linear', (['(120)', '(84)'], {}), '(120, 84)\n', (667, 676), True, 'import megengine.module as M\n'), ((698, 706), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (704, 706), True, 'import megengine.module as M\n'), ((754, 770), 'megengine.module.Linear', 'M.Linear', (['(84)', '(10)'], {}), '(84, 10)\n', (762, 770), True, 'import megengine.module as M\n'), ((1075, 1090), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (1084, 1090), True, 'import megengine.functional as F\n'), ((1403, 1420), 'megengine.module.Conv2d', 'M.Conv2d', (['(1)', '(6)', '(5)'], {}), '(1, 6, 5)\n', (1411, 1420), True, 'import megengine.module as M\n'), ((1442, 1450), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1448, 1450), True, 'import megengine.module as M\n'), ((1472, 1489), 'megengine.module.MaxPool2d', 'M.MaxPool2d', (['(2)', '(2)'], {}), '(2, 2)\n', (1483, 1489), True, 'import megengine.module as M\n'), ((1511, 1529), 'megengine.module.Conv2d', 'M.Conv2d', (['(6)', '(16)', '(5)'], {}), '(6, 16, 5)\n', (1519, 1529), True, 'import megengine.module as M\n'), ((1551, 1559), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1557, 1559), True, 'import megengine.module as M\n'), ((1581, 1598), 'megengine.module.MaxPool2d', 'M.MaxPool2d', (['(2)', '(2)'], {}), '(2, 2)\n', (1592, 1598), True, 'import megengine.module as M\n'), ((1642, 1669), 'megengine.module.Linear', 'M.Linear', (['(16 * 53 * 53)', '(120)'], {}), '(16 * 53 * 53, 120)\n', (1650, 1669), True, 'import megengine.module as M\n'), ((1691, 1699), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1697, 1699), True, 'import megengine.module as M\n'), ((1719, 1736), 'megengine.module.Linear', 'M.Linear', (['(120)', '(84)'], {}), '(120, 84)\n', (1727, 1736), True, 'import megengine.module as M\n'), ((1758, 1766), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1764, 1766), True, 'import megengine.module as M\n'), ((1814, 1830), 'megengine.module.Linear', 'M.Linear', (['(84)', '(10)'], {}), '(84, 10)\n', (1822, 1830), True, 'import megengine.module as M\n'), ((2178, 2193), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (2187, 2193), True, 'import megengine.functional as F\n')]
|
import megengine as mge
import megengine.functional as F
from megengine.core import Tensor
def softmax_loss(pred, label, ignore_label=-1):
max_pred = F.zero_grad(pred.max(axis=1, keepdims=True))
pred -= max_pred
log_prob = pred - F.log(F.exp(pred).sum(axis=1, keepdims=True))
mask = 1 - F.equal(label, ignore_label)
vlabel = label * mask
loss = -(F.indexing_one_hot(log_prob, vlabel, 1) * mask)
return loss
def smooth_l1_loss(pred, target, beta: float):
abs_x = F.abs(pred - target)
in_mask = abs_x < beta
out_mask = 1 - in_mask
in_loss = 0.5 * abs_x ** 2 / beta
out_loss = abs_x - 0.5 * beta
loss = in_loss * in_mask + out_loss * out_mask
return loss.sum(axis=1)
|
[
"megengine.functional.abs",
"megengine.functional.equal",
"megengine.functional.exp",
"megengine.functional.indexing_one_hot"
] |
[((496, 516), 'megengine.functional.abs', 'F.abs', (['(pred - target)'], {}), '(pred - target)\n', (501, 516), True, 'import megengine.functional as F\n'), ((304, 332), 'megengine.functional.equal', 'F.equal', (['label', 'ignore_label'], {}), '(label, ignore_label)\n', (311, 332), True, 'import megengine.functional as F\n'), ((372, 411), 'megengine.functional.indexing_one_hot', 'F.indexing_one_hot', (['log_prob', 'vlabel', '(1)'], {}), '(log_prob, vlabel, 1)\n', (390, 411), True, 'import megengine.functional as F\n'), ((249, 260), 'megengine.functional.exp', 'F.exp', (['pred'], {}), '(pred)\n', (254, 260), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine as mge
from megengine import tensor
from megengine.core.autodiff.grad import Grad
from megengine.core.tensor.function import Function
from megengine.core.tensor.utils import make_shape_tuple
from megengine.quantization.fake_quant import TQT_Function
from megengine.quantization.internal_fake_quant import *
from megengine.quantization.utils import QuantMode, fake_quant_tensor
class numpy_TQT_Function:
def __init__(self, lowerbound, upperbound):
super().__init__()
self.lowerbound = lowerbound
self.upperbound = upperbound
def forward(self, inp, scale):
t = 2 ** scale
# t = F.maximum(t, 1e-4)
inp_scaled = inp / t
inp_clipped = np.maximum(
np.minimum(inp_scaled, self.upperbound), self.lowerbound
)
inp_rounded = np.round(inp_clipped)
inp_flq = inp_rounded * t
self.saved_tensors = (inp_scaled, inp_rounded, t)
return inp_flq
def backward(self, grad_inp_flq):
(inp_scaled, inp_rounded, t) = self.saved_tensors
mask_clip = (inp_scaled < -0.5 + self.lowerbound) + (
inp_scaled > self.upperbound + 0.5
) # mask for accumulating the gradients of |data_scaled|>L
mask_quant = np.abs(
mask_clip - 1
) # mask for accumulating the gradients with |data_scaled|<=L
grad_quant = (
grad_inp_flq * mask_quant * (inp_rounded - inp_scaled)
) # gradient within |data_scaled|<=L
grad_clip = (
grad_inp_flq * mask_clip * inp_rounded
) # gradient with | data_scaled|>L
grad_s = grad_clip.sum() + grad_quant.sum()
# dL/ds = dL/dt * t * ln(2)
grad_s = grad_s * t * np.log(2)
grad_inp = grad_inp_flq * mask_quant
return grad_inp, grad_s
def test_TQT():
f = TQT_Function(-127, 127)
nf = numpy_TQT_Function(-127, 127)
def check_inp(a, b, c, a_np, b_np, c_np):
np.testing.assert_allclose(
f.forward(a, b).numpy(),
nf.forward(a_np, b_np).astype("float32"),
rtol=1e-6,
atol=1e-6,
)
c1, c2 = f.backward(c)
c1_np, c2_np = nf.backward(c_np)
np.testing.assert_allclose(c1.numpy(), c1_np.astype("float32"), rtol=1e-6)
np.testing.assert_allclose(c2.numpy(), c2_np.astype("float32"), rtol=5e-5)
a_np = np.random.random((4, 3)).astype("float32")
b_np = np.random.random((1)).astype("float32")
a = tensor(a_np)
b = tensor(b_np)
check_inp(a, b, b, a_np, b_np, b_np)
def _save_to(self, name="grad"):
def callback(tensor, grad):
setattr(self, name, grad)
return callback
class Round(Function):
def forward(self, x):
return F.round(x)
def backward(self, output_grads):
return output_grads
def fake_quant_tensor_gt(inp, scale, zero_point, qmin, qmax):
oup = Round()(inp / scale) + zero_point
oup = F.minimum(F.maximum(oup, qmin), qmax)
oup = (oup - zero_point) * scale
return oup
def test_fakequant():
qmin = -126
qmax = 129
def run(zero_point, scale):
q_dict = {}
q_dict["mode"] = QuantMode.ASYMMERTIC
q_dict["scale"] = scale
q_dict["zero_point"] = zero_point
inp_data = np.random.uniform(low=-512.0, high=512.0, size=(1, 32, 32, 32))
inp = tensor(inp_data, dtype=np.float32)
# test forward
oup = fake_quant_tensor(inp, qmin, qmax, q_dict).numpy()
oup_gt = fake_quant_tensor_gt(inp, scale, zero_point, qmin, qmax).numpy()
assert np.allclose(oup, oup_gt)
assert oup.shape == oup_gt.shape
# test backward
x = tensor(inp_data, dtype=np.float32)
grad = Grad().wrt(x, callback=_save_to(x))
y = fake_quant_tensor(x, qmin, qmax, q_dict)
grad(y, tensor(F.ones_like(x)))
x1 = tensor(inp_data, dtype=np.float32)
grad = Grad().wrt(x1, callback=_save_to(x1))
y1 = fake_quant_tensor_gt(x1, scale, zero_point, qmin, qmax)
grad(y1, tensor(F.ones_like(x1)))
assert np.allclose(x.grad.numpy(), x1.grad.numpy())
assert make_shape_tuple(x.grad.shape) == make_shape_tuple(x1.grad.shape)
zero_point = tensor([1.0], dtype=np.float32)
scale = tensor([4.0], dtype=np.float32)
run(zero_point, scale)
zero_point = tensor(1.0 * np.ones((1, 32, 1, 1)), dtype=np.float32)
scale = tensor(4.0 * np.ones((1, 32, 1, 1)), dtype=np.float32)
run(zero_point, scale)
|
[
"megengine.tensor",
"megengine.core.tensor.utils.make_shape_tuple",
"megengine.quantization.utils.fake_quant_tensor",
"megengine.quantization.fake_quant.TQT_Function",
"megengine.core.autodiff.grad.Grad"
] |
[((2261, 2284), 'megengine.quantization.fake_quant.TQT_Function', 'TQT_Function', (['(-127)', '(127)'], {}), '(-127, 127)\n', (2273, 2284), False, 'from megengine.quantization.fake_quant import TQT_Function\n'), ((2906, 2918), 'megengine.tensor', 'tensor', (['a_np'], {}), '(a_np)\n', (2912, 2918), False, 'from megengine import tensor\n'), ((2927, 2939), 'megengine.tensor', 'tensor', (['b_np'], {}), '(b_np)\n', (2933, 2939), False, 'from megengine import tensor\n'), ((4657, 4688), 'megengine.tensor', 'tensor', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (4663, 4688), False, 'from megengine import tensor\n'), ((4701, 4732), 'megengine.tensor', 'tensor', (['[4.0]'], {'dtype': 'np.float32'}), '([4.0], dtype=np.float32)\n', (4707, 4732), False, 'from megengine import tensor\n'), ((1238, 1259), 'numpy.round', 'np.round', (['inp_clipped'], {}), '(inp_clipped)\n', (1246, 1259), True, 'import numpy as np\n'), ((1670, 1691), 'numpy.abs', 'np.abs', (['(mask_clip - 1)'], {}), '(mask_clip - 1)\n', (1676, 1691), True, 'import numpy as np\n'), ((3704, 3767), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': '(-512.0)', 'high': '(512.0)', 'size': '(1, 32, 32, 32)'}), '(low=-512.0, high=512.0, size=(1, 32, 32, 32))\n', (3721, 3767), True, 'import numpy as np\n'), ((3782, 3816), 'megengine.tensor', 'tensor', (['inp_data'], {'dtype': 'np.float32'}), '(inp_data, dtype=np.float32)\n', (3788, 3816), False, 'from megengine import tensor\n'), ((4002, 4026), 'numpy.allclose', 'np.allclose', (['oup', 'oup_gt'], {}), '(oup, oup_gt)\n', (4013, 4026), True, 'import numpy as np\n'), ((4105, 4139), 'megengine.tensor', 'tensor', (['inp_data'], {'dtype': 'np.float32'}), '(inp_data, dtype=np.float32)\n', (4111, 4139), False, 'from megengine import tensor\n'), ((4203, 4243), 'megengine.quantization.utils.fake_quant_tensor', 'fake_quant_tensor', (['x', 'qmin', 'qmax', 'q_dict'], {}), '(x, qmin, qmax, q_dict)\n', (4220, 4243), False, 'from megengine.quantization.utils import QuantMode, fake_quant_tensor\n'), ((4298, 4332), 'megengine.tensor', 'tensor', (['inp_data'], {'dtype': 'np.float32'}), '(inp_data, dtype=np.float32)\n', (4304, 4332), False, 'from megengine import tensor\n'), ((1149, 1188), 'numpy.minimum', 'np.minimum', (['inp_scaled', 'self.upperbound'], {}), '(inp_scaled, self.upperbound)\n', (1159, 1188), True, 'import numpy as np\n'), ((2148, 2157), 'numpy.log', 'np.log', (['(2)'], {}), '(2)\n', (2154, 2157), True, 'import numpy as np\n'), ((2804, 2828), 'numpy.random.random', 'np.random.random', (['(4, 3)'], {}), '((4, 3))\n', (2820, 2828), True, 'import numpy as np\n'), ((2858, 2877), 'numpy.random.random', 'np.random.random', (['(1)'], {}), '(1)\n', (2874, 2877), True, 'import numpy as np\n'), ((4573, 4603), 'megengine.core.tensor.utils.make_shape_tuple', 'make_shape_tuple', (['x.grad.shape'], {}), '(x.grad.shape)\n', (4589, 4603), False, 'from megengine.core.tensor.utils import make_shape_tuple\n'), ((4607, 4638), 'megengine.core.tensor.utils.make_shape_tuple', 'make_shape_tuple', (['x1.grad.shape'], {}), '(x1.grad.shape)\n', (4623, 4638), False, 'from megengine.core.tensor.utils import make_shape_tuple\n'), ((4791, 4813), 'numpy.ones', 'np.ones', (['(1, 32, 1, 1)'], {}), '((1, 32, 1, 1))\n', (4798, 4813), True, 'import numpy as np\n'), ((4858, 4880), 'numpy.ones', 'np.ones', (['(1, 32, 1, 1)'], {}), '((1, 32, 1, 1))\n', (4865, 4880), True, 'import numpy as np\n'), ((3854, 3896), 'megengine.quantization.utils.fake_quant_tensor', 'fake_quant_tensor', (['inp', 'qmin', 'qmax', 'q_dict'], {}), '(inp, qmin, qmax, q_dict)\n', (3871, 3896), False, 'from megengine.quantization.utils import QuantMode, fake_quant_tensor\n'), ((4155, 4161), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4159, 4161), False, 'from megengine.core.autodiff.grad import Grad\n'), ((4348, 4354), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4352, 4354), False, 'from megengine.core.autodiff.grad import Grad\n')]
|
# -*- coding: utf-8 -*-
# This repo is licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import megengine.functional as F
import megengine.module as M
import models.backbones.resnet.model as resnet
import layers
class FreeAnchor(M.Module):
"""
Implement RetinaNet (https://arxiv.org/abs/1708.02002).
"""
def __init__(self, cfg):
super().__init__()
self.cfg = cfg
self.anchor_generator = layers.AnchorBoxGenerator(
anchor_scales=self.cfg.anchor_scales,
anchor_ratios=self.cfg.anchor_ratios,
strides=self.cfg.stride,
offset=self.cfg.anchor_offset,
)
self.box_coder = layers.BoxCoder(cfg.reg_mean, cfg.reg_std)
self.in_features = cfg.in_features
# ----------------------- build backbone ------------------------ #
bottom_up = getattr(resnet, cfg.backbone)(
norm=layers.get_norm(cfg.backbone_norm), pretrained=cfg.backbone_pretrained
)
del bottom_up.fc
# ----------------------- build FPN ----------------------------- #
self.backbone = layers.FPN(
bottom_up=bottom_up,
in_features=cfg.fpn_in_features,
out_channels=cfg.fpn_out_channels,
norm=cfg.fpn_norm,
top_block=layers.LastLevelP6P7(
cfg.fpn_top_in_channel, cfg.fpn_out_channels, cfg.fpn_top_in_feature
),
strides=cfg.fpn_in_strides,
channels=cfg.fpn_in_channels,
)
backbone_shape = self.backbone.output_shape()
feature_shapes = [backbone_shape[f] for f in self.in_features]
# ----------------------- build FreeAnchor Head ----------------- #
self.head = layers.BoxHead(cfg, feature_shapes)
def preprocess_image(self, image):
padded_image = layers.get_padded_tensor(image, 32, 0.0)
normed_image = (
padded_image
- np.array(self.cfg.img_mean, dtype="float32")[None, :, None, None]
) / np.array(self.cfg.img_std, dtype="float32")[None, :, None, None]
return normed_image
def forward(self, image, im_info, gt_boxes=None):
image = self.preprocess_image(image)
features = self.backbone(image)
features = [features[f] for f in self.in_features]
box_logits, box_offsets = self.head(features)
box_logits_list = [
_.transpose(0, 2, 3, 1).reshape(image.shape[0], -1, self.cfg.num_classes)
for _ in box_logits
]
box_offsets_list = [
_.transpose(0, 2, 3, 1).reshape(image.shape[0], -1, 4) for _ in box_offsets
]
anchors_list = self.anchor_generator(features)
all_level_box_logits = F.concat(box_logits_list, axis=1)
all_level_box_offsets = F.concat(box_offsets_list, axis=1)
all_level_anchors = F.concat(anchors_list, axis=0)
if self.training:
loss_dict = self.get_losses(
all_level_anchors, all_level_box_logits,
all_level_box_offsets, gt_boxes, im_info
)
self.cfg.losses_keys = list(loss_dict.keys())
return loss_dict
else:
# currently not support multi-batch testing
assert image.shape[0] == 1
pred_boxes = self.box_coder.decode(
all_level_anchors, all_level_box_offsets[0]
)
pred_boxes = pred_boxes.reshape(-1, 4)
scale_w = im_info[0, 1] / im_info[0, 3]
scale_h = im_info[0, 0] / im_info[0, 2]
pred_boxes = pred_boxes / F.concat(
[scale_w, scale_h, scale_w, scale_h], axis=0
)
clipped_boxes = layers.get_clipped_boxes(
pred_boxes, im_info[0, 2:4]
).reshape(-1, 4)
pred_score = F.sigmoid(all_level_box_logits)[0]
return pred_score, clipped_boxes
def get_losses(self, anchors, pred_logits, pred_offsets, gt_boxes, im_info):
# pylint: disable=too-many-statements
def positive_bag_loss(logits, axis=1):
weight = 1.0 / (1.0 - logits)
weight /= weight.sum(axis=axis, keepdims=True)
bag_prob = (weight * logits).sum(axis=1)
return -layers.safelog(bag_prob)
def negative_bag_loss(logits, gamma):
return (logits ** gamma) * (-layers.safelog(1.0 - logits))
pred_scores = F.sigmoid(pred_logits)
box_prob_list = []
positive_losses = []
clamp_eps = 1e-7
bucket_size = self.cfg.bucket_size
for bid in range(im_info.shape[0]):
boxes_info = gt_boxes[bid, : im_info[bid, 4].astype("int32")]
# id 0 is used for background classes, so -1 first
labels = boxes_info[:, 4].astype("int32") - 1
pred_box = self.box_coder.decode(anchors, pred_offsets[bid]).detach()
overlaps = layers.get_iou(boxes_info[:, :4], pred_box).detach()
thresh1 = self.cfg.box_iou_threshold
thresh2 = F.clip(
overlaps.max(axis=1, keepdims=True),
lower=thresh1 + clamp_eps, upper=1.0
)
gt_pred_prob = F.clip(
(overlaps - thresh1) / (thresh2 - thresh1), lower=0, upper=1.0)
image_boxes_prob = F.zeros(pred_logits.shape[1:]).detach()
# guarantee that nonzero_idx is not empty
if gt_pred_prob.max() > clamp_eps:
_, nonzero_idx = F.cond_take(gt_pred_prob != 0, gt_pred_prob)
# since nonzeros is only 1 dim, use num_anchor to get real indices
num_anchors = gt_pred_prob.shape[1]
anchors_idx = nonzero_idx % num_anchors
gt_idx = nonzero_idx // num_anchors
image_boxes_prob[anchors_idx, labels[gt_idx]] = gt_pred_prob[gt_idx, anchors_idx]
box_prob_list.append(image_boxes_prob)
# construct bags for objects
match_quality_matrix = layers.get_iou(boxes_info[:, :4], anchors).detach()
num_gt = match_quality_matrix.shape[0]
_, matched_idx = F.topk(
match_quality_matrix,
k=bucket_size,
descending=True,
no_sort=True,
)
matched_idx = matched_idx.detach()
matched_idx_flatten = matched_idx.reshape(-1)
gather_idx = labels.reshape(-1, 1)
gather_idx = F.broadcast_to(gather_idx, (num_gt, bucket_size))
gather_src = pred_scores[bid, matched_idx_flatten]
gather_src = gather_src.reshape(num_gt, bucket_size, -1)
matched_score = F.indexing_one_hot(gather_src, gather_idx, axis=2)
topk_anchors = anchors[matched_idx_flatten]
boxes_broad_cast = F.broadcast_to(
F.expand_dims(boxes_info[:, :4], axis=1), (num_gt, bucket_size, 4)
).reshape(-1, 4)
matched_offsets = self.box_coder.encode(topk_anchors, boxes_broad_cast)
reg_loss = layers.smooth_l1_loss(
pred_offsets[bid, matched_idx_flatten],
matched_offsets,
beta=self.cfg.smooth_l1_beta
).sum(axis=-1) * self.cfg.reg_loss_weight
matched_reg_scores = F.exp(-reg_loss)
positive_losses.append(
positive_bag_loss(
matched_score * matched_reg_scores.reshape(-1, bucket_size), axis=1
)
)
num_foreground = im_info[:, 4].sum()
pos_loss = F.concat(positive_losses).sum() / F.maximum(num_foreground, 1)
box_probs = F.stack(box_prob_list, axis=0)
neg_loss = negative_bag_loss(
pred_scores * (1 - box_probs), self.cfg.focal_loss_gamma
).sum() / F.maximum(num_foreground * bucket_size, 1)
alpha = self.cfg.focal_loss_alpha
pos_loss = pos_loss * alpha
neg_loss = neg_loss * (1 - alpha)
loss_dict = {
"total_loss": pos_loss + neg_loss,
"pos_loss": pos_loss,
"neg_loss": neg_loss,
}
return loss_dict
class FreeAnchorConfig:
# pylint: disable=too-many-statements
def __init__(self):
self.backbone = "resnet50"
self.backbone_pretrained = True
self.backbone_norm = "FrozenBN"
self.backbone_freeze_at = 2
self.fpn_norm = None
self.fpn_in_features = ["res3", "res4", "res5"]
self.fpn_in_strides = [8, 16, 32]
self.fpn_in_channels = [512, 1024, 2048]
self.fpn_out_channels = 256
self.fpn_top_in_feature = "p5"
self.fpn_top_in_channel = 256
# ------------------------ data cfg -------------------------- #
self.train_dataset = dict(
name="coco",
root="train2017",
ann_file="annotations/instances_train2017.json",
remove_images_without_annotations=True,
)
self.test_dataset = dict(
name="coco",
root="val2017",
ann_file="annotations/instances_val2017.json",
remove_images_without_annotations=False,
)
self.num_classes = 80
self.img_mean = [103.530, 116.280, 123.675] # BGR
self.img_std = [57.375, 57.120, 58.395]
# ----------------------- net cfg ------------------------- #
self.stride = [8, 16, 32, 64, 128]
self.in_features = ["p3", "p4", "p5", "p6", "p7"]
self.reg_mean = [0.0, 0.0, 0.0, 0.0]
self.reg_std = [0.1, 0.1, 0.2, 0.2]
self.anchor_scales = [
[x, x * 2 ** (1.0 / 3), x * 2 ** (2.0 / 3)] for x in [32, 64, 128, 256, 512]
]
self.anchor_ratios = [[0.5, 1, 2]]
self.anchor_offset = 0.5
self.box_iou_threshold = 0.6
self.bucket_size = 50
self.class_aware_box = False
self.cls_prior_prob = 0.02
# ------------------------ loss cfg -------------------------- #
self.focal_loss_alpha = 0.5
self.focal_loss_gamma = 2
self.smooth_l1_beta = 0 # use L1 loss
self.reg_loss_weight = 0.75
self.num_losses = 3
# ------------------------ training cfg ---------------------- #
self.train_image_short_size = (640, 672, 704, 736, 768, 800)
self.train_image_max_size = 1333
self.basic_lr = 0.01 / 16 # The basic learning rate for single-image
self.momentum = 0.9
self.weight_decay = 1e-4
self.log_interval = 20
self.nr_images_epoch = 80000
self.max_epoch = 54
self.warm_iters = 500
self.lr_decay_rate = 0.1
self.lr_decay_stages = [42, 50]
# ------------------------ testing cfg ----------------------- #
self.test_image_short_size = 800
self.test_image_max_size = 1333
self.test_max_boxes_per_image = 100
self.test_vis_threshold = 0.3
self.test_cls_threshold = 0.05
self.test_nms = 0.5
|
[
"megengine.functional.zeros",
"megengine.functional.broadcast_to",
"megengine.functional.stack",
"megengine.functional.concat",
"megengine.functional.exp",
"megengine.functional.sigmoid",
"megengine.functional.maximum",
"megengine.functional.cond_take",
"megengine.functional.topk",
"megengine.functional.expand_dims",
"megengine.functional.clip",
"megengine.functional.indexing_one_hot"
] |
[((740, 906), 'layers.AnchorBoxGenerator', 'layers.AnchorBoxGenerator', ([], {'anchor_scales': 'self.cfg.anchor_scales', 'anchor_ratios': 'self.cfg.anchor_ratios', 'strides': 'self.cfg.stride', 'offset': 'self.cfg.anchor_offset'}), '(anchor_scales=self.cfg.anchor_scales,\n anchor_ratios=self.cfg.anchor_ratios, strides=self.cfg.stride, offset=\n self.cfg.anchor_offset)\n', (765, 906), False, 'import layers\n'), ((982, 1024), 'layers.BoxCoder', 'layers.BoxCoder', (['cfg.reg_mean', 'cfg.reg_std'], {}), '(cfg.reg_mean, cfg.reg_std)\n', (997, 1024), False, 'import layers\n'), ((2048, 2083), 'layers.BoxHead', 'layers.BoxHead', (['cfg', 'feature_shapes'], {}), '(cfg, feature_shapes)\n', (2062, 2083), False, 'import layers\n'), ((2147, 2187), 'layers.get_padded_tensor', 'layers.get_padded_tensor', (['image', '(32)', '(0.0)'], {}), '(image, 32, 0.0)\n', (2171, 2187), False, 'import layers\n'), ((3049, 3082), 'megengine.functional.concat', 'F.concat', (['box_logits_list'], {'axis': '(1)'}), '(box_logits_list, axis=1)\n', (3057, 3082), True, 'import megengine.functional as F\n'), ((3115, 3149), 'megengine.functional.concat', 'F.concat', (['box_offsets_list'], {'axis': '(1)'}), '(box_offsets_list, axis=1)\n', (3123, 3149), True, 'import megengine.functional as F\n'), ((3178, 3208), 'megengine.functional.concat', 'F.concat', (['anchors_list'], {'axis': '(0)'}), '(anchors_list, axis=0)\n', (3186, 3208), True, 'import megengine.functional as F\n'), ((4751, 4773), 'megengine.functional.sigmoid', 'F.sigmoid', (['pred_logits'], {}), '(pred_logits)\n', (4760, 4773), True, 'import megengine.functional as F\n'), ((7984, 8014), 'megengine.functional.stack', 'F.stack', (['box_prob_list'], {'axis': '(0)'}), '(box_prob_list, axis=0)\n', (7991, 8014), True, 'import megengine.functional as F\n'), ((5523, 5593), 'megengine.functional.clip', 'F.clip', (['((overlaps - thresh1) / (thresh2 - thresh1))'], {'lower': '(0)', 'upper': '(1.0)'}), '((overlaps - thresh1) / (thresh2 - thresh1), lower=0, upper=1.0)\n', (5529, 5593), True, 'import megengine.functional as F\n'), ((6464, 6538), 'megengine.functional.topk', 'F.topk', (['match_quality_matrix'], {'k': 'bucket_size', 'descending': '(True)', 'no_sort': '(True)'}), '(match_quality_matrix, k=bucket_size, descending=True, no_sort=True)\n', (6470, 6538), True, 'import megengine.functional as F\n'), ((6796, 6845), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['gather_idx', '(num_gt, bucket_size)'], {}), '(gather_idx, (num_gt, bucket_size))\n', (6810, 6845), True, 'import megengine.functional as F\n'), ((7007, 7057), 'megengine.functional.indexing_one_hot', 'F.indexing_one_hot', (['gather_src', 'gather_idx'], {'axis': '(2)'}), '(gather_src, gather_idx, axis=2)\n', (7025, 7057), True, 'import megengine.functional as F\n'), ((7627, 7643), 'megengine.functional.exp', 'F.exp', (['(-reg_loss)'], {}), '(-reg_loss)\n', (7632, 7643), True, 'import megengine.functional as F\n'), ((7935, 7963), 'megengine.functional.maximum', 'F.maximum', (['num_foreground', '(1)'], {}), '(num_foreground, 1)\n', (7944, 7963), True, 'import megengine.functional as F\n'), ((8141, 8183), 'megengine.functional.maximum', 'F.maximum', (['(num_foreground * bucket_size)', '(1)'], {}), '(num_foreground * bucket_size, 1)\n', (8150, 8183), True, 'import megengine.functional as F\n'), ((1214, 1248), 'layers.get_norm', 'layers.get_norm', (['cfg.backbone_norm'], {}), '(cfg.backbone_norm)\n', (1229, 1248), False, 'import layers\n'), ((1611, 1706), 'layers.LastLevelP6P7', 'layers.LastLevelP6P7', (['cfg.fpn_top_in_channel', 'cfg.fpn_out_channels', 'cfg.fpn_top_in_feature'], {}), '(cfg.fpn_top_in_channel, cfg.fpn_out_channels, cfg.\n fpn_top_in_feature)\n', (1631, 1706), False, 'import layers\n'), ((2330, 2373), 'numpy.array', 'np.array', (['self.cfg.img_std'], {'dtype': '"""float32"""'}), "(self.cfg.img_std, dtype='float32')\n", (2338, 2373), True, 'import numpy as np\n'), ((3919, 3973), 'megengine.functional.concat', 'F.concat', (['[scale_w, scale_h, scale_w, scale_h]'], {'axis': '(0)'}), '([scale_w, scale_h, scale_w, scale_h], axis=0)\n', (3927, 3973), True, 'import megengine.functional as F\n'), ((4156, 4187), 'megengine.functional.sigmoid', 'F.sigmoid', (['all_level_box_logits'], {}), '(all_level_box_logits)\n', (4165, 4187), True, 'import megengine.functional as F\n'), ((4585, 4609), 'layers.safelog', 'layers.safelog', (['bag_prob'], {}), '(bag_prob)\n', (4599, 4609), False, 'import layers\n'), ((5817, 5861), 'megengine.functional.cond_take', 'F.cond_take', (['(gt_pred_prob != 0)', 'gt_pred_prob'], {}), '(gt_pred_prob != 0, gt_pred_prob)\n', (5828, 5861), True, 'import megengine.functional as F\n'), ((2252, 2296), 'numpy.array', 'np.array', (['self.cfg.img_mean'], {'dtype': '"""float32"""'}), "(self.cfg.img_mean, dtype='float32')\n", (2260, 2296), True, 'import numpy as np\n'), ((4032, 4085), 'layers.get_clipped_boxes', 'layers.get_clipped_boxes', (['pred_boxes', 'im_info[0, 2:4]'], {}), '(pred_boxes, im_info[0, 2:4])\n', (4056, 4085), False, 'import layers\n'), ((4698, 4726), 'layers.safelog', 'layers.safelog', (['(1.0 - logits)'], {}), '(1.0 - logits)\n', (4712, 4726), False, 'import layers\n'), ((5244, 5287), 'layers.get_iou', 'layers.get_iou', (['boxes_info[:, :4]', 'pred_box'], {}), '(boxes_info[:, :4], pred_box)\n', (5258, 5287), False, 'import layers\n'), ((5643, 5673), 'megengine.functional.zeros', 'F.zeros', (['pred_logits.shape[1:]'], {}), '(pred_logits.shape[1:])\n', (5650, 5673), True, 'import megengine.functional as F\n'), ((6332, 6374), 'layers.get_iou', 'layers.get_iou', (['boxes_info[:, :4]', 'anchors'], {}), '(boxes_info[:, :4], anchors)\n', (6346, 6374), False, 'import layers\n'), ((7901, 7926), 'megengine.functional.concat', 'F.concat', (['positive_losses'], {}), '(positive_losses)\n', (7909, 7926), True, 'import megengine.functional as F\n'), ((7178, 7218), 'megengine.functional.expand_dims', 'F.expand_dims', (['boxes_info[:, :4]'], {'axis': '(1)'}), '(boxes_info[:, :4], axis=1)\n', (7191, 7218), True, 'import megengine.functional as F\n'), ((7383, 7495), 'layers.smooth_l1_loss', 'layers.smooth_l1_loss', (['pred_offsets[bid, matched_idx_flatten]', 'matched_offsets'], {'beta': 'self.cfg.smooth_l1_beta'}), '(pred_offsets[bid, matched_idx_flatten],\n matched_offsets, beta=self.cfg.smooth_l1_beta)\n', (7404, 7495), False, 'import layers\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import megengine as mge
import megengine.functional as F
import megengine.hub as hub
import megengine.module as M
import official.vision.classification.resnet.model as resnet
import numpy as np
class DeconvLayers(M.Module):
def __init__(self, nf1, nf2s, kernels, num_layers, bias=True, norm=M.BatchNorm2d):
super(DeconvLayers, self).__init__()
_body = []
for i in range(num_layers):
kernel = kernels[i]
padding = (
kernel // 3
) # padding=0 when kernel=2 and padding=1 when kernel=4 or kernel=3
_body += [
M.ConvTranspose2d(nf1, nf2s[i], kernel, 2, padding, bias=bias),
norm(nf2s[i]),
M.ReLU(),
]
nf1 = nf2s[i]
self.body = M.Sequential(*_body)
def forward(self, x):
return self.body(x)
class SimpleBaseline(M.Module):
def __init__(self, backbone, cfg):
super(SimpleBaseline, self).__init__()
norm = M.BatchNorm2d
self.backbone = getattr(resnet, backbone)(
norm=norm, pretrained=cfg.backbone_pretrained
)
del self.backbone.fc
self.cfg = cfg
self.deconv_layers = DeconvLayers(
cfg.initial_deconv_channels,
cfg.deconv_channels,
cfg.deconv_kernel_sizes,
cfg.num_deconv_layers,
cfg.deconv_with_bias,
norm,
)
self.last_layer = M.Conv2d(cfg.deconv_channels[-1], cfg.keypoint_num, 3, 1, 1)
self._initialize_weights()
self.inputs = {
"image": mge.tensor(dtype="float32"),
"heatmap": mge.tensor(dtype="float32"),
"heat_valid": mge.tensor(dtype="float32"),
}
def calc_loss(self):
out = self.forward(self.inputs["image"])
valid = self.inputs["heat_valid"][:, :, None, None]
label = self.inputs["heatmap"][:, -1]
loss = F.square_loss(out * valid, label * valid)
return loss
def predict(self):
return self.forward(self.inputs["image"])
def _initialize_weights(self):
for k, m in self.deconv_layers.named_modules():
if isinstance(m, M.ConvTranspose2d):
M.init.normal_(m.weight, std=0.001)
if self.cfg.deconv_with_bias:
M.init.zeros_(m.bias)
if isinstance(m, M.BatchNorm2d):
M.init.ones_(m.weight)
M.init.zeros_(m.bias)
M.init.normal_(self.last_layer.weight, std=0.001)
M.init.zeros_(self.last_layer.bias)
def forward(self, x):
f = self.backbone.extract_features(x)["res5"]
f = self.deconv_layers(f)
pred = self.last_layer(f)
return pred
class SimpleBaseline_Config:
initial_deconv_channels = 2048
num_deconv_layers = 3
deconv_channels = [256, 256, 256]
deconv_kernel_sizes = [4, 4, 4]
deconv_with_bias = False
keypoint_num = 17
backbone_pretrained = True
cfg = SimpleBaseline_Config()
@hub.pretrained(
"https://data.megengine.org.cn/models/weights/simplebaseline50_256x192_0_255_71_2.pkl"
)
def simplebaseline_res50(**kwargs):
model = SimpleBaseline(backbone="resnet50", cfg=cfg, **kwargs)
return model
@hub.pretrained(
"https://data.megengine.org.cn/models/weights/simplebaseline101_256x192_0_255_72_2.pkl"
)
def simplebaseline_res101(**kwargs):
model = SimpleBaseline(backbone="resnet101", cfg=cfg, **kwargs)
return model
@hub.pretrained(
"https://data.megengine.org.cn/models/weights/simplebaseline152_256x192_0_255_72_4.pkl"
)
def simplebaseline_res152(**kwargs):
model = SimpleBaseline(backbone="resnet152", cfg=cfg, **kwargs)
return model
|
[
"megengine.module.init.zeros_",
"megengine.module.init.normal_",
"megengine.tensor",
"megengine.module.ReLU",
"megengine.module.Conv2d",
"megengine.module.init.ones_",
"megengine.module.ConvTranspose2d",
"megengine.functional.square_loss",
"megengine.module.Sequential",
"megengine.hub.pretrained"
] |
[((3431, 3543), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/models/weights/simplebaseline50_256x192_0_255_71_2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/models/weights/simplebaseline50_256x192_0_255_71_2.pkl'\n )\n", (3445, 3543), True, 'import megengine.hub as hub\n'), ((3664, 3777), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/models/weights/simplebaseline101_256x192_0_255_72_2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/models/weights/simplebaseline101_256x192_0_255_72_2.pkl'\n )\n", (3678, 3777), True, 'import megengine.hub as hub\n'), ((3900, 4013), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/models/weights/simplebaseline152_256x192_0_255_72_4.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/models/weights/simplebaseline152_256x192_0_255_72_4.pkl'\n )\n", (3914, 4013), True, 'import megengine.hub as hub\n'), ((1176, 1196), 'megengine.module.Sequential', 'M.Sequential', (['*_body'], {}), '(*_body)\n', (1188, 1196), True, 'import megengine.module as M\n'), ((1851, 1911), 'megengine.module.Conv2d', 'M.Conv2d', (['cfg.deconv_channels[-1]', 'cfg.keypoint_num', '(3)', '(1)', '(1)'], {}), '(cfg.deconv_channels[-1], cfg.keypoint_num, 3, 1, 1)\n', (1859, 1911), True, 'import megengine.module as M\n'), ((2336, 2377), 'megengine.functional.square_loss', 'F.square_loss', (['(out * valid)', '(label * valid)'], {}), '(out * valid, label * valid)\n', (2349, 2377), True, 'import megengine.functional as F\n'), ((2885, 2934), 'megengine.module.init.normal_', 'M.init.normal_', (['self.last_layer.weight'], {'std': '(0.001)'}), '(self.last_layer.weight, std=0.001)\n', (2899, 2934), True, 'import megengine.module as M\n'), ((2943, 2978), 'megengine.module.init.zeros_', 'M.init.zeros_', (['self.last_layer.bias'], {}), '(self.last_layer.bias)\n', (2956, 2978), True, 'import megengine.module as M\n'), ((1994, 2021), 'megengine.tensor', 'mge.tensor', ([], {'dtype': '"""float32"""'}), "(dtype='float32')\n", (2004, 2021), True, 'import megengine as mge\n'), ((2046, 2073), 'megengine.tensor', 'mge.tensor', ([], {'dtype': '"""float32"""'}), "(dtype='float32')\n", (2056, 2073), True, 'import megengine as mge\n'), ((2101, 2128), 'megengine.tensor', 'mge.tensor', ([], {'dtype': '"""float32"""'}), "(dtype='float32')\n", (2111, 2128), True, 'import megengine as mge\n'), ((995, 1057), 'megengine.module.ConvTranspose2d', 'M.ConvTranspose2d', (['nf1', 'nf2s[i]', 'kernel', '(2)', 'padding'], {'bias': 'bias'}), '(nf1, nf2s[i], kernel, 2, padding, bias=bias)\n', (1012, 1057), True, 'import megengine.module as M\n'), ((1106, 1114), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1112, 1114), True, 'import megengine.module as M\n'), ((2630, 2665), 'megengine.module.init.normal_', 'M.init.normal_', (['m.weight'], {'std': '(0.001)'}), '(m.weight, std=0.001)\n', (2644, 2665), True, 'import megengine.module as M\n'), ((2815, 2837), 'megengine.module.init.ones_', 'M.init.ones_', (['m.weight'], {}), '(m.weight)\n', (2827, 2837), True, 'import megengine.module as M\n'), ((2854, 2875), 'megengine.module.init.zeros_', 'M.init.zeros_', (['m.bias'], {}), '(m.bias)\n', (2867, 2875), True, 'import megengine.module as M\n'), ((2732, 2753), 'megengine.module.init.zeros_', 'M.init.zeros_', (['m.bias'], {}), '(m.bias)\n', (2745, 2753), True, 'import megengine.module as M\n')]
|
# -*- coding: utf-8 -*-
# MIT License
#
# Copyright (c) 2019 Megvii Technology
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# ------------------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# This file has been modified by Megvii ("Megvii Modifications").
# All Megvii Modifications are Copyright (C) 2014-2019 Megvii Inc. All rights reserved.
# ------------------------------------------------------------------------------
import argparse
import multiprocessing as mp
import os
import time
import megengine as mge
import megengine.data as data
import megengine.data.transform as T
import megengine.distributed as dist
import megengine.functional as F
import megengine.jit as jit
import megengine.optimizer as optim
import shufflenet_v2 as M
from tensorboardX import SummaryWriter
logger = mge.get_logger(__name__)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-a", "--arch", default="shufflenet_v2_x0_5", type=str)
parser.add_argument("-d", "--data", default=None, type=str)
parser.add_argument("-s", "--save", default="./models", type=str)
parser.add_argument("-m", "--model", default=None, type=str)
parser.add_argument('-o', '--output', type=str, required=True, help='set path for checkpoints \w tensorboard')
parser.add_argument("-b", "--batch-size", default=128, type=int)
parser.add_argument("--learning-rate", default=0.0625, type=float)
parser.add_argument("--momentum", default=0.9, type=float)
parser.add_argument("--weight-decay", default=4e-5, type=float)
parser.add_argument("--steps", default=300000, type=int)
parser.add_argument("-n", "--ngpus", default=None, type=int)
parser.add_argument("-w", "--workers", default=4, type=int)
parser.add_argument("--report-freq", default=50, type=int)
args = parser.parse_args()
world_size = mge.get_device_count("gpu") if args.ngpus is None else args.ngpus
save_dir = os.path.join(args.save, args.arch, "b{}".format(args.batch_size * world_size))
if not os.path.exists(save_dir):
os.makedirs(save_dir)
mge.set_log_file(os.path.join(save_dir, "log.txt"))
if not os.path.exists(args.output):
os.makedirs(args.output)
if world_size > 1:
# scale learning rate by number of gpus
args.learning_rate *= world_size
# start distributed training, dispatch sub-processes
mp.set_start_method("spawn")
processes = []
for rank in range(world_size):
p = mp.Process(target=worker, args=(rank, world_size, args))
p.start()
processes.append(p)
for p in processes:
p.join()
else:
worker(0, 1, args)
def get_parameters(model):
group_no_weight_decay = []
group_weight_decay = []
for pname, p in model.named_parameters(requires_grad=True):
if pname.find("weight") >= 0 and len(p.shape) > 1:
# print("include ", pname, p.shape)
group_weight_decay.append(p)
else:
# print("not include ", pname, p.shape)
group_no_weight_decay.append(p)
assert len(list(model.parameters())) == len(group_weight_decay) + len(
group_no_weight_decay
)
groups = [
dict(params=group_weight_decay),
dict(params=group_no_weight_decay, weight_decay=0.0),
]
return groups
def worker(rank, world_size, args):
# pylint: disable=too-many-statements
mge.set_log_file(os.path.join(args.save, args.arch, "log.txt"))
if world_size > 1:
# Initialize distributed process group
logger.info("init distributed process group {} / {}".format(rank, world_size))
dist.init_process_group(
master_ip="localhost",
master_port=23456,
world_size=world_size,
rank=rank,
dev=rank,
)
save_dir = os.path.join(args.save, args.arch)
if rank == 0:
prefixs=['train', 'valid']
writers = {prefix: SummaryWriter(os.path.join(args.output, prefix)) for prefix in prefixs}
model = getattr(M, args.arch)()
step_start = 0
if args.model:
logger.info("load weights from %s", args.model)
model.load_state_dict(mge.load(args.model))
step_start = int(args.model.split("-")[1].split(".")[0])
optimizer = optim.SGD(
get_parameters(model),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay,
)
# Define train and valid graph
@jit.trace(symbolic=True)
def train_func(image, label):
model.train()
logits = model(image)
loss = F.cross_entropy_with_softmax(logits, label, label_smooth=0.1)
acc1, acc5 = F.accuracy(logits, label, (1, 5))
optimizer.backward(loss) # compute gradients
if dist.is_distributed(): # all_reduce_mean
loss = dist.all_reduce_sum(loss) / dist.get_world_size()
acc1 = dist.all_reduce_sum(acc1) / dist.get_world_size()
acc5 = dist.all_reduce_sum(acc5) / dist.get_world_size()
return loss, acc1, acc5
@jit.trace(symbolic=True)
def valid_func(image, label):
model.eval()
logits = model(image)
loss = F.cross_entropy_with_softmax(logits, label, label_smooth=0.1)
acc1, acc5 = F.accuracy(logits, label, (1, 5))
if dist.is_distributed(): # all_reduce_mean
loss = dist.all_reduce_sum(loss) / dist.get_world_size()
acc1 = dist.all_reduce_sum(acc1) / dist.get_world_size()
acc5 = dist.all_reduce_sum(acc5) / dist.get_world_size()
return loss, acc1, acc5
# Build train and valid datasets
logger.info("preparing dataset..")
train_dataset = data.dataset.ImageNet(args.data, train=True)
train_sampler = data.Infinite(data.RandomSampler(
train_dataset, batch_size=args.batch_size, drop_last=True
))
train_queue = data.DataLoader(
train_dataset,
sampler=train_sampler,
transform=T.Compose(
[
T.RandomResizedCrop(224),
T.RandomHorizontalFlip(),
T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
T.ToMode("CHW"),
]
),
num_workers=args.workers,
)
train_queue = iter(train_queue)
valid_dataset = data.dataset.ImageNet(args.data, train=False)
valid_sampler = data.SequentialSampler(
valid_dataset, batch_size=100, drop_last=False
)
valid_queue = data.DataLoader(
valid_dataset,
sampler=valid_sampler,
transform=T.Compose(
[
T.Resize(256),
T.CenterCrop(224),
T.ToMode("CHW"),
]
),
num_workers=args.workers,
)
# Start training
objs = AverageMeter("Loss")
top1 = AverageMeter("Acc@1")
top5 = AverageMeter("Acc@5")
total_time = AverageMeter("Time")
t = time.time()
for step in range(step_start, args.steps + 1):
# Linear learning rate decay
decay = 1.0
decay = 1 - float(step) / args.steps if step < args.steps else 0
for param_group in optimizer.param_groups:
param_group["lr"] = args.learning_rate * decay
image, label = next(train_queue)
time_data=time.time()-t
image = image.astype("float32")
label = label.astype("int32")
n = image.shape[0]
optimizer.zero_grad()
loss, acc1, acc5 = train_func(image, label)
optimizer.step()
top1.update(100 * acc1.numpy()[0], n)
top5.update(100 * acc5.numpy()[0], n)
objs.update(loss.numpy()[0], n)
total_time.update(time.time() - t)
time_iter=time.time()-t
t = time.time()
if step % args.report_freq == 0 and rank == 0:
logger.info(
"TRAIN Iter %06d: lr = %f,\tloss = %f,\twc_loss = 1,\tTop-1 err = %f,\tTop-5 err = %f,\tdata_time = %f,\ttrain_time = %f,\tremain_hours=%f",
step,
args.learning_rate * decay,
float(objs.__str__().split()[1]),
1-float(top1.__str__().split()[1])/100,
1-float(top5.__str__().split()[1])/100,
time_data,
time_iter - time_data,
time_iter * (args.steps - step) / 3600,
)
writers['train'].add_scalar('loss', float(objs.__str__().split()[1]), global_step=step)
writers['train'].add_scalar('top1_err', 1-float(top1.__str__().split()[1])/100, global_step=step)
writers['train'].add_scalar('top5_err', 1-float(top5.__str__().split()[1])/100, global_step=step)
objs.reset()
top1.reset()
top5.reset()
total_time.reset()
if step % 10000 == 0 and rank == 0 and step != 0:
logger.info("SAVING %06d", step)
mge.save(
model.state_dict(),
os.path.join(save_dir, "checkpoint-{:06d}.pkl".format(step)),
)
if step % 10000 == 0 and step != 0:
loss, valid_acc, valid_acc5 = infer(valid_func, valid_queue, args)
logger.info("TEST Iter %06d: loss = %f,\tTop-1 err = %f,\tTop-5 err = %f", step, loss, 1-valid_acc/100, 1-valid_acc5/100)
if rank == 0:
writers['valid'].add_scalar('loss', loss, global_step=step)
writers['valid'].add_scalar('top1_err', 1-valid_acc/100, global_step=step)
writers['valid'].add_scalar('top5_err', 1-valid_acc5/100, global_step=step)
mge.save(
model.state_dict(), os.path.join(save_dir, "checkpoint-{:06d}.pkl".format(step))
)
loss, valid_acc, valid_acc5 = infer(valid_func, valid_queue, args)
logger.info("TEST Iter %06d: loss=%f,\tTop-1 err = %f,\tTop-5 err = %f", step, _, 1-valid_acc/100, 1-valid_acc5/100)
def infer(model, data_queue, args):
objs = AverageMeter("Loss")
top1 = AverageMeter("Acc@1")
top5 = AverageMeter("Acc@5")
total_time = AverageMeter("Time")
t = time.time()
for step, (image, label) in enumerate(data_queue):
n = image.shape[0]
image = image.astype("float32") # convert np.uint8 to float32
label = label.astype("int32")
loss, acc1, acc5 = model(image, label)
objs.update(loss.numpy()[0], n)
top1.update(100 * acc1.numpy()[0], n)
top5.update(100 * acc5.numpy()[0], n)
total_time.update(time.time() - t)
t = time.time()
if step % args.report_freq == 0 and dist.get_rank() == 0:
logger.info(
"Step %d, %s %s %s %s",
step,
objs,
top1,
top5,
total_time,
)
return objs.avg, top1.avg, top5.avg
class AverageMeter:
"""Computes and stores the average and current value"""
def __init__(self, name, fmt=":.3f"):
self.name = name
self.fmt = fmt
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def __str__(self):
fmtstr = "{name} {val" + self.fmt + "} ({avg" + self.fmt + "})"
return fmtstr.format(**self.__dict__)
if __name__ == "__main__":
main()
|
[
"megengine.get_device_count",
"megengine.distributed.is_distributed",
"megengine.data.transform.ToMode",
"megengine.data.transform.CenterCrop",
"megengine.data.SequentialSampler",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.data.dataset.ImageNet",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.jit.trace",
"megengine.data.transform.Resize",
"megengine.data.transform.ColorJitter",
"megengine.data.RandomSampler",
"megengine.functional.accuracy",
"megengine.data.transform.RandomResizedCrop",
"megengine.distributed.all_reduce_sum",
"megengine.functional.cross_entropy_with_softmax",
"megengine.distributed.init_process_group",
"megengine.load"
] |
[((2178, 2202), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (2192, 2202), True, 'import megengine as mge\n'), ((2230, 2255), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2253, 2255), False, 'import argparse\n'), ((5245, 5279), 'os.path.join', 'os.path.join', (['args.save', 'args.arch'], {}), '(args.save, args.arch)\n', (5257, 5279), False, 'import os\n'), ((5890, 5914), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (5899, 5914), True, 'import megengine.jit as jit\n'), ((6485, 6509), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (6494, 6509), True, 'import megengine.jit as jit\n'), ((7116, 7160), 'megengine.data.dataset.ImageNet', 'data.dataset.ImageNet', (['args.data'], {'train': '(True)'}), '(args.data, train=True)\n', (7137, 7160), True, 'import megengine.data as data\n'), ((7737, 7782), 'megengine.data.dataset.ImageNet', 'data.dataset.ImageNet', (['args.data'], {'train': '(False)'}), '(args.data, train=False)\n', (7758, 7782), True, 'import megengine.data as data\n'), ((7803, 7873), 'megengine.data.SequentialSampler', 'data.SequentialSampler', (['valid_dataset'], {'batch_size': '(100)', 'drop_last': '(False)'}), '(valid_dataset, batch_size=100, drop_last=False)\n', (7825, 7873), True, 'import megengine.data as data\n'), ((8351, 8362), 'time.time', 'time.time', ([], {}), '()\n', (8360, 8362), False, 'import time\n'), ((11489, 11500), 'time.time', 'time.time', ([], {}), '()\n', (11498, 11500), False, 'import time\n'), ((3225, 3252), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (3245, 3252), True, 'import megengine as mge\n'), ((3397, 3421), 'os.path.exists', 'os.path.exists', (['save_dir'], {}), '(save_dir)\n', (3411, 3421), False, 'import os\n'), ((3431, 3452), 'os.makedirs', 'os.makedirs', (['save_dir'], {}), '(save_dir)\n', (3442, 3452), False, 'import os\n'), ((3474, 3507), 'os.path.join', 'os.path.join', (['save_dir', '"""log.txt"""'], {}), "(save_dir, 'log.txt')\n", (3486, 3507), False, 'import os\n'), ((3521, 3548), 'os.path.exists', 'os.path.exists', (['args.output'], {}), '(args.output)\n', (3535, 3548), False, 'import os\n'), ((3558, 3582), 'os.makedirs', 'os.makedirs', (['args.output'], {}), '(args.output)\n', (3569, 3582), False, 'import os\n'), ((3766, 3794), 'multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (3785, 3794), True, 'import multiprocessing as mp\n'), ((4835, 4880), 'os.path.join', 'os.path.join', (['args.save', 'args.arch', '"""log.txt"""'], {}), "(args.save, args.arch, 'log.txt')\n", (4847, 4880), False, 'import os\n'), ((5048, 5161), 'megengine.distributed.init_process_group', 'dist.init_process_group', ([], {'master_ip': '"""localhost"""', 'master_port': '(23456)', 'world_size': 'world_size', 'rank': 'rank', 'dev': 'rank'}), "(master_ip='localhost', master_port=23456,\n world_size=world_size, rank=rank, dev=rank)\n", (5071, 5161), True, 'import megengine.distributed as dist\n'), ((6016, 6077), 'megengine.functional.cross_entropy_with_softmax', 'F.cross_entropy_with_softmax', (['logits', 'label'], {'label_smooth': '(0.1)'}), '(logits, label, label_smooth=0.1)\n', (6044, 6077), True, 'import megengine.functional as F\n'), ((6099, 6132), 'megengine.functional.accuracy', 'F.accuracy', (['logits', 'label', '(1, 5)'], {}), '(logits, label, (1, 5))\n', (6109, 6132), True, 'import megengine.functional as F\n'), ((6198, 6219), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (6217, 6219), True, 'import megengine.distributed as dist\n'), ((6610, 6671), 'megengine.functional.cross_entropy_with_softmax', 'F.cross_entropy_with_softmax', (['logits', 'label'], {'label_smooth': '(0.1)'}), '(logits, label, label_smooth=0.1)\n', (6638, 6671), True, 'import megengine.functional as F\n'), ((6693, 6726), 'megengine.functional.accuracy', 'F.accuracy', (['logits', 'label', '(1, 5)'], {}), '(logits, label, (1, 5))\n', (6703, 6726), True, 'import megengine.functional as F\n'), ((6738, 6759), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (6757, 6759), True, 'import megengine.distributed as dist\n'), ((7195, 7272), 'megengine.data.RandomSampler', 'data.RandomSampler', (['train_dataset'], {'batch_size': 'args.batch_size', 'drop_last': '(True)'}), '(train_dataset, batch_size=args.batch_size, drop_last=True)\n', (7213, 7272), True, 'import megengine.data as data\n'), ((9162, 9173), 'time.time', 'time.time', ([], {}), '()\n', (9171, 9173), False, 'import time\n'), ((11928, 11939), 'time.time', 'time.time', ([], {}), '()\n', (11937, 11939), False, 'import time\n'), ((3873, 3929), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(rank, world_size, args)'}), '(target=worker, args=(rank, world_size, args))\n', (3883, 3929), True, 'import multiprocessing as mp\n'), ((5594, 5614), 'megengine.load', 'mge.load', (['args.model'], {}), '(args.model)\n', (5602, 5614), True, 'import megengine as mge\n'), ((8714, 8725), 'time.time', 'time.time', ([], {}), '()\n', (8723, 8725), False, 'import time\n'), ((9136, 9147), 'time.time', 'time.time', ([], {}), '()\n', (9145, 9147), False, 'import time\n'), ((5375, 5408), 'os.path.join', 'os.path.join', (['args.output', 'prefix'], {}), '(args.output, prefix)\n', (5387, 5408), False, 'import os\n'), ((6259, 6284), 'megengine.distributed.all_reduce_sum', 'dist.all_reduce_sum', (['loss'], {}), '(loss)\n', (6278, 6284), True, 'import megengine.distributed as dist\n'), ((6287, 6308), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (6306, 6308), True, 'import megengine.distributed as dist\n'), ((6328, 6353), 'megengine.distributed.all_reduce_sum', 'dist.all_reduce_sum', (['acc1'], {}), '(acc1)\n', (6347, 6353), True, 'import megengine.distributed as dist\n'), ((6356, 6377), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (6375, 6377), True, 'import megengine.distributed as dist\n'), ((6397, 6422), 'megengine.distributed.all_reduce_sum', 'dist.all_reduce_sum', (['acc5'], {}), '(acc5)\n', (6416, 6422), True, 'import megengine.distributed as dist\n'), ((6425, 6446), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (6444, 6446), True, 'import megengine.distributed as dist\n'), ((6799, 6824), 'megengine.distributed.all_reduce_sum', 'dist.all_reduce_sum', (['loss'], {}), '(loss)\n', (6818, 6824), True, 'import megengine.distributed as dist\n'), ((6827, 6848), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (6846, 6848), True, 'import megengine.distributed as dist\n'), ((6868, 6893), 'megengine.distributed.all_reduce_sum', 'dist.all_reduce_sum', (['acc1'], {}), '(acc1)\n', (6887, 6893), True, 'import megengine.distributed as dist\n'), ((6896, 6917), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (6915, 6917), True, 'import megengine.distributed as dist\n'), ((6937, 6962), 'megengine.distributed.all_reduce_sum', 'dist.all_reduce_sum', (['acc5'], {}), '(acc5)\n', (6956, 6962), True, 'import megengine.distributed as dist\n'), ((6965, 6986), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (6984, 6986), True, 'import megengine.distributed as dist\n'), ((9101, 9112), 'time.time', 'time.time', ([], {}), '()\n', (9110, 9112), False, 'import time\n'), ((11899, 11910), 'time.time', 'time.time', ([], {}), '()\n', (11908, 11910), False, 'import time\n'), ((11985, 12000), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (11998, 12000), True, 'import megengine.distributed as dist\n'), ((7436, 7460), 'megengine.data.transform.RandomResizedCrop', 'T.RandomResizedCrop', (['(224)'], {}), '(224)\n', (7455, 7460), True, 'import megengine.data.transform as T\n'), ((7478, 7502), 'megengine.data.transform.RandomHorizontalFlip', 'T.RandomHorizontalFlip', ([], {}), '()\n', (7500, 7502), True, 'import megengine.data.transform as T\n'), ((7520, 7579), 'megengine.data.transform.ColorJitter', 'T.ColorJitter', ([], {'brightness': '(0.4)', 'contrast': '(0.4)', 'saturation': '(0.4)'}), '(brightness=0.4, contrast=0.4, saturation=0.4)\n', (7533, 7579), True, 'import megengine.data.transform as T\n'), ((7597, 7612), 'megengine.data.transform.ToMode', 'T.ToMode', (['"""CHW"""'], {}), "('CHW')\n", (7605, 7612), True, 'import megengine.data.transform as T\n'), ((8036, 8049), 'megengine.data.transform.Resize', 'T.Resize', (['(256)'], {}), '(256)\n', (8044, 8049), True, 'import megengine.data.transform as T\n'), ((8067, 8084), 'megengine.data.transform.CenterCrop', 'T.CenterCrop', (['(224)'], {}), '(224)\n', (8079, 8084), True, 'import megengine.data.transform as T\n'), ((8102, 8117), 'megengine.data.transform.ToMode', 'T.ToMode', (['"""CHW"""'], {}), "('CHW')\n", (8110, 8117), True, 'import megengine.data.transform as T\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.jit as jit
import megengine.module as M
import megengine.random as R
def test_random_static_diff_result():
@jit.trace(symbolic=True)
def graph_a():
return R.uniform(5) + R.gaussian(5)
@jit.trace(symbolic=True)
def graph_b():
return R.uniform(5) + R.gaussian(5)
a = graph_a()
b = graph_b()
assert np.any(a.numpy() != b.numpy())
def test_random_static_same_result():
@jit.trace(symbolic=True)
def graph_a():
R.manual_seed(731)
return R.uniform(5) + R.gaussian(5)
@jit.trace(symbolic=True)
def graph_b():
R.manual_seed(731)
return R.uniform(5) + R.gaussian(5)
a = graph_a()
b = graph_b()
assert np.all(a.numpy() == b.numpy())
def test_random_dynamic_diff_result():
a = R.uniform(5) + R.gaussian(5)
b = R.uniform(5) + R.gaussian(5)
assert np.any(a.numpy() != b.numpy())
def test_random_dynamic_same_result():
R.manual_seed(0)
a = R.uniform(5) + R.gaussian(5)
R.manual_seed(0)
b = R.uniform(5) + R.gaussian(5)
assert np.all(a.numpy() == b.numpy())
def test_dropout_dynamic_diff_result():
x = mge.ones(10)
a = F.dropout(x, 0.5)
b = F.dropout(x, 0.5)
assert np.any(a.numpy() != b.numpy())
def test_dropout_dynamic_same_result():
x = mge.ones(10)
R.manual_seed(0)
a = F.dropout(x, 0.5)
R.manual_seed(0)
b = F.dropout(x, 0.5)
assert np.all(a.numpy() == b.numpy())
def test_M_dropout_static_diff_result():
m = M.Dropout(0.5)
@jit.trace(symbolic=True)
def graph_a(x):
return m(x)
@jit.trace(symbolic=True)
def graph_b(x):
return m(x)
x = np.ones(10, dtype="float32")
a = graph_a(x)
a = a.numpy().copy()
b = graph_b(x)
c = graph_a(x)
assert np.any(a != b.numpy())
assert np.any(a != c.numpy())
def test_M_dropout_static_same_result():
m = M.Dropout(0.5)
@jit.trace(symbolic=True)
def graph_a(x):
return m(x)
@jit.trace(symbolic=True)
def graph_b(x):
return m(x)
x = np.ones(10, dtype="float32")
R.manual_seed(0)
a = graph_a(x)
a = a.numpy().copy()
R.manual_seed(0)
b = graph_b(x)
R.manual_seed(0) # useless
c = graph_a(x)
assert np.all(a == b.numpy())
assert np.any(a != c.numpy())
|
[
"megengine.module.Dropout",
"megengine.jit.trace",
"megengine.functional.dropout",
"megengine.random.uniform",
"megengine.ones",
"megengine.random.gaussian",
"megengine.random.manual_seed"
] |
[((585, 609), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (594, 609), True, 'import megengine.jit as jit\n'), ((679, 703), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (688, 703), True, 'import megengine.jit as jit\n'), ((891, 915), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (900, 915), True, 'import megengine.jit as jit\n'), ((1012, 1036), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (1021, 1036), True, 'import megengine.jit as jit\n'), ((1408, 1424), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (1421, 1424), True, 'import megengine.random as R\n'), ((1466, 1482), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (1479, 1482), True, 'import megengine.random as R\n'), ((1612, 1624), 'megengine.ones', 'mge.ones', (['(10)'], {}), '(10)\n', (1620, 1624), True, 'import megengine as mge\n'), ((1633, 1650), 'megengine.functional.dropout', 'F.dropout', (['x', '(0.5)'], {}), '(x, 0.5)\n', (1642, 1650), True, 'import megengine.functional as F\n'), ((1659, 1676), 'megengine.functional.dropout', 'F.dropout', (['x', '(0.5)'], {}), '(x, 0.5)\n', (1668, 1676), True, 'import megengine.functional as F\n'), ((1769, 1781), 'megengine.ones', 'mge.ones', (['(10)'], {}), '(10)\n', (1777, 1781), True, 'import megengine as mge\n'), ((1786, 1802), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (1799, 1802), True, 'import megengine.random as R\n'), ((1811, 1828), 'megengine.functional.dropout', 'F.dropout', (['x', '(0.5)'], {}), '(x, 0.5)\n', (1820, 1828), True, 'import megengine.functional as F\n'), ((1833, 1849), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (1846, 1849), True, 'import megengine.random as R\n'), ((1858, 1875), 'megengine.functional.dropout', 'F.dropout', (['x', '(0.5)'], {}), '(x, 0.5)\n', (1867, 1875), True, 'import megengine.functional as F\n'), ((1969, 1983), 'megengine.module.Dropout', 'M.Dropout', (['(0.5)'], {}), '(0.5)\n', (1978, 1983), True, 'import megengine.module as M\n'), ((1990, 2014), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (1999, 2014), True, 'import megengine.jit as jit\n'), ((2061, 2085), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (2070, 2085), True, 'import megengine.jit as jit\n'), ((2135, 2163), 'numpy.ones', 'np.ones', (['(10)'], {'dtype': '"""float32"""'}), "(10, dtype='float32')\n", (2142, 2163), True, 'import numpy as np\n'), ((2365, 2379), 'megengine.module.Dropout', 'M.Dropout', (['(0.5)'], {}), '(0.5)\n', (2374, 2379), True, 'import megengine.module as M\n'), ((2386, 2410), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (2395, 2410), True, 'import megengine.jit as jit\n'), ((2457, 2481), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (2466, 2481), True, 'import megengine.jit as jit\n'), ((2531, 2559), 'numpy.ones', 'np.ones', (['(10)'], {'dtype': '"""float32"""'}), "(10, dtype='float32')\n", (2538, 2559), True, 'import numpy as np\n'), ((2564, 2580), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (2577, 2580), True, 'import megengine.random as R\n'), ((2629, 2645), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (2642, 2645), True, 'import megengine.random as R\n'), ((2669, 2685), 'megengine.random.manual_seed', 'R.manual_seed', (['(0)'], {}), '(0)\n', (2682, 2685), True, 'import megengine.random as R\n'), ((943, 961), 'megengine.random.manual_seed', 'R.manual_seed', (['(731)'], {}), '(731)\n', (956, 961), True, 'import megengine.random as R\n'), ((1064, 1082), 'megengine.random.manual_seed', 'R.manual_seed', (['(731)'], {}), '(731)\n', (1077, 1082), True, 'import megengine.random as R\n'), ((1255, 1267), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (1264, 1267), True, 'import megengine.random as R\n'), ((1270, 1283), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (1280, 1283), True, 'import megengine.random as R\n'), ((1292, 1304), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (1301, 1304), True, 'import megengine.random as R\n'), ((1307, 1320), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (1317, 1320), True, 'import megengine.random as R\n'), ((1433, 1445), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (1442, 1445), True, 'import megengine.random as R\n'), ((1448, 1461), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (1458, 1461), True, 'import megengine.random as R\n'), ((1491, 1503), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (1500, 1503), True, 'import megengine.random as R\n'), ((1506, 1519), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (1516, 1519), True, 'import megengine.random as R\n'), ((644, 656), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (653, 656), True, 'import megengine.random as R\n'), ((659, 672), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (669, 672), True, 'import megengine.random as R\n'), ((738, 750), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (747, 750), True, 'import megengine.random as R\n'), ((753, 766), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (763, 766), True, 'import megengine.random as R\n'), ((977, 989), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (986, 989), True, 'import megengine.random as R\n'), ((992, 1005), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (1002, 1005), True, 'import megengine.random as R\n'), ((1098, 1110), 'megengine.random.uniform', 'R.uniform', (['(5)'], {}), '(5)\n', (1107, 1110), True, 'import megengine.random as R\n'), ((1113, 1126), 'megengine.random.gaussian', 'R.gaussian', (['(5)'], {}), '(5)\n', (1123, 1126), True, 'import megengine.random as R\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import bisect
import os
import time
import pickle
import numpy as np
import megengine.amp as amp
import megengine as mge
import megengine.distributed as dist
from megengine.autodiff import GradManager
from megengine.data import DataLoader, Infinite, RandomSampler
from megengine.data import transform as T
from megengine.optimizer import SGD
import megengine.jit as jit
from tools.utils import (
AverageMeter,
DetectionPadCollator,
GroupedRandomSampler,
PseudoDetectionDataset,
get_config_info,
import_from_file
)
logger = mge.get_logger(__name__)
logger.setLevel("INFO")
mge.device.set_prealloc_config(1024, 1024, 512 * 1024 * 1024, 2.0)
def make_parser():
parser = argparse.ArgumentParser()
parser.add_argument(
"-a", "--arch", type=str, help="model architecture",
)
parser.add_argument(
"-n", "--ngpus", default=1, type=int, help="total number of gpus for training",
)
parser.add_argument(
"-b", "--batch-size", default=2, type=int, help="batchsize for training",
)
parser.add_argument(
"-s", "--steps", default=100, type=int, help="number of train steps (default: 100)",
)
parser.add_argument(
"--trace",
action='store_true',
default=False,
help="whether use trace or not (default: False)",
)
parser.add_argument(
"--preloader",
action='store_true',
default=False,
help="whether use preloader or not (default: False)",
)
parser.add_argument(
"--symbolic",
action='store_true',
default=False,
help="whether use symbolic trace or not (default: False)",
)
parser.add_argument(
"-d", "--loader", default=False, action="store_true", help="use pseudo detection dataset loader",
)
parser.add_argument(
"-p", "--print-freq", default=1, type=int, help="print frequency (default: 1)",
)
parser.add_argument(
"-m",
"--mode",
default="normal",
type=str,
choices=["normal", "mp"],
help="Quantization Mode\n"
"normal: no quantization, using float32\n"
"mp: input type is fp16",
)
parser.add_argument("--preload", default=False, action="store_true", help="whether use preload")
return parser
def main():
parser = make_parser()
args = parser.parse_args()
# ------------------------ begin training -------------------------- #
if args.ngpus > 1:
train_func = dist.launcher(worker, n_gpus=args.ngpus)
train_func(args)
else:
worker(args)
def worker(args):
config_file = {
"faster_rcnn": "configs/faster_rcnn_res50_coco_1x_800size.py",
"atss": "configs/atss_res50_coco_1x_800size.py",
"retinanet": "configs/retinanet_res50_coco_1x_800size.py",
}[args.arch]
current_network = import_from_file(config_file)
model = current_network.Net(current_network.Cfg())
model.train()
# if dist.get_rank() == 0:
# logger.info(get_config_info(model.cfg))
# logger.info(repr(model))
params_with_grad = []
for name, param in model.named_parameters():
if "bottom_up.conv1" in name and model.cfg.backbone_freeze_at >= 1:
continue
if "bottom_up.layer1" in name and model.cfg.backbone_freeze_at >= 2:
continue
params_with_grad.append(param)
opt = SGD(
params_with_grad,
lr=model.cfg.basic_lr * args.batch_size,
momentum=model.cfg.momentum,
weight_decay=model.cfg.weight_decay * dist.get_world_size(),
)
gm = GradManager()
if dist.get_world_size() > 1:
gm.attach(
params_with_grad,
callbacks=[dist.make_allreduce_cb("SUM", dist.WORLD)]
)
else:
gm.attach(params_with_grad)
if dist.get_world_size() > 1:
dist.bcast_list_(model.parameters(), dist.WORLD) # sync parameters
train_loader = None
for epoch in range(1):
train_one_epoch(model, train_loader, opt, gm, epoch, args)
def train_one_epoch(model, data_queue, opt, gm, epoch, args):
@amp.autocast(enabled=args.mode == "mp")
def train_func(image, im_info, gt_boxes):
with gm:
loss_dict = model(image=image, im_info=im_info, gt_boxes=gt_boxes)
gm.backward(loss_dict["total_loss"])
loss_list = list(loss_dict.values())
opt.step().clear_grad()
return loss_list
if args.trace:
if args.symbolic:
train_func = jit.trace(train_func, symbolic=True, sublinear_memory_config=jit.SublinearMemoryConfig(genetic_nr_iter=50), symbolic_shape=True)
else:
train_func = jit.trace(train_func, symbolic=False, symbolic_shape=False)
else:
assert args.symbolic==False, "invalid arguments: trace=Trace, symbolic=True"
loss_meter = AverageMeter(record_len=model.cfg.num_losses)
time_meter = AverageMeter(record_len=2)
log_interval = model.cfg.log_interval
tot_step = model.cfg.nr_images_epoch // (args.batch_size * dist.get_world_size())
file_dir = os.path.dirname(os.path.abspath(__file__))
data_path = os.path.join(file_dir, 'batch.pkl') # batch_size for batch.pkl is 2
mini_batch = pickle.load(open(data_path, "rb"))
if args.batch_size != 2:
repeats = (args.batch_size+1) // 2
mini_batch['data'] = np.concatenate([mini_batch['data'],]*repeats)[:args.batch_size]
mini_batch['im_info'] = np.concatenate([mini_batch['im_info'],]*repeats)[:args.batch_size]
mini_batch['gt_boxes'] = np.concatenate([mini_batch['gt_boxes'],]*repeats)[:args.batch_size]
# warm up
for step in range(10):
if data_queue:
mini_batch = next(data_queue)
loss_list = train_func(
image=mge.tensor(mini_batch["data"]),
im_info=mge.tensor(mini_batch["im_info"]),
gt_boxes=mge.tensor(mini_batch["gt_boxes"])
)
_ = [loss.numpy() for loss in loss_list]
for step in range(args.steps):
tik = time.time()
if data_queue:
mini_batch = next(data_queue)
data_tok = time.time()
loss_list = train_func(
image=mge.tensor(mini_batch["data"]),
im_info=mge.tensor(mini_batch["im_info"]),
gt_boxes=mge.tensor(mini_batch["gt_boxes"])
)
loss_meter.update([loss.numpy().item() for loss in loss_list])
tok = time.time()
time_meter.update([tok - tik, data_tok - tik])
if step % args.print_freq == 0 and dist.get_rank() == 0:
print(
"Step {}, Loss ({}), Time (tot:{:.3f}, data:{:.3f})".format(
step,
"".join(["{:.3f} ".format(t) for t in loss_meter.average()]),
*time_meter.average(),
))
loss_meter.reset()
if dist.get_rank() == 0:
print("="*20, "summary", "="*20)
print(" benchmark: detection")
if args.trace:
print(" mode: trace(symbolic={})".format("True, sublinear=True" if args.symbolic else "False"))
else:
print(" mode: imperative")
print(" loader: {}".format("" if not args.loader else "--loader"))
if args.loader:
print(" preload: {}".format("" if not args.preload else "--preload"))
print(" arch: {}".format(args.arch))
print("train_mode: {}".format(args.mode))
print(" batchsize: {}".format(args.batch_size))
print(" #GPU: {}".format(args.ngpus))
print(" avg time: {:.3f} seconds".format(time_meter.average()[0]))
# pylint: disable=unused-argument
def build_dataset(dataset_dir, cfg):
return PseudoDetectionDataset(order=["image", "boxes", "boxes_category", "info"])
# pylint: disable=dangerous-default-value
def build_sampler(train_dataset, batch_size, aspect_grouping=[1]):
def _compute_aspect_ratios(dataset):
aspect_ratios = []
for i in range(len(dataset)):
info = dataset.get_img_info(i)
aspect_ratios.append(info["height"] / info["width"])
return aspect_ratios
def _quantize(x, bins):
return list(map(lambda y: bisect.bisect_right(sorted(bins), y), x))
if len(aspect_grouping) == 0:
return Infinite(RandomSampler(train_dataset, batch_size, drop_last=True))
aspect_ratios = _compute_aspect_ratios(train_dataset)
group_ids = _quantize(aspect_ratios, aspect_grouping)
return Infinite(GroupedRandomSampler(train_dataset, batch_size, group_ids))
def build_dataloader(batch_size, dataset_dir, cfg, preloader= False):
train_dataset = build_dataset(dataset_dir, cfg)
train_sampler = build_sampler(train_dataset, batch_size)
train_dataloader = DataLoader(
train_dataset,
sampler=train_sampler,
transform=T.Compose(
transforms=[
T.ShortestEdgeResize(
cfg.train_image_short_size,
cfg.train_image_max_size,
sample_style="choice",
),
T.RandomHorizontalFlip(),
T.ToMode(),
],
order=["image", "boxes", "boxes_category"],
),
collator=DetectionPadCollator(),
num_workers=8,
preload= preloader,
)
return train_dataloader
if __name__ == "__main__":
main()
|
[
"megengine.data.transform.ToMode",
"megengine.amp.autocast",
"megengine.device.set_prealloc_config",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.distributed.make_allreduce_cb",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.jit.trace",
"megengine.jit.SublinearMemoryConfig",
"megengine.tensor",
"megengine.data.RandomSampler",
"megengine.data.transform.ShortestEdgeResize",
"megengine.autodiff.GradManager",
"megengine.distributed.launcher"
] |
[((942, 966), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (956, 966), True, 'import megengine as mge\n'), ((991, 1057), 'megengine.device.set_prealloc_config', 'mge.device.set_prealloc_config', (['(1024)', '(1024)', '(512 * 1024 * 1024)', '(2.0)'], {}), '(1024, 1024, 512 * 1024 * 1024, 2.0)\n', (1021, 1057), True, 'import megengine as mge\n'), ((1092, 1117), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1115, 1117), False, 'import argparse\n'), ((3265, 3294), 'tools.utils.import_from_file', 'import_from_file', (['config_file'], {}), '(config_file)\n', (3281, 3294), False, 'from tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, PseudoDetectionDataset, get_config_info, import_from_file\n'), ((4010, 4023), 'megengine.autodiff.GradManager', 'GradManager', ([], {}), '()\n', (4021, 4023), False, 'from megengine.autodiff import GradManager\n'), ((4528, 4567), 'megengine.amp.autocast', 'amp.autocast', ([], {'enabled': "(args.mode == 'mp')"}), "(enabled=args.mode == 'mp')\n", (4540, 4567), True, 'import megengine.amp as amp\n'), ((5277, 5322), 'tools.utils.AverageMeter', 'AverageMeter', ([], {'record_len': 'model.cfg.num_losses'}), '(record_len=model.cfg.num_losses)\n', (5289, 5322), False, 'from tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, PseudoDetectionDataset, get_config_info, import_from_file\n'), ((5340, 5366), 'tools.utils.AverageMeter', 'AverageMeter', ([], {'record_len': '(2)'}), '(record_len=2)\n', (5352, 5366), False, 'from tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, PseudoDetectionDataset, get_config_info, import_from_file\n'), ((5571, 5606), 'os.path.join', 'os.path.join', (['file_dir', '"""batch.pkl"""'], {}), "(file_dir, 'batch.pkl')\n", (5583, 5606), False, 'import os\n'), ((8136, 8210), 'tools.utils.PseudoDetectionDataset', 'PseudoDetectionDataset', ([], {'order': "['image', 'boxes', 'boxes_category', 'info']"}), "(order=['image', 'boxes', 'boxes_category', 'info'])\n", (8158, 8210), False, 'from tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, PseudoDetectionDataset, get_config_info, import_from_file\n'), ((2893, 2933), 'megengine.distributed.launcher', 'dist.launcher', (['worker'], {'n_gpus': 'args.ngpus'}), '(worker, n_gpus=args.ngpus)\n', (2906, 2933), True, 'import megengine.distributed as dist\n'), ((4031, 4052), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4050, 4052), True, 'import megengine.distributed as dist\n'), ((4237, 4258), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (4256, 4258), True, 'import megengine.distributed as dist\n'), ((5528, 5553), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (5543, 5553), False, 'import os\n'), ((6466, 6477), 'time.time', 'time.time', ([], {}), '()\n', (6475, 6477), False, 'import time\n'), ((6562, 6573), 'time.time', 'time.time', ([], {}), '()\n', (6571, 6573), False, 'import time\n'), ((6864, 6875), 'time.time', 'time.time', ([], {}), '()\n', (6873, 6875), False, 'import time\n'), ((7287, 7302), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (7300, 7302), True, 'import megengine.distributed as dist\n'), ((8924, 8982), 'tools.utils.GroupedRandomSampler', 'GroupedRandomSampler', (['train_dataset', 'batch_size', 'group_ids'], {}), '(train_dataset, batch_size, group_ids)\n', (8944, 8982), False, 'from tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, PseudoDetectionDataset, get_config_info, import_from_file\n'), ((5104, 5163), 'megengine.jit.trace', 'jit.trace', (['train_func'], {'symbolic': '(False)', 'symbolic_shape': '(False)'}), '(train_func, symbolic=False, symbolic_shape=False)\n', (5113, 5163), True, 'import megengine.jit as jit\n'), ((5473, 5494), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (5492, 5494), True, 'import megengine.distributed as dist\n'), ((5793, 5839), 'numpy.concatenate', 'np.concatenate', (["([mini_batch['data']] * repeats)"], {}), "([mini_batch['data']] * repeats)\n", (5807, 5839), True, 'import numpy as np\n'), ((5889, 5938), 'numpy.concatenate', 'np.concatenate', (["([mini_batch['im_info']] * repeats)"], {}), "([mini_batch['im_info']] * repeats)\n", (5903, 5938), True, 'import numpy as np\n'), ((5989, 6039), 'numpy.concatenate', 'np.concatenate', (["([mini_batch['gt_boxes']] * repeats)"], {}), "([mini_batch['gt_boxes']] * repeats)\n", (6003, 6039), True, 'import numpy as np\n'), ((8729, 8785), 'megengine.data.RandomSampler', 'RandomSampler', (['train_dataset', 'batch_size'], {'drop_last': '(True)'}), '(train_dataset, batch_size, drop_last=True)\n', (8742, 8785), False, 'from megengine.data import DataLoader, Infinite, RandomSampler\n'), ((9675, 9697), 'tools.utils.DetectionPadCollator', 'DetectionPadCollator', ([], {}), '()\n', (9695, 9697), False, 'from tools.utils import AverageMeter, DetectionPadCollator, GroupedRandomSampler, PseudoDetectionDataset, get_config_info, import_from_file\n'), ((3971, 3992), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (3990, 3992), True, 'import megengine.distributed as dist\n'), ((6214, 6244), 'megengine.tensor', 'mge.tensor', (["mini_batch['data']"], {}), "(mini_batch['data'])\n", (6224, 6244), True, 'import megengine as mge\n'), ((6266, 6299), 'megengine.tensor', 'mge.tensor', (["mini_batch['im_info']"], {}), "(mini_batch['im_info'])\n", (6276, 6299), True, 'import megengine as mge\n'), ((6322, 6356), 'megengine.tensor', 'mge.tensor', (["mini_batch['gt_boxes']"], {}), "(mini_batch['gt_boxes'])\n", (6332, 6356), True, 'import megengine as mge\n'), ((6625, 6655), 'megengine.tensor', 'mge.tensor', (["mini_batch['data']"], {}), "(mini_batch['data'])\n", (6635, 6655), True, 'import megengine as mge\n'), ((6677, 6710), 'megengine.tensor', 'mge.tensor', (["mini_batch['im_info']"], {}), "(mini_batch['im_info'])\n", (6687, 6710), True, 'import megengine as mge\n'), ((6733, 6767), 'megengine.tensor', 'mge.tensor', (["mini_batch['gt_boxes']"], {}), "(mini_batch['gt_boxes'])\n", (6743, 6767), True, 'import megengine as mge\n'), ((6976, 6991), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (6989, 6991), True, 'import megengine.distributed as dist\n'), ((4130, 4171), 'megengine.distributed.make_allreduce_cb', 'dist.make_allreduce_cb', (['"""SUM"""', 'dist.WORLD'], {}), "('SUM', dist.WORLD)\n", (4152, 4171), True, 'import megengine.distributed as dist\n'), ((4997, 5042), 'megengine.jit.SublinearMemoryConfig', 'jit.SublinearMemoryConfig', ([], {'genetic_nr_iter': '(50)'}), '(genetic_nr_iter=50)\n', (5022, 5042), True, 'import megengine.jit as jit\n'), ((9328, 9429), 'megengine.data.transform.ShortestEdgeResize', 'T.ShortestEdgeResize', (['cfg.train_image_short_size', 'cfg.train_image_max_size'], {'sample_style': '"""choice"""'}), "(cfg.train_image_short_size, cfg.train_image_max_size,\n sample_style='choice')\n", (9348, 9429), True, 'from megengine.data import transform as T\n'), ((9522, 9546), 'megengine.data.transform.RandomHorizontalFlip', 'T.RandomHorizontalFlip', ([], {}), '()\n', (9544, 9546), True, 'from megengine.data import transform as T\n'), ((9564, 9574), 'megengine.data.transform.ToMode', 'T.ToMode', ([], {}), '()\n', (9572, 9574), True, 'from megengine.data import transform as T\n')]
|
import logging
from megengine.distributed.group import get_rank
from megengine.distributed import is_distributed
logger_initialized = {}
def get_logger(name, log_file=None, log_level=logging.INFO):
"""Initialize and get a logger by name.
If the logger has not been initialized, this method will initialize the
logger by adding one or two handlers, otherwise the initialized logger will
be directly returned. During initialization, a StreamHandler will always be
added. If `log_file` is specified and the process rank is 0, a FileHandler
will also be added.
Args:
name (str): Logger name.
log_file (str | None): The log filename. If specified, a FileHandler
will be added to the logger.
log_level (int): The logger level. Note that only the process of
rank 0 is affected, and other processes will set the level to
"Error" thus be silent most of the time.
Returns:
logging.Logger: The expected logger.
"""
logger = logging.getLogger(name)
if name in logger_initialized:
return logger
# handle hierarchical names
# e.g., logger "a" is initialized, then logger "a.b" will skip the
# initialization since it is a child of "a".
for logger_name in logger_initialized:
if name.startswith(logger_name): # child
return logger
# fix stream twice bug
# while logger.handlers:
# logger.handlers.pop()
stream_handler = logging.StreamHandler()
handlers = [stream_handler]
if is_distributed():
rank = get_rank()
else:
rank = 0
# only rank 0 will add a FileHandler
if rank == 0 and log_file is not None:
file_handler = logging.FileHandler(log_file, 'w')
handlers.append(file_handler)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
for handler in handlers:
handler.setFormatter(formatter)
handler.setLevel(log_level)
logger.addHandler(handler)
if rank == 0:
logger.setLevel(log_level)
else:
logger.setLevel(logging.ERROR)
logger_initialized[name] = True
return logger
def get_root_logger(log_file=None, log_level=logging.INFO):
"""Get the root logger.
The logger will be initialized if it has not been initialized.
By default a StreamHandler will be added.
If `log_file` is specified, a FileHandler will also be added.
The name of the root logger is the top-level package name, e.g., "edit".
Args:
log_file (str | None): The log filename. If specified, a FileHandler will be added to the root logger.
log_level (int): The root logger level. Note that only the process of
rank 0 is affected, while other processes will set the level to
"Error" and be silent most of the time.
Returns:
logging.Logger: The root logger.
"""
root_name = __name__.split('.')[0] # edit.utils.logger
if is_distributed():
rank = get_rank()
root_name = "rank" + str(rank) + "_" + root_name
logger = get_logger(root_name, log_file, log_level)
return logger
|
[
"megengine.distributed.is_distributed",
"megengine.distributed.group.get_rank"
] |
[((1026, 1049), 'logging.getLogger', 'logging.getLogger', (['name'], {}), '(name)\n', (1043, 1049), False, 'import logging\n'), ((1494, 1517), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (1515, 1517), False, 'import logging\n'), ((1558, 1574), 'megengine.distributed.is_distributed', 'is_distributed', ([], {}), '()\n', (1572, 1574), False, 'from megengine.distributed import is_distributed\n'), ((1827, 1900), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s - %(name)s - %(levelname)s - %(message)s"""'], {}), "('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n", (1844, 1900), False, 'import logging\n'), ((3007, 3023), 'megengine.distributed.is_distributed', 'is_distributed', ([], {}), '()\n', (3021, 3023), False, 'from megengine.distributed import is_distributed\n'), ((1591, 1601), 'megengine.distributed.group.get_rank', 'get_rank', ([], {}), '()\n', (1599, 1601), False, 'from megengine.distributed.group import get_rank\n'), ((1737, 1771), 'logging.FileHandler', 'logging.FileHandler', (['log_file', '"""w"""'], {}), "(log_file, 'w')\n", (1756, 1771), False, 'import logging\n'), ((3040, 3050), 'megengine.distributed.group.get_rank', 'get_rank', ([], {}), '()\n', (3048, 3050), False, 'from megengine.distributed.group import get_rank\n')]
|
import argparse
import logging
import os
import dataset.data_loader as data_loader
import model.net as net
from common import utils
from loss.losses import compute_losses, compute_metrics
from common.manager import Manager
import megengine.distributed as dist
import megengine.functional as F
parser = argparse.ArgumentParser()
parser.add_argument("--model_dir", default="experiments/base_model", help="Directory containing params.json")
parser.add_argument("--restore_file", default="best", help="name of the file in --model_dir containing weights to load")
def evaluate(model, manager):
rank = dist.get_rank()
world_size = dist.get_world_size()
"""Evaluate the model on `num_steps` batches.
Args:
model: (torch.nn.Module) the neural network
manager: a class instance that contains objects related to train and evaluate.
"""
# set model to evaluation mode
model.eval()
# compute metrics over the dataset
if manager.dataloaders["val"] is not None:
# loss status and val status initial
manager.reset_loss_status()
manager.reset_metric_status("val")
for data_batch in manager.dataloaders["val"]:
# compute the real batch size
bs = data_batch["points_src"].shape[0]
# move to GPU if available
data_batch = utils.tensor_mge(data_batch)
# compute model output
output_batch = model(data_batch)
# compute all loss on this batch
loss = compute_losses(output_batch, manager.params)
metrics = compute_metrics(output_batch, manager.params)
if world_size > 1:
for k, v in loss.items():
loss[k] = F.distributed.all_reduce_sum(v) / world_size
for k, v in metrics.items():
metrics[k] = F.distributed.all_reduce_sum(v) / world_size
manager.update_loss_status(loss, "val", bs)
# compute all metrics on this batch
manager.update_metric_status(metrics, "val", bs)
# update val data to tensorboard
if rank == 0:
# compute RMSE metrics
manager.summarize_metric_status(metrics, "val")
manager.writer.add_scalar("Loss/val", manager.loss_status["total"].avg, manager.epoch)
# manager.logger.info("Loss/valid epoch {}: {:.4f}".format(manager.epoch, manager.loss_status["total"].avg))
for k, v in manager.val_status.items():
manager.writer.add_scalar("Metric/val/{}".format(k), v.avg, manager.epoch)
# For each epoch, print the metric
manager.print_metrics("val", title="Val", color="green")
if manager.dataloaders["test"] is not None:
# loss status and val status initial
manager.reset_loss_status()
manager.reset_metric_status("test")
for data_batch in manager.dataloaders["test"]:
# compute the real batch size
bs = data_batch["points_src"].shape[0]
# move to GPU if available
data_batch = utils.tensor_mge(data_batch)
# compute model output
output_batch = model(data_batch)
# compute all loss on this batch
loss = compute_losses(output_batch, manager.params)
metrics = compute_metrics(output_batch, manager.params)
if world_size > 1:
for k, v in loss.items():
loss[k] = F.distributed.all_reduce_sum(v) / world_size
for k, v in metrics.items():
metrics[k] = F.distributed.all_reduce_sum(v) / world_size
manager.update_loss_status(loss, "test", bs)
# compute all metrics on this batch
manager.update_metric_status(metrics, "test", bs)
# update test data to tensorboard
if rank == 0:
# compute RMSE metrics
manager.summarize_metric_status(metrics, "test")
manager.writer.add_scalar("Loss/test", manager.loss_status["total"].avg, manager.epoch)
# manager.logger.info("Loss/test epoch {}: {:.4f}".format(manager.epoch, manager.loss_status["total"].avg))
for k, v in manager.val_status.items():
manager.writer.add_scalar("Metric/test/{}".format(k), v.avg, manager.epoch)
# For each epoch, print the metric
manager.print_metrics("test", title="Test", color="red")
def test(model, manager):
"""Test the model with loading checkpoints.
Args:
model: (torch.nn.Module) the neural network
manager: a class instance that contains objects related to train and evaluate.
"""
# set model to evaluation mode
model.eval()
# compute metrics over the dataset
if manager.dataloaders["val"] is not None:
# loss status and val status initial
manager.reset_loss_status()
manager.reset_metric_status("val")
for data_batch in manager.dataloaders["val"]:
# compute the real batch size
bs = data_batch["points_src"].shape[0]
# move to GPU if available
data_batch = utils.tensor_mge(data_batch)
# compute model output
output_batch = model(data_batch)
# compute all loss on this batch
loss = compute_losses(output_batch, manager.params)
manager.update_loss_status(loss, "val", bs)
# compute all metrics on this batch
metrics = compute_metrics(output_batch, manager.params)
manager.update_metric_status(metrics, "val", bs)
# compute RMSE metrics
manager.summarize_metric_status(metrics, "val")
# For each epoch, update and print the metric
manager.print_metrics("val", title="Val", color="green")
if manager.dataloaders["test"] is not None:
# loss status and test status initial
manager.reset_loss_status()
manager.reset_metric_status("test")
for data_batch in manager.dataloaders["test"]:
# compute the real batch size
bs = data_batch["points_src"].shape[0]
# move to GPU if available
data_batch = utils.tensor_mge(data_batch)
# compute model output
output_batch = model(data_batch)
# compute all loss on this batch
loss = compute_losses(output_batch, manager.params)
manager.update_loss_status(loss, "test", bs)
# compute all metrics on this batch
metrics = compute_metrics(output_batch, manager.params)
manager.update_metric_status(metrics, "test", bs)
# compute RMSE metrics
manager.summarize_metric_status(metrics, "test")
# For each epoch, print the metric
manager.print_metrics("test", title="Test", color="red")
if __name__ == "__main__":
"""
Evaluate the model on the test set.
"""
# Load the parameters
args = parser.parse_args()
json_path = os.path.join(args.model_dir, "params.json")
assert os.path.isfile(json_path), "No json configuration file found at {}".format(json_path)
params = utils.Params(json_path)
# Only load model weights
params.only_weights = True
# Update args into params
params.update(vars(args))
# Get the logger
logger = utils.set_logger(os.path.join(args.model_dir, "evaluate.log"))
# Create the input data pipeline
logging.info("Creating the dataset...")
# Fetch dataloaders
dataloaders = data_loader.fetch_dataloader(params)
# Define the model and optimizer
model = net.fetch_net(params)
# Initial status for checkpoint manager
manager = Manager(model=model, optimizer=None, scheduler=None, params=params, dataloaders=dataloaders, writer=None, logger=logger)
# Reload weights from the saved file
manager.load_checkpoints()
# Test the model
logger.info("Starting test")
# Evaluate
test(model, manager)
|
[
"megengine.functional.distributed.all_reduce_sum",
"megengine.distributed.get_world_size",
"megengine.distributed.get_rank"
] |
[((306, 331), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (329, 331), False, 'import argparse\n'), ((606, 621), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (619, 621), True, 'import megengine.distributed as dist\n'), ((639, 660), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (658, 660), True, 'import megengine.distributed as dist\n'), ((7021, 7064), 'os.path.join', 'os.path.join', (['args.model_dir', '"""params.json"""'], {}), "(args.model_dir, 'params.json')\n", (7033, 7064), False, 'import os\n'), ((7076, 7101), 'os.path.isfile', 'os.path.isfile', (['json_path'], {}), '(json_path)\n', (7090, 7101), False, 'import os\n'), ((7175, 7198), 'common.utils.Params', 'utils.Params', (['json_path'], {}), '(json_path)\n', (7187, 7198), False, 'from common import utils\n'), ((7461, 7500), 'logging.info', 'logging.info', (['"""Creating the dataset..."""'], {}), "('Creating the dataset...')\n", (7473, 7500), False, 'import logging\n'), ((7544, 7580), 'dataset.data_loader.fetch_dataloader', 'data_loader.fetch_dataloader', (['params'], {}), '(params)\n', (7572, 7580), True, 'import dataset.data_loader as data_loader\n'), ((7631, 7652), 'model.net.fetch_net', 'net.fetch_net', (['params'], {}), '(params)\n', (7644, 7652), True, 'import model.net as net\n'), ((7712, 7836), 'common.manager.Manager', 'Manager', ([], {'model': 'model', 'optimizer': 'None', 'scheduler': 'None', 'params': 'params', 'dataloaders': 'dataloaders', 'writer': 'None', 'logger': 'logger'}), '(model=model, optimizer=None, scheduler=None, params=params,\n dataloaders=dataloaders, writer=None, logger=logger)\n', (7719, 7836), False, 'from common.manager import Manager\n'), ((7373, 7417), 'os.path.join', 'os.path.join', (['args.model_dir', '"""evaluate.log"""'], {}), "(args.model_dir, 'evaluate.log')\n", (7385, 7417), False, 'import os\n'), ((1343, 1371), 'common.utils.tensor_mge', 'utils.tensor_mge', (['data_batch'], {}), '(data_batch)\n', (1359, 1371), False, 'from common import utils\n'), ((1516, 1560), 'loss.losses.compute_losses', 'compute_losses', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (1530, 1560), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((1583, 1628), 'loss.losses.compute_metrics', 'compute_metrics', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (1598, 1628), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((3090, 3118), 'common.utils.tensor_mge', 'utils.tensor_mge', (['data_batch'], {}), '(data_batch)\n', (3106, 3118), False, 'from common import utils\n'), ((3263, 3307), 'loss.losses.compute_losses', 'compute_losses', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (3277, 3307), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((3330, 3375), 'loss.losses.compute_metrics', 'compute_metrics', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (3345, 3375), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((5164, 5192), 'common.utils.tensor_mge', 'utils.tensor_mge', (['data_batch'], {}), '(data_batch)\n', (5180, 5192), False, 'from common import utils\n'), ((5337, 5381), 'loss.losses.compute_losses', 'compute_losses', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (5351, 5381), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((5508, 5553), 'loss.losses.compute_metrics', 'compute_metrics', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (5523, 5553), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((6209, 6237), 'common.utils.tensor_mge', 'utils.tensor_mge', (['data_batch'], {}), '(data_batch)\n', (6225, 6237), False, 'from common import utils\n'), ((6382, 6426), 'loss.losses.compute_losses', 'compute_losses', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (6396, 6426), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((6554, 6599), 'loss.losses.compute_metrics', 'compute_metrics', (['output_batch', 'manager.params'], {}), '(output_batch, manager.params)\n', (6569, 6599), False, 'from loss.losses import compute_losses, compute_metrics\n'), ((1732, 1763), 'megengine.functional.distributed.all_reduce_sum', 'F.distributed.all_reduce_sum', (['v'], {}), '(v)\n', (1760, 1763), True, 'import megengine.functional as F\n'), ((1855, 1886), 'megengine.functional.distributed.all_reduce_sum', 'F.distributed.all_reduce_sum', (['v'], {}), '(v)\n', (1883, 1886), True, 'import megengine.functional as F\n'), ((3479, 3510), 'megengine.functional.distributed.all_reduce_sum', 'F.distributed.all_reduce_sum', (['v'], {}), '(v)\n', (3507, 3510), True, 'import megengine.functional as F\n'), ((3602, 3633), 'megengine.functional.distributed.all_reduce_sum', 'F.distributed.all_reduce_sum', (['v'], {}), '(v)\n', (3630, 3633), True, 'import megengine.functional as F\n')]
|
import sys
sys.path.append('.')
import cv2
import megengine as mge
import megengine.functional as F
import numpy as np
from model.RIFE import Model
model = Model()
model.load_model('train_log')
model.eval()
name = ['Beanbags', 'Dimetrodon', 'DogDance', 'Grove2', 'Grove3', 'Hydrangea', 'MiniCooper', 'RubberWhale', 'Urban2', 'Urban3', 'Venus', 'Walking']
IE_list = []
for i in name:
i0 = cv2.imread('other-data/{}/frame10.png'.format(i)).transpose(2, 0, 1) / 255.
i1 = cv2.imread('other-data/{}/frame11.png'.format(i)).transpose(2, 0, 1) / 255.
gt = cv2.imread('other-gt-interp/{}/frame10i11.png'.format(i))
h, w = i0.shape[1], i0.shape[2]
imgs = F.zeros([1, 6, 480, 640])
ph = (480 - h) // 2
pw = (640 - w) // 2
imgs[:, :3, :h, :w] = F.expand_dims(mge.Tensor(i0), 0).astype("float32")
imgs[:, 3:, :h, :w] = F.expand_dims(mge.Tensor(i1), 0).astype("float32")
I0 = imgs[:, :3]
I2 = imgs[:, 3:]
pred = model.inference(I0, I2)
out = pred[0].detach().numpy().transpose(1, 2, 0)
out = np.round(out[:h, :w] * 255)
IE_list.append(np.abs((out - gt * 1.0)).mean())
print(np.mean(IE_list))
|
[
"megengine.functional.zeros",
"megengine.Tensor"
] |
[((11, 31), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (26, 31), False, 'import sys\n'), ((157, 164), 'model.RIFE.Model', 'Model', ([], {}), '()\n', (162, 164), False, 'from model.RIFE import Model\n'), ((670, 695), 'megengine.functional.zeros', 'F.zeros', (['[1, 6, 480, 640]'], {}), '([1, 6, 480, 640])\n', (677, 695), True, 'import megengine.functional as F\n'), ((1039, 1066), 'numpy.round', 'np.round', (['(out[:h, :w] * 255)'], {}), '(out[:h, :w] * 255)\n', (1047, 1066), True, 'import numpy as np\n'), ((1129, 1145), 'numpy.mean', 'np.mean', (['IE_list'], {}), '(IE_list)\n', (1136, 1145), True, 'import numpy as np\n'), ((784, 798), 'megengine.Tensor', 'mge.Tensor', (['i0'], {}), '(i0)\n', (794, 798), True, 'import megengine as mge\n'), ((861, 875), 'megengine.Tensor', 'mge.Tensor', (['i1'], {}), '(i1)\n', (871, 875), True, 'import megengine as mge\n'), ((1086, 1108), 'numpy.abs', 'np.abs', (['(out - gt * 1.0)'], {}), '(out - gt * 1.0)\n', (1092, 1108), True, 'import numpy as np\n')]
|
# Copyright (c) 2014-2022 Megvii Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import copy
import megengine
import megengine.functional as F
import megengine.module as nn
import numpy as np
from basecls.layers import DropPath, init_weights
from basecls.utils import registers
def _fuse_prebn_conv1x1(bn, conv):
module_output = copy.deepcopy(conv)
module_output.bias = megengine.Parameter(np.zeros(module_output._infer_bias_shape(), dtype=np.float32))
assert conv.groups == 1
kernel = conv.weight
running_mean = bn.running_mean
running_var = bn.running_var
gamma = bn.weight
beta = bn.bias
eps = bn.eps
std = F.sqrt(running_var + eps)
t = (gamma / std).reshape(1, -1, 1, 1)
module_output.weight[:] = kernel * t
module_output.bias[:] = F.conv2d(beta - running_mean * gamma / std, kernel, conv.bias)
return module_output
def _fuse_conv_bn(conv, bn):
module_output = copy.deepcopy(conv)
module_output.bias = megengine.Parameter(np.zeros(module_output._infer_bias_shape(), dtype=np.float32))
# flatten then reshape in case of group conv
kernel = F.flatten(conv.weight, end_axis=conv.weight.ndim - 4)
running_mean = bn.running_mean
running_var = bn.running_var
gamma = bn.weight
beta = bn.bias
eps = bn.eps
std = F.sqrt(running_var + eps)
t = (gamma / std).reshape(-1, 1, 1, 1)
module_output.weight[:] = (kernel * t).reshape(module_output.weight.shape)
module_output.bias[:] = beta + ((conv.bias if conv.bias is not None else 0) - running_mean) * gamma / std
return module_output
class ConvBn2d(nn.ConvBn2d):
def __init__(self, *args, **kwargs):
bias = kwargs.pop("bias", False) and False
super().__init__(*args, bias=bias, **kwargs)
@classmethod
def fuse_conv_bn(cls, module: nn.Module):
module_output = module
if isinstance(module, ConvBn2d):
return _fuse_conv_bn(module.conv, module.bn)
for name, child in module.named_children():
setattr(module_output, name, cls.fuse_conv_bn(child))
del module
return module_output
class LargeKernelReparam(nn.Module):
def __init__(self, channels, kernel, small_kernels=()):
super(LargeKernelReparam, self).__init__()
self.dw_large = ConvBn2d(channels, channels, kernel, padding=kernel // 2, groups=channels)
self.small_kernels = small_kernels
for k in self.small_kernels:
setattr(self, f"dw_small_{k}", ConvBn2d(channels, channels, k, padding=k // 2, groups=channels))
def forward(self, inp):
outp = self.dw_large(inp)
for k in self.small_kernels:
outp += getattr(self, f"dw_small_{k}")(inp)
return outp
@classmethod
def convert_to_deploy(cls, module: nn.Module):
module_output = module
if isinstance(module, LargeKernelReparam):
module = ConvBn2d.fuse_conv_bn(module)
module_output = copy.deepcopy(module.dw_large)
kernel = module_output.kernel_size[0]
for k in module.small_kernels:
dw_small = getattr(module, f"dw_small_{k}")
module_output.weight += F.pad(dw_small.weight, [[0, 0]] * 3 + [[(kernel - k) // 2] * 2] * 2)
module_output.bias += dw_small.bias
return module_output
for name, child in module.named_children():
setattr(module_output, name, cls.convert_to_deploy(child))
del module
return module_output
class Mlp(nn.Module):
def __init__(self, in_channels, hidden_channels=None, out_channels=None, act_layer=nn.GELU, drop=0.,):
super().__init__()
out_features = out_channels or in_channels
hidden_features = hidden_channels or in_channels
self.fc1 = ConvBn2d(in_channels, hidden_features, 1, stride=1, padding=0)
self.act = act_layer()
self.fc2 = ConvBn2d(hidden_features, out_features, 1, stride=1, padding=0)
self.drop = nn.Dropout(drop)
def forward(self, x):
x = self.fc1(x)
x = self.act(x)
x = self.drop(x)
x = self.fc2(x)
x = self.drop(x)
return x
class RepLKBlock(nn.Module):
def __init__(self, channels, kernel, small_kernels=(), dw_ratio=1.0, mlp_ratio=4.0, drop_path=0., activation=nn.ReLU):
super().__init__()
self.pre_bn = nn.BatchNorm2d(channels)
self.pw1 = ConvBn2d(channels, int(channels * dw_ratio), 1, 1, 0)
self.pw1_act = activation()
self.dw = LargeKernelReparam(int(channels * dw_ratio), kernel, small_kernels=small_kernels)
self.dw_act = activation()
self.pw2 = ConvBn2d(int(channels * dw_ratio), channels, 1, 1, 0)
self.premlp_bn = nn.BatchNorm2d(channels)
self.mlp = Mlp(in_channels=channels, hidden_channels=int(channels * mlp_ratio))
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
def forward(self, x):
y = self.pre_bn(x)
y = self.pw1_act(self.pw1(y))
y = self.dw_act(self.dw(y))
y = self.pw2(y)
x = x + self.drop_path(y)
y = self.premlp_bn(x)
y = self.mlp(y)
x = x + self.drop_path(y)
return x
@classmethod
def convert_to_deploy(cls, module: nn.Module):
module_output = module
if isinstance(module, RepLKBlock):
LargeKernelReparam.convert_to_deploy(module)
ConvBn2d.fuse_conv_bn(module)
module.pre_bn, module.pw1 = nn.Identity(), _fuse_prebn_conv1x1(module.pre_bn, module.pw1)
module.premlp_bn, module.mlp.fc1 = nn.Identity(), _fuse_prebn_conv1x1(module.premlp_bn, module.mlp.fc1)
return module_output
for name, child in module.named_children():
setattr(module_output, name, cls.convert_to_deploy(child))
del module
return module_output
class DownSample(nn.Sequential):
def __init__(self, in_channels, out_channels, activation=nn.ReLU):
super().__init__(
ConvBn2d(in_channels, out_channels, 1),
activation(),
ConvBn2d(out_channels, out_channels, 3, stride=2, padding=1, groups=out_channels),
activation(),
)
class Stem(nn.Sequential):
def __init__(self, in_channels, out_channels, activation=nn.ReLU):
super().__init__(
ConvBn2d(in_channels, out_channels, 3, stride=2, padding=1),
activation(),
ConvBn2d(out_channels, out_channels, 3, padding=1, groups=out_channels),
activation(),
ConvBn2d(out_channels, out_channels, 1),
activation(),
ConvBn2d(out_channels, out_channels, 3, stride=2, padding=1, groups=out_channels),
activation(),
)
class RepLKNet(nn.Module):
def __init__(
self,
in_channels=3,
depths=(2, 2, 18, 2),
dims=(128, 256, 512, 1024),
kernel_sizes=(31, 29, 27, 13),
small_kernels=(5,),
dw_ratio=1.0,
mlp_ratio=4.0,
num_classes=1000,
drop_path_rate=0.5,
):
super().__init__()
self.stem = Stem(in_channels, dims[0])
# stochastic depth
dpr = (x for x in np.linspace(0, drop_path_rate, sum(depths))) # stochastic depth decay rule
self.blocks = []
for stage, (depth, dim, ksize) in enumerate(zip(depths, dims, kernel_sizes)):
for _ in range(depth):
self.blocks.append(
RepLKBlock(dim, ksize, small_kernels=small_kernels,
dw_ratio=dw_ratio, mlp_ratio=mlp_ratio, drop_path=next(dpr))
)
if stage < len(depths) - 1:
self.blocks.append(DownSample(dim, dims[stage + 1]))
self.norm = nn.BatchNorm2d(dims[-1])
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.head = nn.Linear(dims[-1], num_classes) if num_classes > 0 else nn.Identity()
init_weights(self)
def forward_features(self, x):
x = self.stem(x)
for blk in self.blocks:
x = blk(x)
x = self.norm(x)
x = self.avgpool(x)
x = F.flatten(x, 1)
return x
def forward(self, x):
x = self.forward_features(x)
x = self.head(x)
return x
@classmethod
def convert_to_deploy(cls, module: nn.Module):
module_output = module
if isinstance(module, RepLKNet):
RepLKBlock.convert_to_deploy(module)
ConvBn2d.fuse_conv_bn(module)
return module_output
for name, child in module.named_children():
setattr(module_output, name, cls.convert_to_deploy(child))
del module
return module_output
@registers.models.register()
def replknet31_base(**kwargs):
kwargs.pop("head", None)
return RepLKNet(dims=(128, 256, 512, 1024), dw_ratio=1.0, **kwargs)
@registers.models.register()
def replknet31_large(**kwargs):
kwargs.pop("head", None)
return RepLKNet(dims=(192, 384, 768, 1536), dw_ratio=1.0, **kwargs)
@registers.models.register()
def replknet_xlarge(**kwargs):
kwargs.pop("head", None)
return RepLKNet(dims=(256, 512, 1024, 2048), kernel_sizes=(27, 27, 27, 13), small_kernels=(), dw_ratio=1.5, **kwargs)
|
[
"megengine.module.Dropout",
"megengine.module.Linear",
"megengine.functional.pad",
"megengine.functional.sqrt",
"megengine.module.BatchNorm2d",
"megengine.functional.conv2d",
"megengine.module.AdaptiveAvgPool2d",
"megengine.module.Identity",
"megengine.functional.flatten"
] |
[((9027, 9054), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9052, 9054), False, 'from basecls.utils import registers\n'), ((9190, 9217), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9215, 9217), False, 'from basecls.utils import registers\n'), ((9354, 9381), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9379, 9381), False, 'from basecls.utils import registers\n'), ((597, 616), 'copy.deepcopy', 'copy.deepcopy', (['conv'], {}), '(conv)\n', (610, 616), False, 'import copy\n'), ((914, 939), 'megengine.functional.sqrt', 'F.sqrt', (['(running_var + eps)'], {}), '(running_var + eps)\n', (920, 939), True, 'import megengine.functional as F\n'), ((1052, 1114), 'megengine.functional.conv2d', 'F.conv2d', (['(beta - running_mean * gamma / std)', 'kernel', 'conv.bias'], {}), '(beta - running_mean * gamma / std, kernel, conv.bias)\n', (1060, 1114), True, 'import megengine.functional as F\n'), ((1191, 1210), 'copy.deepcopy', 'copy.deepcopy', (['conv'], {}), '(conv)\n', (1204, 1210), False, 'import copy\n'), ((1381, 1434), 'megengine.functional.flatten', 'F.flatten', (['conv.weight'], {'end_axis': '(conv.weight.ndim - 4)'}), '(conv.weight, end_axis=conv.weight.ndim - 4)\n', (1390, 1434), True, 'import megengine.functional as F\n'), ((1571, 1596), 'megengine.functional.sqrt', 'F.sqrt', (['(running_var + eps)'], {}), '(running_var + eps)\n', (1577, 1596), True, 'import megengine.functional as F\n'), ((4265, 4281), 'megengine.module.Dropout', 'nn.Dropout', (['drop'], {}), '(drop)\n', (4275, 4281), True, 'import megengine.module as nn\n'), ((4653, 4677), 'megengine.module.BatchNorm2d', 'nn.BatchNorm2d', (['channels'], {}), '(channels)\n', (4667, 4677), True, 'import megengine.module as nn\n'), ((5021, 5045), 'megengine.module.BatchNorm2d', 'nn.BatchNorm2d', (['channels'], {}), '(channels)\n', (5035, 5045), True, 'import megengine.module as nn\n'), ((8078, 8102), 'megengine.module.BatchNorm2d', 'nn.BatchNorm2d', (['dims[-1]'], {}), '(dims[-1])\n', (8092, 8102), True, 'import megengine.module as nn\n'), ((8126, 8149), 'megengine.module.AdaptiveAvgPool2d', 'nn.AdaptiveAvgPool2d', (['(1)'], {}), '(1)\n', (8146, 8149), True, 'import megengine.module as nn\n'), ((8249, 8267), 'basecls.layers.init_weights', 'init_weights', (['self'], {}), '(self)\n', (8261, 8267), False, 'from basecls.layers import DropPath, init_weights\n'), ((8449, 8464), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (8458, 8464), True, 'import megengine.functional as F\n'), ((3234, 3264), 'copy.deepcopy', 'copy.deepcopy', (['module.dw_large'], {}), '(module.dw_large)\n', (3247, 3264), False, 'import copy\n'), ((5160, 5179), 'basecls.layers.DropPath', 'DropPath', (['drop_path'], {}), '(drop_path)\n', (5168, 5179), False, 'from basecls.layers import DropPath, init_weights\n'), ((5203, 5216), 'megengine.module.Identity', 'nn.Identity', ([], {}), '()\n', (5214, 5216), True, 'import megengine.module as nn\n'), ((8170, 8202), 'megengine.module.Linear', 'nn.Linear', (['dims[-1]', 'num_classes'], {}), '(dims[-1], num_classes)\n', (8179, 8202), True, 'import megengine.module as nn\n'), ((8227, 8240), 'megengine.module.Identity', 'nn.Identity', ([], {}), '()\n', (8238, 8240), True, 'import megengine.module as nn\n'), ((3458, 3526), 'megengine.functional.pad', 'F.pad', (['dw_small.weight', '([[0, 0]] * 3 + [[(kernel - k) // 2] * 2] * 2)'], {}), '(dw_small.weight, [[0, 0]] * 3 + [[(kernel - k) // 2] * 2] * 2)\n', (3463, 3526), True, 'import megengine.functional as F\n'), ((5793, 5806), 'megengine.module.Identity', 'nn.Identity', ([], {}), '()\n', (5804, 5806), True, 'import megengine.module as nn\n'), ((5902, 5915), 'megengine.module.Identity', 'nn.Identity', ([], {}), '()\n', (5913, 5915), True, 'import megengine.module as nn\n')]
|
#!/usr/bin/env python3
import megengine as mge
import megengine.module as nn
import megengine.functional as F
def conv3x3(in_chn, out_chn, bias=True):
layer = nn.Conv2d(in_chn, out_chn, kernel_size=3, stride=1, padding=1, bias=bias)
return layer
def conv_down(in_chn, out_chn, bias=False):
layer = nn.Conv2d(in_chn, out_chn, kernel_size=4, stride=2, padding=1, bias=bias)
return layer
class UNetD(nn.Module):
def __init__(self, in_chn, wf=32, depth=5, relu_slope=0.2, subspace_dim=16):
super(UNetD, self).__init__()
self.depth = depth
self.down_path = []
prev_channels = self.get_input_chn(in_chn)
for i in range(depth):
downsample = True if (i+1) < depth else False
self.down_path.append(UNetConvBlock(prev_channels, (2**i)*wf, downsample, relu_slope))
prev_channels = (2**i) * wf
# self.ema = EMAU(prev_channels, prev_channels//8)
self.up_path = []
subnet_repeat_num = 1
for i in reversed(range(depth - 1)):
self.up_path.append(UNetUpBlock(prev_channels, (2**i)*wf, relu_slope, subnet_repeat_num, subspace_dim))
prev_channels = (2**i)*wf
subnet_repeat_num += 1
self.last = conv3x3(prev_channels, in_chn, bias=True)
#self._initialize()
def forward(self, x1):
blocks = []
for i, down in enumerate(self.down_path):
# print(x1.shape)
if (i+1) < self.depth:
x1, x1_up = down(x1)
blocks.append(x1_up)
else:
x1 = down(x1)
# print(x1.shape)
# x1 = self.ema(x1)
for i, up in enumerate(self.up_path):
# print(x1.shape, blocks[-i-1].shape)
x1 = up(x1, blocks[-i-1])
pred = self.last(x1)
return pred
def get_input_chn(self, in_chn):
return in_chn
def _initialize(self):
gain = nn.init.calculate_gain('leaky_relu', 0.20)
for m in self.modules():
if isinstance(m, nn.Conv2d):
print("weight")
nn.init.xavier_uniform_(m.weight)
if m.bias is not None:
print("bias")
nn.init.zeros_(m.bias)
class UNetConvBlock(nn.Module):
def __init__(self, in_size, out_size, downsample, relu_slope):
super(UNetConvBlock, self).__init__()
self.block = nn.Sequential(
nn.Conv2d(in_size, out_size, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(relu_slope),
nn.Conv2d(out_size, out_size, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(relu_slope))
self.downsample = downsample
if downsample:
self.downsample = conv_down(out_size, out_size, bias=False)
self.shortcut = nn.Conv2d(in_size, out_size, kernel_size=1, bias=True)
def forward(self, x):
out = self.block(x)
sc = self.shortcut(x)
out = out + sc
if self.downsample:
out_down = self.downsample(out)
return out_down, out
else:
return out
class UNetUpBlock(nn.Module):
def __init__(self, in_size, out_size, relu_slope, subnet_repeat_num, subspace_dim=16):
super(UNetUpBlock, self).__init__()
self.up = nn.ConvTranspose2d(in_size, out_size, kernel_size=2, stride=2, bias=True)
self.conv_block = UNetConvBlock(in_size, out_size, False, relu_slope)
self.num_subspace = subspace_dim
print(self.num_subspace, subnet_repeat_num)
self.subnet = Subspace(in_size, self.num_subspace)
self.skip_m = skip_blocks(out_size, out_size, subnet_repeat_num)
def forward(self, x, bridge):
up = self.up(x)
bridge = self.skip_m(bridge)
out = F.concat([up, bridge], 1)
if self.subnet:
b_, c_, h_, w_ = bridge.shape
sub = self.subnet(out)
V_t = sub.reshape(b_, self.num_subspace, h_*w_)
V_t = V_t / (1e-6 + F.abs(V_t).sum(axis=2, keepdims=True))
V = V_t.transpose(0, 2, 1)
mat = F.matmul(V_t, V)
mat_inv = F.matinv(mat)
project_mat = F.matmul(mat_inv, V_t)
bridge_ = bridge.reshape(b_, c_, h_*w_)
project_feature = F.matmul(project_mat, bridge_.transpose(0, 2, 1))
bridge = F.matmul(V, project_feature).transpose(0, 2, 1).reshape(b_, c_, h_, w_)
out = F.concat([up, bridge], 1)
out = self.conv_block(out)
return out
class Subspace(nn.Module):
def __init__(self, in_size, out_size):
super(Subspace, self).__init__()
self.blocks = []
self.blocks.append(UNetConvBlock(in_size, out_size, False, 0.2))
self.shortcut = nn.Conv2d(in_size, out_size, kernel_size=1, bias=True)
def forward(self, x):
sc = self.shortcut(x)
for i in range(len(self.blocks)):
x = self.blocks[i](x)
return x + sc
class skip_blocks(nn.Module):
def __init__(self, in_size, out_size, repeat_num=1):
super(skip_blocks, self).__init__()
self.blocks = []
self.re_num = repeat_num
mid_c = 128
self.blocks.append(UNetConvBlock(in_size, mid_c, False, 0.2))
for i in range(self.re_num - 2):
self.blocks.append(UNetConvBlock(mid_c, mid_c, False, 0.2))
self.blocks.append(UNetConvBlock(mid_c, out_size, False, 0.2))
self.shortcut = nn.Conv2d(in_size, out_size, kernel_size=1, bias=True)
def forward(self, x):
sc = self.shortcut(x)
for m in self.blocks:
x = m(x)
return x + sc
if __name__ == "__main__":
import numpy as np
a = UNetD(3)
#print(a)
im = mge.tensor(np.random.randn(1, 3, 128, 128).astype(np.float32))
print(a(im))
|
[
"megengine.module.init.calculate_gain",
"megengine.functional.matmul",
"megengine.module.init.zeros_",
"megengine.functional.concat",
"megengine.functional.matinv",
"megengine.module.ConvTranspose2d",
"megengine.module.init.xavier_uniform_",
"megengine.module.Conv2d",
"megengine.functional.abs",
"megengine.module.LeakyReLU"
] |
[((164, 237), 'megengine.module.Conv2d', 'nn.Conv2d', (['in_chn', 'out_chn'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)', 'bias': 'bias'}), '(in_chn, out_chn, kernel_size=3, stride=1, padding=1, bias=bias)\n', (173, 237), True, 'import megengine.module as nn\n'), ((313, 386), 'megengine.module.Conv2d', 'nn.Conv2d', (['in_chn', 'out_chn'], {'kernel_size': '(4)', 'stride': '(2)', 'padding': '(1)', 'bias': 'bias'}), '(in_chn, out_chn, kernel_size=4, stride=2, padding=1, bias=bias)\n', (322, 386), True, 'import megengine.module as nn\n'), ((1951, 1992), 'megengine.module.init.calculate_gain', 'nn.init.calculate_gain', (['"""leaky_relu"""', '(0.2)'], {}), "('leaky_relu', 0.2)\n", (1973, 1992), True, 'import megengine.module as nn\n'), ((2843, 2897), 'megengine.module.Conv2d', 'nn.Conv2d', (['in_size', 'out_size'], {'kernel_size': '(1)', 'bias': '(True)'}), '(in_size, out_size, kernel_size=1, bias=True)\n', (2852, 2897), True, 'import megengine.module as nn\n'), ((3334, 3407), 'megengine.module.ConvTranspose2d', 'nn.ConvTranspose2d', (['in_size', 'out_size'], {'kernel_size': '(2)', 'stride': '(2)', 'bias': '(True)'}), '(in_size, out_size, kernel_size=2, stride=2, bias=True)\n', (3352, 3407), True, 'import megengine.module as nn\n'), ((3821, 3846), 'megengine.functional.concat', 'F.concat', (['[up, bridge]', '(1)'], {}), '([up, bridge], 1)\n', (3829, 3846), True, 'import megengine.functional as F\n'), ((4797, 4851), 'megengine.module.Conv2d', 'nn.Conv2d', (['in_size', 'out_size'], {'kernel_size': '(1)', 'bias': '(True)'}), '(in_size, out_size, kernel_size=1, bias=True)\n', (4806, 4851), True, 'import megengine.module as nn\n'), ((5497, 5551), 'megengine.module.Conv2d', 'nn.Conv2d', (['in_size', 'out_size'], {'kernel_size': '(1)', 'bias': '(True)'}), '(in_size, out_size, kernel_size=1, bias=True)\n', (5506, 5551), True, 'import megengine.module as nn\n'), ((2462, 2527), 'megengine.module.Conv2d', 'nn.Conv2d', (['in_size', 'out_size'], {'kernel_size': '(3)', 'padding': '(1)', 'bias': '(True)'}), '(in_size, out_size, kernel_size=3, padding=1, bias=True)\n', (2471, 2527), True, 'import megengine.module as nn\n'), ((2541, 2565), 'megengine.module.LeakyReLU', 'nn.LeakyReLU', (['relu_slope'], {}), '(relu_slope)\n', (2553, 2565), True, 'import megengine.module as nn\n'), ((2579, 2645), 'megengine.module.Conv2d', 'nn.Conv2d', (['out_size', 'out_size'], {'kernel_size': '(3)', 'padding': '(1)', 'bias': '(True)'}), '(out_size, out_size, kernel_size=3, padding=1, bias=True)\n', (2588, 2645), True, 'import megengine.module as nn\n'), ((2659, 2683), 'megengine.module.LeakyReLU', 'nn.LeakyReLU', (['relu_slope'], {}), '(relu_slope)\n', (2671, 2683), True, 'import megengine.module as nn\n'), ((4136, 4152), 'megengine.functional.matmul', 'F.matmul', (['V_t', 'V'], {}), '(V_t, V)\n', (4144, 4152), True, 'import megengine.functional as F\n'), ((4175, 4188), 'megengine.functional.matinv', 'F.matinv', (['mat'], {}), '(mat)\n', (4183, 4188), True, 'import megengine.functional as F\n'), ((4215, 4237), 'megengine.functional.matmul', 'F.matmul', (['mat_inv', 'V_t'], {}), '(mat_inv, V_t)\n', (4223, 4237), True, 'import megengine.functional as F\n'), ((4481, 4506), 'megengine.functional.concat', 'F.concat', (['[up, bridge]', '(1)'], {}), '([up, bridge], 1)\n', (4489, 4506), True, 'import megengine.functional as F\n'), ((2116, 2149), 'megengine.module.init.xavier_uniform_', 'nn.init.xavier_uniform_', (['m.weight'], {}), '(m.weight)\n', (2139, 2149), True, 'import megengine.module as nn\n'), ((5786, 5817), 'numpy.random.randn', 'np.random.randn', (['(1)', '(3)', '(128)', '(128)'], {}), '(1, 3, 128, 128)\n', (5801, 5817), True, 'import numpy as np\n'), ((2243, 2265), 'megengine.module.init.zeros_', 'nn.init.zeros_', (['m.bias'], {}), '(m.bias)\n', (2257, 2265), True, 'import megengine.module as nn\n'), ((4040, 4050), 'megengine.functional.abs', 'F.abs', (['V_t'], {}), '(V_t)\n', (4045, 4050), True, 'import megengine.functional as F\n'), ((4391, 4419), 'megengine.functional.matmul', 'F.matmul', (['V', 'project_feature'], {}), '(V, project_feature)\n', (4399, 4419), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# This repo is licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import os
import pickle
import boto3
import megengine as mge
from collections import defaultdict
from termcolor import colored
from common import utils
class Manager():
def __init__(self, model, optimizer, params, dataloaders, writer, logger, scheduler):
# params status
self.model = model
self.writer = writer
self.logger = logger
self.params = params
self.optimizer = optimizer
self.scheduler = scheduler
self.dataloaders = dataloaders
# metric_rule should be either Descende or Ascende
self.metric_rule = params.metric_rule
self.epoch = 0
self.step = 0
# 越低越好
if self.metric_rule == "Descende":
self.best_val_score = 100
self.best_test_score = 100
# 越高越好
elif self.metric_rule == "Ascende":
self.best_val_score = 0
self.best_test_score = 0
self.cur_val_score = 0
self.cur_test_score = 0
# train status
self.train_status = defaultdict(utils.AverageMeter)
# val status
self.val_status = defaultdict(utils.AverageMeter)
# test status
self.test_status = defaultdict(utils.AverageMeter)
# model status
self.loss_status = defaultdict(utils.AverageMeter)
# client init
self.s3_client = boto3.client('s3', endpoint_url='http://oss.i.brainpp.cn')
self.bucket_name = params.bucket_name
def update_step(self):
self.step += 1
def update_epoch(self):
self.epoch += 1
def update_loss_status(self, loss, split, bs=None):
if split == "train":
for k, v in loss.items():
bs = self.params.train_batch_size
self.loss_status[k].update(val=v.item(), num=bs)
elif split == "val":
for k, v in loss.items():
self.loss_status[k].update(val=v.item(), num=bs)
elif split == "test":
for k, v in loss.items():
self.loss_status[k].update(val=v.item(), num=bs)
else:
raise ValueError("Wrong eval type: {}".format(split))
def update_metric_status(self, metrics, split, bs):
if split == "val":
for k, v in metrics.items():
self.val_status[k].update(val=v.item(), num=bs)
self.cur_val_score = self.val_status[self.params.major_metric].avg
elif split == "test":
for k, v in metrics.items():
self.test_status[k].update(val=v.item(), num=bs)
self.cur_test_score = self.test_status[self.params.major_metric].avg
else:
raise ValueError("Wrong eval type: {}".format(split))
def reset_loss_status(self):
for k, v in self.loss_status.items():
self.loss_status[k].reset()
def reset_metric_status(self, split):
if split == "val":
for k, v in self.val_status.items():
self.val_status[k].reset()
elif split == "test":
for k, v in self.test_status.items():
self.test_status[k].reset()
else:
raise ValueError("Wrong eval type: {}".format(split))
def print_train_info(self):
exp_name = self.params.model_dir.split('/')[-1]
print_str = "{} Epoch: {:4d}, lr={:.6f} ".format(exp_name, self.epoch, self.scheduler.get_lr()[0])
print_str += "total loss: %.4f(%.4f)" % (self.loss_status['total'].val, self.loss_status['total'].avg)
return print_str
def print_metrics(self, split, title="Eval", color="red"):
if split == "val":
metric_status = self.val_status
elif split == "test":
metric_status = self.test_status
else:
raise ValueError("Wrong eval type: {}".format(split))
if split == "val":
print_str = " | ".join("{}: {:.4f} - avg: {:.4f}".format(k, v.val, v.avg) for k, v in metric_status.items())
print_str += " | lastest: {:.4f} | pre_best: {:.4f}".format(self.cur_val_score, self.best_val_score)
elif split == "test":
print_str = " | ".join("{}: {:.4f} - avg: {:.4f}".format(k, v.val, v.avg) for k, v in metric_status.items())
self.logger.info(colored("{} Results: {}".format(title, print_str), color, attrs=["bold"]))
def check_best_save_last_checkpoints(self, latest_freq=5):
state = {
"state_dict": self.model.state_dict(),
"optimizer": self.optimizer.state_dict(),
"scheduler": self.scheduler.state_dict(),
"step": self.step,
"epoch": self.epoch,
}
if "val" in self.dataloaders:
state["best_val_score"] = self.best_val_score
if "test" in self.dataloaders:
state["best_test_score"] = self.best_test_score
# save latest checkpoint
if self.epoch % latest_freq == 0:
latest_ckpt_name = os.path.join(self.params.model_dir, "model_latest.pth")
if self.params.save_mode == "local":
# print(state)
mge.save(state, latest_ckpt_name)
elif self.params.save_mode == "oss":
save_dict = pickle.dumps(state)
resp = self.s3_client.put_object(Bucket=self.bucket_name, Key=latest_ckpt_name, Body=save_dict[0:])
else:
raise NotImplementedError
self.logger.info("Saved latest checkpoint to: {}".format(latest_ckpt_name))
# save val latest metrics, and check if val is best checkpoints
if "val" in self.dataloaders:
val_latest_metrics_name = os.path.join(self.params.model_dir, "val_metrics_latest.json")
utils.save_dict_to_json(self.val_status, val_latest_metrics_name)
# 越低越好
if self.metric_rule == "Descende":
is_best = self.cur_val_score < self.best_val_score
# 越高越好
elif self.metric_rule == "Ascende":
is_best = self.cur_val_score > self.best_val_score
else:
raise Exception("metric_rule should be either Descende or Ascende")
if is_best:
# save metrics
self.best_val_score = self.cur_val_score
best_metrics_name = os.path.join(self.params.model_dir, "val_metrics_best.json")
utils.save_dict_to_json(self.val_status, best_metrics_name)
self.logger.info("Current is val best, score={:.4f}".format(self.best_val_score))
# save checkpoint
best_ckpt_name = os.path.join(self.params.model_dir, "val_model_best.pth")
if self.params.save_mode == "local":
mge.save(state, best_ckpt_name)
elif self.params.save_mode == "oss":
save_dict = pickle.dumps(state)
resp = self.s3_client.put_object(Bucket=self.bucket_name, Key=best_ckpt_name, Body=save_dict[0:])
else:
raise NotImplementedError
self.logger.info("Saved val best checkpoint to: {}".format(best_ckpt_name))
# save test latest metrics, and check if test is best checkpoints
# if self.dataloaders["test"] is not None:
if "test" in self.dataloaders:
test_latest_metrics_name = os.path.join(self.params.model_dir, "test_metrics_latest.json")
utils.save_dict_to_json(self.test_status, test_latest_metrics_name)
# 越低越好
if self.metric_rule == "Descende":
is_best = self.cur_test_score < self.best_test_score
# 越高越好
elif self.metric_rule == "Ascende":
is_best = self.cur_test_score > self.best_test_score
else:
raise Exception("metric_rule should be either Descende or Ascende")
if is_best:
# save metrics
self.best_test_score = self.cur_test_score
best_metrics_name = os.path.join(self.params.model_dir, "test_metrics_best.json")
utils.save_dict_to_json(self.test_status, best_metrics_name)
self.logger.info("Current is test best, score={:.4f}".format(self.best_test_score))
# save checkpoint
best_ckpt_name = os.path.join(self.params.model_dir, "test_model_best.pth")
if self.params.save_mode == "local":
mge.save(state, best_ckpt_name)
elif self.params.save_mode == "oss":
save_dict = pickle.dumps(state)
resp = self.s3_client.put_object(Bucket=self.bucket_name, Key=best_ckpt_name, Body=save_dict[0:])
else:
raise NotImplementedError
self.logger.info("Saved test best checkpoint to: {}".format(best_ckpt_name))
def load_checkpoints(self):
if self.params.save_mode == "local":
state = mge.load(self.params.restore_file)
elif self.params.save_mode == "oss":
resp = self.s3_client.get_object(Bucket=self.bucket_name, Key=self.params.restore_file[0:])
state = resp["Body"].read()
state = pickle.loads(state)
else:
raise NotImplementedError
ckpt_component = []
if "state_dict" in state and self.model is not None:
try:
self.model.load_state_dict(state["state_dict"])
except Warning("Using custom loading net"):
net_dict = self.model.state_dict()
if "module" not in list(state["state_dict"].keys())[0]:
state_dict = {"module." + k: v for k, v in state["state_dict"].items() if "module." + k in net_dict.keys()}
else:
state_dict = {k: v for k, v in state["state_dict"].items() if k in net_dict.keys()}
net_dict.update(state_dict)
self.model.load_state_dict(net_dict, strict=False)
ckpt_component.append("net")
if not self.params.only_weights:
print("reload states from checkpoints!")
if "optimizer" in state and self.optimizer is not None:
try:
self.optimizer.load_state_dict(state["optimizer"])
except Warning("Using custom loading optimizer"):
optimizer_dict = self.optimizer.state_dict()
state_dict = {k: v for k, v in state["optimizer"].items() if k in optimizer_dict.keys()}
optimizer_dict.update(state_dict)
self.optimizer.load_state_dict(optimizer_dict)
ckpt_component.append("opt")
if "scheduler" in state and self.train_status["scheduler"] is not None:
try:
self.scheduler.load_state_dict(state["scheduler"])
except Warning("Using custom loading scheduler"):
scheduler_dict = self.scheduler.state_dict()
state_dict = {k: v for k, v in state["scheduler"].items() if k in scheduler_dict.keys()}
scheduler_dict.update(state_dict)
self.scheduler.load_state_dict(scheduler_dict)
ckpt_component.append("sch")
if "step" in state:
self.step = state["step"] + 1
self.train_status["step"] = state["step"] + 1
ckpt_component.append("step: {}".format(self.train_status["step"]))
if "epoch" in state:
self.epoch = state["epoch"] + 1
self.train_status["epoch"] = state["epoch"] + 1
ckpt_component.append("epoch: {}".format(self.train_status["epoch"]))
if "best_val_score" in state:
self.best_val_score = state["best_val_score"]
ckpt_component.append("best val score: {:.3g}".format(self.best_val_score))
if "best_test_score" in state:
self.best_test_score = state["best_test_score"]
ckpt_component.append("best test score: {:.3g}".format(self.best_test_score))
ckpt_component = ", ".join(i for i in ckpt_component)
self.logger.info("Loaded models from: {}".format(self.params.restore_file))
self.logger.info("Ckpt load: {}".format(ckpt_component))
|
[
"megengine.save",
"megengine.load"
] |
[((1472, 1503), 'collections.defaultdict', 'defaultdict', (['utils.AverageMeter'], {}), '(utils.AverageMeter)\n', (1483, 1503), False, 'from collections import defaultdict\n'), ((1555, 1586), 'collections.defaultdict', 'defaultdict', (['utils.AverageMeter'], {}), '(utils.AverageMeter)\n', (1566, 1586), False, 'from collections import defaultdict\n'), ((1640, 1671), 'collections.defaultdict', 'defaultdict', (['utils.AverageMeter'], {}), '(utils.AverageMeter)\n', (1651, 1671), False, 'from collections import defaultdict\n'), ((1726, 1757), 'collections.defaultdict', 'defaultdict', (['utils.AverageMeter'], {}), '(utils.AverageMeter)\n', (1737, 1757), False, 'from collections import defaultdict\n'), ((1809, 1867), 'boto3.client', 'boto3.client', (['"""s3"""'], {'endpoint_url': '"""http://oss.i.brainpp.cn"""'}), "('s3', endpoint_url='http://oss.i.brainpp.cn')\n", (1821, 1867), False, 'import boto3\n'), ((5498, 5553), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""model_latest.pth"""'], {}), "(self.params.model_dir, 'model_latest.pth')\n", (5510, 5553), False, 'import os\n'), ((6207, 6269), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""val_metrics_latest.json"""'], {}), "(self.params.model_dir, 'val_metrics_latest.json')\n", (6219, 6269), False, 'import os\n'), ((6283, 6348), 'common.utils.save_dict_to_json', 'utils.save_dict_to_json', (['self.val_status', 'val_latest_metrics_name'], {}), '(self.val_status, val_latest_metrics_name)\n', (6306, 6348), False, 'from common import utils\n'), ((7951, 8014), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""test_metrics_latest.json"""'], {}), "(self.params.model_dir, 'test_metrics_latest.json')\n", (7963, 8014), False, 'import os\n'), ((8028, 8095), 'common.utils.save_dict_to_json', 'utils.save_dict_to_json', (['self.test_status', 'test_latest_metrics_name'], {}), '(self.test_status, test_latest_metrics_name)\n', (8051, 8095), False, 'from common import utils\n'), ((9599, 9633), 'megengine.load', 'mge.load', (['self.params.restore_file'], {}), '(self.params.restore_file)\n', (9607, 9633), True, 'import megengine as mge\n'), ((5653, 5686), 'megengine.save', 'mge.save', (['state', 'latest_ckpt_name'], {}), '(state, latest_ckpt_name)\n', (5661, 5686), True, 'import megengine as mge\n'), ((6882, 6942), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""val_metrics_best.json"""'], {}), "(self.params.model_dir, 'val_metrics_best.json')\n", (6894, 6942), False, 'import os\n'), ((6960, 7019), 'common.utils.save_dict_to_json', 'utils.save_dict_to_json', (['self.val_status', 'best_metrics_name'], {}), '(self.val_status, best_metrics_name)\n', (6983, 7019), False, 'from common import utils\n'), ((7188, 7245), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""val_model_best.pth"""'], {}), "(self.params.model_dir, 'val_model_best.pth')\n", (7200, 7245), False, 'import os\n'), ((8631, 8692), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""test_metrics_best.json"""'], {}), "(self.params.model_dir, 'test_metrics_best.json')\n", (8643, 8692), False, 'import os\n'), ((8710, 8770), 'common.utils.save_dict_to_json', 'utils.save_dict_to_json', (['self.test_status', 'best_metrics_name'], {}), '(self.test_status, best_metrics_name)\n', (8733, 8770), False, 'from common import utils\n'), ((8941, 8999), 'os.path.join', 'os.path.join', (['self.params.model_dir', '"""test_model_best.pth"""'], {}), "(self.params.model_dir, 'test_model_best.pth')\n", (8953, 8999), False, 'import os\n'), ((9849, 9868), 'pickle.loads', 'pickle.loads', (['state'], {}), '(state)\n', (9861, 9868), False, 'import pickle\n'), ((5766, 5785), 'pickle.dumps', 'pickle.dumps', (['state'], {}), '(state)\n', (5778, 5785), False, 'import pickle\n'), ((7321, 7352), 'megengine.save', 'mge.save', (['state', 'best_ckpt_name'], {}), '(state, best_ckpt_name)\n', (7329, 7352), True, 'import megengine as mge\n'), ((9075, 9106), 'megengine.save', 'mge.save', (['state', 'best_ckpt_name'], {}), '(state, best_ckpt_name)\n', (9083, 9106), True, 'import megengine as mge\n'), ((7440, 7459), 'pickle.dumps', 'pickle.dumps', (['state'], {}), '(state)\n', (7452, 7459), False, 'import pickle\n'), ((9194, 9213), 'pickle.dumps', 'pickle.dumps', (['state'], {}), '(state)\n', (9206, 9213), False, 'import pickle\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
from functools import partial
from typing import Tuple, Union
import megengine._internal as mgb
from ... import module as Float
from ...core import Parameter
from ...functional import conv_bias_activation
from ...module import Conv2d
from ...quantization.utils import register_method_to_class
class _ConvBnActivation2d(Conv2d):
r"""Applies a 2D convolution over an quantized input tensor, inference only.
The parameter is same with :class: `~.Conv2d`
"""
def __init__(
self,
in_channels: int,
out_channels: int,
kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]] = 1,
padding: Union[int, Tuple[int, int]] = 0,
dilation: Union[int, Tuple[int, int]] = 1,
groups: int = 1,
conv_mode: str = "CROSS_CORRELATION",
compute_mode: str = "DEFAULT",
):
super().__init__(
in_channels,
out_channels,
kernel_size,
stride,
padding,
dilation,
groups,
True,
conv_mode,
compute_mode,
)
self.scale = 1.0
self.zero_point = 0.0
self.output_dtype = mgb.dtype.qint8(self.scale)
self.weight = self.weight.astype(self.output_dtype)
self.bias = self.bias.astype(mgb.dtype.qint32(self.scale))
def calc_conv_quantized(self, inp, nonlinear_mode="IDENTITY"):
inp_scale = mgb.dtype.get_scale(inp.dtype)
w_scale = mgb.dtype.get_scale(self.weight.dtype)
bias_scale = inp_scale * w_scale
return conv_bias_activation(
inp,
self.weight,
self.bias.astype(mgb.dtype.qint32(bias_scale)),
self.output_dtype,
self.stride,
self.padding,
self.dilation,
self.groups,
conv_mode=self.conv_mode,
compute_mode=self.compute_mode,
nonlinear_mode=nonlinear_mode,
)
class ConvBn2d(_ConvBnActivation2d):
def forward(self, inp):
if self.training:
raise ValueError("quantized module only support inference.")
return self.calc_conv_quantized(inp, nonlinear_mode="IDENTITY")
class ConvBnRelu2d(_ConvBnActivation2d):
def forward(self, inp):
if self.training:
raise ValueError("quantized module only support inference.")
return self.calc_conv_quantized(inp, nonlinear_mode="RELU")
def to_quantized(quantized_class, float_module):
qconv = quantized_class(
float_module.conv.in_channels,
float_module.conv.out_channels,
float_module.conv.kernel_size,
float_module.conv.stride,
float_module.conv.padding,
float_module.conv.dilation,
float_module.conv.groups,
)
w_fold, b_fold = float_module.fold_weight_bias(
float_module.bn.running_mean, float_module.bn.running_var
)
weight = w_fold.astype(float_module.weight_observer.get_dtype())
qconv.output_dtype = float_module.act_observer.get_dtype()
qconv.weight = Parameter(weight.numpy())
qconv.bias = Parameter(b_fold.numpy())
qconv.scale, qconv.zero_point = float_module.act_observer.get_qparams()
return qconv
# replace :class:`~.module.QATModule`'s ``to_quantized`` method.
# implemented here to avoid circular import.
register_method_to_class(Float.ConvBn2d)(partial(to_quantized, ConvBn2d))
register_method_to_class(Float.ConvBnRelu2d)(partial(to_quantized, ConvBnRelu2d))
|
[
"megengine._internal.dtype.qint32",
"megengine._internal.dtype.qint8",
"megengine._internal.dtype.get_scale"
] |
[((3763, 3794), 'functools.partial', 'partial', (['to_quantized', 'ConvBn2d'], {}), '(to_quantized, ConvBn2d)\n', (3770, 3794), False, 'from functools import partial\n'), ((3841, 3876), 'functools.partial', 'partial', (['to_quantized', 'ConvBnRelu2d'], {}), '(to_quantized, ConvBnRelu2d)\n', (3848, 3876), False, 'from functools import partial\n'), ((1573, 1600), 'megengine._internal.dtype.qint8', 'mgb.dtype.qint8', (['self.scale'], {}), '(self.scale)\n', (1588, 1600), True, 'import megengine._internal as mgb\n'), ((1816, 1846), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['inp.dtype'], {}), '(inp.dtype)\n', (1835, 1846), True, 'import megengine._internal as mgb\n'), ((1865, 1903), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['self.weight.dtype'], {}), '(self.weight.dtype)\n', (1884, 1903), True, 'import megengine._internal as mgb\n'), ((1698, 1726), 'megengine._internal.dtype.qint32', 'mgb.dtype.qint32', (['self.scale'], {}), '(self.scale)\n', (1714, 1726), True, 'import megengine._internal as mgb\n'), ((2053, 2081), 'megengine._internal.dtype.qint32', 'mgb.dtype.qint32', (['bias_scale'], {}), '(bias_scale)\n', (2069, 2081), True, 'import megengine._internal as mgb\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
from megengine import tensor
from megengine.test import assertTensorClose
def test_reshape_tuple():
inp = tensor(np.arange(1, 17, dtype=np.int32).reshape(4, 4))
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
out = out.reshape(inp.shape)
assertTensorClose(out.numpy(), np.arange(100, 116, dtype=np.int32).reshape(4, 4))
def test_reshape_asterisk():
inp = tensor(np.arange(1, 17, dtype=np.int32).reshape(4, 4))
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
out = out.reshape(*inp.shape)
assertTensorClose(out.numpy(), np.arange(100, 116, dtype=np.int32).reshape(4, 4))
def test_reshape_shapeof():
inp = tensor(np.arange(1, 17, dtype=np.int32).reshape(4, 4))
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
out = out.reshape(inp.shapeof())
assertTensorClose(out.numpy(), np.arange(100, 116, dtype=np.int32).reshape(4, 4))
def test_reshape_tensor():
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
out = out.reshape(tensor([4, 4]))
assertTensorClose(out.numpy(), np.arange(100, 116, dtype=np.int32).reshape(4, 4))
def test_reshape_tensor_fused():
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
out = out.reshape(tensor([4, 4]), 1)
assertTensorClose(out.numpy(), np.arange(100, 116, dtype=np.int32).reshape(4, 4, 1))
def test_reshape_fused():
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
out = out.reshape(tensor(2), 2, tensor(4), 1)
assertTensorClose(
out.numpy(), np.arange(100, 116, dtype=np.int32).reshape(2, 2, 4, 1)
)
def test_reshape_wrong_tuple():
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
with pytest.raises(ValueError):
out = out.reshape((2, 2), 4)
def test_reshape_wrong_tuple2():
out = tensor(np.arange(100, 116, dtype=np.int32).reshape(1, 16))
with pytest.raises(AssertionError):
out = out.reshape(4, (2, 2))
def test_broadcast_tuple():
inp = tensor(np.arange(1, 17, dtype=np.int32).reshape(4, 4))
out = tensor(np.arange(100, 104, dtype=np.int32).reshape(1, 4))
out = out.broadcast(inp.shape)
tmp = np.array([[100, 101, 102, 103]], dtype=np.int32)
out2 = np.repeat(tmp, 4, axis=0)
assertTensorClose(out.numpy(), out2)
def test_broadcast_asterisk():
inp = tensor(np.arange(1, 17, dtype=np.int32).reshape(4, 4))
out = tensor(np.arange(100, 104, dtype=np.int32).reshape(1, 4))
out = out.broadcast(*inp.shape)
tmp = np.array([[100, 101, 102, 103]], dtype=np.int32)
out2 = np.repeat(tmp, 4, axis=0)
assertTensorClose(out.numpy(), out2)
def test_broadcast_shapeof():
inp = tensor(np.arange(1, 17, dtype=np.int32).reshape(4, 4))
out = tensor(np.arange(100, 104, dtype=np.int32).reshape(1, 4))
out = out.broadcast(inp.shapeof())
tmp = np.array([[100, 101, 102, 103]], dtype=np.int32)
out2 = np.repeat(tmp, 4, axis=0)
assertTensorClose(out.numpy(), out2)
|
[
"megengine.tensor"
] |
[((2620, 2668), 'numpy.array', 'np.array', (['[[100, 101, 102, 103]]'], {'dtype': 'np.int32'}), '([[100, 101, 102, 103]], dtype=np.int32)\n', (2628, 2668), True, 'import numpy as np\n'), ((2680, 2705), 'numpy.repeat', 'np.repeat', (['tmp', '(4)'], {'axis': '(0)'}), '(tmp, 4, axis=0)\n', (2689, 2705), True, 'import numpy as np\n'), ((2962, 3010), 'numpy.array', 'np.array', (['[[100, 101, 102, 103]]'], {'dtype': 'np.int32'}), '([[100, 101, 102, 103]], dtype=np.int32)\n', (2970, 3010), True, 'import numpy as np\n'), ((3022, 3047), 'numpy.repeat', 'np.repeat', (['tmp', '(4)'], {'axis': '(0)'}), '(tmp, 4, axis=0)\n', (3031, 3047), True, 'import numpy as np\n'), ((3306, 3354), 'numpy.array', 'np.array', (['[[100, 101, 102, 103]]'], {'dtype': 'np.int32'}), '([[100, 101, 102, 103]], dtype=np.int32)\n', (3314, 3354), True, 'import numpy as np\n'), ((3366, 3391), 'numpy.repeat', 'np.repeat', (['tmp', '(4)'], {'axis': '(0)'}), '(tmp, 4, axis=0)\n', (3375, 3391), True, 'import numpy as np\n'), ((1461, 1475), 'megengine.tensor', 'tensor', (['[4, 4]'], {}), '([4, 4])\n', (1467, 1475), False, 'from megengine import tensor\n'), ((1690, 1704), 'megengine.tensor', 'tensor', (['[4, 4]'], {}), '([4, 4])\n', (1696, 1704), False, 'from megengine import tensor\n'), ((1918, 1927), 'megengine.tensor', 'tensor', (['(2)'], {}), '(2)\n', (1924, 1927), False, 'from megengine import tensor\n'), ((1932, 1941), 'megengine.tensor', 'tensor', (['(4)'], {}), '(4)\n', (1938, 1941), False, 'from megengine import tensor\n'), ((2165, 2190), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (2178, 2190), False, 'import pytest\n'), ((2342, 2371), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (2355, 2371), False, 'import pytest\n'), ((530, 562), 'numpy.arange', 'np.arange', (['(1)', '(17)'], {'dtype': 'np.int32'}), '(1, 17, dtype=np.int32)\n', (539, 562), True, 'import numpy as np\n'), ((595, 630), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (604, 630), True, 'import numpy as np\n'), ((716, 751), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (725, 751), True, 'import numpy as np\n'), ((815, 847), 'numpy.arange', 'np.arange', (['(1)', '(17)'], {'dtype': 'np.int32'}), '(1, 17, dtype=np.int32)\n', (824, 847), True, 'import numpy as np\n'), ((880, 915), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (889, 915), True, 'import numpy as np\n'), ((1002, 1037), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1011, 1037), True, 'import numpy as np\n'), ((1100, 1132), 'numpy.arange', 'np.arange', (['(1)', '(17)'], {'dtype': 'np.int32'}), '(1, 17, dtype=np.int32)\n', (1109, 1132), True, 'import numpy as np\n'), ((1165, 1200), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1174, 1200), True, 'import numpy as np\n'), ((1290, 1325), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1299, 1325), True, 'import numpy as np\n'), ((1387, 1422), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1396, 1422), True, 'import numpy as np\n'), ((1513, 1548), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1522, 1548), True, 'import numpy as np\n'), ((1616, 1651), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1625, 1651), True, 'import numpy as np\n'), ((1745, 1780), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1754, 1780), True, 'import numpy as np\n'), ((1844, 1879), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (1853, 1879), True, 'import numpy as np\n'), ((1991, 2026), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (2000, 2026), True, 'import numpy as np\n'), ((2104, 2139), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (2113, 2139), True, 'import numpy as np\n'), ((2281, 2316), 'numpy.arange', 'np.arange', (['(100)', '(116)'], {'dtype': 'np.int32'}), '(100, 116, dtype=np.int32)\n', (2290, 2316), True, 'import numpy as np\n'), ((2457, 2489), 'numpy.arange', 'np.arange', (['(1)', '(17)'], {'dtype': 'np.int32'}), '(1, 17, dtype=np.int32)\n', (2466, 2489), True, 'import numpy as np\n'), ((2522, 2557), 'numpy.arange', 'np.arange', (['(100)', '(104)'], {'dtype': 'np.int32'}), '(100, 104, dtype=np.int32)\n', (2531, 2557), True, 'import numpy as np\n'), ((2798, 2830), 'numpy.arange', 'np.arange', (['(1)', '(17)'], {'dtype': 'np.int32'}), '(1, 17, dtype=np.int32)\n', (2807, 2830), True, 'import numpy as np\n'), ((2863, 2898), 'numpy.arange', 'np.arange', (['(100)', '(104)'], {'dtype': 'np.int32'}), '(100, 104, dtype=np.int32)\n', (2872, 2898), True, 'import numpy as np\n'), ((3139, 3171), 'numpy.arange', 'np.arange', (['(1)', '(17)'], {'dtype': 'np.int32'}), '(1, 17, dtype=np.int32)\n', (3148, 3171), True, 'import numpy as np\n'), ((3204, 3239), 'numpy.arange', 'np.arange', (['(100)', '(104)'], {'dtype': 'np.int32'}), '(100, 104, dtype=np.int32)\n', (3213, 3239), True, 'import numpy as np\n')]
|
import sys
sys.path.append('.')
import time
import megengine as mge
from model.RIFE import Model
model = Model()
model.eval()
I0 = mge.random(1, 3, 480, 640)
I1 = mge.random(1, 3, 480, 640)
for i in range(100):
pred = model.inference(I0, I1)
mge._full_sync()
time_stamp = time.time()
for i in range(100):
pred = model.inference(I0, I1)
mge._full_sync()
print((time.time() - time_stamp) / 100)
|
[
"megengine.random",
"megengine._full_sync"
] |
[((11, 31), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (26, 31), False, 'import sys\n'), ((106, 113), 'model.RIFE.Model', 'Model', ([], {}), '()\n', (111, 113), False, 'from model.RIFE import Model\n'), ((133, 159), 'megengine.random', 'mge.random', (['(1)', '(3)', '(480)', '(640)'], {}), '(1, 3, 480, 640)\n', (143, 159), True, 'import megengine as mge\n'), ((165, 191), 'megengine.random', 'mge.random', (['(1)', '(3)', '(480)', '(640)'], {}), '(1, 3, 480, 640)\n', (175, 191), True, 'import megengine as mge\n'), ((248, 264), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (262, 264), True, 'import megengine as mge\n'), ((278, 289), 'time.time', 'time.time', ([], {}), '()\n', (287, 289), False, 'import time\n'), ((346, 362), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (360, 362), True, 'import megengine as mge\n'), ((370, 381), 'time.time', 'time.time', ([], {}), '()\n', (379, 381), False, 'import time\n')]
|
# Copyright (c) Megvii, Inc. and its affiliates.
import megengine.functional as F
import megengine.module as M
from .head import get_head
from .loss import get_loss
from .resnet import get_backbone
from .stn import STN
class FaceRecognitionModel(M.Module):
"""combination of all building blocks, including backbone, head and loss
"""
def __init__(self, configs):
"""initialize with configuration
Args:
configs (dict): configuration, required fields include:
backbone: custom name of backbone
output_head: custon name of output head
feature_dim: dimension number of output embedding
loss_type: custon name of loss function
num_class: classification number of dataset
loss_scale: used in loss function
loss_m1: used in loss function
loss_m2: used in loss function
loss_m3: used in loss function
use_stn: whether or not use stn
"""
super().__init__()
backbone_constructor = get_backbone(configs["backbone"])
self.backbone = backbone_constructor()
head_constructor = get_head(configs["output_head"])
self.head = head_constructor(feature_dim=configs["feature_dim"], channel=self.backbone.output_channel)
metric_constructor = get_loss(configs["loss_type"])
self.metric = metric_constructor(
num_class=configs["num_class"],
scale=configs["loss_scale"],
m1=configs["loss_m1"],
m2=configs["loss_m2"],
m3=configs["loss_m3"],
feature_dim=configs["feature_dim"],
)
if configs["use_stn"]:
self.stn = STN()
self.use_stn = True
else:
self.use_stn = False
def forward_embedding_only(self, images):
"""run forward pass without calculating loss, expected useful during evaluation.
Args:
images (Tensor): preprocessed images (shape: n * 3 * 112 * 112)
Returns:
embedding (Tensor): embedding
"""
if self.use_stn:
images = self.stn(images)
feature_map = self.backbone(images)
embedding = self.head(feature_map)
embedding = F.normalize(embedding, axis=1)
return embedding
def forward(self, images, labels):
"""run forward pass and calculate loss, expected useful during training.
Args:
images (Tensor): preprocessed images (shape: n * 3 * 112 * 112)
labels (Tensor): ground truth class id (shape: n)
Returns:
loss (Tensor): loss
accuracy (Tensor): top1 accuracy (range: 0~1)
embedding （Tensor): embedding
"""
embedding = self.forward_embedding_only(images)
loss, accuracy = self.metric(embedding, labels)
return loss, accuracy, embedding
|
[
"megengine.functional.normalize"
] |
[((2314, 2344), 'megengine.functional.normalize', 'F.normalize', (['embedding'], {'axis': '(1)'}), '(embedding, axis=1)\n', (2325, 2344), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine as mge
import megengine.functional as F
from megengine import tensor
from megengine.core.autodiff.grad import Function, Grad
from megengine.core.tensor.dtype import QuantDtypeMeta
from megengine.core.tensor.utils import make_shape_tuple
from megengine.quantization.internal_fake_quant import *
from megengine.quantization.utils import (
QuantMode,
create_qparams,
fake_quant_tensor,
lsq_forward,
tqt_forward,
)
class TQT_numpy:
def __init__(self, lowerbound, upperbound):
super().__init__()
self.lowerbound = lowerbound
self.upperbound = upperbound
def forward(self, inp, scale):
t = 2 ** scale
# t = F.maximum(t, 1e-4)
inp_scaled = inp / t
inp_clipped = np.maximum(
np.minimum(inp_scaled, self.upperbound), self.lowerbound
)
inp_rounded = np.round(inp_clipped)
inp_flq = inp_rounded * t
self.saved_tensors = (inp_scaled, inp_rounded, t)
return inp_flq
def backward(self, grad_inp_flq):
(inp_scaled, inp_rounded, t) = self.saved_tensors
mask_clip = (inp_scaled < -0.5 + self.lowerbound) + (
inp_scaled > self.upperbound + 0.5
) # mask for accumulating the gradients of |data_scaled|>L
mask_quant = np.abs(
mask_clip - 1
) # mask for accumulating the gradients with |data_scaled|<=L
grad_quant = (
grad_inp_flq * mask_quant * (inp_rounded - inp_scaled)
) # gradient within |data_scaled|<=L
grad_clip = (
grad_inp_flq * mask_clip * inp_rounded
) # gradient with | data_scaled|>L
grad_s = grad_clip.sum() + grad_quant.sum()
# dL/ds = dL/dt * t * ln(2)
grad_s = grad_s * t * np.log(2)
grad_inp = grad_inp_flq * mask_quant
return grad_inp, grad_s
def test_tqt():
g = []
def cb(grad):
g.append(grad)
x = np.random.randint(-128, 128, size=(1, 2, 3, 4)).astype("float32")
s = np.random.rand(1) - 1
g_y = np.ones(shape=(1, 2, 3, 4), dtype="float32")
n = TQT_numpy(-127, 127)
y_np = n.forward(x, s)
g_x_np, g_s_np = n.backward(g_y)
x = mge.tensor(x, dtype="float32")
s = mge.tensor(s, dtype="float32")
g_y = mge.tensor(g_y, dtype="float32")
with Grad() as grad:
grad.wrt(x, s, callback=cb)
y = tqt_forward(-127, 127, x, s)
grad(y, g_y)
g_x, g_s = g
np.testing.assert_allclose(y.numpy(), y_np, rtol=1e-5, atol=1e-5)
np.testing.assert_allclose(g_x.numpy(), g_x_np, rtol=1e-5, atol=1e-5)
np.testing.assert_allclose(g_s.numpy(), g_s_np, rtol=5e-5, atol=5e-5)
def _save_to(self, name="grad"):
def callback(grad):
setattr(self, name, grad)
return callback
class Round(Function):
def forward(self, x):
return F.round(x)
def backward(self, output_grads):
return output_grads
def fake_quant_tensor_gt(inp, scale, zero_point, qmin, qmax):
oup = Round()(inp / scale) + zero_point
oup = F.minimum(F.maximum(oup, qmin), qmax)
oup = (oup - zero_point) * scale
return oup
def test_fakequant():
qmin = -126
qmax = 129
test_dtype = QuantDtypeMeta("test_qint8", None, "int8", qmin, qmax)
def run(zero_point, scale):
qparams = create_qparams(QuantMode.ASYMMERTIC, test_dtype, scale, zero_point)
inp_data = np.random.uniform(low=-512.0, high=512.0, size=(1, 32, 32, 32))
inp = tensor(inp_data, dtype=np.float32)
# test forward
oup = fake_quant_tensor(inp, qparams).numpy()
oup_gt = fake_quant_tensor_gt(inp, scale, zero_point, qmin, qmax).numpy()
assert np.allclose(oup, oup_gt)
assert oup.shape == oup_gt.shape
# test backward
x = tensor(inp_data, dtype=np.float32)
with Grad() as grad:
grad.wrt(x, callback=_save_to(x))
y = fake_quant_tensor(x, qparams)
grad(y, tensor(F.ones_like(x)))
x1 = tensor(inp_data, dtype=np.float32)
with Grad() as grad:
grad.wrt(x1, callback=_save_to(x1))
y1 = fake_quant_tensor_gt(x1, scale, zero_point, qmin, qmax)
grad(y1, tensor(F.ones_like(x1)))
assert np.allclose(x.grad.numpy(), x1.grad.numpy())
assert make_shape_tuple(x.grad.shape) == make_shape_tuple(x1.grad.shape)
# test nan
x = F.full((1, 32, 3, 3), np.nan)
y = fake_quant_tensor(x, qparams).numpy()
assert np.isnan(y).all()
zero_point = tensor([1.0], dtype=np.float32)
scale = tensor([4.0], dtype=np.float32)
run(zero_point, scale)
zero_point = tensor(1.0 * np.ones((1, 32, 1, 1)), dtype=np.float32)
scale = tensor(4.0 * np.ones((1, 32, 1, 1)), dtype=np.float32)
run(zero_point, scale)
class LSQ_numpy:
def __init__(self, lowerbound, upperbound):
super().__init__()
self.lowerbound = lowerbound
self.upperbound = upperbound
def forward(self, inp, scale, zero_point, grad_scale):
inp_scaled = inp / scale + zero_point
inp_clipped = np.maximum(
np.minimum(inp_scaled, self.upperbound), self.lowerbound
)
inp_rounded = np.floor(inp_clipped + 0.5)
inp_flq = (inp_rounded - zero_point) * scale
self.saved_tensors = (inp_scaled, inp_rounded, scale, grad_scale)
return inp_flq
def backward(self, grad_inp_flq):
(inp_scaled, inp_rounded, scale, grad_scale) = self.saved_tensors
ind_small = inp_scaled < self.lowerbound
ind_big = inp_scaled > self.upperbound
ind_middle = np.logical_xor(ind_small, ind_big)
ind_middle = np.abs(ind_middle - 1)
grad_s = (
ind_small * self.lowerbound
+ ind_big * self.upperbound
+ ind_middle * (-inp_scaled + inp_rounded)
)
grad_s = grad_s * grad_scale * grad_inp_flq
grad_s = grad_s.sum()
grad_inp = grad_inp_flq * ind_middle
return grad_inp, grad_s
def test_lsq():
g = []
def cb(grad):
g.append(grad)
# FIXME: use random number when LSQ is fixed
# x = np.random.randint(-128, 128, size=(1, 2, 3, 4)).astype("float32")
# s = np.random.rand(1)
x = np.array(
[
[
[
[4.0, 38.0, -121.0, 38.0],
[15.0, -115.0, -112.0, 24.0],
[23.0, -65.0, 109.0, -115.0],
],
[
[-66.0, -90.0, -45.0, -101.0],
[68.0, -98.0, 108.0, -79.0],
[54.0, 63.0, -10.0, -50.0],
],
]
],
dtype="float32",
)
s = np.array([0.02918224], dtype="float32")
eps = np.array([1e-5], dtype="float32")
s = np.abs(s) if np.abs(s) > eps else eps
zero_point = np.array([1.0], dtype="float32")
grad_s = np.array([2.0], dtype="float32")
g_y = np.ones(shape=(1, 2, 3, 4), dtype="float32")
n = LSQ_numpy(-127, 127)
y_np = n.forward(x, s, zero_point, grad_s)
g_x_np, g_s_np = n.backward(g_y)
x = mge.tensor(x, dtype="float32")
s = mge.tensor(s, dtype="float32")
zero_point = mge.tensor(zero_point, dtype="float32")
grad_s = mge.tensor(grad_s, dtype="float32")
g_y = mge.tensor(g_y, dtype="float32")
with Grad() as grad:
grad.wrt(x, s, callback=cb)
y = lsq_forward(-127, 127, x, s, zero_point, grad_s)
grad(y, g_y)
g_x, g_s = g
np.testing.assert_allclose(y.numpy(), y_np, rtol=1e-7, atol=1e-7)
np.testing.assert_allclose(g_x.numpy(), g_x_np, rtol=1e-7, atol=1e-7)
np.testing.assert_allclose(g_s.numpy(), g_s_np, rtol=5e-7, atol=5e-7)
|
[
"megengine.quantization.utils.fake_quant_tensor",
"megengine.functional.maximum",
"megengine.quantization.utils.lsq_forward",
"megengine.functional.full",
"megengine.core.tensor.utils.make_shape_tuple",
"megengine.quantization.utils.create_qparams",
"megengine.functional.ones_like",
"megengine.core.autodiff.grad.Grad",
"megengine.tensor",
"megengine.quantization.utils.tqt_forward",
"megengine.core.tensor.dtype.QuantDtypeMeta",
"megengine.functional.round"
] |
[((2467, 2511), 'numpy.ones', 'np.ones', ([], {'shape': '(1, 2, 3, 4)', 'dtype': '"""float32"""'}), "(shape=(1, 2, 3, 4), dtype='float32')\n", (2474, 2511), True, 'import numpy as np\n'), ((2615, 2645), 'megengine.tensor', 'mge.tensor', (['x'], {'dtype': '"""float32"""'}), "(x, dtype='float32')\n", (2625, 2645), True, 'import megengine as mge\n'), ((2654, 2684), 'megengine.tensor', 'mge.tensor', (['s'], {'dtype': '"""float32"""'}), "(s, dtype='float32')\n", (2664, 2684), True, 'import megengine as mge\n'), ((2695, 2727), 'megengine.tensor', 'mge.tensor', (['g_y'], {'dtype': '"""float32"""'}), "(g_y, dtype='float32')\n", (2705, 2727), True, 'import megengine as mge\n'), ((3625, 3679), 'megengine.core.tensor.dtype.QuantDtypeMeta', 'QuantDtypeMeta', (['"""test_qint8"""', 'None', '"""int8"""', 'qmin', 'qmax'], {}), "('test_qint8', None, 'int8', qmin, qmax)\n", (3639, 3679), False, 'from megengine.core.tensor.dtype import QuantDtypeMeta\n'), ((4958, 4989), 'megengine.tensor', 'tensor', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (4964, 4989), False, 'from megengine import tensor\n'), ((5002, 5033), 'megengine.tensor', 'tensor', (['[4.0]'], {'dtype': 'np.float32'}), '([4.0], dtype=np.float32)\n', (5008, 5033), False, 'from megengine import tensor\n'), ((6683, 6900), 'numpy.array', 'np.array', (['[[[[4.0, 38.0, -121.0, 38.0], [15.0, -115.0, -112.0, 24.0], [23.0, -65.0, \n 109.0, -115.0]], [[-66.0, -90.0, -45.0, -101.0], [68.0, -98.0, 108.0, -\n 79.0], [54.0, 63.0, -10.0, -50.0]]]]'], {'dtype': '"""float32"""'}), "([[[[4.0, 38.0, -121.0, 38.0], [15.0, -115.0, -112.0, 24.0], [23.0,\n -65.0, 109.0, -115.0]], [[-66.0, -90.0, -45.0, -101.0], [68.0, -98.0, \n 108.0, -79.0], [54.0, 63.0, -10.0, -50.0]]]], dtype='float32')\n", (6691, 6900), True, 'import numpy as np\n'), ((7150, 7189), 'numpy.array', 'np.array', (['[0.02918224]'], {'dtype': '"""float32"""'}), "([0.02918224], dtype='float32')\n", (7158, 7189), True, 'import numpy as np\n'), ((7200, 7234), 'numpy.array', 'np.array', (['[1e-05]'], {'dtype': '"""float32"""'}), "([1e-05], dtype='float32')\n", (7208, 7234), True, 'import numpy as np\n'), ((7297, 7329), 'numpy.array', 'np.array', (['[1.0]'], {'dtype': '"""float32"""'}), "([1.0], dtype='float32')\n", (7305, 7329), True, 'import numpy as np\n'), ((7343, 7375), 'numpy.array', 'np.array', (['[2.0]'], {'dtype': '"""float32"""'}), "([2.0], dtype='float32')\n", (7351, 7375), True, 'import numpy as np\n'), ((7387, 7431), 'numpy.ones', 'np.ones', ([], {'shape': '(1, 2, 3, 4)', 'dtype': '"""float32"""'}), "(shape=(1, 2, 3, 4), dtype='float32')\n", (7394, 7431), True, 'import numpy as np\n'), ((7555, 7585), 'megengine.tensor', 'mge.tensor', (['x'], {'dtype': '"""float32"""'}), "(x, dtype='float32')\n", (7565, 7585), True, 'import megengine as mge\n'), ((7594, 7624), 'megengine.tensor', 'mge.tensor', (['s'], {'dtype': '"""float32"""'}), "(s, dtype='float32')\n", (7604, 7624), True, 'import megengine as mge\n'), ((7642, 7681), 'megengine.tensor', 'mge.tensor', (['zero_point'], {'dtype': '"""float32"""'}), "(zero_point, dtype='float32')\n", (7652, 7681), True, 'import megengine as mge\n'), ((7695, 7730), 'megengine.tensor', 'mge.tensor', (['grad_s'], {'dtype': '"""float32"""'}), "(grad_s, dtype='float32')\n", (7705, 7730), True, 'import megengine as mge\n'), ((7742, 7774), 'megengine.tensor', 'mge.tensor', (['g_y'], {'dtype': '"""float32"""'}), "(g_y, dtype='float32')\n", (7752, 7774), True, 'import megengine as mge\n'), ((1283, 1304), 'numpy.round', 'np.round', (['inp_clipped'], {}), '(inp_clipped)\n', (1291, 1304), True, 'import numpy as np\n'), ((1715, 1736), 'numpy.abs', 'np.abs', (['(mask_clip - 1)'], {}), '(mask_clip - 1)\n', (1721, 1736), True, 'import numpy as np\n'), ((2435, 2452), 'numpy.random.rand', 'np.random.rand', (['(1)'], {}), '(1)\n', (2449, 2452), True, 'import numpy as np\n'), ((2737, 2743), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (2741, 2743), False, 'from megengine.core.autodiff.grad import Function, Grad\n'), ((2801, 2829), 'megengine.quantization.utils.tqt_forward', 'tqt_forward', (['(-127)', '(127)', 'x', 's'], {}), '(-127, 127, x, s)\n', (2812, 2829), False, 'from megengine.quantization.utils import QuantMode, create_qparams, fake_quant_tensor, lsq_forward, tqt_forward\n'), ((3267, 3277), 'megengine.functional.round', 'F.round', (['x'], {}), '(x)\n', (3274, 3277), True, 'import megengine.functional as F\n'), ((3473, 3493), 'megengine.functional.maximum', 'F.maximum', (['oup', 'qmin'], {}), '(oup, qmin)\n', (3482, 3493), True, 'import megengine.functional as F\n'), ((3731, 3798), 'megengine.quantization.utils.create_qparams', 'create_qparams', (['QuantMode.ASYMMERTIC', 'test_dtype', 'scale', 'zero_point'], {}), '(QuantMode.ASYMMERTIC, test_dtype, scale, zero_point)\n', (3745, 3798), False, 'from megengine.quantization.utils import QuantMode, create_qparams, fake_quant_tensor, lsq_forward, tqt_forward\n'), ((3818, 3881), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': '(-512.0)', 'high': '(512.0)', 'size': '(1, 32, 32, 32)'}), '(low=-512.0, high=512.0, size=(1, 32, 32, 32))\n', (3835, 3881), True, 'import numpy as np\n'), ((3896, 3930), 'megengine.tensor', 'tensor', (['inp_data'], {'dtype': 'np.float32'}), '(inp_data, dtype=np.float32)\n', (3902, 3930), False, 'from megengine import tensor\n'), ((4105, 4129), 'numpy.allclose', 'np.allclose', (['oup', 'oup_gt'], {}), '(oup, oup_gt)\n', (4116, 4129), True, 'import numpy as np\n'), ((4208, 4242), 'megengine.tensor', 'tensor', (['inp_data'], {'dtype': 'np.float32'}), '(inp_data, dtype=np.float32)\n', (4214, 4242), False, 'from megengine import tensor\n'), ((4422, 4456), 'megengine.tensor', 'tensor', (['inp_data'], {'dtype': 'np.float32'}), '(inp_data, dtype=np.float32)\n', (4428, 4456), False, 'from megengine import tensor\n'), ((4827, 4856), 'megengine.functional.full', 'F.full', (['(1, 32, 3, 3)', 'np.nan'], {}), '((1, 32, 3, 3), np.nan)\n', (4833, 4856), True, 'import megengine.functional as F\n'), ((5637, 5664), 'numpy.floor', 'np.floor', (['(inp_clipped + 0.5)'], {}), '(inp_clipped + 0.5)\n', (5645, 5664), True, 'import numpy as np\n'), ((6046, 6080), 'numpy.logical_xor', 'np.logical_xor', (['ind_small', 'ind_big'], {}), '(ind_small, ind_big)\n', (6060, 6080), True, 'import numpy as np\n'), ((6102, 6124), 'numpy.abs', 'np.abs', (['(ind_middle - 1)'], {}), '(ind_middle - 1)\n', (6108, 6124), True, 'import numpy as np\n'), ((7242, 7251), 'numpy.abs', 'np.abs', (['s'], {}), '(s)\n', (7248, 7251), True, 'import numpy as np\n'), ((7784, 7790), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (7788, 7790), False, 'from megengine.core.autodiff.grad import Function, Grad\n'), ((7848, 7896), 'megengine.quantization.utils.lsq_forward', 'lsq_forward', (['(-127)', '(127)', 'x', 's', 'zero_point', 'grad_s'], {}), '(-127, 127, x, s, zero_point, grad_s)\n', (7859, 7896), False, 'from megengine.quantization.utils import QuantMode, create_qparams, fake_quant_tensor, lsq_forward, tqt_forward\n'), ((1194, 1233), 'numpy.minimum', 'np.minimum', (['inp_scaled', 'self.upperbound'], {}), '(inp_scaled, self.upperbound)\n', (1204, 1233), True, 'import numpy as np\n'), ((2193, 2202), 'numpy.log', 'np.log', (['(2)'], {}), '(2)\n', (2199, 2202), True, 'import numpy as np\n'), ((2361, 2408), 'numpy.random.randint', 'np.random.randint', (['(-128)', '(128)'], {'size': '(1, 2, 3, 4)'}), '(-128, 128, size=(1, 2, 3, 4))\n', (2378, 2408), True, 'import numpy as np\n'), ((4256, 4262), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4260, 4262), False, 'from megengine.core.autodiff.grad import Function, Grad\n'), ((4334, 4363), 'megengine.quantization.utils.fake_quant_tensor', 'fake_quant_tensor', (['x', 'qparams'], {}), '(x, qparams)\n', (4351, 4363), False, 'from megengine.quantization.utils import QuantMode, create_qparams, fake_quant_tensor, lsq_forward, tqt_forward\n'), ((4470, 4476), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4474, 4476), False, 'from megengine.core.autodiff.grad import Function, Grad\n'), ((4729, 4759), 'megengine.core.tensor.utils.make_shape_tuple', 'make_shape_tuple', (['x.grad.shape'], {}), '(x.grad.shape)\n', (4745, 4759), False, 'from megengine.core.tensor.utils import make_shape_tuple\n'), ((4763, 4794), 'megengine.core.tensor.utils.make_shape_tuple', 'make_shape_tuple', (['x1.grad.shape'], {}), '(x1.grad.shape)\n', (4779, 4794), False, 'from megengine.core.tensor.utils import make_shape_tuple\n'), ((5092, 5114), 'numpy.ones', 'np.ones', (['(1, 32, 1, 1)'], {}), '((1, 32, 1, 1))\n', (5099, 5114), True, 'import numpy as np\n'), ((5159, 5181), 'numpy.ones', 'np.ones', (['(1, 32, 1, 1)'], {}), '((1, 32, 1, 1))\n', (5166, 5181), True, 'import numpy as np\n'), ((5548, 5587), 'numpy.minimum', 'np.minimum', (['inp_scaled', 'self.upperbound'], {}), '(inp_scaled, self.upperbound)\n', (5558, 5587), True, 'import numpy as np\n'), ((7255, 7264), 'numpy.abs', 'np.abs', (['s'], {}), '(s)\n', (7261, 7264), True, 'import numpy as np\n'), ((3968, 3999), 'megengine.quantization.utils.fake_quant_tensor', 'fake_quant_tensor', (['inp', 'qparams'], {}), '(inp, qparams)\n', (3985, 3999), False, 'from megengine.quantization.utils import QuantMode, create_qparams, fake_quant_tensor, lsq_forward, tqt_forward\n'), ((4869, 4898), 'megengine.quantization.utils.fake_quant_tensor', 'fake_quant_tensor', (['x', 'qparams'], {}), '(x, qparams)\n', (4886, 4898), False, 'from megengine.quantization.utils import QuantMode, create_qparams, fake_quant_tensor, lsq_forward, tqt_forward\n'), ((4922, 4933), 'numpy.isnan', 'np.isnan', (['y'], {}), '(y)\n', (4930, 4933), True, 'import numpy as np\n'), ((4391, 4405), 'megengine.functional.ones_like', 'F.ones_like', (['x'], {}), '(x)\n', (4402, 4405), True, 'import megengine.functional as F\n'), ((4635, 4650), 'megengine.functional.ones_like', 'F.ones_like', (['x1'], {}), '(x1)\n', (4646, 4650), True, 'import megengine.functional as F\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
from typing import Tuple, Union
import numpy as np
import megengine._internal as mgb
from ... import module as Float
from ...core import Parameter
from ...functional import conv_bias_activation
from ..qat import conv as QAT
from .module import QuantizedModule
class Conv2d(Float.Conv2d, QuantizedModule):
r"""quantized version of :class:`~.qat.conv.Conv2d`."""
r"""Applies a 2D convolution over an quantized input tensor, inference only.
The parameter is same with :class: `~.Conv2d`
"""
def __init__(
self,
in_channels: int,
out_channels: int,
kernel_size: Union[int, Tuple[int, int]],
stride: Union[int, Tuple[int, int]] = 1,
padding: Union[int, Tuple[int, int]] = 0,
dilation: Union[int, Tuple[int, int]] = 1,
groups: int = 1,
conv_mode: str = "CROSS_CORRELATION",
compute_mode: str = "DEFAULT",
dtype=None,
):
super().__init__(
in_channels,
out_channels,
kernel_size,
stride,
padding,
dilation,
groups,
True,
conv_mode,
compute_mode,
)
self.output_dtype = dtype
def calc_conv_quantized(self, inp, nonlinear_mode="IDENTITY"):
inp_scale = mgb.dtype.get_scale(inp.dtype)
w_scale = mgb.dtype.get_scale(self.weight.dtype)
bias_scale = inp_scale * w_scale
return conv_bias_activation(
inp,
self.weight,
self.bias.astype(mgb.dtype.qint32(bias_scale)),
self.output_dtype,
self.stride,
self.padding,
self.dilation,
self.groups,
conv_mode=self.conv_mode,
compute_mode=self.compute_mode,
nonlinear_mode=nonlinear_mode,
)
@classmethod
def from_qat_module(cls, qat_module: QAT.Conv2d):
r"""
return a :class:`~.QuantizedModule` instance converted from a
:class:`~.QATModule` instance.
"""
output_dtype = qat_module.get_activation_dtype()
qconv = cls(
qat_module.in_channels,
qat_module.out_channels,
qat_module.kernel_size,
qat_module.stride,
qat_module.padding,
qat_module.dilation,
qat_module.groups,
dtype=output_dtype,
)
weight = qat_module.weight.astype(qat_module.get_weight_dtype())
qconv.weight = Parameter(weight.numpy())
if qat_module.bias is not None:
qconv.bias = Parameter(qat_module.bias.numpy())
else:
qconv.bias = Parameter(
np.zeros(qat_module._infer_bias_shape(), dtype=np.float32)
)
return qconv
def forward(self, inp):
return self.calc_conv_quantized(inp, nonlinear_mode="IDENTITY")
class ConvRelu2d(Conv2d):
r"""quantized version of :class:`~.qat.conv.ConvRelu2d`."""
def forward(self, inp):
return self.calc_conv_quantized(inp, nonlinear_mode="RELU")
|
[
"megengine._internal.dtype.get_scale",
"megengine._internal.dtype.qint32"
] |
[((1670, 1700), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['inp.dtype'], {}), '(inp.dtype)\n', (1689, 1700), True, 'import megengine._internal as mgb\n'), ((1719, 1757), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['self.weight.dtype'], {}), '(self.weight.dtype)\n', (1738, 1757), True, 'import megengine._internal as mgb\n'), ((1907, 1935), 'megengine._internal.dtype.qint32', 'mgb.dtype.qint32', (['bias_scale'], {}), '(bias_scale)\n', (1923, 1935), True, 'import megengine._internal as mgb\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import copy
import numpy as np
import pytest
import megengine as mge
import megengine.functional as F
from megengine.core import Buffer, Graph, Parameter
from megengine.module import Conv2d
from megengine.test import assertTensorClose
def test_set_value():
v0 = np.random.random((2, 3)).astype(np.float32)
param = Parameter(v0)
v1 = np.random.random((2, 3)).astype(np.float32)
param.set_value(v1)
assertTensorClose(param.numpy(), v1, max_err=5e-6)
v2 = np.random.random((3, 3)).astype(np.float32)
# TODO: add this
# with pytest.raises(ValueError):
# param.set_value(v2)
assertTensorClose(param.numpy(), v1, max_err=5e-6)
def test_fill():
a = Buffer(np.zeros((2, 3), dtype=np.float32))
a.fill(3)
assertTensorClose(a.numpy(), np.full((2, 3), 3, dtype=np.float32))
a.fill(124.568)
assertTensorClose(a.numpy(), np.full((2, 3), 124.568, dtype=np.float32))
# TODO: remove or rewrite following test
# def test_attach():
# p_ = np.random.random((2, 3)).astype(np.float32)
# with Graph() as g:
# g.set_option('eager_evaluation', False)
# p = Parameter(p_)
# v = p * 2
# f = compile(v, None)
# out, = f()
# assertTensorClose(out, p_ * 2)
# F.add_update(p, p)
# out, = f()
# assertTensorClose(out, p_ * 4)
# TODO: remove or rewrite following test
# def test_module_attach():
# v = np.random.random((1, 3, 64, 64)).astype(np.float32)
# net = Conv2d(3, 16, 3)
# with Graph() as g:
# g.set_option('eager_evaluation', False)
# data0 = Input("data")
# f = compile(net(data0), None)
# out0, = f(data=v)
# data1 = Input("data", value=v)
# out1 = net(data1)
# assertTensorClose(out0, out1.numpy())
def test_shape_warning():
with Graph() as cg:
cg.set_option("eager_evaluation", False)
b = Buffer(np.ones((2, 3)).astype(np.float32))
with pytest.warns(None) as record:
print(b.shape)
if len(record) != 0:
raise ValueError(
"Getting the shape of a constant Tensor should throw no Warning"
)
|
[
"megengine.core.Graph",
"megengine.core.Parameter"
] |
[((703, 716), 'megengine.core.Parameter', 'Parameter', (['v0'], {}), '(v0)\n', (712, 716), False, 'from megengine.core import Buffer, Graph, Parameter\n'), ((1080, 1114), 'numpy.zeros', 'np.zeros', (['(2, 3)'], {'dtype': 'np.float32'}), '((2, 3), dtype=np.float32)\n', (1088, 1114), True, 'import numpy as np\n'), ((1163, 1199), 'numpy.full', 'np.full', (['(2, 3)', '(3)'], {'dtype': 'np.float32'}), '((2, 3), 3, dtype=np.float32)\n', (1170, 1199), True, 'import numpy as np\n'), ((1254, 1296), 'numpy.full', 'np.full', (['(2, 3)', '(124.568)'], {'dtype': 'np.float32'}), '((2, 3), 124.568, dtype=np.float32)\n', (1261, 1296), True, 'import numpy as np\n'), ((2186, 2193), 'megengine.core.Graph', 'Graph', ([], {}), '()\n', (2191, 2193), False, 'from megengine.core import Buffer, Graph, Parameter\n'), ((647, 671), 'numpy.random.random', 'np.random.random', (['(2, 3)'], {}), '((2, 3))\n', (663, 671), True, 'import numpy as np\n'), ((726, 750), 'numpy.random.random', 'np.random.random', (['(2, 3)'], {}), '((2, 3))\n', (742, 750), True, 'import numpy as np\n'), ((858, 882), 'numpy.random.random', 'np.random.random', (['(3, 3)'], {}), '((3, 3))\n', (874, 882), True, 'import numpy as np\n'), ((2318, 2336), 'pytest.warns', 'pytest.warns', (['None'], {}), '(None)\n', (2330, 2336), False, 'import pytest\n'), ((2269, 2284), 'numpy.ones', 'np.ones', (['(2, 3)'], {}), '((2, 3))\n', (2276, 2284), True, 'import numpy as np\n')]
|
#!/usr/bin/env python3
import argparse
import math
import megengine.functional as F
import megengine.module as M
import numpy as np
from megengine import jit, tensor
class ConvNet(M.Module):
def __init__(self):
super().__init__()
self.conv1 = M.Conv2d(in_channels=3, out_channels=1, kernel_size=3, bias=False)
def forward(self, input):
x = self.conv1(input)
return x
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="dump mge model for add_demo",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
parser.add_argument(
"--dir",
help="set the dir where the model to dump",
default=".",
type=str,
)
args = parser.parse_args()
net = ConvNet()
net.eval()
@jit.trace(symbolic=True, capture_as_const=True)
def fun(data):
return net(data)
inp = tensor(np.arange(0, 96).astype("float32").reshape(2, 3, 4, 4))
out = fun(inp)
fun.dump(args.dir + "/conv_demo_f32_without_data.mge", arg_names=["data"],
no_assert=True)
|
[
"megengine.module.Conv2d",
"megengine.jit.trace"
] |
[((457, 583), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""dump mge model for add_demo"""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description='dump mge model for add_demo',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n", (480, 583), False, 'import argparse\n'), ((816, 863), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (825, 863), False, 'from megengine import jit, tensor\n'), ((268, 334), 'megengine.module.Conv2d', 'M.Conv2d', ([], {'in_channels': '(3)', 'out_channels': '(1)', 'kernel_size': '(3)', 'bias': '(False)'}), '(in_channels=3, out_channels=1, kernel_size=3, bias=False)\n', (276, 334), True, 'import megengine.module as M\n'), ((925, 941), 'numpy.arange', 'np.arange', (['(0)', '(96)'], {}), '(0, 96)\n', (934, 941), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import contextlib
import functools
import itertools
import os
from typing import Callable, Tuple, Union
import numpy as np
import megengine._internal as mgb
from megengine._internal.plugin import CompGraphProfiler
from ..core import Tensor, graph, tensor
from .sublinear_memory_config import SublinearMemoryConfig
def sideeffect(f):
# during eager tracing, wrapped function is called with proxy inputs
# during static tracing, wrapped function will not be called at all
@functools.wraps(f)
def wrapper(*args, **kwargs): # pylint: disable=inconsistent-return-statements
if not trace._active_instance:
return f(*args, **kwargs)
tensors = {}
for i, x in itertools.chain(enumerate(args), kwargs.items()):
if isinstance(x, Tensor):
tensors[i] = x
if tensors:
_keys, tensors = zip(*tensors.items())
else:
_keys, tensors = (), ()
def callback(*tensors, f=f, keys=_keys, args=args, kwargs=kwargs):
replace = dict(zip(keys, tensors))
args = tuple(replace.get(i, x) for i, x in enumerate(args))
kwargs = {i: replace.get(i, x) for i, x in kwargs.items()}
if f(*args, **kwargs) is not None:
raise TypeError("a sideeffect function should return None")
# TODO: clear memory
trace._active_instance._register_callback(callback, tensors)
return wrapper
def mark_impure(x):
if not trace._active_instance:
return x
return trace._active_instance._mark_impure(x)
def barrier(x):
if not trace._active_instance:
return x
return trace._active_instance._insert_barrier(x)
def _dummy():
return mgb.make_immutable(*graph._use_default_if_none(None, None), 0)
class unset:
pass
class trace:
"""
Wrap a callable and provide:
* tracing via :meth:`.trace` and :meth:`.dump`
* accelerated evalutaion via :meth:`.__call__`
:param func: Positional only argument.
:param symbolic: Whether to use symbolic tensor. Default: False
:param opt_level: Optimization level for compiling trace.
:param log_level: Log level.
:param sublinear_memory_config: Configuration for sublinear memory optimization.
If not None, it enables sublinear memory optimization with given setting.
:param allreduce_pack_max_size: Maximum size of an allreduce pack in MB.
If not None, multiple gradients will be packed and synchronized together
:param profiling: Whether to profile compiled trace. Default: False
"""
_active_instance = None
enabled = not os.getenv("MGE_DISABLE_TRACE")
_UNSTARTED = "unstarted"
_STARTED = "started"
_FINISHED = "finished"
def __new__(cls, *args, **kwargs):
if not args:
return functools.partial(cls, **kwargs)
return super().__new__(cls)
def __init__(
self,
func: Callable[..., Union[None, Tensor, Tuple[Tensor]]],
*,
symbolic: bool = False,
opt_level: int = None,
log_level: int = None,
sublinear_memory_config: SublinearMemoryConfig = None,
allreduce_pack_max_size: int = None,
profiling: bool = False
):
self.__wrapped__ = func
self._symbolic = symbolic
self._graph_opt_level = opt_level
self._log_level = log_level
self._sublinear_memory_config = sublinear_memory_config
self._allreduce_pack_max_size = allreduce_pack_max_size
self._status = self._UNSTARTED
self._args = None
self._kwargs = None
self._outputs = unset
self._sym_outputs = unset
self._outspec = None
self._checkpoint = None
self._compiled_func = None
self._profiling = profiling
self._profiler = None
@property
def _active(self):
c1 = self._status == self._STARTED
c2 = type(self)._active_instance is self
assert c1 == c2
return c1
def _register_callback(self, f, args=()):
assert self._active
assert isinstance(args, (tuple, list))
proxies = self._make_proxies(args)
self._forward(args, proxies, checkpoint=True)
# NOTE: under eager graph callback will fire immediately
job = mgb.opr.callback_injector(
self._insert_barrier(_dummy()), lambda _: f(*proxies)
)
self._insert_checkpoint(job)
self._outspec.append(job)
def _insert_barrier(self, x):
assert self._active
if self._checkpoint is None:
return x
if isinstance(x, Tensor):
x = x._symvar
wrap = True
else:
wrap = False
if not isinstance(x, mgb.SymbolVar):
raise TypeError
x = mgb.opr.virtual_dep([x, self._checkpoint])
if wrap:
x = Tensor(x)
return x
def _insert_checkpoint(self, *args, no_barrier=False):
assert self._active
if not args:
return
args = tuple(x._symvar if isinstance(x, Tensor) else x for x in args)
for x in args:
if not isinstance(x, mgb.SymbolVar):
raise TypeError
if not no_barrier and self._checkpoint is not None:
# normally no need to _insert_barrier here, but if
# someone forget to call _insert_barrier beforehand,
# this can make things less broken
args += (self._checkpoint,)
if len(args) == 1:
self._checkpoint = args[0]
else:
self._checkpoint = mgb.opr.virtual_dep(args)
def _mark_impure(self, x):
assert self._active
ret = x
if isinstance(x, Tensor):
x = x._symvar
if not isinstance(x, mgb.SymbolVar):
raise TypeError
self._outspec.append(x)
self._insert_checkpoint(x)
return ret
def _make_proxies(self, args):
assert isinstance(args, (tuple, list))
for x in args:
assert isinstance(x, Tensor)
return tuple(tensor(dtype=x.dtype, device=x.device) for x in args)
def _forward(self, srcs, dests, checkpoint=True):
# pseudo-op: does not run under static graph; traced
# TODO: use shared memory
assert len(srcs) == len(dests)
if not self._active:
for s, d in zip(srcs, dests):
d.set_value(s, share=False)
return
jobs = []
for s, d in zip(srcs, dests):
def callback(value, dest=d):
dest.set_value(value, share=False)
s = self._insert_barrier(s._symvar)
# NOTE: callback immediately fire in eager graph
jobs.append(mgb.opr.callback_injector(s, callback))
self._outspec.extend(jobs)
if checkpoint:
self._insert_checkpoint(*jobs, no_barrier=True)
def _forward_inputs(self, *args, **kwargs):
if self._kwargs is None:
self._kwargs = kwargs
elif self._kwargs != kwargs:
raise ValueError("kwargs must not change between invocations")
if self._args is None:
self._args = []
for i in args:
if isinstance(i, Tensor):
self._args.append(tensor(dtype=i.dtype, device=i.device))
self._args[-1].set_value(i, share=False)
else:
self._args.append(tensor(i))
else:
if not len(args) == len(self._args):
raise TypeError
for i, proxy in zip(args, self._args):
proxy.set_value(i, share=False)
# XXX: sync?
def _make_outputs(self, outputs):
if outputs is None:
self._outputs = None
return
if isinstance(outputs, Tensor):
# no one is able to call barrier after this, so no need to checkpoint
# but checkpoint do little harm anyway
(self._outputs,) = self._make_proxies([outputs])
return
if not isinstance(outputs, (tuple, list)):
raise TypeError("should return (tuple of) tensor")
for i in outputs:
if not isinstance(i, Tensor):
raise TypeError("should return (tuple of) tensor")
self._outputs = self._make_proxies(outputs)
def _foward_outputs(self, outputs):
# pseudo-op: does not run under static graph; traced
if self._outputs is unset:
self._make_outputs(outputs)
if self._outputs is None:
if outputs is not None:
raise TypeError("should return None")
elif isinstance(self._outputs, Tensor):
if not isinstance(outputs, Tensor):
raise TypeError("should return a tensor")
self._forward([outputs], [self._outputs])
else:
assert isinstance(self._outputs, tuple)
def check():
if not isinstance(outputs, (tuple, list)):
return False
if len(self._outputs) != len(outputs):
return False
for x in outputs:
if not isinstance(x, Tensor):
return False
return True
if not check():
raise TypeError(
"should return tuple of %d tensors" % len(self._outputs)
)
self._forward(outputs, self._outputs)
def _apply_graph_options(self, cg):
# graph opt level
if self._graph_opt_level is not None:
cg.set_option("graph_opt_level", self._graph_opt_level)
# log level
if self._log_level is not None:
cg.set_option("log_level", self._log_level)
# sublinear
if self._sublinear_memory_config is not None:
cg.set_option("enable_sublinear_memory_opt", True)
cg.set_option(
"sublinear_mem_cofig.lb_memory",
self._sublinear_memory_config.lb_memory,
)
cg.set_option(
"sublinear_mem_cofig.genetic_nr_iter",
self._sublinear_memory_config.genetic_nr_iter,
)
cg.set_option(
"sublinear_mem_cofig.genetic_pool_size",
self._sublinear_memory_config.genetic_pool_size,
)
cg.set_option(
"sublinear_mem_cofig.thresh_nr_try",
self._sublinear_memory_config.thresh_nr_try,
)
cg.set_option(
"sublinear_mem_cofig.num_worker",
self._sublinear_memory_config.num_worker,
)
# pack allreduce
if self._allreduce_pack_max_size is not None:
cg.set_option("allreduce_pack_max_size", self._allreduce_pack_max_size)
# profile
if self._profiling:
self._profiler = CompGraphProfiler(cg)
def _get_graph(self, eager):
if eager:
if not hasattr(self, "_eager_graph"):
# pylint: disable=attribute-defined-outside-init
self._eager_graph = graph.Graph(eager_evaluation=True)
self._apply_graph_options(self._eager_graph)
return self._eager_graph
else:
if not hasattr(self, "_static_graph"):
# pylint: disable=attribute-defined-outside-init
self._static_graph = graph.Graph(eager_evaluation=False)
self._apply_graph_options(self._static_graph)
return self._static_graph
@contextlib.contextmanager
def _prepare(self, args, kwargs, enable):
# prepare for execution
self._forward_inputs(*args, **kwargs)
if not enable:
# XXX: use our own graph here?
cg = None
elif self._status == self._FINISHED:
cg = None
elif self._symbolic:
cg = self._get_graph(eager=False)
else:
cg = self._get_graph(eager=True)
try:
# NOTE: always trace in a new graph, so capturing an undetached tensor
# will never work (would work if tracing in default graph)
if cg is None:
yield
else:
with cg:
yield
finally:
# XXX: properly release memory
if cg:
cg.clear_device_memory()
@contextlib.contextmanager
def _activate(self):
# prepare for tracing
if self._status != self._UNSTARTED:
raise RuntimeError("cannot trace a second time")
if type(self)._active_instance is not None:
raise RuntimeError("nested trace is unsupported")
self._status = self._STARTED
type(self)._active_instance = self
self._user_cache = {}
try:
yield
finally:
self._status = self._FINISHED
self._user_cache = None
type(self)._active_instance = None
def _run_wrapped(self):
outputs = self.__wrapped__(*self._args, **self._kwargs)
self._foward_outputs(outputs)
return outputs
def _do_trace(self):
with self._activate():
self._outspec = []
outputs = self._run_wrapped()
if outputs is None:
self._sym_outputs = None
else:
if isinstance(outputs, Tensor):
outputs = [outputs]
# _run_wrapped has checked validity of outputs
self._sym_outputs = tuple(i._symvar for i in outputs)
mgb.comp_graph_tools.set_priority_to_id(self._outspec)
self._compiled_func = graph.get_default_graph().compile(None, self._outspec)
def trace(self, *args: Tensor, **kwargs):
"""
Trace wrapped callable with provided arguments.
"""
with self._prepare(args, kwargs, enable=True):
self._do_trace()
return self
def __call__(self, *args: Tensor, **kwargs):
"""
Evaluate on provided arguments, using compiled trace
instead of the original callable if applicable.
:return: ``None`` or :class:`~.Tensor` or tuple of :class:`~.Tensor`, depending on the
return value of wrapped callable.
"""
with self._prepare(args, kwargs, enable=self.enabled):
if not self.enabled:
self._run_wrapped()
elif self._status == self._FINISHED:
self._compiled_func()
else:
if self._status == self._UNSTARTED:
self._do_trace()
if self._symbolic:
self._compiled_func()
return self._outputs
def dump(
self,
fpath,
*,
arg_names=None,
append=False,
optimize_for_inference=False,
**kwargs
):
"""
Serialize trace to file system.
:param fpath: positional only argument. Path of output file.
:param arg_names: names of the input tensors in the traced function.
:param append: whether output is appended to ``fpath``.
:param optimize_for_inference: whether to enable optimize_for_inference
pass before dump.
:param enable_io16xc32: whether to use float16 for I/O between oprs and use
float32 as internal computation precision. Note the output var would be
changed to float16.
:param enable_ioc16: whether to use float16 for both I/O and computation
precision.
:param enable_hwcd4: whether to use NHWCD4 data layout. This is faster on some
OpenCL backend.
:param enable_nchw88: whether to use NCHW88 data layout. it currently
used in X86 AVX backend.
:param enable_nchw44: whether to use NCHW44 data layout. it currently
used in arm backend.
:param enable_nchw44_dot: whether to use NCHW44_dot data layout. it currently
used in armv8.2+dotprod backend.
:param enable_nchw4: whether to use NCHW4 data layout. it currently
used in nvidia backend(based on cudnn).
:param enable_nchw32: whether to use NCHW32 data layout. it currently
used in nvidia backend with tensorcore(based on cudnn).
:param enable_chwn4: whether to use CHWN4 data layout. it currently
used in nvidia backend with tensorcore.
:param enable_fuse_conv_bias_nonlinearity: whether to fuse conv+bias+nonlinearty
into one opr.
:param enable_fuse_conv_bias_with_z: whether to fuse conv_bias with z
input for inference on nvidia backend(this optimization pass will
result in mismatch of the precision of output of training and
inference)
"""
if self._status != self._FINISHED:
raise ValueError("not traced")
assert isinstance(self._sym_outputs, (tuple, type(None)))
if not self._sym_outputs:
raise ValueError("not outputs")
if arg_names is None:
arg_names = ["arg_%d" % i for i in range(len(self._args))]
elif len(arg_names) != len(self._args):
raise ValueError(
"len(arg_names) should be {}, got {}".format(
len(self._args), len(arg_names)
)
)
optimize_for_inference_args_map = {
"enable_io16xc32": "f16_io_f32_comp",
"enable_ioc16": "f16_io_comp",
"enable_hwcd4": "use_nhwcd4",
"enable_nchw4": "use_nchw4",
"enable_nchw88": "use_nchw88",
"enable_nchw32": "use_nchw32",
"enable_nchw44": "use_nchw44",
"enable_nchw44_dot": "use_nchw44_dot",
"enable_chwn4": "use_chwn4",
"enable_fuse_conv_bias_nonlinearity": "fuse_conv_bias_nonlinearity",
"enable_fuse_conv_bias_with_z": "fuse_conv_bias_with_z",
}
if optimize_for_inference:
optimize_for_inference_kwargs = {}
for k, v in optimize_for_inference_args_map.items():
if kwargs.pop(k, False):
optimize_for_inference_kwargs[v] = True
else:
for k in optimize_for_inference_args_map:
if kwargs.get(k, False):
raise ValueError(
"cannot set %s when optimize_for_inference is not set" % k
)
if kwargs:
raise ValueError("unknown options: %s" % list(kwargs))
cg = self._sym_outputs[0].owner_graph
replace = {}
for t, name in zip(self._args, arg_names):
# relies on symvar dedup
s = t.__mgb_symvar__(comp_graph=cg)
replace[s] = mgb.make_arg(
t.device, cg, dtype=t.dtype, shape=t.shape, name=name
)
# Convert VolatileSharedDeviceTensor to SharedDeviceTensor,
# otherwise some optimizations would not work. The conversion is
# safe because there simply is no way (using builtin ops) to make
# a VolatileSharedDeviceTensor actually volatile.
for s in mgb.cgtools.get_dep_vars(
self._sym_outputs, "VolatileSharedDeviceTensor"
):
if s in replace:
continue # is an input
replace[s] = mgb.SharedND._from_symvar(s).symvar(
cg, name=s.name, volatile=False
)
sym_outputs = mgb.cgtools.replace_vars(self._sym_outputs, replace)
sym_outputs = list(sym_outputs)
if optimize_for_inference:
sym_outputs = mgb.optimize_for_inference(
sym_outputs, **optimize_for_inference_kwargs
)
mgb.serialize_comp_graph_to_file(fpath, sym_outputs, append=append)
def get_profile(self):
"""
Get profiling result for compiled trace.
:return: a json compatible object.
"""
if not self._profiler:
raise RuntimeError("trace is not set with profiling=True")
return self._profiler.get()
|
[
"megengine._internal.cgtools.get_dep_vars",
"megengine._internal.opr.callback_injector",
"megengine._internal.make_arg",
"megengine._internal.plugin.CompGraphProfiler",
"megengine._internal.serialize_comp_graph_to_file",
"megengine._internal.optimize_for_inference",
"megengine._internal.comp_graph_tools.set_priority_to_id",
"megengine._internal.opr.virtual_dep",
"megengine._internal.SharedND._from_symvar",
"megengine._internal.cgtools.replace_vars"
] |
[((865, 883), 'functools.wraps', 'functools.wraps', (['f'], {}), '(f)\n', (880, 883), False, 'import functools\n'), ((3018, 3048), 'os.getenv', 'os.getenv', (['"""MGE_DISABLE_TRACE"""'], {}), "('MGE_DISABLE_TRACE')\n", (3027, 3048), False, 'import os\n'), ((5194, 5236), 'megengine._internal.opr.virtual_dep', 'mgb.opr.virtual_dep', (['[x, self._checkpoint]'], {}), '([x, self._checkpoint])\n', (5213, 5236), True, 'import megengine._internal as mgb\n'), ((19650, 19723), 'megengine._internal.cgtools.get_dep_vars', 'mgb.cgtools.get_dep_vars', (['self._sym_outputs', '"""VolatileSharedDeviceTensor"""'], {}), "(self._sym_outputs, 'VolatileSharedDeviceTensor')\n", (19674, 19723), True, 'import megengine._internal as mgb\n'), ((19962, 20014), 'megengine._internal.cgtools.replace_vars', 'mgb.cgtools.replace_vars', (['self._sym_outputs', 'replace'], {}), '(self._sym_outputs, replace)\n', (19986, 20014), True, 'import megengine._internal as mgb\n'), ((20227, 20294), 'megengine._internal.serialize_comp_graph_to_file', 'mgb.serialize_comp_graph_to_file', (['fpath', 'sym_outputs'], {'append': 'append'}), '(fpath, sym_outputs, append=append)\n', (20259, 20294), True, 'import megengine._internal as mgb\n'), ((3211, 3243), 'functools.partial', 'functools.partial', (['cls'], {}), '(cls, **kwargs)\n', (3228, 3243), False, 'import functools\n'), ((5993, 6018), 'megengine._internal.opr.virtual_dep', 'mgb.opr.virtual_dep', (['args'], {}), '(args)\n', (6012, 6018), True, 'import megengine._internal as mgb\n'), ((11341, 11362), 'megengine._internal.plugin.CompGraphProfiler', 'CompGraphProfiler', (['cg'], {}), '(cg)\n', (11358, 11362), False, 'from megengine._internal.plugin import CompGraphProfiler\n'), ((14050, 14104), 'megengine._internal.comp_graph_tools.set_priority_to_id', 'mgb.comp_graph_tools.set_priority_to_id', (['self._outspec'], {}), '(self._outspec)\n', (14089, 14104), True, 'import megengine._internal as mgb\n'), ((19262, 19329), 'megengine._internal.make_arg', 'mgb.make_arg', (['t.device', 'cg'], {'dtype': 't.dtype', 'shape': 't.shape', 'name': 'name'}), '(t.device, cg, dtype=t.dtype, shape=t.shape, name=name)\n', (19274, 19329), True, 'import megengine._internal as mgb\n'), ((20116, 20188), 'megengine._internal.optimize_for_inference', 'mgb.optimize_for_inference', (['sym_outputs'], {}), '(sym_outputs, **optimize_for_inference_kwargs)\n', (20142, 20188), True, 'import megengine._internal as mgb\n'), ((7142, 7180), 'megengine._internal.opr.callback_injector', 'mgb.opr.callback_injector', (['s', 'callback'], {}), '(s, callback)\n', (7167, 7180), True, 'import megengine._internal as mgb\n'), ((19841, 19869), 'megengine._internal.SharedND._from_symvar', 'mgb.SharedND._from_symvar', (['s'], {}), '(s)\n', (19866, 19869), True, 'import megengine._internal as mgb\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import multiprocessing as mp
import platform
import numpy as np
import pytest
import megengine as mge
import megengine.distributed as dist
from megengine.core import Parameter, tensor
def _init_process_group_wrapper(world_size, rank, dev, backend, q):
if rank == 0:
dist.init_process_group("localhost", 0, world_size, rank, dev, backend)
q.put(dist.get_master_port())
else:
port = q.get()
dist.init_process_group("localhost", port, world_size, rank, dev, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_reduce_sum():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.reduce_sum(inp)
if rank == 0:
assert np.allclose(output.numpy(), expect)
else:
assert np.allclose(output.numpy(), 0)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = x + y
p0 = mp.Process(target=worker, args=(0, x, backend, z, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, None, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_gather():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.gather(inp)
if rank == 0:
assert np.allclose(output.numpy(), expect)
else:
assert np.allclose(output.numpy(), 0)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = np.concatenate((x, y))
p0 = mp.Process(target=worker, args=(0, x, backend, z, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, None, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_broadcast():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.broadcast(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = x + 1
p0 = mp.Process(target=worker, args=(0, x, backend, x, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, x, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_scatter():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.scatter(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = x + 1
p0 = mp.Process(
target=worker, args=(0, x, backend, x[: shape[0] // 2], port_queue)
)
p1 = mp.Process(
target=worker, args=(1, y, backend, x[shape[0] // 2 :], port_queue)
)
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (100, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_all_to_all():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.all_to_all(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
a = np.concatenate((x[: shape[0] // 2], y[: shape[0] // 2]))
b = np.concatenate((x[shape[0] // 2 :], y[shape[0] // 2 :]))
p0 = mp.Process(target=worker, args=(0, x, backend, a, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, b, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (100, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_all_gather():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.all_gather(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = np.concatenate((x, y))
p0 = mp.Process(target=worker, args=(0, x, backend, z, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, z, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_reduce_scatter_sum():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.reduce_scatter_sum(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = x + y
p0 = mp.Process(
target=worker, args=(0, x, backend, z[: shape[0] // 2], port_queue)
)
p1 = mp.Process(
target=worker, args=(1, y, backend, z[shape[0] // 2 :], port_queue)
)
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 4), (8, 10), (88, 44)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_all_reduce_sum():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.all_reduce_sum(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = x + y
p0 = mp.Process(target=worker, args=(0, x, backend, z, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, z, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_all_reduce_max():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.all_reduce_max(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = np.maximum(x, y)
p0 = mp.Process(target=worker, args=(0, x, backend, z, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, z, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_all_reduce_min():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = tensor(data)
output = dist.functional.all_reduce_min(inp)
assert np.allclose(output.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = np.random.rand(*shape).astype("float32")
z = np.minimum(x, y)
p0 = mp.Process(target=worker, args=(0, x, backend, z, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, z, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="do not imp GPU mode at Windows now"
)
@pytest.mark.isolated_distributed
def test_bcast_param():
world_size = 2
def worker(rank, data, backend, expect, port_queue):
if mge.get_device_count("gpu") < world_size:
return
_init_process_group_wrapper(world_size, rank, rank, backend, port_queue)
inp = Parameter(data)
dist.functional.bcast_param(inp)
assert np.allclose(inp.numpy(), expect)
def check(shape, backend):
port_queue = mp.Queue()
x = np.random.rand(*shape).astype("float32")
y = x + 1
p0 = mp.Process(target=worker, args=(0, x, backend, x, port_queue))
p1 = mp.Process(target=worker, args=(1, y, backend, x, port_queue))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
for shape in [(2, 3), (8, 10), (99, 77)]:
for backend in ["nccl", "ucx"]:
check(shape, backend)
|
[
"megengine.core.tensor",
"megengine.distributed.functional.all_reduce_min",
"megengine.distributed.get_master_port",
"megengine.distributed.functional.all_gather",
"megengine.distributed.init_process_group",
"megengine.distributed.functional.all_to_all",
"megengine.get_device_count",
"megengine.distributed.functional.bcast_param",
"megengine.distributed.functional.reduce_sum",
"megengine.distributed.functional.gather",
"megengine.distributed.functional.broadcast",
"megengine.distributed.functional.all_reduce_max",
"megengine.distributed.functional.scatter",
"megengine.distributed.functional.all_reduce_sum",
"megengine.core.Parameter",
"megengine.distributed.functional.reduce_scatter_sum"
] |
[((636, 707), 'megengine.distributed.init_process_group', 'dist.init_process_group', (['"""localhost"""', '(0)', 'world_size', 'rank', 'dev', 'backend'], {}), "('localhost', 0, world_size, rank, dev, backend)\n", (659, 707), True, 'import megengine.distributed as dist\n'), ((787, 861), 'megengine.distributed.init_process_group', 'dist.init_process_group', (['"""localhost"""', 'port', 'world_size', 'rank', 'dev', 'backend'], {}), "('localhost', port, world_size, rank, dev, backend)\n", (810, 861), True, 'import megengine.distributed as dist\n'), ((1368, 1380), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (1374, 1380), False, 'from megengine.core import Parameter, tensor\n'), ((1398, 1429), 'megengine.distributed.functional.reduce_sum', 'dist.functional.reduce_sum', (['inp'], {}), '(inp)\n', (1424, 1429), True, 'import megengine.distributed as dist\n'), ((1624, 1634), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (1632, 1634), True, 'import multiprocessing as mp\n'), ((1772, 1834), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z, port_queue)'}), '(target=worker, args=(0, x, backend, z, port_queue))\n', (1782, 1834), True, 'import multiprocessing as mp\n'), ((1848, 1913), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, None, port_queue)'}), '(target=worker, args=(1, y, backend, None, port_queue))\n', (1858, 1913), True, 'import multiprocessing as mp\n'), ((889, 906), 'platform.system', 'platform.system', ([], {}), '()\n', (904, 906), False, 'import platform\n'), ((989, 1006), 'platform.system', 'platform.system', ([], {}), '()\n', (1004, 1006), False, 'import platform\n'), ((2671, 2683), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (2677, 2683), False, 'from megengine.core import Parameter, tensor\n'), ((2701, 2728), 'megengine.distributed.functional.gather', 'dist.functional.gather', (['inp'], {}), '(inp)\n', (2723, 2728), True, 'import megengine.distributed as dist\n'), ((2923, 2933), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (2931, 2933), True, 'import multiprocessing as mp\n'), ((3052, 3074), 'numpy.concatenate', 'np.concatenate', (['(x, y)'], {}), '((x, y))\n', (3066, 3074), True, 'import numpy as np\n'), ((3088, 3150), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z, port_queue)'}), '(target=worker, args=(0, x, backend, z, port_queue))\n', (3098, 3150), True, 'import multiprocessing as mp\n'), ((3164, 3229), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, None, port_queue)'}), '(target=worker, args=(1, y, backend, None, port_queue))\n', (3174, 3229), True, 'import multiprocessing as mp\n'), ((2196, 2213), 'platform.system', 'platform.system', ([], {}), '()\n', (2211, 2213), False, 'import platform\n'), ((2296, 2313), 'platform.system', 'platform.system', ([], {}), '()\n', (2311, 2313), False, 'import platform\n'), ((3990, 4002), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (3996, 4002), False, 'from megengine.core import Parameter, tensor\n'), ((4020, 4050), 'megengine.distributed.functional.broadcast', 'dist.functional.broadcast', (['inp'], {}), '(inp)\n', (4045, 4050), True, 'import megengine.distributed as dist\n'), ((4155, 4165), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (4163, 4165), True, 'import multiprocessing as mp\n'), ((4250, 4312), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, x, port_queue)'}), '(target=worker, args=(0, x, backend, x, port_queue))\n', (4260, 4312), True, 'import multiprocessing as mp\n'), ((4326, 4388), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, x, port_queue)'}), '(target=worker, args=(1, y, backend, x, port_queue))\n', (4336, 4388), True, 'import multiprocessing as mp\n'), ((3512, 3529), 'platform.system', 'platform.system', ([], {}), '()\n', (3527, 3529), False, 'import platform\n'), ((3612, 3629), 'platform.system', 'platform.system', ([], {}), '()\n', (3627, 3629), False, 'import platform\n'), ((5147, 5159), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (5153, 5159), False, 'from megengine.core import Parameter, tensor\n'), ((5177, 5205), 'megengine.distributed.functional.scatter', 'dist.functional.scatter', (['inp'], {}), '(inp)\n', (5200, 5205), True, 'import megengine.distributed as dist\n'), ((5310, 5320), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (5318, 5320), True, 'import multiprocessing as mp\n'), ((5405, 5483), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, x[:shape[0] // 2], port_queue)'}), '(target=worker, args=(0, x, backend, x[:shape[0] // 2], port_queue))\n', (5415, 5483), True, 'import multiprocessing as mp\n'), ((5520, 5598), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, x[shape[0] // 2:], port_queue)'}), '(target=worker, args=(1, y, backend, x[shape[0] // 2:], port_queue))\n', (5530, 5598), True, 'import multiprocessing as mp\n'), ((4671, 4688), 'platform.system', 'platform.system', ([], {}), '()\n', (4686, 4688), False, 'import platform\n'), ((4771, 4788), 'platform.system', 'platform.system', ([], {}), '()\n', (4786, 4788), False, 'import platform\n'), ((6384, 6396), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (6390, 6396), False, 'from megengine.core import Parameter, tensor\n'), ((6414, 6445), 'megengine.distributed.functional.all_to_all', 'dist.functional.all_to_all', (['inp'], {}), '(inp)\n', (6440, 6445), True, 'import megengine.distributed as dist\n'), ((6550, 6560), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (6558, 6560), True, 'import multiprocessing as mp\n'), ((6679, 6733), 'numpy.concatenate', 'np.concatenate', (['(x[:shape[0] // 2], y[:shape[0] // 2])'], {}), '((x[:shape[0] // 2], y[:shape[0] // 2]))\n', (6693, 6733), True, 'import numpy as np\n'), ((6748, 6802), 'numpy.concatenate', 'np.concatenate', (['(x[shape[0] // 2:], y[shape[0] // 2:])'], {}), '((x[shape[0] // 2:], y[shape[0] // 2:]))\n', (6762, 6802), True, 'import numpy as np\n'), ((6818, 6880), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, a, port_queue)'}), '(target=worker, args=(0, x, backend, a, port_queue))\n', (6828, 6880), True, 'import multiprocessing as mp\n'), ((6894, 6956), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, b, port_queue)'}), '(target=worker, args=(1, y, backend, b, port_queue))\n', (6904, 6956), True, 'import multiprocessing as mp\n'), ((5905, 5922), 'platform.system', 'platform.system', ([], {}), '()\n', (5920, 5922), False, 'import platform\n'), ((6005, 6022), 'platform.system', 'platform.system', ([], {}), '()\n', (6020, 6022), False, 'import platform\n'), ((7719, 7731), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (7725, 7731), False, 'from megengine.core import Parameter, tensor\n'), ((7749, 7780), 'megengine.distributed.functional.all_gather', 'dist.functional.all_gather', (['inp'], {}), '(inp)\n', (7775, 7780), True, 'import megengine.distributed as dist\n'), ((7885, 7895), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (7893, 7895), True, 'import multiprocessing as mp\n'), ((8014, 8036), 'numpy.concatenate', 'np.concatenate', (['(x, y)'], {}), '((x, y))\n', (8028, 8036), True, 'import numpy as np\n'), ((8050, 8112), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z, port_queue)'}), '(target=worker, args=(0, x, backend, z, port_queue))\n', (8060, 8112), True, 'import multiprocessing as mp\n'), ((8126, 8188), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, z, port_queue)'}), '(target=worker, args=(1, y, backend, z, port_queue))\n', (8136, 8188), True, 'import multiprocessing as mp\n'), ((7240, 7257), 'platform.system', 'platform.system', ([], {}), '()\n', (7255, 7257), False, 'import platform\n'), ((7340, 7357), 'platform.system', 'platform.system', ([], {}), '()\n', (7355, 7357), False, 'import platform\n'), ((8958, 8970), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (8964, 8970), False, 'from megengine.core import Parameter, tensor\n'), ((8988, 9027), 'megengine.distributed.functional.reduce_scatter_sum', 'dist.functional.reduce_scatter_sum', (['inp'], {}), '(inp)\n', (9022, 9027), True, 'import megengine.distributed as dist\n'), ((9132, 9142), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (9140, 9142), True, 'import multiprocessing as mp\n'), ((9280, 9358), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z[:shape[0] // 2], port_queue)'}), '(target=worker, args=(0, x, backend, z[:shape[0] // 2], port_queue))\n', (9290, 9358), True, 'import multiprocessing as mp\n'), ((9395, 9473), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, z[shape[0] // 2:], port_queue)'}), '(target=worker, args=(1, y, backend, z[shape[0] // 2:], port_queue))\n', (9405, 9473), True, 'import multiprocessing as mp\n'), ((8471, 8488), 'platform.system', 'platform.system', ([], {}), '()\n', (8486, 8488), False, 'import platform\n'), ((8571, 8588), 'platform.system', 'platform.system', ([], {}), '()\n', (8586, 8588), False, 'import platform\n'), ((10262, 10274), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (10268, 10274), False, 'from megengine.core import Parameter, tensor\n'), ((10292, 10327), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['inp'], {}), '(inp)\n', (10322, 10327), True, 'import megengine.distributed as dist\n'), ((10432, 10442), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (10440, 10442), True, 'import multiprocessing as mp\n'), ((10580, 10642), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z, port_queue)'}), '(target=worker, args=(0, x, backend, z, port_queue))\n', (10590, 10642), True, 'import multiprocessing as mp\n'), ((10656, 10718), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, z, port_queue)'}), '(target=worker, args=(1, y, backend, z, port_queue))\n', (10666, 10718), True, 'import multiprocessing as mp\n'), ((9779, 9796), 'platform.system', 'platform.system', ([], {}), '()\n', (9794, 9796), False, 'import platform\n'), ((9879, 9896), 'platform.system', 'platform.system', ([], {}), '()\n', (9894, 9896), False, 'import platform\n'), ((11484, 11496), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (11490, 11496), False, 'from megengine.core import Parameter, tensor\n'), ((11514, 11549), 'megengine.distributed.functional.all_reduce_max', 'dist.functional.all_reduce_max', (['inp'], {}), '(inp)\n', (11544, 11549), True, 'import megengine.distributed as dist\n'), ((11654, 11664), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (11662, 11664), True, 'import multiprocessing as mp\n'), ((11783, 11799), 'numpy.maximum', 'np.maximum', (['x', 'y'], {}), '(x, y)\n', (11793, 11799), True, 'import numpy as np\n'), ((11813, 11875), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z, port_queue)'}), '(target=worker, args=(0, x, backend, z, port_queue))\n', (11823, 11875), True, 'import multiprocessing as mp\n'), ((11889, 11951), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, z, port_queue)'}), '(target=worker, args=(1, y, backend, z, port_queue))\n', (11899, 11951), True, 'import multiprocessing as mp\n'), ((11001, 11018), 'platform.system', 'platform.system', ([], {}), '()\n', (11016, 11018), False, 'import platform\n'), ((11101, 11118), 'platform.system', 'platform.system', ([], {}), '()\n', (11116, 11118), False, 'import platform\n'), ((12717, 12729), 'megengine.core.tensor', 'tensor', (['data'], {}), '(data)\n', (12723, 12729), False, 'from megengine.core import Parameter, tensor\n'), ((12747, 12782), 'megengine.distributed.functional.all_reduce_min', 'dist.functional.all_reduce_min', (['inp'], {}), '(inp)\n', (12777, 12782), True, 'import megengine.distributed as dist\n'), ((12887, 12897), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (12895, 12897), True, 'import multiprocessing as mp\n'), ((13016, 13032), 'numpy.minimum', 'np.minimum', (['x', 'y'], {}), '(x, y)\n', (13026, 13032), True, 'import numpy as np\n'), ((13046, 13108), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, z, port_queue)'}), '(target=worker, args=(0, x, backend, z, port_queue))\n', (13056, 13108), True, 'import multiprocessing as mp\n'), ((13122, 13184), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, z, port_queue)'}), '(target=worker, args=(1, y, backend, z, port_queue))\n', (13132, 13184), True, 'import multiprocessing as mp\n'), ((12234, 12251), 'platform.system', 'platform.system', ([], {}), '()\n', (12249, 12251), False, 'import platform\n'), ((12334, 12351), 'platform.system', 'platform.system', ([], {}), '()\n', (12349, 12351), False, 'import platform\n'), ((13947, 13962), 'megengine.core.Parameter', 'Parameter', (['data'], {}), '(data)\n', (13956, 13962), False, 'from megengine.core import Parameter, tensor\n'), ((13971, 14003), 'megengine.distributed.functional.bcast_param', 'dist.functional.bcast_param', (['inp'], {}), '(inp)\n', (13998, 14003), True, 'import megengine.distributed as dist\n'), ((14105, 14115), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (14113, 14115), True, 'import multiprocessing as mp\n'), ((14200, 14262), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, x, backend, x, port_queue)'}), '(target=worker, args=(0, x, backend, x, port_queue))\n', (14210, 14262), True, 'import multiprocessing as mp\n'), ((14276, 14338), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, y, backend, x, port_queue)'}), '(target=worker, args=(1, y, backend, x, port_queue))\n', (14286, 14338), True, 'import multiprocessing as mp\n'), ((13467, 13484), 'platform.system', 'platform.system', ([], {}), '()\n', (13482, 13484), False, 'import platform\n'), ((13567, 13584), 'platform.system', 'platform.system', ([], {}), '()\n', (13582, 13584), False, 'import platform\n'), ((722, 744), 'megengine.distributed.get_master_port', 'dist.get_master_port', ([], {}), '()\n', (742, 744), True, 'import megengine.distributed as dist\n'), ((1212, 1239), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (1232, 1239), True, 'import megengine as mge\n'), ((2515, 2542), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (2535, 2542), True, 'import megengine as mge\n'), ((3834, 3861), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (3854, 3861), True, 'import megengine as mge\n'), ((4991, 5018), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (5011, 5018), True, 'import megengine as mge\n'), ((6228, 6255), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (6248, 6255), True, 'import megengine as mge\n'), ((7563, 7590), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (7583, 7590), True, 'import megengine as mge\n'), ((8802, 8829), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (8822, 8829), True, 'import megengine as mge\n'), ((10106, 10133), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (10126, 10133), True, 'import megengine as mge\n'), ((11328, 11355), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (11348, 11355), True, 'import megengine as mge\n'), ((12561, 12588), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (12581, 12588), True, 'import megengine as mge\n'), ((13791, 13818), 'megengine.get_device_count', 'mge.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (13811, 13818), True, 'import megengine as mge\n'), ((1647, 1669), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (1661, 1669), True, 'import numpy as np\n'), ((1700, 1722), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (1714, 1722), True, 'import numpy as np\n'), ((2946, 2968), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (2960, 2968), True, 'import numpy as np\n'), ((2999, 3021), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (3013, 3021), True, 'import numpy as np\n'), ((4178, 4200), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (4192, 4200), True, 'import numpy as np\n'), ((5333, 5355), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (5347, 5355), True, 'import numpy as np\n'), ((6573, 6595), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (6587, 6595), True, 'import numpy as np\n'), ((6626, 6648), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (6640, 6648), True, 'import numpy as np\n'), ((7908, 7930), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (7922, 7930), True, 'import numpy as np\n'), ((7961, 7983), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (7975, 7983), True, 'import numpy as np\n'), ((9155, 9177), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (9169, 9177), True, 'import numpy as np\n'), ((9208, 9230), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (9222, 9230), True, 'import numpy as np\n'), ((10455, 10477), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (10469, 10477), True, 'import numpy as np\n'), ((10508, 10530), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (10522, 10530), True, 'import numpy as np\n'), ((11677, 11699), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (11691, 11699), True, 'import numpy as np\n'), ((11730, 11752), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (11744, 11752), True, 'import numpy as np\n'), ((12910, 12932), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (12924, 12932), True, 'import numpy as np\n'), ((12963, 12985), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (12977, 12985), True, 'import numpy as np\n'), ((14128, 14150), 'numpy.random.rand', 'np.random.rand', (['*shape'], {}), '(*shape)\n', (14142, 14150), True, 'import numpy as np\n')]
|
import os
import sys
import time
from collections import OrderedDict
from time import strftime, gmtime
from tensorboardX import SummaryWriter
from dataset import AsrDataset, DataLoader, AsrCollator
from models.transformer import Model
import hparams as hp
import argparse
import megengine as mge
import megengine.module as M
import megengine.functional as F
from megengine.functional import clip, concat, minimum, norm
from megengine.core._imperative_rt.core2 import pop_scope, push_scope
from typing import Iterable, Union
from megengine.tensor import Tensor
import megengine.distributed as dist
from megengine.data import SequentialSampler, RandomSampler, DataLoader
from criterions.label_smoothing_loss import LabelSmoothingLoss
from megengine.utils.network import Network as Net
import megengine.autodiff as autodiff
import megengine.data as data
import megengine
import multiprocessing
logging = megengine.logger.get_logger()
def clip_grad_norm(
tensors: Union[Tensor, Iterable[Tensor]],
max_norm: float,
ord: float = 2.0,
):
push_scope("clip_grad_norm")
if isinstance(tensors, Tensor):
tensors = [tensors]
tensors = [t for t in tensors if t.grad is not None]
norm_ = [norm(t.grad.flatten(), ord=ord) for t in tensors]
if len(norm_) > 1:
norm_ = norm(concat(norm_), ord=ord)
else:
norm_ = norm_[0]
scale = max_norm / (norm_ + 1e-6)
scale = minimum(scale, 1)
for tensor in tensors:
tensor.grad._reset(tensor.grad * scale)
pop_scope("clip_grad_norm")
return norm_
class exponential_ma:
def __init__(self, ratio):
self.value = 0
self.weight = 0
self.ratio = ratio
def update(self, x):
self.value = self.value * self.ratio + (1 - self.ratio) * x
self.weight = self.weight * self.ratio + (1 - self.ratio)
def get_value(self):
if self.weight < 1e-8:
return 0
return self.value / self.weight
def update_train_log(monitor_vars_name, ma_dict, losses, ttrain, tdata):
for n in monitor_vars_name:
for ma in ma_dict["losses"]:
ma[n].update(losses[n])
for ma in ma_dict["ttrain"]:
ma.update(ttrain)
for ma in ma_dict["tdata"]:
ma.update(tdata)
def print_train_log(sess, epoch, minibatch, ma_dict, minibatch_per_epoch):
ma_output = "[{}] e:{}, {}/{} ".format(
strftime("%Y-%m-%d %H:%M:%S", gmtime()), epoch, minibatch, minibatch_per_epoch
)
print(ma_output, file=sys.stderr)
line = " {:31}:".format("speed")
for ma in ma_dict["ttrain"]:
line += "{:10.2g}".format(1 / ma.get_value())
print(line, file=sys.stderr)
line = " {:31}".format("dp/tot")
for ma1, ma2 in zip(ma_dict["ttrain"], ma_dict["tdata"]):
line += "{:10.2g}".format(ma2.get_value() / ma1.get_value())
print(line, file=sys.stderr)
for k in sess.loss_names:
line = " {:31}".format(k)
for ma in ma_dict["losses"]:
line += "{:10.2E}".format(ma[k].get_value())
print(line, file=sys.stderr)
line = " {:31}: {}".format("lr", sess.get_learning_rate())
print(line, file=sys.stderr)
sys.stderr.flush()
def adjust_learning_rate(optimizer, step_num, warmup_step=4000):
lr = (
hp.lr
* warmup_step ** 0.5
* min(step_num * warmup_step ** -1.5, step_num ** -0.5)
)
for param_group in optimizer.param_groups:
param_group["lr"] = lr
def set_grad(net, min, max):
for param in net.parameters():
param.grad = mge.random.uniform(min, max, param.shape)
param.grad_backup = F.copy(param.grad)
class Session:
def __init__(self, args):
with open(os.path.join(hp.dataset_root, "vocab.txt")) as f:
self.vocab = [w.strip() for w in f.readlines()]
self.vocab = ["<pad>"] + self.vocab
print(f"Vocab Size: {len(self.vocab)}")
self.model = Model(hp.num_mels, len(self.vocab))
world_size = args.world_size * args.ngpus
if world_size > 1:
dist.bcast_list_(self.model.parameters(), dist.WORLD)
# Autodiff gradient manager
self.gm = autodiff.GradManager().attach(
self.model.parameters(),
callbacks=dist.make_allreduce_cb("SUM") if world_size > 1 else None,
)
self.global_step = 0
self.optimizer = mge.optimizer.Adam(self.model.parameters(), lr=hp.lr)
# load pretrain model
if args.continue_path:
ckpt = mge.load(args.continue_path)
if "model" in ckpt:
state_dict = ckpt["model"]
self.model.load_state_dict(state_dict, strict=False)
self.loss_names = ["total"]
self.criterion = LabelSmoothingLoss(len(self.vocab), 0, hp.lsm_weight)
def get_learning_rate(self):
lr = self.optimizer.param_groups[0]["lr"]
return lr
def get_current_losses(self):
losses = OrderedDict()
for name in self.loss_names:
losses[name] = float(getattr(self, "loss_" + name))
return losses
def optimize_parameters(self, data):
"""Calculate losses, gradients, and update network weights; called in every training iteration"""
text_input, text_output, mel, pos_text, pos_mel, text_length, mel_length = data
with self.gm:
hs_pad, hs_mask, pred_pad, pred_mask = self.model.forward(
mel, mel_length, text_input, text_length
)
self.loss_total = self.criterion(pred_pad, text_output)
self.gm.backward(self.loss_total)
clip_grad_norm(self.model.parameters(), 1.0)
self.optimizer.step().clear_grad()
def main():
os.makedirs(hp.checkpoint_path, exist_ok=True)
parser = argparse.ArgumentParser()
parser.add_argument("--continue_path")
parser.add_argument(
"-n",
"--ngpus",
default=None,
type=int,
help="number of GPUs per node (default: None, use all available GPUs)",
)
parser.add_argument(
"--save",
metavar="DIR",
default="output",
help="path to save checkpoint and log",
)
parser.add_argument(
"--epochs",
default=90,
type=int,
help="number of total epochs to run (default: 90)",
)
parser.add_argument("-j", "--workers", default=2, type=int)
parser.add_argument(
"-p",
"--print-freq",
default=20,
type=int,
metavar="N",
help="print frequency (default: 10)",
)
parser.add_argument("--dist-addr", default="localhost")
parser.add_argument("--dist-port", default=23456, type=int)
parser.add_argument("--world-size", default=1, type=int)
parser.add_argument("--rank", default=0, type=int)
args = parser.parse_args()
# create server if is master
if args.rank <= 0:
server = dist.Server(
port=args.dist_port
) # pylint: disable=unused-variable # noqa: F841
# get device count
with multiprocessing.Pool(1) as pool:
ngpus_per_node, _ = pool.map(megengine.get_device_count, ["gpu", "cpu"])
if args.ngpus:
ngpus_per_node = args.ngpus
# launch processes
procs = []
for local_rank in range(ngpus_per_node):
p = multiprocessing.Process(
target=worker,
kwargs=dict(
rank=args.rank * ngpus_per_node + local_rank,
world_size=args.world_size * ngpus_per_node,
ngpus_per_node=ngpus_per_node,
args=args,
),
)
p.start()
procs.append(p)
# join processes
for p in procs:
p.join()
def worker(rank, world_size, ngpus_per_node, args):
# pylint: disable=too-many-statements
if rank == 0:
os.makedirs(os.path.join(args.save, "asr"), exist_ok=True)
megengine.logger.set_log_file(os.path.join(args.save, "asr", "log.txt"))
# init process group
if world_size > 1:
dist.init_process_group(
master_ip=args.dist_addr,
port=args.dist_port,
world_size=world_size,
rank=rank,
device=rank % ngpus_per_node,
backend="nccl",
)
logging.info(
"init process group rank %d / %d", dist.get_rank(), dist.get_world_size()
)
# build dataset
train_dataloader = build_dataset(args)
train_queue = iter(train_dataloader)
steps_per_epoch = 164905 // (world_size * hp.batch_size)
sess = Session(args)
ma_rates = [1 - 0.01 ** x for x in range(3)]
ma_dict = {
"losses": [
{k: exponential_ma(rate) for k in sess.loss_names} for rate in ma_rates
],
"ttrain": [exponential_ma(rate) for rate in ma_rates],
"tdata": [exponential_ma(rate) for rate in ma_rates],
}
for epoch in range(1, (hp.epochs + 1) * steps_per_epoch):
t_minibatch_start = time.time()
sess.global_step += 1
if sess.global_step < 400000:
adjust_learning_rate(sess.optimizer, sess.global_step)
tdata = time.time() - t_minibatch_start
data = next(train_queue)
sess.optimize_parameters(data)
losses = sess.get_current_losses()
ttrain = time.time() - t_minibatch_start
# print(ttrain, tdata)
update_train_log(sess.loss_names, ma_dict, losses, ttrain, tdata)
if sess.global_step % hp.log_interval == 0 and rank == 0:
print_train_log(sess, epoch, epoch, ma_dict, hp.epochs * steps_per_epoch)
if sess.global_step % hp.save_interval == 0 and rank == 0:
print("*******************************************")
mge.save(
{"model": sess.model.state_dict(), "global_step": sess.global_step},
os.path.join(
hp.checkpoint_path, "checkpoint_%d.pkl" % sess.global_step
),
)
print("*******************************************")
if sess.global_step > hp.max_steps:
exit(1)
def build_dataset(args):
dataset = AsrDataset()
train_sampler = data.Infinite(
RandomSampler(dataset=dataset, batch_size=hp.batch_size)
)
dataloader = DataLoader(
dataset=dataset, sampler=train_sampler, collator=AsrCollator()
)
return dataloader
if __name__ == "__main__":
main()
|
[
"megengine.core._imperative_rt.core2.push_scope",
"megengine.autodiff.GradManager",
"megengine.logger.get_logger",
"megengine.functional.minimum",
"megengine.random.uniform",
"megengine.distributed.init_process_group",
"megengine.distributed.make_allreduce_cb",
"megengine.functional.concat",
"megengine.distributed.Server",
"megengine.functional.copy",
"megengine.load",
"megengine.distributed.get_rank",
"megengine.data.RandomSampler",
"megengine.distributed.get_world_size",
"megengine.core._imperative_rt.core2.pop_scope"
] |
[((902, 931), 'megengine.logger.get_logger', 'megengine.logger.get_logger', ([], {}), '()\n', (929, 931), False, 'import megengine\n'), ((1050, 1078), 'megengine.core._imperative_rt.core2.push_scope', 'push_scope', (['"""clip_grad_norm"""'], {}), "('clip_grad_norm')\n", (1060, 1078), False, 'from megengine.core._imperative_rt.core2 import pop_scope, push_scope\n'), ((1416, 1433), 'megengine.functional.minimum', 'minimum', (['scale', '(1)'], {}), '(scale, 1)\n', (1423, 1433), False, 'from megengine.functional import clip, concat, minimum, norm\n'), ((1513, 1540), 'megengine.core._imperative_rt.core2.pop_scope', 'pop_scope', (['"""clip_grad_norm"""'], {}), "('clip_grad_norm')\n", (1522, 1540), False, 'from megengine.core._imperative_rt.core2 import pop_scope, push_scope\n'), ((3181, 3199), 'sys.stderr.flush', 'sys.stderr.flush', ([], {}), '()\n', (3197, 3199), False, 'import sys\n'), ((5731, 5777), 'os.makedirs', 'os.makedirs', (['hp.checkpoint_path'], {'exist_ok': '(True)'}), '(hp.checkpoint_path, exist_ok=True)\n', (5742, 5777), False, 'import os\n'), ((5791, 5816), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (5814, 5816), False, 'import argparse\n'), ((10157, 10169), 'dataset.AsrDataset', 'AsrDataset', ([], {}), '()\n', (10167, 10169), False, 'from dataset import AsrDataset, DataLoader, AsrCollator\n'), ((3556, 3597), 'megengine.random.uniform', 'mge.random.uniform', (['min', 'max', 'param.shape'], {}), '(min, max, param.shape)\n', (3574, 3597), True, 'import megengine as mge\n'), ((3626, 3644), 'megengine.functional.copy', 'F.copy', (['param.grad'], {}), '(param.grad)\n', (3632, 3644), True, 'import megengine.functional as F\n'), ((4966, 4979), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (4977, 4979), False, 'from collections import OrderedDict\n'), ((6925, 6957), 'megengine.distributed.Server', 'dist.Server', ([], {'port': 'args.dist_port'}), '(port=args.dist_port)\n', (6936, 6957), True, 'import megengine.distributed as dist\n'), ((7062, 7085), 'multiprocessing.Pool', 'multiprocessing.Pool', (['(1)'], {}), '(1)\n', (7082, 7085), False, 'import multiprocessing\n'), ((8045, 8204), 'megengine.distributed.init_process_group', 'dist.init_process_group', ([], {'master_ip': 'args.dist_addr', 'port': 'args.dist_port', 'world_size': 'world_size', 'rank': 'rank', 'device': '(rank % ngpus_per_node)', 'backend': '"""nccl"""'}), "(master_ip=args.dist_addr, port=args.dist_port,\n world_size=world_size, rank=rank, device=rank % ngpus_per_node, backend\n ='nccl')\n", (8068, 8204), True, 'import megengine.distributed as dist\n'), ((8989, 9000), 'time.time', 'time.time', ([], {}), '()\n', (8998, 9000), False, 'import time\n'), ((10213, 10269), 'megengine.data.RandomSampler', 'RandomSampler', ([], {'dataset': 'dataset', 'batch_size': 'hp.batch_size'}), '(dataset=dataset, batch_size=hp.batch_size)\n', (10226, 10269), False, 'from megengine.data import SequentialSampler, RandomSampler, DataLoader\n'), ((1307, 1320), 'megengine.functional.concat', 'concat', (['norm_'], {}), '(norm_)\n', (1313, 1320), False, 'from megengine.functional import clip, concat, minimum, norm\n'), ((2420, 2428), 'time.gmtime', 'gmtime', ([], {}), '()\n', (2426, 2428), False, 'from time import strftime, gmtime\n'), ((4523, 4551), 'megengine.load', 'mge.load', (['args.continue_path'], {}), '(args.continue_path)\n', (4531, 4551), True, 'import megengine as mge\n'), ((7861, 7891), 'os.path.join', 'os.path.join', (['args.save', '"""asr"""'], {}), "(args.save, 'asr')\n", (7873, 7891), False, 'import os\n'), ((7946, 7987), 'os.path.join', 'os.path.join', (['args.save', '"""asr"""', '"""log.txt"""'], {}), "(args.save, 'asr', 'log.txt')\n", (7958, 7987), False, 'import os\n'), ((8348, 8363), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (8361, 8363), True, 'import megengine.distributed as dist\n'), ((8365, 8386), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (8384, 8386), True, 'import megengine.distributed as dist\n'), ((9152, 9163), 'time.time', 'time.time', ([], {}), '()\n', (9161, 9163), False, 'import time\n'), ((9316, 9327), 'time.time', 'time.time', ([], {}), '()\n', (9325, 9327), False, 'import time\n'), ((10362, 10375), 'dataset.AsrCollator', 'AsrCollator', ([], {}), '()\n', (10373, 10375), False, 'from dataset import AsrDataset, DataLoader, AsrCollator\n'), ((3710, 3752), 'os.path.join', 'os.path.join', (['hp.dataset_root', '"""vocab.txt"""'], {}), "(hp.dataset_root, 'vocab.txt')\n", (3722, 3752), False, 'import os\n'), ((4175, 4197), 'megengine.autodiff.GradManager', 'autodiff.GradManager', ([], {}), '()\n', (4195, 4197), True, 'import megengine.autodiff as autodiff\n'), ((9860, 9932), 'os.path.join', 'os.path.join', (['hp.checkpoint_path', "('checkpoint_%d.pkl' % sess.global_step)"], {}), "(hp.checkpoint_path, 'checkpoint_%d.pkl' % sess.global_step)\n", (9872, 9932), False, 'import os\n'), ((4265, 4294), 'megengine.distributed.make_allreduce_cb', 'dist.make_allreduce_cb', (['"""SUM"""'], {}), "('SUM')\n", (4287, 4294), True, 'import megengine.distributed as dist\n')]
|
# Copyright (c) 2020 <NAME>
# This code is licensed under MIT license
# (https://github.com/kwotsin/mimicry/blob/master/LICENSE)
# ------------------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# This file has been modified by Megvii ("Megvii Modifications").
# All Megvii Modifications are Copyright (C) 2014-2019 Megvii Inc. All rights reserved.
# ------------------------------------------------------------------------------
import megengine.functional as F
import megengine.jit as jit
from .. import gan
from ..blocks import DBlock, DBlockOptimized
class WGANBaseGenerator(gan.BaseGenerator):
r"""
ResNet backbone generator for ResNet WGAN.
Attributes:
nz (int): Noise dimension for upsampling.
ngf (int): Variable controlling generator feature map sizes.
bottom_width (int): Starting width for upsampling generator output to an image.
loss_type (str): Name of loss to use for GAN loss.
"""
def __init__(self, nz, ngf, bottom_width, **kwargs):
super().__init__(nz=nz,
ngf=ngf,
bottom_width=bottom_width,
loss_type="wasserstein",
**kwargs)
class WGANBaseDiscriminator(gan.BaseDiscriminator):
r"""
ResNet backbone discriminator for ResNet WGAN.
Attributes:
ndf (int): Variable controlling discriminator feature map sizes.
loss_type (str): Name of loss to use for GAN loss.
"""
def __init__(self, ndf, **kwargs):
super().__init__(ndf=ndf, loss_type="wasserstein", **kwargs)
def _reset_jit_graph(self, impl: callable):
"""We override this func to attach weight clipping after default training step"""
traced_obj = jit.trace(impl)
def _(*args, **kwargs):
ret = traced_obj(*args, **kwargs)
if self.training:
self._apply_lipshitz_constraint() # dynamically apply weight clipping
return ret
return _
def _apply_lipshitz_constraint(self):
"""Weight clipping described in [Wasserstein GAN](https://arxiv.org/abs/1701.07875)"""
for p in self.parameters():
F.add_update(p, F.clamp(p, lower=-3e-2, upper=3e-2), alpha=0)
def layernorm(x):
original_shape = x.shape
x = x.reshape(original_shape[0], -1)
m = F.mean(x, axis=1, keepdims=True)
v = F.mean((x - m) ** 2, axis=1, keepdims=True)
x = (x - m) / F.maximum(F.sqrt(v), 1e-6)
x = x.reshape(original_shape)
return x
class WGANDBlockWithLayerNorm(DBlock):
def _residual(self, x):
h = x
h = layernorm(h)
h = self.activation(h)
h = self.c1(h)
h = layernorm(h)
h = self.activation(h)
h = self.c2(h)
if self.downsample:
h = F.avg_pool2d(h, 2)
return h
class WGANDBlockOptimized(DBlockOptimized):
pass
|
[
"megengine.functional.sqrt",
"megengine.functional.mean",
"megengine.jit.trace",
"megengine.functional.clamp",
"megengine.functional.avg_pool2d"
] |
[((2715, 2747), 'megengine.functional.mean', 'F.mean', (['x'], {'axis': '(1)', 'keepdims': '(True)'}), '(x, axis=1, keepdims=True)\n', (2721, 2747), True, 'import megengine.functional as F\n'), ((2756, 2799), 'megengine.functional.mean', 'F.mean', (['((x - m) ** 2)'], {'axis': '(1)', 'keepdims': '(True)'}), '((x - m) ** 2, axis=1, keepdims=True)\n', (2762, 2799), True, 'import megengine.functional as F\n'), ((2118, 2133), 'megengine.jit.trace', 'jit.trace', (['impl'], {}), '(impl)\n', (2127, 2133), True, 'import megengine.jit as jit\n'), ((2828, 2837), 'megengine.functional.sqrt', 'F.sqrt', (['v'], {}), '(v)\n', (2834, 2837), True, 'import megengine.functional as F\n'), ((3177, 3195), 'megengine.functional.avg_pool2d', 'F.avg_pool2d', (['h', '(2)'], {}), '(h, 2)\n', (3189, 3195), True, 'import megengine.functional as F\n'), ((2571, 2606), 'megengine.functional.clamp', 'F.clamp', (['p'], {'lower': '(-0.03)', 'upper': '(0.03)'}), '(p, lower=-0.03, upper=0.03)\n', (2578, 2606), True, 'import megengine.functional as F\n')]
|
import megengine as mge
import megengine.module as M
import megengine.functional as F
from megengine.core import Parameter
from utils import *
def addLeakyRelu(x):
return M.Sequential(x, M.LeakyReLU(0.1))
def addSig(x):
return M.Sequential(x, M.Sigmoid())
def up_block(x, ic, oc):
return M.ConvTranspose2d(ic, oc, 4, stride=2, padding=1)
def down_block(x, ic, oc):
return M.Conv2d(ic, oc, 3, padding=1, stride=2)
class BasicBlock(M.Module):
expansion = 1
def __init__(
self,
in_channels,
channels,
stride=1,
groups=1,
base_width=64,
dilation=1,
norm=M.BatchNorm2d,
):
super().__init__()
if groups != 1 or base_width != 64:
raise ValueError("BasicBlock only supports groups=1 and base_width=64")
if dilation > 1:
raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
self.conv1 = M.Conv2d(
in_channels, channels, 3, stride, padding=dilation, bias=True
)
self.conv2 = M.Conv2d(channels, channels, 3, 1, padding=1, bias=True)
if in_channels == channels and stride == 1:
self.downsample = M.Identity()
elif stride == 1:
self.downsample = M.Conv2d(in_channels, channels, 1, stride, bias=False)
else:
self.downsample = M.Sequential(
M.AvgPool2d(kernel_size=stride, stride=stride),
M.Conv2d(in_channels, channels, 1, 1, bias=False)
)
self.fc1 = M.Conv2d(channels, 16, kernel_size=1)
self.fc2 = M.Conv2d(16, channels, kernel_size=1)
self.relu1 = M.LeakyReLU(0.1)
self.relu2 = M.LeakyReLU(0.1)
self.relu3 = M.LeakyReLU(0.1)
def forward(self, x):
identity = x
x = self.conv1(x)
x = self.relu1(x)
x = self.conv2(x)
identity = self.downsample(identity)
w = x.mean(3, True).mean(2, True)
w = self.relu2(self.fc1(w))
w = F.sigmoid(self.fc2(w))
x = x * w + identity
x = self.relu3(x)
return x
def subpixel(x):
shape = x.shape
x = x.reshape(shape[0], shape[1] // 4, 2, 2, shape[2], shape[3])
x = F.dimshuffle(x, (0, 1, 4, 2, 5, 3))
return x.reshape(shape[0], shape[1] // 4, shape[2]*2, shape[3]*2)
c = 64
class SimpleUNet(M.Module):
def __init__(self):
super().__init__()
self.conv0_ = (BasicBlock(3, 32, stride=2))
self.conv1_ = (BasicBlock(32, c, stride=2))
self.conv0 = (BasicBlock(15, 32, stride=2))
self.conv1 = (BasicBlock(32, c, stride=2))
self.conv2 = (BasicBlock(c, 2*c, stride=1))
self.conv3 = (BasicBlock(2*c, 2*c, stride=1))
self.conv4 = (BasicBlock(4*c, 2*c, stride=1))
self.conv5 = (BasicBlock(4*c, 2*c, stride=1))
self.conv6 = (BasicBlock(6*c, 2*c, stride=1))
self.conv7 = (BasicBlock(6*c, 2*c, stride=1))
self.conv8 = (BasicBlock(6*c, 2*c, stride=1))
self.conv9 = (BasicBlock(6*c, 2*c, stride=1))
self.conv10 = (BasicBlock(3*c, 4*c, stride=1))
self.conv11 = addSig(M.Conv2d(c+32, 12, 1))
def forward(self, x):
size = x.shape
x = x.reshape((size[0] * 5, 3) + size[2:])
conv0 = tsm(self.conv0_(x))
conv1 = tsm(self.conv1_(conv0))
#
x = (x.reshape((size[0], 15) + x.shape[2:]))
conv0_ = (conv0.reshape((size[0], 5) + conv0.shape[1:]))[:, 2]
conv1_ = (conv1.reshape((size[0], 5) + conv1.shape[1:]))[:, 2]
conv0 = self.conv0(x)
conv1 = self.conv1(conv0)
conv0 += conv0_
conv1 += conv1_
conv2 = (self.conv2(conv1))
conv3 = (self.conv3(conv2))
conv4 = (self.conv4(F.concat((conv3, conv2), 1)))
conv5 = (self.conv5(F.concat((conv4, conv3), 1)))
conv6 = (self.conv6(F.concat((conv5, conv4, conv2), 1)))
conv7 = (self.conv7(F.concat((conv6, conv5, conv3), 1)))
conv8 = (self.conv8(F.concat((conv7, conv6, conv4), 1)))
conv9 = (self.conv9(F.concat((conv8, conv7, conv5), 1)))
conv10 = subpixel(self.conv10(F.concat((conv9, conv1), 1)))
conv11 = subpixel(self.conv11(F.concat((conv10, conv0), 1)))
conv11 = conv11 * 2 - 1 # sigmoid to [-1, 1]
return F.minimum(F.maximum(conv11 + x[:, 6:9], 0), 1)
|
[
"megengine.module.ConvTranspose2d",
"megengine.functional.maximum",
"megengine.module.LeakyReLU",
"megengine.module.Conv2d",
"megengine.module.AvgPool2d",
"megengine.module.Sigmoid",
"megengine.module.Identity",
"megengine.functional.dimshuffle",
"megengine.functional.concat"
] |
[((303, 352), 'megengine.module.ConvTranspose2d', 'M.ConvTranspose2d', (['ic', 'oc', '(4)'], {'stride': '(2)', 'padding': '(1)'}), '(ic, oc, 4, stride=2, padding=1)\n', (320, 352), True, 'import megengine.module as M\n'), ((392, 432), 'megengine.module.Conv2d', 'M.Conv2d', (['ic', 'oc', '(3)'], {'padding': '(1)', 'stride': '(2)'}), '(ic, oc, 3, padding=1, stride=2)\n', (400, 432), True, 'import megengine.module as M\n'), ((2241, 2276), 'megengine.functional.dimshuffle', 'F.dimshuffle', (['x', '(0, 1, 4, 2, 5, 3)'], {}), '(x, (0, 1, 4, 2, 5, 3))\n', (2253, 2276), True, 'import megengine.functional as F\n'), ((192, 208), 'megengine.module.LeakyReLU', 'M.LeakyReLU', (['(0.1)'], {}), '(0.1)\n', (203, 208), True, 'import megengine.module as M\n'), ((253, 264), 'megengine.module.Sigmoid', 'M.Sigmoid', ([], {}), '()\n', (262, 264), True, 'import megengine.module as M\n'), ((949, 1020), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'channels', '(3)', 'stride'], {'padding': 'dilation', 'bias': '(True)'}), '(in_channels, channels, 3, stride, padding=dilation, bias=True)\n', (957, 1020), True, 'import megengine.module as M\n'), ((1064, 1120), 'megengine.module.Conv2d', 'M.Conv2d', (['channels', 'channels', '(3)', '(1)'], {'padding': '(1)', 'bias': '(True)'}), '(channels, channels, 3, 1, padding=1, bias=True)\n', (1072, 1120), True, 'import megengine.module as M\n'), ((1560, 1597), 'megengine.module.Conv2d', 'M.Conv2d', (['channels', '(16)'], {'kernel_size': '(1)'}), '(channels, 16, kernel_size=1)\n', (1568, 1597), True, 'import megengine.module as M\n'), ((1618, 1655), 'megengine.module.Conv2d', 'M.Conv2d', (['(16)', 'channels'], {'kernel_size': '(1)'}), '(16, channels, kernel_size=1)\n', (1626, 1655), True, 'import megengine.module as M\n'), ((1677, 1693), 'megengine.module.LeakyReLU', 'M.LeakyReLU', (['(0.1)'], {}), '(0.1)\n', (1688, 1693), True, 'import megengine.module as M\n'), ((1715, 1731), 'megengine.module.LeakyReLU', 'M.LeakyReLU', (['(0.1)'], {}), '(0.1)\n', (1726, 1731), True, 'import megengine.module as M\n'), ((1753, 1769), 'megengine.module.LeakyReLU', 'M.LeakyReLU', (['(0.1)'], {}), '(0.1)\n', (1764, 1769), True, 'import megengine.module as M\n'), ((1203, 1215), 'megengine.module.Identity', 'M.Identity', ([], {}), '()\n', (1213, 1215), True, 'import megengine.module as M\n'), ((3156, 3179), 'megengine.module.Conv2d', 'M.Conv2d', (['(c + 32)', '(12)', '(1)'], {}), '(c + 32, 12, 1)\n', (3164, 3179), True, 'import megengine.module as M\n'), ((3782, 3809), 'megengine.functional.concat', 'F.concat', (['(conv3, conv2)', '(1)'], {}), '((conv3, conv2), 1)\n', (3790, 3809), True, 'import megengine.functional as F\n'), ((3840, 3867), 'megengine.functional.concat', 'F.concat', (['(conv4, conv3)', '(1)'], {}), '((conv4, conv3), 1)\n', (3848, 3867), True, 'import megengine.functional as F\n'), ((3898, 3932), 'megengine.functional.concat', 'F.concat', (['(conv5, conv4, conv2)', '(1)'], {}), '((conv5, conv4, conv2), 1)\n', (3906, 3932), True, 'import megengine.functional as F\n'), ((3963, 3997), 'megengine.functional.concat', 'F.concat', (['(conv6, conv5, conv3)', '(1)'], {}), '((conv6, conv5, conv3), 1)\n', (3971, 3997), True, 'import megengine.functional as F\n'), ((4028, 4062), 'megengine.functional.concat', 'F.concat', (['(conv7, conv6, conv4)', '(1)'], {}), '((conv7, conv6, conv4), 1)\n', (4036, 4062), True, 'import megengine.functional as F\n'), ((4093, 4127), 'megengine.functional.concat', 'F.concat', (['(conv8, conv7, conv5)', '(1)'], {}), '((conv8, conv7, conv5), 1)\n', (4101, 4127), True, 'import megengine.functional as F\n'), ((4347, 4379), 'megengine.functional.maximum', 'F.maximum', (['(conv11 + x[:, 6:9])', '(0)'], {}), '(conv11 + x[:, 6:9], 0)\n', (4356, 4379), True, 'import megengine.functional as F\n'), ((1272, 1326), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'channels', '(1)', 'stride'], {'bias': '(False)'}), '(in_channels, channels, 1, stride, bias=False)\n', (1280, 1326), True, 'import megengine.module as M\n'), ((4168, 4195), 'megengine.functional.concat', 'F.concat', (['(conv9, conv1)', '(1)'], {}), '((conv9, conv1), 1)\n', (4176, 4195), True, 'import megengine.functional as F\n'), ((4236, 4264), 'megengine.functional.concat', 'F.concat', (['(conv10, conv0)', '(1)'], {}), '((conv10, conv0), 1)\n', (4244, 4264), True, 'import megengine.functional as F\n'), ((1405, 1451), 'megengine.module.AvgPool2d', 'M.AvgPool2d', ([], {'kernel_size': 'stride', 'stride': 'stride'}), '(kernel_size=stride, stride=stride)\n', (1416, 1451), True, 'import megengine.module as M\n'), ((1473, 1522), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'channels', '(1)', '(1)'], {'bias': '(False)'}), '(in_channels, channels, 1, 1, bias=False)\n', (1481, 1522), True, 'import megengine.module as M\n')]
|
# MegFlow is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2019-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#!/usr/bin/env python
# coding=utf-8
from math import log
from loguru import logger
import megengine as mge
import cv2
import megengine.functional as F
import numpy as np
from .model import Model
if __name__ == "__main__":
import sys
if len(sys.argv) < 5:
print("usage: python3 -m reid_alignedreid/demo reid.pkl positive1.png positive2.png negtive.jpg")
sys.exit(0)
model = Model()
sd = mge.load(sys.argv[1])
model.load_state_dict(sd, strict=False)
model.eval()
feat1 = model.inference(cv2.imread(sys.argv[2]))
logger.info(f'{feat1}')
feat2 = model.inference(cv2.imread(sys.argv[3]))
logger.info(f'{feat2}')
feat3 = model.inference(cv2.imread(sys.argv[4]))
logger.info(f'{feat3}')
positive = np.linalg.norm(feat1-feat2)
print(f'distance_positive: {positive}')
negtive = np.linalg.norm(feat3-feat2)
print(f'distance_negtive: {negtive}')
|
[
"megengine.load"
] |
[((778, 799), 'megengine.load', 'mge.load', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (786, 799), True, 'import megengine as mge\n'), ((918, 941), 'loguru.logger.info', 'logger.info', (['f"""{feat1}"""'], {}), "(f'{feat1}')\n", (929, 941), False, 'from loguru import logger\n'), ((999, 1022), 'loguru.logger.info', 'logger.info', (['f"""{feat2}"""'], {}), "(f'{feat2}')\n", (1010, 1022), False, 'from loguru import logger\n'), ((1081, 1104), 'loguru.logger.info', 'logger.info', (['f"""{feat3}"""'], {}), "(f'{feat3}')\n", (1092, 1104), False, 'from loguru import logger\n'), ((1121, 1150), 'numpy.linalg.norm', 'np.linalg.norm', (['(feat1 - feat2)'], {}), '(feat1 - feat2)\n', (1135, 1150), True, 'import numpy as np\n'), ((1208, 1237), 'numpy.linalg.norm', 'np.linalg.norm', (['(feat3 - feat2)'], {}), '(feat3 - feat2)\n', (1222, 1237), True, 'import numpy as np\n'), ((737, 748), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (745, 748), False, 'import sys\n'), ((889, 912), 'cv2.imread', 'cv2.imread', (['sys.argv[2]'], {}), '(sys.argv[2])\n', (899, 912), False, 'import cv2\n'), ((970, 993), 'cv2.imread', 'cv2.imread', (['sys.argv[3]'], {}), '(sys.argv[3])\n', (980, 993), False, 'import cv2\n'), ((1052, 1075), 'cv2.imread', 'cv2.imread', (['sys.argv[4]'], {}), '(sys.argv[4])\n', (1062, 1075), False, 'import cv2\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import pickle
import numpy as np
import pytest
from megengine.core.tensor.dtype import intb1, intb2, intb4
from megengine.tensor import Tensor
def bit_define_test(bit, low_bit_type):
max_value = (1 << bit) - 1
min_value = 1 - (1 << bit)
a = np.array([i for i in range(min_value, max_value + 2, 2)], dtype=low_bit_type)
for i in range(max_value + 1):
np.testing.assert_equal(a[i], i * 2 - max_value)
np.testing.assert_equal(str(a[i]), str(i * 2 - max_value))
with pytest.raises(ValueError):
np.arange(min_value, max_value, dtype=low_bit_type)
with pytest.raises(ValueError):
np.arange(min_value - 2, max_value + 4, 2, dtype=low_bit_type)
np.testing.assert_allclose(
np.arange(min_value, 12, 2, dtype=low_bit_type),
(np.arange((13 - min_value) // 2, dtype=np.int8) % (max_value + 1)) * 2
- max_value,
)
np.testing.assert_allclose(
np.arange(max_value, max_value - 20, -2, dtype=low_bit_type),
(np.arange(max_value, max_value - 10, -1, dtype=np.int8) % (max_value + 1)) * 2
- max_value,
)
def test_define():
bit_define_test(1, intb1)
bit_define_test(2, intb2)
bit_define_test(4, intb4)
def _bit_cast_test(bit, low_bit_type):
dtypes = [np.int8, np.int16, np.int32, np.float32, np.float64]
max_value = (1 << bit) - 1
min_value = 1 - (1 << bit)
for dtype in dtypes:
np.testing.assert_allclose(
np.arange(min_value, max_value + 2, 2, dtype=low_bit_type).astype(dtype),
np.arange(min_value, max_value + 2, 2, dtype=dtype),
)
with pytest.raises(ValueError):
np.array([2, 1, -1], dtype=int).astype(low_bit_type)
with pytest.raises(ValueError):
np.array([min_value - 2, 1, max_value + 2], dtype=int).astype(low_bit_type)
def test_cast():
_bit_cast_test(1, intb1)
_bit_cast_test(2, intb2)
_bit_cast_test(4, intb4)
def _shared_nd_test(bit, low_bit_type):
max_value = (1 << bit) - 1
min_value = 1 - (1 << bit)
data = np.arange(min_value, max_value + 2, 2, dtype=low_bit_type)
snd = Tensor(data, dtype=low_bit_type, device="xpux")
np.testing.assert_allclose(snd.numpy(), range(min_value, max_value + 2, 2))
data = np.arange(min_value, max_value + 2, 4, dtype=low_bit_type)
snd = Tensor(data, dtype=low_bit_type, device="xpux")
np.testing.assert_allclose(snd.numpy(), range(min_value, max_value + 2, 4))
def test_shared_nd():
_shared_nd_test(1, intb1)
_shared_nd_test(2, intb2)
_shared_nd_test(4, intb4)
def test_pickle():
x = np.ascontiguousarray(np.random.randint(2, size=8192) * 2 - 1, dtype=intb1)
pkl = pickle.dumps(x, pickle.HIGHEST_PROTOCOL)
y = pickle.loads(pkl)
assert x.dtype is y.dtype
np.testing.assert_allclose(x.astype(np.float32), y.astype(np.float32))
|
[
"megengine.tensor.Tensor"
] |
[((2414, 2472), 'numpy.arange', 'np.arange', (['min_value', '(max_value + 2)', '(2)'], {'dtype': 'low_bit_type'}), '(min_value, max_value + 2, 2, dtype=low_bit_type)\n', (2423, 2472), True, 'import numpy as np\n'), ((2483, 2530), 'megengine.tensor.Tensor', 'Tensor', (['data'], {'dtype': 'low_bit_type', 'device': '"""xpux"""'}), "(data, dtype=low_bit_type, device='xpux')\n", (2489, 2530), False, 'from megengine.tensor import Tensor\n'), ((2623, 2681), 'numpy.arange', 'np.arange', (['min_value', '(max_value + 2)', '(4)'], {'dtype': 'low_bit_type'}), '(min_value, max_value + 2, 4, dtype=low_bit_type)\n', (2632, 2681), True, 'import numpy as np\n'), ((2692, 2739), 'megengine.tensor.Tensor', 'Tensor', (['data'], {'dtype': 'low_bit_type', 'device': '"""xpux"""'}), "(data, dtype=low_bit_type, device='xpux')\n", (2698, 2739), False, 'from megengine.tensor import Tensor\n'), ((3048, 3088), 'pickle.dumps', 'pickle.dumps', (['x', 'pickle.HIGHEST_PROTOCOL'], {}), '(x, pickle.HIGHEST_PROTOCOL)\n', (3060, 3088), False, 'import pickle\n'), ((3097, 3114), 'pickle.loads', 'pickle.loads', (['pkl'], {}), '(pkl)\n', (3109, 3114), False, 'import pickle\n'), ((734, 782), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['a[i]', '(i * 2 - max_value)'], {}), '(a[i], i * 2 - max_value)\n', (757, 782), True, 'import numpy as np\n'), ((860, 885), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (873, 885), False, 'import pytest\n'), ((895, 946), 'numpy.arange', 'np.arange', (['min_value', 'max_value'], {'dtype': 'low_bit_type'}), '(min_value, max_value, dtype=low_bit_type)\n', (904, 946), True, 'import numpy as np\n'), ((957, 982), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (970, 982), False, 'import pytest\n'), ((992, 1054), 'numpy.arange', 'np.arange', (['(min_value - 2)', '(max_value + 4)', '(2)'], {'dtype': 'low_bit_type'}), '(min_value - 2, max_value + 4, 2, dtype=low_bit_type)\n', (1001, 1054), True, 'import numpy as np\n'), ((1096, 1143), 'numpy.arange', 'np.arange', (['min_value', '(12)', '(2)'], {'dtype': 'low_bit_type'}), '(min_value, 12, 2, dtype=low_bit_type)\n', (1105, 1143), True, 'import numpy as np\n'), ((1293, 1353), 'numpy.arange', 'np.arange', (['max_value', '(max_value - 20)', '(-2)'], {'dtype': 'low_bit_type'}), '(max_value, max_value - 20, -2, dtype=low_bit_type)\n', (1302, 1353), True, 'import numpy as np\n'), ((1984, 2009), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (1997, 2009), False, 'import pytest\n'), ((2081, 2106), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (2094, 2106), False, 'import pytest\n'), ((1911, 1962), 'numpy.arange', 'np.arange', (['min_value', '(max_value + 2)', '(2)'], {'dtype': 'dtype'}), '(min_value, max_value + 2, 2, dtype=dtype)\n', (1920, 1962), True, 'import numpy as np\n'), ((2019, 2050), 'numpy.array', 'np.array', (['[2, 1, -1]'], {'dtype': 'int'}), '([2, 1, -1], dtype=int)\n', (2027, 2050), True, 'import numpy as np\n'), ((2116, 2170), 'numpy.array', 'np.array', (['[min_value - 2, 1, max_value + 2]'], {'dtype': 'int'}), '([min_value - 2, 1, max_value + 2], dtype=int)\n', (2124, 2170), True, 'import numpy as np\n'), ((2984, 3015), 'numpy.random.randint', 'np.random.randint', (['(2)'], {'size': '(8192)'}), '(2, size=8192)\n', (3001, 3015), True, 'import numpy as np\n'), ((1154, 1201), 'numpy.arange', 'np.arange', (['((13 - min_value) // 2)'], {'dtype': 'np.int8'}), '((13 - min_value) // 2, dtype=np.int8)\n', (1163, 1201), True, 'import numpy as np\n'), ((1364, 1419), 'numpy.arange', 'np.arange', (['max_value', '(max_value - 10)', '(-1)'], {'dtype': 'np.int8'}), '(max_value, max_value - 10, -1, dtype=np.int8)\n', (1373, 1419), True, 'import numpy as np\n'), ((1825, 1883), 'numpy.arange', 'np.arange', (['min_value', '(max_value + 2)', '(2)'], {'dtype': 'low_bit_type'}), '(min_value, max_value + 2, 2, dtype=low_bit_type)\n', (1834, 1883), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# pylint: skip-file
import argparse
import sys
# pylint: disable=import-error
import resnet.model as resnet_model
# pylint: disable=import-error
import shufflenet.model as snet_model
import numpy as np
import megengine as mge
import megengine.functional as F
from megengine import jit
def dump_static_graph(model, graph_name, shape):
model.eval()
data = mge.Tensor(np.ones(shape, dtype=np.uint8))
@jit.trace(capture_as_const=True)
def pred_func(data):
out = data.astype(np.float32)
output_h, output_w = 224, 224
# resize
print(shape)
M = mge.tensor(np.array([[1,0,0], [0,1,0], [0,0,1]], dtype=np.float32))
M_shape = F.concat([data.shape[0],M.shape])
M = F.broadcast_to(M, M_shape)
out = F.vision.warp_perspective(out, M, (output_h, output_w), format='NHWC')
# mean
_mean = mge.Tensor(np.array([103.530, 116.280, 123.675], dtype=np.float32))
out = F.sub(out, _mean)
# div
_div = mge.Tensor(np.array([57.375, 57.120, 58.395], dtype=np.float32))
out = F.div(out, _div)
# dimshuffile
out = F.transpose(out, (0,3,1,2))
outputs = model(out)
return outputs
pred_func(data)
pred_func.dump(
graph_name,
arg_names=["data"],
optimize_for_inference=True,
enable_fuse_conv_bias_nonlinearity=True,
)
def main():
parser = argparse.ArgumentParser(description="MegEngine Classification Dump .mge")
parser.add_argument(
"-a",
"--arch",
default="resnet18",
help="model architecture (default: resnet18)",
)
parser.add_argument(
"-s",
"--shape",
type=int,
nargs='+',
default="1 3 224 224",
help="input shape (default: 1 3 224 224)"
)
parser.add_argument(
"-o",
"--output",
type=str,
default="model.mge",
help="output filename"
)
args = parser.parse_args()
if 'resnet' in args.arch:
model = getattr(resnet_model, args.arch)(pretrained=True)
elif 'shufflenet' in args.arch:
model = getattr(snet_model, args.arch)(pretrained=True)
else:
print('unavailable arch {}'.format(args.arch))
sys.exit()
print(model)
dump_static_graph(model, args.output, tuple(args.shape))
if __name__ == "__main__":
main()
|
[
"megengine.functional.div",
"megengine.functional.broadcast_to",
"megengine.jit.trace",
"megengine.functional.sub",
"megengine.functional.vision.warp_perspective",
"megengine.functional.concat",
"megengine.functional.transpose"
] |
[((795, 827), 'megengine.jit.trace', 'jit.trace', ([], {'capture_as_const': '(True)'}), '(capture_as_const=True)\n', (804, 827), False, 'from megengine import jit\n'), ((1815, 1888), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""MegEngine Classification Dump .mge"""'}), "(description='MegEngine Classification Dump .mge')\n", (1838, 1888), False, 'import argparse\n'), ((757, 787), 'numpy.ones', 'np.ones', (['shape'], {'dtype': 'np.uint8'}), '(shape, dtype=np.uint8)\n', (764, 787), True, 'import numpy as np\n'), ((1074, 1108), 'megengine.functional.concat', 'F.concat', (['[data.shape[0], M.shape]'], {}), '([data.shape[0], M.shape])\n', (1082, 1108), True, 'import megengine.functional as F\n'), ((1120, 1146), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['M', 'M_shape'], {}), '(M, M_shape)\n', (1134, 1146), True, 'import megengine.functional as F\n'), ((1161, 1231), 'megengine.functional.vision.warp_perspective', 'F.vision.warp_perspective', (['out', 'M', '(output_h, output_w)'], {'format': '"""NHWC"""'}), "(out, M, (output_h, output_w), format='NHWC')\n", (1186, 1231), True, 'import megengine.functional as F\n'), ((1345, 1362), 'megengine.functional.sub', 'F.sub', (['out', '_mean'], {}), '(out, _mean)\n', (1350, 1362), True, 'import megengine.functional as F\n'), ((1472, 1488), 'megengine.functional.div', 'F.div', (['out', '_div'], {}), '(out, _div)\n', (1477, 1488), True, 'import megengine.functional as F\n'), ((1526, 1556), 'megengine.functional.transpose', 'F.transpose', (['out', '(0, 3, 1, 2)'], {}), '(out, (0, 3, 1, 2))\n', (1537, 1556), True, 'import megengine.functional as F\n'), ((991, 1052), 'numpy.array', 'np.array', (['[[1, 0, 0], [0, 1, 0], [0, 0, 1]]'], {'dtype': 'np.float32'}), '([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.float32)\n', (999, 1052), True, 'import numpy as np\n'), ((1274, 1327), 'numpy.array', 'np.array', (['[103.53, 116.28, 123.675]'], {'dtype': 'np.float32'}), '([103.53, 116.28, 123.675], dtype=np.float32)\n', (1282, 1327), True, 'import numpy as np\n'), ((1404, 1455), 'numpy.array', 'np.array', (['[57.375, 57.12, 58.395]'], {'dtype': 'np.float32'}), '([57.375, 57.12, 58.395], dtype=np.float32)\n', (1412, 1455), True, 'import numpy as np\n'), ((2661, 2671), 'sys.exit', 'sys.exit', ([], {}), '()\n', (2669, 2671), False, 'import sys\n')]
|
# -*- coding:utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import megengine as mge
import megengine.functional as F
import megengine.module as M
from official.vision.detection import layers
class RCNN(M.Module):
def __init__(self, cfg):
super().__init__()
self.cfg = cfg
self.box_coder = layers.BoxCoder(cfg.rcnn_reg_mean, cfg.rcnn_reg_std)
# roi head
self.in_features = cfg.rcnn_in_features
self.stride = cfg.rcnn_stride
self.pooling_method = cfg.pooling_method
self.pooling_size = cfg.pooling_size
self.fc1 = M.Linear(256 * self.pooling_size[0] * self.pooling_size[1], 1024)
self.fc2 = M.Linear(1024, 1024)
for l in [self.fc1, self.fc2]:
M.init.normal_(l.weight, std=0.01)
M.init.fill_(l.bias, 0)
# box predictor
self.pred_cls = M.Linear(1024, cfg.num_classes + 1)
self.pred_delta = M.Linear(1024, (cfg.num_classes + 1) * 4)
M.init.normal_(self.pred_cls.weight, std=0.01)
M.init.normal_(self.pred_delta.weight, std=0.001)
for l in [self.pred_cls, self.pred_delta]:
M.init.fill_(l.bias, 0)
def forward(self, fpn_fms, rcnn_rois, im_info=None, gt_boxes=None):
rcnn_rois, labels, bbox_targets = self.get_ground_truth(
rcnn_rois, im_info, gt_boxes
)
fpn_fms = [fpn_fms[x] for x in self.in_features]
pool_features = layers.roi_pool(
fpn_fms, rcnn_rois, self.stride, self.pooling_size, self.pooling_method,
)
flatten_feature = F.flatten(pool_features, start_axis=1)
roi_feature = F.relu(self.fc1(flatten_feature))
roi_feature = F.relu(self.fc2(roi_feature))
pred_logits = self.pred_cls(roi_feature)
pred_offsets = self.pred_delta(roi_feature)
if self.training:
# loss for classification
loss_rcnn_cls = layers.softmax_loss(pred_logits, labels)
# loss for regression
pred_offsets = pred_offsets.reshape(-1, self.cfg.num_classes + 1, 4)
vlabels = labels.reshape(-1, 1).broadcast((labels.shapeof(0), 4))
pred_offsets = F.indexing_one_hot(pred_offsets, vlabels, axis=1)
loss_rcnn_loc = layers.get_smooth_l1_loss(
pred_offsets,
bbox_targets,
labels,
self.cfg.rcnn_smooth_l1_beta,
norm_type="all",
)
loss_dict = {"loss_rcnn_cls": loss_rcnn_cls, "loss_rcnn_loc": loss_rcnn_loc}
return loss_dict
else:
# slice 1 for removing background
pred_scores = F.softmax(pred_logits, axis=1)[:, 1:]
pred_offsets = pred_offsets[:, 4:].reshape(-1, 4)
target_shape = (rcnn_rois.shapeof(0), self.cfg.num_classes, 4)
# rois (N, 4) -> (N, 1, 4) -> (N, 80, 4) -> (N * 80, 4)
base_rois = (
F.add_axis(rcnn_rois[:, 1:5], 1).broadcast(target_shape).reshape(-1, 4)
)
pred_bbox = self.box_coder.decode(base_rois, pred_offsets)
return pred_bbox, pred_scores
def get_ground_truth(self, rpn_rois, im_info, gt_boxes):
if not self.training:
return rpn_rois, None, None
return_rois = []
return_labels = []
return_bbox_targets = []
# get per image proposals and gt_boxes
for bid in range(self.cfg.batch_per_gpu):
num_valid_boxes = im_info[bid, 4]
gt_boxes_per_img = gt_boxes[bid, :num_valid_boxes, :]
batch_inds = mge.ones((gt_boxes_per_img.shapeof(0), 1)) * bid
# if config.proposal_append_gt:
gt_rois = F.concat([batch_inds, gt_boxes_per_img[:, :4]], axis=1)
batch_roi_mask = rpn_rois[:, 0] == bid
_, batch_roi_inds = F.cond_take(batch_roi_mask == 1, batch_roi_mask)
# all_rois : [batch_id, x1, y1, x2, y2]
all_rois = F.concat([rpn_rois.ai[batch_roi_inds], gt_rois])
overlaps_normal, overlaps_ignore = layers.get_iou(
all_rois[:, 1:5], gt_boxes_per_img, return_ignore=True,
)
max_overlaps_normal = overlaps_normal.max(axis=1)
gt_assignment_normal = F.argmax(overlaps_normal, axis=1)
max_overlaps_ignore = overlaps_ignore.max(axis=1)
gt_assignment_ignore = F.argmax(overlaps_ignore, axis=1)
ignore_assign_mask = (max_overlaps_normal < self.cfg.fg_threshold) * (
max_overlaps_ignore > max_overlaps_normal
)
max_overlaps = (
max_overlaps_normal * (1 - ignore_assign_mask)
+ max_overlaps_ignore * ignore_assign_mask
)
gt_assignment = (
gt_assignment_normal * (1 - ignore_assign_mask)
+ gt_assignment_ignore * ignore_assign_mask
)
gt_assignment = gt_assignment.astype("int32")
labels = gt_boxes_per_img.ai[gt_assignment, 4]
# ---------------- get the fg/bg labels for each roi ---------------#
fg_mask = (max_overlaps >= self.cfg.fg_threshold) * (
labels != self.cfg.ignore_label
)
bg_mask = (max_overlaps < self.cfg.bg_threshold_high) * (
max_overlaps >= self.cfg.bg_threshold_low
)
num_fg_rois = self.cfg.num_rois * self.cfg.fg_ratio
fg_inds_mask = self._bernoulli_sample_masks(fg_mask, num_fg_rois, 1)
num_bg_rois = self.cfg.num_rois - fg_inds_mask.sum()
bg_inds_mask = self._bernoulli_sample_masks(bg_mask, num_bg_rois, 1)
labels = labels * fg_inds_mask
keep_mask = fg_inds_mask + bg_inds_mask
_, keep_inds = F.cond_take(keep_mask == 1, keep_mask)
# Add next line to avoid memory exceed
keep_inds = keep_inds[: F.minimum(self.cfg.num_rois, keep_inds.shapeof(0))]
# labels
labels = labels.ai[keep_inds].astype("int32")
rois = all_rois.ai[keep_inds]
target_boxes = gt_boxes_per_img.ai[gt_assignment.ai[keep_inds], :4]
bbox_targets = self.box_coder.encode(rois[:, 1:5], target_boxes)
bbox_targets = bbox_targets.reshape(-1, 4)
return_rois.append(rois)
return_labels.append(labels)
return_bbox_targets.append(bbox_targets)
return (
F.zero_grad(F.concat(return_rois, axis=0)),
F.zero_grad(F.concat(return_labels, axis=0)),
F.zero_grad(F.concat(return_bbox_targets, axis=0)),
)
def _bernoulli_sample_masks(self, masks, num_samples, sample_value):
""" Using the bernoulli sampling method"""
sample_mask = masks == sample_value
num_mask = sample_mask.sum()
num_final_samples = F.minimum(num_mask, num_samples)
# here, we use the bernoulli probability to sample the anchors
sample_prob = num_final_samples / num_mask
uniform_rng = mge.random.uniform(sample_mask.shapeof(0))
after_sampled_mask = (uniform_rng <= sample_prob) * sample_mask
return after_sampled_mask
|
[
"megengine.functional.argmax",
"megengine.functional.flatten",
"megengine.module.init.fill_",
"megengine.functional.indexing_one_hot",
"megengine.functional.softmax",
"megengine.functional.minimum",
"megengine.module.init.normal_",
"megengine.functional.add_axis",
"megengine.module.Linear",
"megengine.functional.concat",
"megengine.functional.cond_take"
] |
[((636, 688), 'official.vision.detection.layers.BoxCoder', 'layers.BoxCoder', (['cfg.rcnn_reg_mean', 'cfg.rcnn_reg_std'], {}), '(cfg.rcnn_reg_mean, cfg.rcnn_reg_std)\n', (651, 688), False, 'from official.vision.detection import layers\n'), ((909, 974), 'megengine.module.Linear', 'M.Linear', (['(256 * self.pooling_size[0] * self.pooling_size[1])', '(1024)'], {}), '(256 * self.pooling_size[0] * self.pooling_size[1], 1024)\n', (917, 974), True, 'import megengine.module as M\n'), ((994, 1014), 'megengine.module.Linear', 'M.Linear', (['(1024)', '(1024)'], {}), '(1024, 1024)\n', (1002, 1014), True, 'import megengine.module as M\n'), ((1186, 1221), 'megengine.module.Linear', 'M.Linear', (['(1024)', '(cfg.num_classes + 1)'], {}), '(1024, cfg.num_classes + 1)\n', (1194, 1221), True, 'import megengine.module as M\n'), ((1248, 1289), 'megengine.module.Linear', 'M.Linear', (['(1024)', '((cfg.num_classes + 1) * 4)'], {}), '(1024, (cfg.num_classes + 1) * 4)\n', (1256, 1289), True, 'import megengine.module as M\n'), ((1298, 1344), 'megengine.module.init.normal_', 'M.init.normal_', (['self.pred_cls.weight'], {'std': '(0.01)'}), '(self.pred_cls.weight, std=0.01)\n', (1312, 1344), True, 'import megengine.module as M\n'), ((1353, 1402), 'megengine.module.init.normal_', 'M.init.normal_', (['self.pred_delta.weight'], {'std': '(0.001)'}), '(self.pred_delta.weight, std=0.001)\n', (1367, 1402), True, 'import megengine.module as M\n'), ((1761, 1854), 'official.vision.detection.layers.roi_pool', 'layers.roi_pool', (['fpn_fms', 'rcnn_rois', 'self.stride', 'self.pooling_size', 'self.pooling_method'], {}), '(fpn_fms, rcnn_rois, self.stride, self.pooling_size, self.\n pooling_method)\n', (1776, 1854), False, 'from official.vision.detection import layers\n'), ((1899, 1937), 'megengine.functional.flatten', 'F.flatten', (['pool_features'], {'start_axis': '(1)'}), '(pool_features, start_axis=1)\n', (1908, 1937), True, 'import megengine.functional as F\n'), ((7226, 7258), 'megengine.functional.minimum', 'F.minimum', (['num_mask', 'num_samples'], {}), '(num_mask, num_samples)\n', (7235, 7258), True, 'import megengine.functional as F\n'), ((1066, 1100), 'megengine.module.init.normal_', 'M.init.normal_', (['l.weight'], {'std': '(0.01)'}), '(l.weight, std=0.01)\n', (1080, 1100), True, 'import megengine.module as M\n'), ((1113, 1136), 'megengine.module.init.fill_', 'M.init.fill_', (['l.bias', '(0)'], {}), '(l.bias, 0)\n', (1125, 1136), True, 'import megengine.module as M\n'), ((1466, 1489), 'megengine.module.init.fill_', 'M.init.fill_', (['l.bias', '(0)'], {}), '(l.bias, 0)\n', (1478, 1489), True, 'import megengine.module as M\n'), ((2240, 2280), 'official.vision.detection.layers.softmax_loss', 'layers.softmax_loss', (['pred_logits', 'labels'], {}), '(pred_logits, labels)\n', (2259, 2280), False, 'from official.vision.detection import layers\n'), ((2502, 2551), 'megengine.functional.indexing_one_hot', 'F.indexing_one_hot', (['pred_offsets', 'vlabels'], {'axis': '(1)'}), '(pred_offsets, vlabels, axis=1)\n', (2520, 2551), True, 'import megengine.functional as F\n'), ((2581, 2694), 'official.vision.detection.layers.get_smooth_l1_loss', 'layers.get_smooth_l1_loss', (['pred_offsets', 'bbox_targets', 'labels', 'self.cfg.rcnn_smooth_l1_beta'], {'norm_type': '"""all"""'}), "(pred_offsets, bbox_targets, labels, self.cfg.\n rcnn_smooth_l1_beta, norm_type='all')\n", (2606, 2694), False, 'from official.vision.detection import layers\n'), ((4041, 4096), 'megengine.functional.concat', 'F.concat', (['[batch_inds, gt_boxes_per_img[:, :4]]'], {'axis': '(1)'}), '([batch_inds, gt_boxes_per_img[:, :4]], axis=1)\n', (4049, 4096), True, 'import megengine.functional as F\n'), ((4180, 4228), 'megengine.functional.cond_take', 'F.cond_take', (['(batch_roi_mask == 1)', 'batch_roi_mask'], {}), '(batch_roi_mask == 1, batch_roi_mask)\n', (4191, 4228), True, 'import megengine.functional as F\n'), ((4304, 4352), 'megengine.functional.concat', 'F.concat', (['[rpn_rois.ai[batch_roi_inds], gt_rois]'], {}), '([rpn_rois.ai[batch_roi_inds], gt_rois])\n', (4312, 4352), True, 'import megengine.functional as F\n'), ((4401, 4471), 'official.vision.detection.layers.get_iou', 'layers.get_iou', (['all_rois[:, 1:5]', 'gt_boxes_per_img'], {'return_ignore': '(True)'}), '(all_rois[:, 1:5], gt_boxes_per_img, return_ignore=True)\n', (4415, 4471), False, 'from official.vision.detection import layers\n'), ((4601, 4634), 'megengine.functional.argmax', 'F.argmax', (['overlaps_normal'], {'axis': '(1)'}), '(overlaps_normal, axis=1)\n', (4609, 4634), True, 'import megengine.functional as F\n'), ((4733, 4766), 'megengine.functional.argmax', 'F.argmax', (['overlaps_ignore'], {'axis': '(1)'}), '(overlaps_ignore, axis=1)\n', (4741, 4766), True, 'import megengine.functional as F\n'), ((6143, 6181), 'megengine.functional.cond_take', 'F.cond_take', (['(keep_mask == 1)', 'keep_mask'], {}), '(keep_mask == 1, keep_mask)\n', (6154, 6181), True, 'import megengine.functional as F\n'), ((2989, 3019), 'megengine.functional.softmax', 'F.softmax', (['pred_logits'], {'axis': '(1)'}), '(pred_logits, axis=1)\n', (2998, 3019), True, 'import megengine.functional as F\n'), ((6828, 6857), 'megengine.functional.concat', 'F.concat', (['return_rois'], {'axis': '(0)'}), '(return_rois, axis=0)\n', (6836, 6857), True, 'import megengine.functional as F\n'), ((6884, 6915), 'megengine.functional.concat', 'F.concat', (['return_labels'], {'axis': '(0)'}), '(return_labels, axis=0)\n', (6892, 6915), True, 'import megengine.functional as F\n'), ((6942, 6979), 'megengine.functional.concat', 'F.concat', (['return_bbox_targets'], {'axis': '(0)'}), '(return_bbox_targets, axis=0)\n', (6950, 6979), True, 'import megengine.functional as F\n'), ((3274, 3306), 'megengine.functional.add_axis', 'F.add_axis', (['rcnn_rois[:, 1:5]', '(1)'], {}), '(rcnn_rois[:, 1:5], 1)\n', (3284, 3306), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import math
from typing import List
import megengine.module as M
from megengine.core import Tensor
from official.vision.detection.layers import basic
class RetinaNetHead(M.Module):
"""
The head used in RetinaNet for object classification and box regression.
"""
def __init__(self, cfg, input_shape: List[basic.ShapeSpec]):
super().__init__()
in_channels = input_shape[0].channels
num_classes = cfg.num_classes
num_convs = 4
prior_prob = cfg.cls_prior_prob
num_anchors = [9, 9, 9, 9, 9]
assert (
len(set(num_anchors)) == 1
), "not support different number of anchors between levels"
num_anchors = num_anchors[0]
cls_subnet = []
bbox_subnet = []
for _ in range(num_convs):
cls_subnet.append(
M.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1,)
)
cls_subnet.append(M.ReLU())
bbox_subnet.append(
M.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1,)
)
bbox_subnet.append(M.ReLU())
self.cls_subnet = M.Sequential(*cls_subnet)
self.bbox_subnet = M.Sequential(*bbox_subnet)
self.cls_score = M.Conv2d(
in_channels, num_anchors * num_classes, kernel_size=3, stride=1, padding=1,
)
self.bbox_pred = M.Conv2d(
in_channels, num_anchors * 4, kernel_size=3, stride=1, padding=1
)
# Initialization
for modules in [
self.cls_subnet,
self.bbox_subnet,
self.cls_score,
self.bbox_pred,
]:
for layer in modules.modules():
if isinstance(layer, M.Conv2d):
M.init.normal_(layer.weight, mean=0, std=0.01)
M.init.fill_(layer.bias, 0)
# Use prior in model initialization to improve stability
bias_value = -math.log((1 - prior_prob) / prior_prob)
M.init.fill_(self.cls_score.bias, bias_value)
def forward(self, features: List[Tensor]):
logits, bbox_reg = [], []
for feature in features:
logits.append(self.cls_score(self.cls_subnet(feature)))
bbox_reg.append(self.bbox_pred(self.bbox_subnet(feature)))
return logits, bbox_reg
|
[
"megengine.module.init.normal_",
"megengine.module.init.fill_",
"megengine.module.ReLU",
"megengine.module.Sequential",
"megengine.module.Conv2d"
] |
[((1556, 1581), 'megengine.module.Sequential', 'M.Sequential', (['*cls_subnet'], {}), '(*cls_subnet)\n', (1568, 1581), True, 'import megengine.module as M\n'), ((1609, 1635), 'megengine.module.Sequential', 'M.Sequential', (['*bbox_subnet'], {}), '(*bbox_subnet)\n', (1621, 1635), True, 'import megengine.module as M\n'), ((1661, 1749), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', '(num_anchors * num_classes)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, num_anchors * num_classes, kernel_size=3, stride=1,\n padding=1)\n', (1669, 1749), True, 'import megengine.module as M\n'), ((1794, 1868), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', '(num_anchors * 4)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, num_anchors * 4, kernel_size=3, stride=1, padding=1)\n', (1802, 1868), True, 'import megengine.module as M\n'), ((2411, 2456), 'megengine.module.init.fill_', 'M.init.fill_', (['self.cls_score.bias', 'bias_value'], {}), '(self.cls_score.bias, bias_value)\n', (2423, 2456), True, 'import megengine.module as M\n'), ((2363, 2402), 'math.log', 'math.log', (['((1 - prior_prob) / prior_prob)'], {}), '((1 - prior_prob) / prior_prob)\n', (2371, 2402), False, 'import math\n'), ((1228, 1298), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'in_channels'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, in_channels, kernel_size=3, stride=1, padding=1)\n', (1236, 1298), True, 'import megengine.module as M\n'), ((1344, 1352), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1350, 1352), True, 'import megengine.module as M\n'), ((1402, 1472), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'in_channels'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, in_channels, kernel_size=3, stride=1, padding=1)\n', (1410, 1472), True, 'import megengine.module as M\n'), ((1519, 1527), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1525, 1527), True, 'import megengine.module as M\n'), ((2180, 2226), 'megengine.module.init.normal_', 'M.init.normal_', (['layer.weight'], {'mean': '(0)', 'std': '(0.01)'}), '(layer.weight, mean=0, std=0.01)\n', (2194, 2226), True, 'import megengine.module as M\n'), ((2247, 2274), 'megengine.module.init.fill_', 'M.init.fill_', (['layer.bias', '(0)'], {}), '(layer.bias, 0)\n', (2259, 2274), True, 'import megengine.module as M\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine as mge
import megengine.functional as F
from megengine.core.tensor import dtype
from megengine.device import get_cuda_compute_capability, get_device_count
from megengine.functional.elemwise import _elemwise_multi_type, _elwise
from megengine.module.quantized.conv import ConvTranspose2d
from megengine.quantization import QuantMode, create_qparams
def quant(x, scale):
x_dtype = dtype.qint8(scale)
return x.astype(x_dtype)
def fake_quant(x, scale):
x = x / scale
x = F.round(x)
x = F.clip(x, -128, 127)
x = x * scale
return x
@pytest.mark.parametrize("kind", ["abs", "sin", "sub", "mul", "fuse_add_tanh"])
def test_elemwise(kind):
x1 = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
x1_scale = np.float32(np.random.rand() + 1)
x1 = fake_quant(x1, x1_scale)
x1.qparams.update(create_qparams(QuantMode.SYMMERTIC, "qint8", x1_scale))
x1_int8 = quant(x1, x1_scale)
x2 = mge.tensor(np.random.normal(size=(3, 3)).astype("float32"))
x2_scale = np.float32(np.random.rand() + 1)
x2 = fake_quant(x2, x2_scale)
x2.qparams.update(create_qparams(QuantMode.SYMMERTIC, "qint8", x2_scale))
x2_int8 = quant(x2, x2_scale)
output_scale = np.float32(np.random.rand() + 1)
output_dtype = dtype.qint8(output_scale)
quantized_kind = "q" + kind
if kind in ("abs", "sin"):
desired_out = fake_quant(_elwise(x1, mode=kind), output_scale)
actual_out = (
_elemwise_multi_type(
x1_int8, mode=quantized_kind, dtype=output_dtype
).numpy()
* output_scale
)
else:
desired_out = fake_quant(_elwise(x1, x2, mode=kind), output_scale)
actual_out = (
_elemwise_multi_type(
x1_int8, x2_int8, mode=quantized_kind, dtype=output_dtype
).numpy()
* output_scale
)
np.testing.assert_allclose(actual_out, desired_out.numpy())
@pytest.mark.skipif(
get_device_count("gpu") > 0, reason="cuda does not support nchw int8"
)
def test_conv_bias():
inp_scale = np.float32(np.random.rand() + 1)
w_scale = np.float32(np.random.rand() + 1)
outp_scale = np.float32(np.random.rand() + 1)
inp_dtype = dtype.qint8(inp_scale)
w_dtype = dtype.qint8(w_scale)
b_dtype = dtype.qint32(inp_scale * w_scale)
out_dtype = dtype.qint8(outp_scale)
def run(
N,
IC,
OC,
IH,
IW,
KH,
KW,
PH,
PW,
SH,
SW,
has_bias=True,
nonlinear_mode="identity",
):
inp_v = np.random.normal(size=(N, IC, IH, IW))
w_v = np.random.normal(size=(OC, IC, KH, KW))
b_v = np.random.normal(size=(1, OC, 1, 1))
inp_scale = dtype.get_scale(inp_dtype)
w_scale = dtype.get_scale(w_dtype)
b_scale = dtype.get_scale(b_dtype)
inpv = dtype.convert_to_qint8(inp_v * inp_scale, inp_dtype)
wv = dtype.convert_to_qint8(w_v * w_scale, w_dtype)
bv = dtype.convert_to_qint32(b_v * b_scale, b_dtype)
inp_int8 = mge.tensor(inpv, dtype=inp_dtype)
w_int8 = mge.Parameter(wv, dtype=w_dtype)
b_int32 = mge.Parameter(bv, dtype=b_dtype)
inp_fp32 = inp_int8.astype("float32")
w_fp32 = w_int8.astype("float32")
b_fp32 = b_int32.astype("float32")
def convert_to_nchw4(var):
var = F.reshape(
var, (var.shape[0], var.shape[1] // 4, 4, var.shape[2], var.shape[3])
)
var = F.transpose(var, (0, 1, 3, 4, 2))
return var
def run_conv2d(inp, w, b):
O = F.conv2d(
inp, w, b if has_bias else None, stride=(SH, SW), padding=(PH, PW),
)
if nonlinear_mode == "relu":
return F.relu(O)
else:
return O
def run_conv_bias(inp, w, b, format="NCHW"):
b = b if has_bias else mge.Parameter(np.zeros_like(b.numpy()))
if format == "NCHW4":
inp = convert_to_nchw4(inp)
w = convert_to_nchw4(w)
b = convert_to_nchw4(b)
return F.quantized.conv_bias_activation(
inp,
w,
b,
stride=(SH, SW),
padding=(PH, PW),
dtype=out_dtype,
nonlinear_mode=nonlinear_mode,
)
format = "NCHW4" if mge.is_cuda_available() else "NCHW"
expected = run_conv2d(inp_fp32, w_fp32, b_fp32)
expected = expected.astype(out_dtype).astype("float32")
result = run_conv_bias(inp_int8, w_int8, b_int32, format=format).astype(
"float32"
)
if format == "NCHW4":
result = F.transpose(result, (0, 1, 4, 2, 3))
expected = F.flatten(expected)
result = F.flatten(result)
np.testing.assert_allclose(result.numpy(), expected.numpy(), atol=outp_scale)
run(1, 4, 4, 24, 33, 1, 1, 2, 3, 1, 1, False)
run(10, 12, 24, 46, 46, 1, 1, 2, 1, 3, 1, False)
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2, False)
run(1, 4, 4, 24, 33, 1, 1, 2, 3, 1, 1)
run(10, 12, 24, 46, 46, 1, 1, 2, 1, 3, 1)
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2)
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2, False, "relu")
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2, True, "relu")
@pytest.mark.skip(reason="does not support int4 when cuda version is lower than 10.2")
def test_conv_bias_int4():
inp_scale = 1.5
w_scale = 2.5
outp_scale = 1.5
inp_dtype = dtype.quint4(inp_scale, 0)
w_dtype = dtype.qint4(w_scale)
b_dtype = dtype.qint32(inp_scale * w_scale)
out_dtype = dtype.quint4(outp_scale, 0)
def run(
N,
IC,
OC,
IH,
IW,
KH,
KW,
PH,
PW,
SH,
SW,
has_bias=True,
nonlinear_mode="identity",
):
inp_v = np.random.normal(size=(N, IC, IH, IW))
w_v = np.random.normal(size=(OC, IC, KH, KW))
b_v = np.random.normal(size=(1, OC, 1, 1))
inp_scale = dtype.get_scale(inp_dtype)
w_scale = dtype.get_scale(w_dtype)
b_scale = dtype.get_scale(b_dtype)
inpv = dtype.convert_to_quint4(inp_v * inp_scale, inp_dtype)
wv = dtype.convert_to_qint4(w_v * w_scale, w_dtype)
bv = dtype.convert_to_qint32(b_v * b_scale, b_dtype)
inp_uint4 = mge.Tensor(inpv, dtype=inp_dtype)
w_int4 = mge.Parameter(wv, dtype=w_dtype)
b_int32 = mge.Parameter(bv, dtype=b_dtype)
inp_fp32 = inp_uint4.astype("float32")
w_fp32 = w_int4.astype("float32")
b_fp32 = b_int32.astype("float32")
def run_conv2d(inp, w, b):
O = F.conv2d(
inp, w, b if has_bias else None, stride=(SH, SW), padding=(PH, PW),
)
if nonlinear_mode == "relu":
return F.relu(O)
else:
return O
def run_conv_bias(inp, w, b):
b = b if has_bias else mge.Parameter(np.zeros_like(b.numpy()))
return F.quantized.conv_bias_activation(
inp,
w,
b,
stride=(SH, SW),
padding=(PH, PW),
dtype=out_dtype,
nonlinear_mode=nonlinear_mode,
)
expected = run_conv2d(inp_fp32, w_fp32, b_fp32)
expected = expected.astype(out_dtype).astype("float32")
result = run_conv_bias(inp_uint4, w_int4, b_int32).astype("float32")
expected = F.flatten(expected)
result = F.flatten(result)
np.testing.assert_allclose(result.numpy(), expected.numpy(), atol=outp_scale)
run(1, 4, 4, 24, 33, 1, 1, 2, 3, 1, 1, False)
run(10, 12, 24, 46, 46, 1, 1, 2, 1, 3, 1, False)
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2, False)
run(1, 4, 4, 24, 33, 1, 1, 2, 3, 1, 1)
run(10, 12, 24, 46, 46, 1, 1, 2, 1, 3, 1)
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2)
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2, False, "relu")
run(10, 36, 8, 46, 26, 2, 2, 2, 1, 1, 2, True, "relu")
@pytest.mark.skipif(
get_device_count("gpu") > 0 and get_cuda_compute_capability(0) < 61,
reason="does not support int8 when gpu compute capability less than 6.1",
)
def test_conv_transpose2d():
rng = np.random.RandomState(seed=2021)
def test_func(
N,
IC,
IH,
IW,
OC,
KH,
KW,
SH,
SW,
PH,
PW,
DH,
DW,
groups=1,
has_bias=True,
conv_mode: str = "cross_correlation",
compute_mode: str = "default",
):
inp_scale = np.float32(rng.uniform(low=0.04, high=0.06))
weight_scale = np.float32(rng.uniform(low=0.04, high=0.06))
bias_scale = inp_scale * weight_scale
out_scale = np.float32(rng.uniform(low=0.04, high=0.06))
inp_dtype = dtype.qint8(inp_scale)
weight_dtype = dtype.qint8(weight_scale)
bias_dtype = dtype.qint32(bias_scale)
out_dtype = dtype.qint8(out_scale)
inp_fp32 = rng.uniform(low=-1, high=1, size=(N, IC, IH, IW)).astype(np.float32)
weight_fp32 = rng.uniform(low=-1, high=1, size=(IC, OC, KH, KW)).astype(
np.float32
)
bias_fp32 = rng.uniform(low=-1, high=1, size=(1, OC, 1, 1)).astype(np.float32)
inp_int8 = dtype.convert_to_qint8(inp_fp32, inp_dtype)
weight_int8 = dtype.convert_to_qint8(weight_fp32, weight_dtype)
bias_int32 = dtype.convert_to_qint32(bias_fp32, bias_dtype)
inp_int8 = mge.tensor(inp_int8, dtype=inp_dtype)
weight_int8 = mge.Parameter(weight_int8, dtype=weight_dtype)
bias_int32 = mge.Parameter(bias_int32, dtype=bias_dtype)
inp_fp32 = inp_int8.astype("float32")
weight_fp32 = weight_int8.astype("float32")
bias_fp32 = bias_int32.astype("float32")
expected = F.conv_transpose2d(
inp_fp32,
weight_fp32,
bias_fp32 if has_bias else None,
stride=(SH, SW),
padding=(PH, PW),
dilation=(DH, DW),
groups=groups,
conv_mode=conv_mode,
compute_mode=compute_mode,
)
expected = dtype.convert_to_qint8(expected.numpy(), out_dtype)
expected = dtype.convert_from_qint8(expected)
conv_transpose2d = ConvTranspose2d(
in_channels=IC,
out_channels=OC,
kernel_size=(KH, KW),
stride=(SH, SW),
padding=(PH, PW),
dilation=(DH, DW),
groups=groups,
bias=has_bias,
conv_mode=conv_mode,
compute_mode=compute_mode,
dtype=out_dtype,
)
conv_transpose2d.weight = mge.Parameter(weight_int8)
if has_bias:
conv_transpose2d.bias = mge.Parameter(bias_int32)
result = conv_transpose2d.forward(inp_int8).numpy()
result = dtype.convert_from_qint8(result)
np.testing.assert_allclose(result, expected, atol=out_scale)
test_func(1, 4, 1, 1, 4, 1, 1, 1, 1, 0, 0, 1, 1, 1, False)
test_func(2, 4, 3, 1, 8, 1, 1, 1, 1, 0, 0, 1, 1, 1, False)
test_func(4, 4, 16, 16, 8, 3, 3, 1, 1, 1, 1, 1, 1, 1, False)
test_func(32, 64, 36, 28, 16, 3, 2, 1, 3, 1, 0, 1, 1, 1, False)
|
[
"megengine.functional.conv2d",
"megengine.functional.reshape",
"megengine.core.tensor.dtype.convert_to_qint4",
"megengine.functional.transpose",
"megengine.core.tensor.dtype.qint32",
"megengine.functional.clip",
"megengine.Tensor",
"megengine.core.tensor.dtype.qint4",
"megengine.device.get_device_count",
"megengine.core.tensor.dtype.quint4",
"megengine.functional.quantized.conv_bias_activation",
"megengine.tensor",
"megengine.functional.elemwise._elwise",
"megengine.core.tensor.dtype.convert_to_qint32",
"megengine.core.tensor.dtype.qint8",
"megengine.functional.elemwise._elemwise_multi_type",
"megengine.is_cuda_available",
"megengine.quantization.create_qparams",
"megengine.functional.relu",
"megengine.core.tensor.dtype.get_scale",
"megengine.functional.flatten",
"megengine.core.tensor.dtype.convert_from_qint8",
"megengine.device.get_cuda_compute_capability",
"megengine.functional.conv_transpose2d",
"megengine.Parameter",
"megengine.core.tensor.dtype.convert_to_quint4",
"megengine.module.quantized.conv.ConvTranspose2d",
"megengine.functional.round",
"megengine.core.tensor.dtype.convert_to_qint8"
] |
[((966, 1044), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""kind"""', "['abs', 'sin', 'sub', 'mul', 'fuse_add_tanh']"], {}), "('kind', ['abs', 'sin', 'sub', 'mul', 'fuse_add_tanh'])\n", (989, 1044), False, 'import pytest\n'), ((5797, 5887), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""does not support int4 when cuda version is lower than 10.2"""'}), "(reason=\n 'does not support int4 when cuda version is lower than 10.2')\n", (5813, 5887), False, 'import pytest\n'), ((790, 808), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['scale'], {}), '(scale)\n', (801, 808), False, 'from megengine.core.tensor import dtype\n'), ((892, 902), 'megengine.functional.round', 'F.round', (['x'], {}), '(x)\n', (899, 902), True, 'import megengine.functional as F\n'), ((911, 931), 'megengine.functional.clip', 'F.clip', (['x', '(-128)', '(127)'], {}), '(x, -128, 127)\n', (917, 931), True, 'import megengine.functional as F\n'), ((1669, 1694), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['output_scale'], {}), '(output_scale)\n', (1680, 1694), False, 'from megengine.core.tensor import dtype\n'), ((2633, 2655), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['inp_scale'], {}), '(inp_scale)\n', (2644, 2655), False, 'from megengine.core.tensor import dtype\n'), ((2670, 2690), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['w_scale'], {}), '(w_scale)\n', (2681, 2690), False, 'from megengine.core.tensor import dtype\n'), ((2705, 2738), 'megengine.core.tensor.dtype.qint32', 'dtype.qint32', (['(inp_scale * w_scale)'], {}), '(inp_scale * w_scale)\n', (2717, 2738), False, 'from megengine.core.tensor import dtype\n'), ((2755, 2778), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['outp_scale'], {}), '(outp_scale)\n', (2766, 2778), False, 'from megengine.core.tensor import dtype\n'), ((5985, 6011), 'megengine.core.tensor.dtype.quint4', 'dtype.quint4', (['inp_scale', '(0)'], {}), '(inp_scale, 0)\n', (5997, 6011), False, 'from megengine.core.tensor import dtype\n'), ((6026, 6046), 'megengine.core.tensor.dtype.qint4', 'dtype.qint4', (['w_scale'], {}), '(w_scale)\n', (6037, 6046), False, 'from megengine.core.tensor import dtype\n'), ((6061, 6094), 'megengine.core.tensor.dtype.qint32', 'dtype.qint32', (['(inp_scale * w_scale)'], {}), '(inp_scale * w_scale)\n', (6073, 6094), False, 'from megengine.core.tensor import dtype\n'), ((6111, 6138), 'megengine.core.tensor.dtype.quint4', 'dtype.quint4', (['outp_scale', '(0)'], {}), '(outp_scale, 0)\n', (6123, 6138), False, 'from megengine.core.tensor import dtype\n'), ((8770, 8802), 'numpy.random.RandomState', 'np.random.RandomState', ([], {'seed': '(2021)'}), '(seed=2021)\n', (8791, 8802), True, 'import numpy as np\n'), ((1243, 1297), 'megengine.quantization.create_qparams', 'create_qparams', (['QuantMode.SYMMERTIC', '"""qint8"""', 'x1_scale'], {}), "(QuantMode.SYMMERTIC, 'qint8', x1_scale)\n", (1257, 1297), False, 'from megengine.quantization import QuantMode, create_qparams\n'), ((1507, 1561), 'megengine.quantization.create_qparams', 'create_qparams', (['QuantMode.SYMMERTIC', '"""qint8"""', 'x2_scale'], {}), "(QuantMode.SYMMERTIC, 'qint8', x2_scale)\n", (1521, 1561), False, 'from megengine.quantization import QuantMode, create_qparams\n'), ((3005, 3043), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(N, IC, IH, IW)'}), '(size=(N, IC, IH, IW))\n', (3021, 3043), True, 'import numpy as np\n'), ((3058, 3097), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(OC, IC, KH, KW)'}), '(size=(OC, IC, KH, KW))\n', (3074, 3097), True, 'import numpy as np\n'), ((3112, 3148), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(1, OC, 1, 1)'}), '(size=(1, OC, 1, 1))\n', (3128, 3148), True, 'import numpy as np\n'), ((3169, 3195), 'megengine.core.tensor.dtype.get_scale', 'dtype.get_scale', (['inp_dtype'], {}), '(inp_dtype)\n', (3184, 3195), False, 'from megengine.core.tensor import dtype\n'), ((3214, 3238), 'megengine.core.tensor.dtype.get_scale', 'dtype.get_scale', (['w_dtype'], {}), '(w_dtype)\n', (3229, 3238), False, 'from megengine.core.tensor import dtype\n'), ((3257, 3281), 'megengine.core.tensor.dtype.get_scale', 'dtype.get_scale', (['b_dtype'], {}), '(b_dtype)\n', (3272, 3281), False, 'from megengine.core.tensor import dtype\n'), ((3298, 3350), 'megengine.core.tensor.dtype.convert_to_qint8', 'dtype.convert_to_qint8', (['(inp_v * inp_scale)', 'inp_dtype'], {}), '(inp_v * inp_scale, inp_dtype)\n', (3320, 3350), False, 'from megengine.core.tensor import dtype\n'), ((3364, 3410), 'megengine.core.tensor.dtype.convert_to_qint8', 'dtype.convert_to_qint8', (['(w_v * w_scale)', 'w_dtype'], {}), '(w_v * w_scale, w_dtype)\n', (3386, 3410), False, 'from megengine.core.tensor import dtype\n'), ((3424, 3471), 'megengine.core.tensor.dtype.convert_to_qint32', 'dtype.convert_to_qint32', (['(b_v * b_scale)', 'b_dtype'], {}), '(b_v * b_scale, b_dtype)\n', (3447, 3471), False, 'from megengine.core.tensor import dtype\n'), ((3492, 3525), 'megengine.tensor', 'mge.tensor', (['inpv'], {'dtype': 'inp_dtype'}), '(inpv, dtype=inp_dtype)\n', (3502, 3525), True, 'import megengine as mge\n'), ((3543, 3575), 'megengine.Parameter', 'mge.Parameter', (['wv'], {'dtype': 'w_dtype'}), '(wv, dtype=w_dtype)\n', (3556, 3575), True, 'import megengine as mge\n'), ((3594, 3626), 'megengine.Parameter', 'mge.Parameter', (['bv'], {'dtype': 'b_dtype'}), '(bv, dtype=b_dtype)\n', (3607, 3626), True, 'import megengine as mge\n'), ((5242, 5261), 'megengine.functional.flatten', 'F.flatten', (['expected'], {}), '(expected)\n', (5251, 5261), True, 'import megengine.functional as F\n'), ((5279, 5296), 'megengine.functional.flatten', 'F.flatten', (['result'], {}), '(result)\n', (5288, 5296), True, 'import megengine.functional as F\n'), ((2377, 2400), 'megengine.device.get_device_count', 'get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (2393, 2400), False, 'from megengine.device import get_cuda_compute_capability, get_device_count\n'), ((6365, 6403), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(N, IC, IH, IW)'}), '(size=(N, IC, IH, IW))\n', (6381, 6403), True, 'import numpy as np\n'), ((6418, 6457), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(OC, IC, KH, KW)'}), '(size=(OC, IC, KH, KW))\n', (6434, 6457), True, 'import numpy as np\n'), ((6472, 6508), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(1, OC, 1, 1)'}), '(size=(1, OC, 1, 1))\n', (6488, 6508), True, 'import numpy as np\n'), ((6529, 6555), 'megengine.core.tensor.dtype.get_scale', 'dtype.get_scale', (['inp_dtype'], {}), '(inp_dtype)\n', (6544, 6555), False, 'from megengine.core.tensor import dtype\n'), ((6574, 6598), 'megengine.core.tensor.dtype.get_scale', 'dtype.get_scale', (['w_dtype'], {}), '(w_dtype)\n', (6589, 6598), False, 'from megengine.core.tensor import dtype\n'), ((6617, 6641), 'megengine.core.tensor.dtype.get_scale', 'dtype.get_scale', (['b_dtype'], {}), '(b_dtype)\n', (6632, 6641), False, 'from megengine.core.tensor import dtype\n'), ((6658, 6711), 'megengine.core.tensor.dtype.convert_to_quint4', 'dtype.convert_to_quint4', (['(inp_v * inp_scale)', 'inp_dtype'], {}), '(inp_v * inp_scale, inp_dtype)\n', (6681, 6711), False, 'from megengine.core.tensor import dtype\n'), ((6725, 6771), 'megengine.core.tensor.dtype.convert_to_qint4', 'dtype.convert_to_qint4', (['(w_v * w_scale)', 'w_dtype'], {}), '(w_v * w_scale, w_dtype)\n', (6747, 6771), False, 'from megengine.core.tensor import dtype\n'), ((6785, 6832), 'megengine.core.tensor.dtype.convert_to_qint32', 'dtype.convert_to_qint32', (['(b_v * b_scale)', 'b_dtype'], {}), '(b_v * b_scale, b_dtype)\n', (6808, 6832), False, 'from megengine.core.tensor import dtype\n'), ((6854, 6887), 'megengine.Tensor', 'mge.Tensor', (['inpv'], {'dtype': 'inp_dtype'}), '(inpv, dtype=inp_dtype)\n', (6864, 6887), True, 'import megengine as mge\n'), ((6905, 6937), 'megengine.Parameter', 'mge.Parameter', (['wv'], {'dtype': 'w_dtype'}), '(wv, dtype=w_dtype)\n', (6918, 6937), True, 'import megengine as mge\n'), ((6956, 6988), 'megengine.Parameter', 'mge.Parameter', (['bv'], {'dtype': 'b_dtype'}), '(bv, dtype=b_dtype)\n', (6969, 6988), True, 'import megengine as mge\n'), ((8003, 8022), 'megengine.functional.flatten', 'F.flatten', (['expected'], {}), '(expected)\n', (8012, 8022), True, 'import megengine.functional as F\n'), ((8040, 8057), 'megengine.functional.flatten', 'F.flatten', (['result'], {}), '(result)\n', (8049, 8057), True, 'import megengine.functional as F\n'), ((9376, 9398), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['inp_scale'], {}), '(inp_scale)\n', (9387, 9398), False, 'from megengine.core.tensor import dtype\n'), ((9422, 9447), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['weight_scale'], {}), '(weight_scale)\n', (9433, 9447), False, 'from megengine.core.tensor import dtype\n'), ((9469, 9493), 'megengine.core.tensor.dtype.qint32', 'dtype.qint32', (['bias_scale'], {}), '(bias_scale)\n', (9481, 9493), False, 'from megengine.core.tensor import dtype\n'), ((9514, 9536), 'megengine.core.tensor.dtype.qint8', 'dtype.qint8', (['out_scale'], {}), '(out_scale)\n', (9525, 9536), False, 'from megengine.core.tensor import dtype\n'), ((9847, 9890), 'megengine.core.tensor.dtype.convert_to_qint8', 'dtype.convert_to_qint8', (['inp_fp32', 'inp_dtype'], {}), '(inp_fp32, inp_dtype)\n', (9869, 9890), False, 'from megengine.core.tensor import dtype\n'), ((9913, 9962), 'megengine.core.tensor.dtype.convert_to_qint8', 'dtype.convert_to_qint8', (['weight_fp32', 'weight_dtype'], {}), '(weight_fp32, weight_dtype)\n', (9935, 9962), False, 'from megengine.core.tensor import dtype\n'), ((9984, 10030), 'megengine.core.tensor.dtype.convert_to_qint32', 'dtype.convert_to_qint32', (['bias_fp32', 'bias_dtype'], {}), '(bias_fp32, bias_dtype)\n', (10007, 10030), False, 'from megengine.core.tensor import dtype\n'), ((10051, 10088), 'megengine.tensor', 'mge.tensor', (['inp_int8'], {'dtype': 'inp_dtype'}), '(inp_int8, dtype=inp_dtype)\n', (10061, 10088), True, 'import megengine as mge\n'), ((10111, 10157), 'megengine.Parameter', 'mge.Parameter', (['weight_int8'], {'dtype': 'weight_dtype'}), '(weight_int8, dtype=weight_dtype)\n', (10124, 10157), True, 'import megengine as mge\n'), ((10179, 10222), 'megengine.Parameter', 'mge.Parameter', (['bias_int32'], {'dtype': 'bias_dtype'}), '(bias_int32, dtype=bias_dtype)\n', (10192, 10222), True, 'import megengine as mge\n'), ((10391, 10590), 'megengine.functional.conv_transpose2d', 'F.conv_transpose2d', (['inp_fp32', 'weight_fp32', '(bias_fp32 if has_bias else None)'], {'stride': '(SH, SW)', 'padding': '(PH, PW)', 'dilation': '(DH, DW)', 'groups': 'groups', 'conv_mode': 'conv_mode', 'compute_mode': 'compute_mode'}), '(inp_fp32, weight_fp32, bias_fp32 if has_bias else None,\n stride=(SH, SW), padding=(PH, PW), dilation=(DH, DW), groups=groups,\n conv_mode=conv_mode, compute_mode=compute_mode)\n', (10409, 10590), True, 'import megengine.functional as F\n'), ((10792, 10826), 'megengine.core.tensor.dtype.convert_from_qint8', 'dtype.convert_from_qint8', (['expected'], {}), '(expected)\n', (10816, 10826), False, 'from megengine.core.tensor import dtype\n'), ((10855, 11087), 'megengine.module.quantized.conv.ConvTranspose2d', 'ConvTranspose2d', ([], {'in_channels': 'IC', 'out_channels': 'OC', 'kernel_size': '(KH, KW)', 'stride': '(SH, SW)', 'padding': '(PH, PW)', 'dilation': '(DH, DW)', 'groups': 'groups', 'bias': 'has_bias', 'conv_mode': 'conv_mode', 'compute_mode': 'compute_mode', 'dtype': 'out_dtype'}), '(in_channels=IC, out_channels=OC, kernel_size=(KH, KW),\n stride=(SH, SW), padding=(PH, PW), dilation=(DH, DW), groups=groups,\n bias=has_bias, conv_mode=conv_mode, compute_mode=compute_mode, dtype=\n out_dtype)\n', (10870, 11087), False, 'from megengine.module.quantized.conv import ConvTranspose2d\n'), ((11253, 11279), 'megengine.Parameter', 'mge.Parameter', (['weight_int8'], {}), '(weight_int8)\n', (11266, 11279), True, 'import megengine as mge\n'), ((11440, 11472), 'megengine.core.tensor.dtype.convert_from_qint8', 'dtype.convert_from_qint8', (['result'], {}), '(result)\n', (11464, 11472), False, 'from megengine.core.tensor import dtype\n'), ((11481, 11541), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['result', 'expected'], {'atol': 'out_scale'}), '(result, expected, atol=out_scale)\n', (11507, 11541), True, 'import numpy as np\n'), ((1165, 1181), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (1179, 1181), True, 'import numpy as np\n'), ((1429, 1445), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (1443, 1445), True, 'import numpy as np\n'), ((1628, 1644), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (1642, 1644), True, 'import numpy as np\n'), ((1792, 1814), 'megengine.functional.elemwise._elwise', '_elwise', (['x1'], {'mode': 'kind'}), '(x1, mode=kind)\n', (1799, 1814), False, 'from megengine.functional.elemwise import _elemwise_multi_type, _elwise\n'), ((2054, 2080), 'megengine.functional.elemwise._elwise', '_elwise', (['x1', 'x2'], {'mode': 'kind'}), '(x1, x2, mode=kind)\n', (2061, 2080), False, 'from megengine.functional.elemwise import _elemwise_multi_type, _elwise\n'), ((2498, 2514), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2512, 2514), True, 'import numpy as np\n'), ((2545, 2561), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2559, 2561), True, 'import numpy as np\n'), ((2595, 2611), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2609, 2611), True, 'import numpy as np\n'), ((3813, 3898), 'megengine.functional.reshape', 'F.reshape', (['var', '(var.shape[0], var.shape[1] // 4, 4, var.shape[2], var.shape[3])'], {}), '(var, (var.shape[0], var.shape[1] // 4, 4, var.shape[2], var.shape[3])\n )\n', (3822, 3898), True, 'import megengine.functional as F\n'), ((3942, 3975), 'megengine.functional.transpose', 'F.transpose', (['var', '(0, 1, 3, 4, 2)'], {}), '(var, (0, 1, 3, 4, 2))\n', (3953, 3975), True, 'import megengine.functional as F\n'), ((4051, 4127), 'megengine.functional.conv2d', 'F.conv2d', (['inp', 'w', '(b if has_bias else None)'], {'stride': '(SH, SW)', 'padding': '(PH, PW)'}), '(inp, w, b if has_bias else None, stride=(SH, SW), padding=(PH, PW))\n', (4059, 4127), True, 'import megengine.functional as F\n'), ((4582, 4712), 'megengine.functional.quantized.conv_bias_activation', 'F.quantized.conv_bias_activation', (['inp', 'w', 'b'], {'stride': '(SH, SW)', 'padding': '(PH, PW)', 'dtype': 'out_dtype', 'nonlinear_mode': 'nonlinear_mode'}), '(inp, w, b, stride=(SH, SW), padding=(PH,\n PW), dtype=out_dtype, nonlinear_mode=nonlinear_mode)\n', (4614, 4712), True, 'import megengine.functional as F\n'), ((4865, 4888), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (4886, 4888), True, 'import megengine as mge\n'), ((5186, 5222), 'megengine.functional.transpose', 'F.transpose', (['result', '(0, 1, 4, 2, 3)'], {}), '(result, (0, 1, 4, 2, 3))\n', (5197, 5222), True, 'import megengine.functional as F\n'), ((7174, 7250), 'megengine.functional.conv2d', 'F.conv2d', (['inp', 'w', '(b if has_bias else None)'], {'stride': '(SH, SW)', 'padding': '(PH, PW)'}), '(inp, w, b if has_bias else None, stride=(SH, SW), padding=(PH, PW))\n', (7182, 7250), True, 'import megengine.functional as F\n'), ((7532, 7662), 'megengine.functional.quantized.conv_bias_activation', 'F.quantized.conv_bias_activation', (['inp', 'w', 'b'], {'stride': '(SH, SW)', 'padding': '(PH, PW)', 'dtype': 'out_dtype', 'nonlinear_mode': 'nonlinear_mode'}), '(inp, w, b, stride=(SH, SW), padding=(PH,\n PW), dtype=out_dtype, nonlinear_mode=nonlinear_mode)\n', (7564, 7662), True, 'import megengine.functional as F\n'), ((11337, 11362), 'megengine.Parameter', 'mge.Parameter', (['bias_int32'], {}), '(bias_int32)\n', (11350, 11362), True, 'import megengine as mge\n'), ((8582, 8605), 'megengine.device.get_device_count', 'get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (8598, 8605), False, 'from megengine.device import get_cuda_compute_capability, get_device_count\n'), ((8614, 8644), 'megengine.device.get_cuda_compute_capability', 'get_cuda_compute_capability', (['(0)'], {}), '(0)\n', (8641, 8644), False, 'from megengine.device import get_cuda_compute_capability, get_device_count\n'), ((1090, 1119), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (1106, 1119), True, 'import numpy as np\n'), ((1354, 1383), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(3, 3)'}), '(size=(3, 3))\n', (1370, 1383), True, 'import numpy as np\n'), ((4223, 4232), 'megengine.functional.relu', 'F.relu', (['O'], {}), '(O)\n', (4229, 4232), True, 'import megengine.functional as F\n'), ((7346, 7355), 'megengine.functional.relu', 'F.relu', (['O'], {}), '(O)\n', (7352, 7355), True, 'import megengine.functional as F\n'), ((1865, 1935), 'megengine.functional.elemwise._elemwise_multi_type', '_elemwise_multi_type', (['x1_int8'], {'mode': 'quantized_kind', 'dtype': 'output_dtype'}), '(x1_int8, mode=quantized_kind, dtype=output_dtype)\n', (1885, 1935), False, 'from megengine.functional.elemwise import _elemwise_multi_type, _elwise\n'), ((2131, 2210), 'megengine.functional.elemwise._elemwise_multi_type', '_elemwise_multi_type', (['x1_int8', 'x2_int8'], {'mode': 'quantized_kind', 'dtype': 'output_dtype'}), '(x1_int8, x2_int8, mode=quantized_kind, dtype=output_dtype)\n', (2151, 2210), False, 'from megengine.functional.elemwise import _elemwise_multi_type, _elwise\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import functools
from typing import Callable, Optional
import megengine._internal as mgb
from ..core import set_default_device
_master_ip = None
_master_port = 0
_world_size = 0
_rank = 0
_backend = None
def init_process_group(
master_ip: str,
master_port: int,
world_size: int,
rank: int,
dev: int,
backend: Optional[str] = "nccl",
) -> None:
"""Initialize the distributed process group, and also specify the device used in the current process.
:param master_ip: IP address of the master node.
:param master_port: Port available for all processes to communicate.
:param world_size: Total number of processes participating in the job.
:param rank: Rank of the current process.
:param dev: The GPU device id to bind this process to.
:param backend: Communicator backend, currently support 'nccl' and 'ucx'
"""
global _master_ip # pylint: disable=global-statement
global _master_port # pylint: disable=global-statement
global _world_size # pylint: disable=global-statement
global _rank # pylint: disable=global-statement
global _backend # pylint: disable=global-statement
if not isinstance(master_ip, str):
raise TypeError("Expect type str but got {}".format(type(master_ip)))
if not isinstance(master_port, int):
raise TypeError("Expect type int but got {}".format(type(master_port)))
if not isinstance(world_size, int):
raise TypeError("Expect type int but got {}".format(type(world_size)))
if not isinstance(rank, int):
raise TypeError("Expect type int but got {}".format(type(rank)))
if not isinstance(backend, str):
raise TypeError("Expect type str but got {}".format(type(backend)))
_master_ip = master_ip
_master_port = master_port
_world_size = world_size
_rank = rank
_backend = backend
set_default_device(mgb.comp_node("gpu" + str(dev)))
if rank == 0:
_master_port = mgb.config.create_mm_server("0.0.0.0", master_port)
if _master_port == -1:
raise Exception("Failed to start server on port {}".format(master_port))
else:
assert master_port > 0, "master_port must be specified for non-zero rank"
def is_distributed() -> bool:
"""Return True if the distributed process group has been initialized"""
return _world_size is not None and _world_size > 1
def get_master_ip() -> str:
"""Get the IP address of the master node"""
return str(_master_ip)
def get_master_port() -> int:
"""Get the port of the rpc server on the master node"""
return _master_port
def get_world_size() -> int:
"""Get the total number of processes participating in the job"""
return _world_size
def get_rank() -> int:
"""Get the rank of the current process"""
return _rank
def get_backend() -> str:
"""Get the backend str"""
return str(_backend)
def group_barrier() -> None:
"""Block until all ranks in the group reach this barrier"""
mgb.config.group_barrier(_master_ip, _master_port, _world_size, _rank)
def synchronized(func: Callable):
"""Decorator. Decorated function will synchronize when finished.
Specifically, we use this to prevent data race during hub.load"""
@functools.wraps(func)
def _(*args, **kwargs):
if not is_distributed():
return func(*args, **kwargs)
ret = func(*args, **kwargs)
group_barrier()
return ret
return _
|
[
"megengine._internal.config.create_mm_server",
"megengine._internal.config.group_barrier"
] |
[((3376, 3446), 'megengine._internal.config.group_barrier', 'mgb.config.group_barrier', (['_master_ip', '_master_port', '_world_size', '_rank'], {}), '(_master_ip, _master_port, _world_size, _rank)\n', (3400, 3446), True, 'import megengine._internal as mgb\n'), ((3628, 3649), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (3643, 3649), False, 'import functools\n'), ((2339, 2390), 'megengine._internal.config.create_mm_server', 'mgb.config.create_mm_server', (['"""0.0.0.0"""', 'master_port'], {}), "('0.0.0.0', master_port)\n", (2366, 2390), True, 'import megengine._internal as mgb\n')]
|
import functools
import numpy as np
import pytest
import megengine
from megengine.autodiff.grad_manager import GradManager
from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt
from megengine.core.tensor.utils import subgraph_fn
from megengine.device import CompNode, get_default_device
from megengine.jit import trace
_assert_allclose = functools.partial(np.testing.assert_allclose, atol=5e-6, rtol=5e-6)
@functools.lru_cache(maxsize=None)
def _get_batch_norm_fn(dtype, device, channels, ndim, interpret, gopt_level):
@subgraph_fn(
"BatchNormNd",
dtype=dtype,
device=device,
nr_inputs=4,
interpret=interpret,
gopt_level=gopt_level,
)
def batch_norm_nd(inputs, f, c):
input, eps, weight, bias = inputs[0:4]
reduce_shape = c(
(1, channels) + (1,) * (ndim - 2), dtype="int32", device=device
)
input_shape = f(GetVarShape(), input)
input_elems = f(Reduce(mode="product", axis=0), input_shape)
reduce_elems = f(Reduce(mode="product", axis=0), reduce_shape)
reduce_size = f("//", input_elems, reduce_elems)
reduce_size = f(TypeCvt(dtype=dtype), reduce_size)
channel_x1s = f(Reduce(mode="sum"), input, reduce_shape)
channel_x2s = f(Reduce(mode="sum_sqr"), input, reduce_shape)
channel_mean = f("/", channel_x1s, reduce_size)
channel_var = f(
"-", f("/", channel_x2s, reduce_size), f("*", channel_mean, channel_mean),
)
invsqrt_channel_var = f("**", f("+", channel_var, eps), c(-0.5))
inv_var_wt = f("*", invsqrt_channel_var, weight)
neg_channel_mean = f("-", channel_mean)
outvar = f(
"fma3", input, inv_var_wt, f("fma3", neg_channel_mean, inv_var_wt, bias),
)
return (outvar,), (True,)
return batch_norm_nd
@pytest.mark.parametrize("device", [get_default_device(), "cpux"])
@pytest.mark.parametrize("batch_size", [1, 8])
@pytest.mark.parametrize("channels", [3])
@pytest.mark.parametrize(
"use_trace, symbolic", [(False, None), (True, False), (True, True)]
)
@pytest.mark.parametrize("gopt_level", [None, 1, 2])
@pytest.mark.parametrize("dtype", ["float32"])
def test_subgraph(device, batch_size, channels, use_trace, symbolic, gopt_level, dtype):
device = CompNode(device)
def subgraph_batch_norm(inp, weight, bias, eps, diff):
inp = inp.detach()
with GradManager().attach(inp) as gm:
batch_norm_fn = _get_batch_norm_fn(
dtype, device, channels, ndim, interpret=False, gopt_level=gopt_level
)
out, *_ = batch_norm_fn(inp, eps, weight, bias)
gm.backward(out * 1e3 + 1e3, diff)
return out, inp.grad
def primitive_batch_norm(inp, weight, bias, eps, diff):
inp = inp.detach()
with GradManager().attach(inp) as gm:
batch_norm_fn = _get_batch_norm_fn(
dtype, device, channels, ndim, interpret=True, gopt_level=gopt_level
)
(out,) = batch_norm_fn(inp, eps, weight, bias)
gm.backward(out * 1e3 + 1e3, diff)
return out, inp.grad
if use_trace:
subgraph_batch_norm = trace(symbolic=symbolic)(subgraph_batch_norm)
primitive_batch_norm = trace(symbolic=symbolic)(primitive_batch_norm)
def rand_tensor(shape, dtype=dtype, device=device):
return megengine.tensor(np.random.random(shape), dtype=dtype, device=device)
# skip this test because could not do several reduce sequentially with opr cache
return
# test shape change
for image_shape in [(223, 223), (10, 20)]:
ndim = len(image_shape) + 2
input_shape = (batch_size, channels) + image_shape
param_shape = (1, channels) + (1,) * len(image_shape)
inp = rand_tensor(input_shape) * 1e3 + 1e3
weight = rand_tensor(param_shape)
bias = rand_tensor(param_shape)
eps = megengine.tensor(1e-5, dtype=dtype, device=device)
diff = rand_tensor(input_shape)
out1, grad1 = subgraph_batch_norm(inp, weight, bias, eps, diff)
out2, grad2 = primitive_batch_norm(inp, weight, bias, eps, diff)
_assert_allclose(out1.numpy(), out2.numpy())
_assert_allclose(grad1.numpy(), grad2.numpy())
@functools.lru_cache(maxsize=None)
def _get_mul_fn(dtype, device):
@subgraph_fn(
"Mul",
dtype=dtype,
device=device,
nr_inputs=2,
gopt_level=None,
jit_fusion=False,
custom_grad=True,
)
def mul(inputs, f, c):
x, y = inputs[0:2]
z = f("*", x, y)
(dz,) = yield (z,)
dx = f("*", dz, y)
dy = f("*", dz, x)
yield (dx, dy)
return mul
def test_subgraph_jit_backward():
x_np = np.random.rand(3, 4, 5).astype("float32")
x1 = megengine.Tensor(x_np)
x2 = megengine.Tensor(x_np)
mul = _get_mul_fn(x1.dtype, x1.device)
gm = GradManager()
gm.attach([x1, x2])
with gm:
y1 = x1 * x1
y2 = mul(x2, x2)
gm.backward(y1)
with gm:
y1 = x1 * x1
y2 = mul(x2, x2)
gm.backward(y1 + y2)
with gm:
y1 = x1 * x1
y2 = mul(x2, x2)
gm.backward(y2)
|
[
"megengine.core.ops.builtin.GetVarShape",
"megengine.tensor",
"megengine.device.CompNode",
"megengine.Tensor",
"megengine.device.get_default_device",
"megengine.jit.trace",
"megengine.core.tensor.utils.subgraph_fn",
"megengine.autodiff.grad_manager.GradManager",
"megengine.core.ops.builtin.Reduce",
"megengine.core.ops.builtin.TypeCvt"
] |
[((355, 424), 'functools.partial', 'functools.partial', (['np.testing.assert_allclose'], {'atol': '(5e-06)', 'rtol': '(5e-06)'}), '(np.testing.assert_allclose, atol=5e-06, rtol=5e-06)\n', (372, 424), False, 'import functools\n'), ((426, 459), 'functools.lru_cache', 'functools.lru_cache', ([], {'maxsize': 'None'}), '(maxsize=None)\n', (445, 459), False, 'import functools\n'), ((1944, 1989), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""batch_size"""', '[1, 8]'], {}), "('batch_size', [1, 8])\n", (1967, 1989), False, 'import pytest\n'), ((1991, 2031), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""channels"""', '[3]'], {}), "('channels', [3])\n", (2014, 2031), False, 'import pytest\n'), ((2033, 2130), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""use_trace, symbolic"""', '[(False, None), (True, False), (True, True)]'], {}), "('use_trace, symbolic', [(False, None), (True, False\n ), (True, True)])\n", (2056, 2130), False, 'import pytest\n'), ((2133, 2184), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""gopt_level"""', '[None, 1, 2]'], {}), "('gopt_level', [None, 1, 2])\n", (2156, 2184), False, 'import pytest\n'), ((2186, 2231), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', "['float32']"], {}), "('dtype', ['float32'])\n", (2209, 2231), False, 'import pytest\n'), ((4331, 4364), 'functools.lru_cache', 'functools.lru_cache', ([], {'maxsize': 'None'}), '(maxsize=None)\n', (4350, 4364), False, 'import functools\n'), ((543, 658), 'megengine.core.tensor.utils.subgraph_fn', 'subgraph_fn', (['"""BatchNormNd"""'], {'dtype': 'dtype', 'device': 'device', 'nr_inputs': '(4)', 'interpret': 'interpret', 'gopt_level': 'gopt_level'}), "('BatchNormNd', dtype=dtype, device=device, nr_inputs=4,\n interpret=interpret, gopt_level=gopt_level)\n", (554, 658), False, 'from megengine.core.tensor.utils import subgraph_fn\n'), ((2334, 2350), 'megengine.device.CompNode', 'CompNode', (['device'], {}), '(device)\n', (2342, 2350), False, 'from megengine.device import CompNode, get_default_device\n'), ((4402, 4518), 'megengine.core.tensor.utils.subgraph_fn', 'subgraph_fn', (['"""Mul"""'], {'dtype': 'dtype', 'device': 'device', 'nr_inputs': '(2)', 'gopt_level': 'None', 'jit_fusion': '(False)', 'custom_grad': '(True)'}), "('Mul', dtype=dtype, device=device, nr_inputs=2, gopt_level=None,\n jit_fusion=False, custom_grad=True)\n", (4413, 4518), False, 'from megengine.core.tensor.utils import subgraph_fn\n'), ((4875, 4897), 'megengine.Tensor', 'megengine.Tensor', (['x_np'], {}), '(x_np)\n', (4891, 4897), False, 'import megengine\n'), ((4907, 4929), 'megengine.Tensor', 'megengine.Tensor', (['x_np'], {}), '(x_np)\n', (4923, 4929), False, 'import megengine\n'), ((4982, 4995), 'megengine.autodiff.grad_manager.GradManager', 'GradManager', ([], {}), '()\n', (4993, 4995), False, 'from megengine.autodiff.grad_manager import GradManager\n'), ((3981, 4032), 'megengine.tensor', 'megengine.tensor', (['(1e-05)'], {'dtype': 'dtype', 'device': 'device'}), '(1e-05, dtype=dtype, device=device)\n', (3997, 4032), False, 'import megengine\n'), ((1912, 1932), 'megengine.device.get_default_device', 'get_default_device', ([], {}), '()\n', (1930, 1932), False, 'from megengine.device import CompNode, get_default_device\n'), ((930, 943), 'megengine.core.ops.builtin.GetVarShape', 'GetVarShape', ([], {}), '()\n', (941, 943), False, 'from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt\n'), ((976, 1006), 'megengine.core.ops.builtin.Reduce', 'Reduce', ([], {'mode': '"""product"""', 'axis': '(0)'}), "(mode='product', axis=0)\n", (982, 1006), False, 'from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt\n'), ((1046, 1076), 'megengine.core.ops.builtin.Reduce', 'Reduce', ([], {'mode': '"""product"""', 'axis': '(0)'}), "(mode='product', axis=0)\n", (1052, 1076), False, 'from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt\n'), ((1173, 1193), 'megengine.core.ops.builtin.TypeCvt', 'TypeCvt', ([], {'dtype': 'dtype'}), '(dtype=dtype)\n', (1180, 1193), False, 'from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt\n'), ((1232, 1250), 'megengine.core.ops.builtin.Reduce', 'Reduce', ([], {'mode': '"""sum"""'}), "(mode='sum')\n", (1238, 1250), False, 'from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt\n'), ((1297, 1319), 'megengine.core.ops.builtin.Reduce', 'Reduce', ([], {'mode': '"""sum_sqr"""'}), "(mode='sum_sqr')\n", (1303, 1319), False, 'from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt\n'), ((3241, 3265), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (3246, 3265), False, 'from megengine.jit import trace\n'), ((3318, 3342), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (3323, 3342), False, 'from megengine.jit import trace\n'), ((3454, 3477), 'numpy.random.random', 'np.random.random', (['shape'], {}), '(shape)\n', (3470, 3477), True, 'import numpy as np\n'), ((4824, 4847), 'numpy.random.rand', 'np.random.rand', (['(3)', '(4)', '(5)'], {}), '(3, 4, 5)\n', (4838, 4847), True, 'import numpy as np\n'), ((2451, 2464), 'megengine.autodiff.grad_manager.GradManager', 'GradManager', ([], {}), '()\n', (2462, 2464), False, 'from megengine.autodiff.grad_manager import GradManager\n'), ((2873, 2886), 'megengine.autodiff.grad_manager.GradManager', 'GradManager', ([], {}), '()\n', (2884, 2886), False, 'from megengine.autodiff.grad_manager import GradManager\n')]
|
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) Megvii, Inc. and its affiliates.
import random
import megengine as mge
import megengine.distributed as dist
import megengine.functional as F
class DataPrefetcher:
"""
DataPrefetcher is inspired by code of following file:
https://github.com/NVIDIA/apex/blob/master/examples/imagenet/main_amp.py
It could speedup your pytorch dataloader. For more information, please check
https://github.com/NVIDIA/apex/issues/304#issuecomment-493562789.
"""
def __init__(self, loader):
self.loader = iter(loader)
def preload(self):
try:
self.next_input, self.next_target, _, _ = next(self.loader)
except StopIteration:
self.next_input = None
self.next_target = None
return
def next(self):
inputs, target, _, _ = next(self.loader)
return inputs.numpy(), target.numpy()
def random_resize(data_loader, exp, epoch, rank, is_distributed):
tensor = mge.tensor([1])
if rank == 0:
if epoch > exp.max_epoch - 10:
size = exp.input_size
else:
size = random.randint(*exp.random_size)
size = int(32 * size)
tensor *= size
if is_distributed:
tensor = F.distributed.broadcast(tensor)
dist.group_barrier()
input_size = data_loader.change_input_dim(multiple=tensor.item(), random_range=None)
return input_size
|
[
"megengine.functional.distributed.broadcast",
"megengine.tensor",
"megengine.distributed.group_barrier"
] |
[((1025, 1040), 'megengine.tensor', 'mge.tensor', (['[1]'], {}), '([1])\n', (1035, 1040), True, 'import megengine as mge\n'), ((1297, 1328), 'megengine.functional.distributed.broadcast', 'F.distributed.broadcast', (['tensor'], {}), '(tensor)\n', (1320, 1328), True, 'import megengine.functional as F\n'), ((1337, 1357), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (1355, 1357), True, 'import megengine.distributed as dist\n'), ((1166, 1198), 'random.randint', 'random.randint', (['*exp.random_size'], {}), '(*exp.random_size)\n', (1180, 1198), False, 'import random\n')]
|
import megengine as mge
import megengine.functional as F
import numpy as np
from megengine import Tensor
import pdb
def softmax_loss(pred, label, ignore_label=-1):
max_pred = pred.max(axis=1, keepdims=True).detach()
pred -= max_pred
log_prob = pred - F.log(F.exp(pred).sum(axis=1, keepdims=True))
mask = 1 - F.equal(label, ignore_label)
vlabel = label * mask.astype(np.float32)
loss = -(F.nn.indexing_one_hot(log_prob, vlabel.astype(np.int32), 1).flatten() * mask)
loss = loss.sum() / F.maximum(mask.sum(), 1)
return loss
def softmax_loss_opr(pred, label, ignore_label=-1):
max_pred = pred.max(axis=1, keepdims=True).detach()
pred -= max_pred
log_prob = pred - F.log(F.exp(pred).sum(axis=1, keepdims=True))
mask = 1 - F.equal(label, ignore_label)
vlabel = label * mask.astype(np.float32)
loss = -(F.nn.indexing_one_hot(log_prob, vlabel.astype(np.int32), 1).flatten() * mask)
return loss
def _smooth_l1_base(pred, gt, sigma):
sigma2 = sigma ** 2
cond_point = 1 / sigma2
x = pred - gt
abs_x = F.abs(x)
in_mask = abs_x < cond_point
out_mask = 1 - in_mask.astype(np.float32)
in_value = 0.5 * (sigma * x) ** 2
out_value = abs_x - 0.5 / sigma2
value = in_value * in_mask.astype(np.float32) + out_value * out_mask
return value
def _get_mask_of_label(label, background, ignore_label):
mask_fg = 1 - F.equal(label, background).astype(np.float32)
mask_ig = 1 - F.equal(label, ignore_label).astype(np.float32)
mask = mask_fg * mask_ig
return mask, mask_ig
def smooth_l1_loss_rcnn_opr(
pred, gt, label, sigma = 1, background=0, ignore_label=-1):
"""
pred : (minibatch, class_num, 4)
gt : (minibatch, 4)
label : (minibatch, )
"""
broadcast_label = F.broadcast_to(label.reshape(-1, 1), (1, pred.shape[-1]))
broadcast_mask, broadcast_mask_ig = _get_mask_of_label(
broadcast_label, background, ignore_label)
vlabel = broadcast_label * broadcast_mask
pred_corr = F.nn.indexing_one_hot(pred, vlabel.astype(np.int32), 1)
value = _smooth_l1_base(pred_corr, gt, sigma)
loss = (value * broadcast_mask).sum(dim=1)
return loss
def smooth_l1_loss_rpn(pred, gt, label, sigma=1,
background=0, ignore_label=-1, axis=1):
value = _smooth_l1_base(pred, gt, sigma)
mask, mask_ig = _get_mask_of_label(label, background, ignore_label)
loss = (value.sum(axis = axis) * mask).sum() / F.maximum(mask_ig.sum(), 1)
return loss
def smooth_l1_loss_rcnn_opr(
pred, gt, label, sigma = 1, background=0, ignore_label=-1):
"""
pred : (minibatch, class_num, 4)
gt : (minibatch, 4)
label : (minibatch, )
"""
broadcast_label = F.broadcast_to(label.reshape(-1, 1), (label.shape[0], pred.shape[-1]))
broadcast_mask, broadcast_mask_ig = _get_mask_of_label(
broadcast_label, background, ignore_label)
vlabel = broadcast_label * broadcast_mask
pred_corr = F.nn.indexing_one_hot(pred, vlabel.astype(np.int32), 1)
value = _smooth_l1_base(pred_corr, gt, sigma)
loss = (value * broadcast_mask).sum(axis=1)
return loss
def smooth_l1_loss(pred, target, beta: float):
abs_x = F.abs(pred - target)
in_mask = abs_x < beta
out_mask = 1 - in_mask.astype(np.float32)
in_loss = 0.5 * abs_x ** 2 / beta
out_loss = abs_x - 0.5 * beta
loss = in_loss * in_mask.astype(np.float32) + out_loss * out_mask
return loss.sum(axis=1)
def sigmoid_cross_entropy_retina(
pred, label, ignore_label=-1, background=0, alpha=0.5, gamma=0):
device = pred.device
mask = 1 - F.equal(label, ignore_label).astype(np.float32)
vlabel = label * mask
n, m, c = pred.shape
zero_mat = F.zeros([n, m, c + 1]).to(device)
index = F.expand_dims(vlabel, 2).astype(np.int32)
one_hot = F.scatter(zero_mat, 2, index, F.ones([n, m, 1]))
onehot = one_hot[:, :, 1:]
pos_part = F.pow(1 - pred, gamma) * onehot * F.log(pred)
neg_part = F.pow(pred, gamma) * (1 - onehot) * F.log(1 - pred)
loss = -(alpha * pos_part + (1 - alpha) * neg_part).sum(axis=2) * mask
positive_mask = (label > 0)
return loss.sum() / F.maximum(positive_mask.sum(), 1)
def smooth_l1_loss_retina(
pred, gt, label, sigma=3, background=0, ignore_label=-1, axis=2):
value = _smooth_l1_base(pred, gt, sigma)
mask, mask_ig = _get_mask_of_label(label, background, ignore_label)
loss = (value.sum(axis=axis) * mask).sum() / F.maximum(mask.sum(), 1)
return loss
def iou_l1_loss(pred, max_overlaps, gt, ignore_label=-1, background=0):
pred = pred.reshape(pred.shape[0], -1, max_overlaps.shape[2])
abs_x = F.abs(pred - max_overlaps)
mask_bg = 1 - F.equal(gt, background).astype(np.float32)
mask_ig = 1 - F.equal(gt, ignore_label).astype(np.float32)
mask = mask_bg * mask_ig
mask = mask.reshape(mask.shape[0], -1, pred.shape[2])
loss = (abs_x * mask).sum() / F.maximum(mask.sum(), 1)
return loss
def smooth_l1_loss_rcnn(
pred, gt, label, sigma = 1, background=0, ignore_label=-1):
"""
pred : (minibatch, class_num, 4)
gt : (minibatch, 4)
label : (minibatch, )
"""
loss = smooth_l1_loss_rcnn_opr(pred, gt, label, sigma)
loss = loss.sum()/F.maximum((label > 0).sum(), 1)
return loss
|
[
"megengine.functional.exp",
"megengine.functional.pow",
"megengine.functional.equal",
"megengine.functional.zeros",
"megengine.functional.log",
"megengine.functional.ones",
"megengine.functional.expand_dims",
"megengine.functional.abs"
] |
[((1072, 1080), 'megengine.functional.abs', 'F.abs', (['x'], {}), '(x)\n', (1077, 1080), True, 'import megengine.functional as F\n'), ((3251, 3271), 'megengine.functional.abs', 'F.abs', (['(pred - target)'], {}), '(pred - target)\n', (3256, 3271), True, 'import megengine.functional as F\n'), ((4722, 4748), 'megengine.functional.abs', 'F.abs', (['(pred - max_overlaps)'], {}), '(pred - max_overlaps)\n', (4727, 4748), True, 'import megengine.functional as F\n'), ((325, 353), 'megengine.functional.equal', 'F.equal', (['label', 'ignore_label'], {}), '(label, ignore_label)\n', (332, 353), True, 'import megengine.functional as F\n'), ((769, 797), 'megengine.functional.equal', 'F.equal', (['label', 'ignore_label'], {}), '(label, ignore_label)\n', (776, 797), True, 'import megengine.functional as F\n'), ((3916, 3933), 'megengine.functional.ones', 'F.ones', (['[n, m, 1]'], {}), '([n, m, 1])\n', (3922, 3933), True, 'import megengine.functional as F\n'), ((4016, 4027), 'megengine.functional.log', 'F.log', (['pred'], {}), '(pred)\n', (4021, 4027), True, 'import megengine.functional as F\n'), ((4079, 4094), 'megengine.functional.log', 'F.log', (['(1 - pred)'], {}), '(1 - pred)\n', (4084, 4094), True, 'import megengine.functional as F\n'), ((3783, 3805), 'megengine.functional.zeros', 'F.zeros', (['[n, m, c + 1]'], {}), '([n, m, c + 1])\n', (3790, 3805), True, 'import megengine.functional as F\n'), ((3829, 3853), 'megengine.functional.expand_dims', 'F.expand_dims', (['vlabel', '(2)'], {}), '(vlabel, 2)\n', (3842, 3853), True, 'import megengine.functional as F\n'), ((3982, 4004), 'megengine.functional.pow', 'F.pow', (['(1 - pred)', 'gamma'], {}), '(1 - pred, gamma)\n', (3987, 4004), True, 'import megengine.functional as F\n'), ((4043, 4061), 'megengine.functional.pow', 'F.pow', (['pred', 'gamma'], {}), '(pred, gamma)\n', (4048, 4061), True, 'import megengine.functional as F\n'), ((1406, 1432), 'megengine.functional.equal', 'F.equal', (['label', 'background'], {}), '(label, background)\n', (1413, 1432), True, 'import megengine.functional as F\n'), ((1470, 1498), 'megengine.functional.equal', 'F.equal', (['label', 'ignore_label'], {}), '(label, ignore_label)\n', (1477, 1498), True, 'import megengine.functional as F\n'), ((3668, 3696), 'megengine.functional.equal', 'F.equal', (['label', 'ignore_label'], {}), '(label, ignore_label)\n', (3675, 3696), True, 'import megengine.functional as F\n'), ((4767, 4790), 'megengine.functional.equal', 'F.equal', (['gt', 'background'], {}), '(gt, background)\n', (4774, 4790), True, 'import megengine.functional as F\n'), ((4828, 4853), 'megengine.functional.equal', 'F.equal', (['gt', 'ignore_label'], {}), '(gt, ignore_label)\n', (4835, 4853), True, 'import megengine.functional as F\n'), ((270, 281), 'megengine.functional.exp', 'F.exp', (['pred'], {}), '(pred)\n', (275, 281), True, 'import megengine.functional as F\n'), ((714, 725), 'megengine.functional.exp', 'F.exp', (['pred'], {}), '(pred)\n', (719, 725), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import inspect
import io
import itertools
from tempfile import mkstemp
import numpy as np
import pytest
import megengine.core.tensor.megbrain_graph as G
import megengine.functional as F
import megengine.optimizer as optim
import megengine.utils.comp_graph_tools as cgtools
from megengine import Parameter, tensor
from megengine.autodiff import GradManager
from megengine.core._trace_option import set_symbolic_shape
from megengine.core.ops import builtin as ops
from megengine.core.ops.builtin import Elemwise
from megengine.core.tensor.utils import isscalar
from megengine.functional import exp, log
from megengine.jit import exclude_from_trace, trace
from megengine.module import Module
from megengine.random import normal, uniform
from megengine.utils.naming import AutoNaming
@pytest.mark.parametrize("trace_mode", [False, True])
@pytest.mark.parametrize("return_mode", ["Value", "Tuple", "List", "Dict"])
def test_trace(trace_mode, return_mode):
@trace(symbolic=trace_mode)
def f(x):
if return_mode == "Tuple":
return (-x,)
elif return_mode == "List":
return [-x]
elif return_mode == "Dict":
return {"neg": -x}
else:
return -x
def get_numpy(y):
if return_mode == "Tuple" or return_mode == "List":
return y[0].numpy()
elif return_mode == "Dict":
return y["neg"].numpy()
return y.numpy()
x = tensor([1])
y = get_numpy(f(x))
for i in range(3):
np.testing.assert_equal(get_numpy(f(x)), y)
def test_output_copy_trace():
class Simple(Module):
def __init__(self):
super().__init__()
self.a = Parameter([1.0], dtype=np.float32)
def forward(self, x):
x = x * self.a
# will result into a copy of output in grad
x = F.exp(x)
return x
ys = {False: [], True: []}
for symbolic in [False, True]:
net = Simple()
gm = GradManager().attach(net.parameters())
opt = optim.SGD(net.parameters(), 1e-3, momentum=0.9)
data = tensor(np.arange(4).reshape(2, 2), dtype="float32")
@trace(symbolic=symbolic)
def train_func(d):
with gm:
loss = net(d)
gm.backward(loss)
opt.step().clear_grad()
return loss
for i in range(3):
y = train_func(data).numpy()
ys[symbolic].append(y)
for i in range(3):
np.testing.assert_equal(ys[False][i], ys[True][i])
@pytest.mark.parametrize("trace_mode", [False, True])
def test_exclude_from_trace(trace_mode):
@trace(symbolic=trace_mode)
def f(x):
x = -x
with exclude_from_trace():
if i % 2:
x = -x
x = -x
return x
x = tensor([1])
for i in range(3):
y = f(x).numpy()
np.testing.assert_equal(f(x).numpy(), y)
@pytest.mark.parametrize("trace_mode", [False, True])
def test_elemwise_fuse(trace_mode):
# explicitly declare opt_level as 2
@trace(symbolic=trace_mode, opt_level=2)
def f(a, b):
base = 0
c = b - a
_, idx = F.topk(c, 3)
# internally, biased_idx will be idx as gopt will ignore the addition
biased_idx = base + idx
return biased_idx
a = tensor(np.ones((7, 2)), dtype=np.int32)
b = tensor(2 * np.ones((7, 2)), dtype=np.float32)
for i in range(3):
y = f(a, b)
y.numpy()
@pytest.mark.parametrize("trace_mode", [False, True])
def test_elemwise_fuse_in_grad(trace_mode):
w = Parameter(np.ones([4, 6]), dtype="float32")
gm = GradManager().attach(w)
opt = optim.SGD([w], lr=0.01, momentum=0.9, weight_decay=5e-4)
# explicitly declare opt_level as 2
@trace(symbolic=trace_mode, opt_level=2)
def f():
with gm:
wm = F.sum(w ** 2, axis=1) ** 0.5
loss = wm.mean()
gm.backward(loss)
opt.step().clear_grad()
return loss
for i in range(3):
y = f()
y.numpy()
def test_print_in_trace():
for symbolic in [False]: # cannot read value in symbolic mode
@trace(symbolic=symbolic)
def f(x):
nonlocal buf
x = -x
buf = x.numpy()
x = -x
return x
buf = None
x = tensor([1])
for i in range(3):
y = f(x).numpy()
z = buf
buf = None
np.testing.assert_equal(f(x).numpy(), y)
np.testing.assert_equal(z, buf)
def test_dump():
@trace(symbolic=True, capture_as_const=True)
def f(a, b):
return a + b
# prevent from remaining scope from exception test
AutoNaming.clear()
a = tensor([2])
b = tensor([4])
y = f(a, b).numpy()
for i in range(3):
np.testing.assert_equal(f(a, b).numpy(), y)
file = io.BytesIO()
dump_info = f.dump(file)
assert dump_info.nr_opr == 3
np.testing.assert_equal(dump_info.inputs, ["arg_0", "arg_1"])
np.testing.assert_equal(dump_info.outputs, ["ADD"])
file.seek(0)
infer_cg = cgtools.GraphInference(file)
result = list((infer_cg.run(a, b)).values())[0]
np.testing.assert_equal(result[0], y)
def test_capture_dump():
a = tensor([2])
@trace(symbolic=True, capture_as_const=True)
def f(x):
return x * a
x = tensor([3])
y = f(x).numpy()
for i in range(3):
np.testing.assert_equal(f(x).numpy(), y)
file = io.BytesIO()
f.dump(file)
file.seek(0)
infer_cg = cgtools.GraphInference(file)
result = list((infer_cg.run(x)).values())[0]
np.testing.assert_equal(result[0], y)
def test_dump_volatile():
p = tensor([2])
@trace(symbolic=True, capture_as_const=True)
def f(x):
return x * p
x = tensor([3])
y = f(x).numpy()
for i in range(3):
np.testing.assert_equal(f(x).numpy(), y)
file = io.BytesIO()
f.dump(file, optimize_for_inference=False)
file.seek(0)
cg, _, outputs = G.load_graph(file)
(out,) = outputs
assert (
cgtools.get_owner_opr_type(cgtools.get_owner_opr_inputs(out)[1])
== "ImmutableTensor"
)
@pytest.mark.parametrize("trace_mode", [False, True])
def test_trace_profiler(trace_mode):
@trace(symbolic=trace_mode, profiling=True)
def f(x):
return -x
x = tensor([1])
y = f(x).numpy()
f(x)
f(x) # XXX: has to run twice
out = f.get_profile()
assert out.get("profiler")
def test_goptions():
@trace(symbolic=True, opt_level=0, capture_as_const=True)
def f(x):
# directly return x / x will not trigger gopt
# since there's no way to tell the two x are the same
y = 2.0 * x
return y / y
@trace(symbolic=True, opt_level=1, capture_as_const=True)
def g(x):
y = 2.0 * x
return y / y
d = tensor(0.0)
assert not np.isfinite(f(d).numpy())
np.testing.assert_equal(g(d).numpy().item(), 1.0)
def test_goptions_log_sum_exp():
@trace(symbolic=True, opt_level=0, capture_as_const=True)
def f(x, y):
return log(exp(x) + exp(y))
@trace(symbolic=True, opt_level=1, capture_as_const=True)
def g(x, y):
return log(exp(x) + exp(y))
val = 1.0e4
d = tensor(val)
o = tensor(0.0)
assert not np.isfinite(f(d, o).numpy())
np.testing.assert_almost_equal(g(d, o), val)
def test_goptions_log_exp():
@trace(symbolic=True, opt_level=0, capture_as_const=True)
def f(x):
return log(exp(x))
@trace(symbolic=True, opt_level=1, capture_as_const=True)
def g(x):
return log(exp(x))
f(tensor(1.0))
_, out = mkstemp()
f.dump(out, optimize_for_inference=False)
*_, outputs = G.load_graph(out)
oprs_1 = cgtools.get_oprs_seq(outputs)
g(tensor(1.0))
g.dump(out, optimize_for_inference=False)
*_, outputs = G.load_graph(out)
oprs_2 = cgtools.get_oprs_seq(outputs)
assert len(oprs_1) - len(oprs_2) == 2
def test_optimize_for_inference():
@trace(symbolic=True, capture_as_const=True)
def f(x):
return exp(x)
_, out = mkstemp()
f(tensor(5.0))
f.dump(out, enable_io16xc32=True)
res = G.load_graph(out)
computing_input = res.output_vars_list[0].owner.inputs[0]
assert computing_input.dtype == np.float16
def test_optimize_for_inference_broadcast():
a = tensor(np.ones(1, dtype=np.float32))
@trace(capture_as_const=True, symbolic_shape=True)
def f():
return a._broadcast(tensor([1, 10], dtype=np.int32))
f()
f.dump(io.BytesIO())
def test_trace_cvt_bool():
x = tensor([0], dtype=np.int32)
@trace(symbolic=True)
def f(x):
a = x.shape
b = a[0]
assert isscalar(b)
return b == 0
for i in range(3):
np.testing.assert_equal(f(x).numpy(), False)
@pytest.mark.parametrize("trace_mode", [False, True])
def test_trace_reshape(trace_mode):
x1 = tensor(np.random.randn(2, 10, 10))
x2 = tensor(np.random.randn(4, 10, 10))
x3 = tensor(np.random.randn(8, 10, 10))
@trace(symbolic=trace_mode, capture_as_const=True)
def f(x):
y = x.reshape(x.shape[0], 100)
return y
f(x1)
f(x2)
f(x3)
def test_trace_topk():
x = tensor([5, 2, 7, 1, 0, 3, 2])
@trace(symbolic=True)
def f(x):
y = F.topk(x, 3)
np.testing.assert_equal(y[0].shape.numpy(), np.array([3,]))
return y
for i in range(3):
f(x)
def test_trace_warp_perspective():
inp_shape = (1, 1, 4, 4)
x = tensor(np.arange(16, dtype=np.float32).reshape(inp_shape))
M_shape = (1, 3, 3)
M = tensor(
np.array(
[[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]], dtype=np.float32
).reshape(M_shape)
)
@trace(symbolic=True)
def f(x, M):
out = F.vision.warp_perspective(x, M, (2, 2))
np.testing.assert_equal(out.shape.numpy(), np.array([1, 1, 2, 2]))
return out
for i in range(3):
f(x, M)
def test_raise_on_trace():
step_count = 0
catch_count = 0
bad_step = 10
class CatchMe(Exception):
pass
a = tensor([1, 2, 3, 4])
b = tensor([5, 6, 7, 8])
c = tensor([9, 0, 1, 2])
@trace
def add_abc(a, b, c):
ps = a + b
result = ps + c
if step_count == bad_step:
raise CatchMe("catch me")
return result
for i in range(100):
try:
d = add_abc(a, b, c)
except CatchMe as e:
catch_count += 1
else:
np.testing.assert_equal(d.numpy(), (a + b + c).numpy())
step_count += 1
assert catch_count == 1
@pytest.mark.parametrize("trace_mode", [False, True])
def test_trace_broadcast(trace_mode):
x1 = tensor(np.random.randn(3, 1, 1))
x2 = tensor(np.random.randn(1, 4, 1))
x3 = tensor(np.random.randn(1, 1, 5))
@trace(symbolic=trace_mode, capture_as_const=True)
def f(x):
y = F.broadcast_to(x, (3, 4, 5))
return y
f(x1)
f(x2)
f(x3)
def test_trace_nms():
def make_inputs(n):
boxes = np.zeros((n, 4))
boxes[:, :2] = np.random.rand(n, 2) * 100
boxes[:, 2:] = np.random.rand(n, 2) * 100 + 100
scores = np.random.rand(n)
return tensor(boxes), tensor(scores)
@trace(symbolic=False)
def f(boxes, scores):
# with tracing, max_output must be specified
results = F.vision.nms(boxes, scores=scores, iou_thresh=0.5, max_output=20)
# without tracing, max output can be inferred inside nms
with exclude_from_trace():
_ = F.vision.nms(boxes, scores=scores, iou_thresh=0.5)
return results
f(*make_inputs(10))
f(*make_inputs(20))
f(*make_inputs(30))
def test_trace_valid_broadcast():
x1 = tensor(np.random.randn(1, 1))
x2 = tensor(np.random.randn(1, 2))
shape = (tensor([2]), tensor([2]))
@trace(symbolic=False)
def f(x, shape):
y = F.broadcast_to(x, shape)
return y
f(x1, shape)
f(x2, shape)
def test_clip():
x = tensor(np.random.randn(10, 10))
@trace(symbolic=True)
def f(x, lower, upper):
y = F.clip(x, lower, upper)
return y
for i in range(3):
f(x, tensor([0]), tensor([1]))
# test returning noncontiguous tensor from trace
def test_slice():
@trace
def f(x):
return x[:, 1::2]
x = F.arange(8).reshape(2, 4)
f(x)
y = f(x)
np.testing.assert_array_equal(y.numpy(), x.numpy()[:, 1::2])
y + y
@pytest.mark.parametrize("shape_mode", [False, True])
def test_random(shape_mode):
def run_test(op):
@trace(symbolic=True, symbolic_shape=shape_mode)
def f():
out = op(size=[10, 10])
out_shape = out.shape
assert out_shape is not None
if not isinstance(out_shape, tuple):
assert out.shape.numpy() is not None
return out
for _ in range(3):
f()
run_test(uniform)
run_test(normal)
@pytest.mark.parametrize("shape_mode", [False, True])
def test_trace_advance_indexing(shape_mode):
funcs = [
lambda x, i: x[i],
# lambda x, i, j: x[i, j], # FIXME
lambda x, i, j: x[i, :, j, ...],
# lambda x, start, end: x[start:end], # FIXME
lambda x, start, end: x[:, 0, start:end, ..., 1],
lambda x, vec: x[vec],
lambda x, vec: x[vec, ..., 0, 1:3],
lambda x, vec: x[vec, vec[0], vec[1]],
# lambda x, i, start, end, vec: x[i, ..., :, vec, start:end], # FIXME
lambda x, mask: x[mask],
]
inputs = {
"x": np.random.randn(5, 5, 5, 5, 5).astype("float32"),
"i": 0,
"j": 2,
"start": 1,
"end": 3,
"vec": [1, 2, 3],
"mask": np.random.randn(5, 5, 5, 5, 5) >= 0,
}
for f in funcs:
sig = inspect.signature(f)
param_names = list(sig._parameters.keys())
params = {}
params_np = {}
f_traced = trace(f, symbolic=False, symbolic_shape=shape_mode)
for name in param_names:
params[name] = tensor(inputs[name])
params_np[name] = inputs[name]
expected = f(**params_np)
result_imperative = f(**params)
np.testing.assert_equal(expected, result_imperative.numpy())
for _ in range(3):
result_trace = f_traced(**params)
np.testing.assert_equal(expected, result_trace.numpy())
|
[
"megengine.functional.arange",
"megengine.utils.comp_graph_tools.GraphInference",
"megengine.utils.naming.AutoNaming.clear",
"megengine.optimizer.SGD",
"megengine.autodiff.GradManager",
"megengine.jit.trace",
"megengine.functional.clip",
"megengine.functional.sum",
"megengine.core.tensor.utils.isscalar",
"megengine.functional.vision.warp_perspective",
"megengine.utils.comp_graph_tools.get_owner_opr_inputs",
"megengine.functional.vision.nms",
"megengine.tensor",
"megengine.core.tensor.megbrain_graph.load_graph",
"megengine.functional.topk",
"megengine.functional.exp",
"megengine.functional.broadcast_to",
"megengine.jit.exclude_from_trace",
"megengine.Parameter",
"megengine.utils.comp_graph_tools.get_oprs_seq"
] |
[((1162, 1214), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (1185, 1214), False, 'import pytest\n'), ((1216, 1290), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""return_mode"""', "['Value', 'Tuple', 'List', 'Dict']"], {}), "('return_mode', ['Value', 'Tuple', 'List', 'Dict'])\n", (1239, 1290), False, 'import pytest\n'), ((2940, 2992), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (2963, 2992), False, 'import pytest\n'), ((3329, 3381), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (3352, 3381), False, 'import pytest\n'), ((3889, 3941), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (3912, 3941), False, 'import pytest\n'), ((6628, 6680), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (6651, 6680), False, 'import pytest\n'), ((9311, 9363), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (9334, 9363), False, 'import pytest\n'), ((11140, 11192), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""trace_mode"""', '[False, True]'], {}), "('trace_mode', [False, True])\n", (11163, 11192), False, 'import pytest\n'), ((13015, 13067), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape_mode"""', '[False, True]'], {}), "('shape_mode', [False, True])\n", (13038, 13067), False, 'import pytest\n'), ((13520, 13572), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape_mode"""', '[False, True]'], {}), "('shape_mode', [False, True])\n", (13543, 13572), False, 'import pytest\n'), ((1337, 1363), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode'}), '(symbolic=trace_mode)\n', (1342, 1363), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((1822, 1833), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (1828, 1833), False, 'from megengine import Parameter, tensor\n'), ((3039, 3065), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode'}), '(symbolic=trace_mode)\n', (3044, 3065), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((3216, 3227), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (3222, 3227), False, 'from megengine import Parameter, tensor\n'), ((3463, 3502), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode', 'opt_level': '(2)'}), '(symbolic=trace_mode, opt_level=2)\n', (3468, 3502), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((4082, 4140), 'megengine.optimizer.SGD', 'optim.SGD', (['[w]'], {'lr': '(0.01)', 'momentum': '(0.9)', 'weight_decay': '(0.0005)'}), '([w], lr=0.01, momentum=0.9, weight_decay=0.0005)\n', (4091, 4140), True, 'import megengine.optimizer as optim\n'), ((4185, 4224), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode', 'opt_level': '(2)'}), '(symbolic=trace_mode, opt_level=2)\n', (4190, 4224), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((5000, 5043), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (5005, 5043), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((5142, 5160), 'megengine.utils.naming.AutoNaming.clear', 'AutoNaming.clear', ([], {}), '()\n', (5158, 5160), False, 'from megengine.utils.naming import AutoNaming\n'), ((5169, 5180), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (5175, 5180), False, 'from megengine import Parameter, tensor\n'), ((5189, 5200), 'megengine.tensor', 'tensor', (['[4]'], {}), '([4])\n', (5195, 5200), False, 'from megengine import Parameter, tensor\n'), ((5313, 5325), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (5323, 5325), False, 'import io\n'), ((5392, 5453), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['dump_info.inputs', "['arg_0', 'arg_1']"], {}), "(dump_info.inputs, ['arg_0', 'arg_1'])\n", (5415, 5453), True, 'import numpy as np\n'), ((5458, 5509), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['dump_info.outputs', "['ADD']"], {}), "(dump_info.outputs, ['ADD'])\n", (5481, 5509), True, 'import numpy as np\n'), ((5542, 5570), 'megengine.utils.comp_graph_tools.GraphInference', 'cgtools.GraphInference', (['file'], {}), '(file)\n', (5564, 5570), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((5627, 5664), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['result[0]', 'y'], {}), '(result[0], y)\n', (5650, 5664), True, 'import numpy as np\n'), ((5700, 5711), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (5706, 5711), False, 'from megengine import Parameter, tensor\n'), ((5718, 5761), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (5723, 5761), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((5806, 5817), 'megengine.tensor', 'tensor', (['[3]'], {}), '([3])\n', (5812, 5817), False, 'from megengine import Parameter, tensor\n'), ((5924, 5936), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (5934, 5936), False, 'import io\n'), ((5986, 6014), 'megengine.utils.comp_graph_tools.GraphInference', 'cgtools.GraphInference', (['file'], {}), '(file)\n', (6008, 6014), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((6068, 6105), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['result[0]', 'y'], {}), '(result[0], y)\n', (6091, 6105), True, 'import numpy as np\n'), ((6142, 6153), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (6148, 6153), False, 'from megengine import Parameter, tensor\n'), ((6160, 6203), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (6165, 6203), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((6248, 6259), 'megengine.tensor', 'tensor', (['[3]'], {}), '([3])\n', (6254, 6259), False, 'from megengine import Parameter, tensor\n'), ((6366, 6378), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (6376, 6378), False, 'import io\n'), ((6464, 6482), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['file'], {}), '(file)\n', (6476, 6482), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((6723, 6765), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode', 'profiling': '(True)'}), '(symbolic=trace_mode, profiling=True)\n', (6728, 6765), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((6807, 6818), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (6813, 6818), False, 'from megengine import Parameter, tensor\n'), ((6970, 7026), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(0)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=0, capture_as_const=True)\n', (6975, 7026), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((7204, 7260), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(1)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=1, capture_as_const=True)\n', (7209, 7260), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((7325, 7336), 'megengine.tensor', 'tensor', (['(0.0)'], {}), '(0.0)\n', (7331, 7336), False, 'from megengine import Parameter, tensor\n'), ((7472, 7528), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(0)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=0, capture_as_const=True)\n', (7477, 7528), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((7588, 7644), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(1)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=1, capture_as_const=True)\n', (7593, 7644), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((7723, 7734), 'megengine.tensor', 'tensor', (['val'], {}), '(val)\n', (7729, 7734), False, 'from megengine import Parameter, tensor\n'), ((7743, 7754), 'megengine.tensor', 'tensor', (['(0.0)'], {}), '(0.0)\n', (7749, 7754), False, 'from megengine import Parameter, tensor\n'), ((7884, 7940), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(0)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=0, capture_as_const=True)\n', (7889, 7940), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((7988, 8044), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(1)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=1, capture_as_const=True)\n', (7993, 8044), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((8119, 8128), 'tempfile.mkstemp', 'mkstemp', ([], {}), '()\n', (8126, 8128), False, 'from tempfile import mkstemp\n'), ((8193, 8210), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['out'], {}), '(out)\n', (8205, 8210), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((8224, 8253), 'megengine.utils.comp_graph_tools.get_oprs_seq', 'cgtools.get_oprs_seq', (['outputs'], {}), '(outputs)\n', (8244, 8253), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((8338, 8355), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['out'], {}), '(out)\n', (8350, 8355), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((8369, 8398), 'megengine.utils.comp_graph_tools.get_oprs_seq', 'cgtools.get_oprs_seq', (['outputs'], {}), '(outputs)\n', (8389, 8398), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((8484, 8527), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (8489, 8527), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((8578, 8587), 'tempfile.mkstemp', 'mkstemp', ([], {}), '()\n', (8585, 8587), False, 'from tempfile import mkstemp\n'), ((8656, 8673), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['out'], {}), '(out)\n', (8668, 8673), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((8881, 8930), 'megengine.jit.trace', 'trace', ([], {'capture_as_const': '(True)', 'symbolic_shape': '(True)'}), '(capture_as_const=True, symbolic_shape=True)\n', (8886, 8930), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((9076, 9103), 'megengine.tensor', 'tensor', (['[0]'], {'dtype': 'np.int32'}), '([0], dtype=np.int32)\n', (9082, 9103), False, 'from megengine import Parameter, tensor\n'), ((9110, 9130), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (9115, 9130), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((9538, 9587), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode', 'capture_as_const': '(True)'}), '(symbolic=trace_mode, capture_as_const=True)\n', (9543, 9587), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((9722, 9751), 'megengine.tensor', 'tensor', (['[5, 2, 7, 1, 0, 3, 2]'], {}), '([5, 2, 7, 1, 0, 3, 2])\n', (9728, 9751), False, 'from megengine import Parameter, tensor\n'), ((9758, 9778), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (9763, 9778), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((10252, 10272), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (10257, 10272), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((10617, 10637), 'megengine.tensor', 'tensor', (['[1, 2, 3, 4]'], {}), '([1, 2, 3, 4])\n', (10623, 10637), False, 'from megengine import Parameter, tensor\n'), ((10646, 10666), 'megengine.tensor', 'tensor', (['[5, 6, 7, 8]'], {}), '([5, 6, 7, 8])\n', (10652, 10666), False, 'from megengine import Parameter, tensor\n'), ((10675, 10695), 'megengine.tensor', 'tensor', (['[9, 0, 1, 2]'], {}), '([9, 0, 1, 2])\n', (10681, 10695), False, 'from megengine import Parameter, tensor\n'), ((11363, 11412), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'trace_mode', 'capture_as_const': '(True)'}), '(symbolic=trace_mode, capture_as_const=True)\n', (11368, 11412), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((11791, 11812), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(False)'}), '(symbolic=False)\n', (11796, 11812), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((12398, 12419), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(False)'}), '(symbolic=False)\n', (12403, 12419), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((12595, 12615), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (12600, 12615), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((2549, 2573), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (2554, 2573), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((2886, 2936), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['ys[False][i]', 'ys[True][i]'], {}), '(ys[False][i], ys[True][i])\n', (2909, 2936), True, 'import numpy as np\n'), ((3572, 3584), 'megengine.functional.topk', 'F.topk', (['c', '(3)'], {}), '(c, 3)\n', (3578, 3584), True, 'import megengine.functional as F\n'), ((3737, 3752), 'numpy.ones', 'np.ones', (['(7, 2)'], {}), '((7, 2))\n', (3744, 3752), True, 'import numpy as np\n'), ((4004, 4019), 'numpy.ones', 'np.ones', (['[4, 6]'], {}), '([4, 6])\n', (4011, 4019), True, 'import numpy as np\n'), ((4580, 4604), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (4585, 4604), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((4767, 4778), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (4773, 4778), False, 'from megengine import Parameter, tensor\n'), ((8093, 8104), 'megengine.tensor', 'tensor', (['(1.0)'], {}), '(1.0)\n', (8099, 8104), False, 'from megengine import Parameter, tensor\n'), ((8261, 8272), 'megengine.tensor', 'tensor', (['(1.0)'], {}), '(1.0)\n', (8267, 8272), False, 'from megengine import Parameter, tensor\n'), ((8557, 8563), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (8560, 8563), False, 'from megengine.functional import exp, log\n'), ((8594, 8605), 'megengine.tensor', 'tensor', (['(5.0)'], {}), '(5.0)\n', (8600, 8605), False, 'from megengine import Parameter, tensor\n'), ((8845, 8873), 'numpy.ones', 'np.ones', (['(1)'], {'dtype': 'np.float32'}), '(1, dtype=np.float32)\n', (8852, 8873), True, 'import numpy as np\n'), ((9025, 9037), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (9035, 9037), False, 'import io\n'), ((9197, 9208), 'megengine.core.tensor.utils.isscalar', 'isscalar', (['b'], {}), '(b)\n', (9205, 9208), False, 'from megengine.core.tensor.utils import isscalar\n'), ((9416, 9442), 'numpy.random.randn', 'np.random.randn', (['(2)', '(10)', '(10)'], {}), '(2, 10, 10)\n', (9431, 9442), True, 'import numpy as np\n'), ((9460, 9486), 'numpy.random.randn', 'np.random.randn', (['(4)', '(10)', '(10)'], {}), '(4, 10, 10)\n', (9475, 9486), True, 'import numpy as np\n'), ((9504, 9530), 'numpy.random.randn', 'np.random.randn', (['(8)', '(10)', '(10)'], {}), '(8, 10, 10)\n', (9519, 9530), True, 'import numpy as np\n'), ((9805, 9817), 'megengine.functional.topk', 'F.topk', (['x', '(3)'], {}), '(x, 3)\n', (9811, 9817), True, 'import megengine.functional as F\n'), ((10304, 10343), 'megengine.functional.vision.warp_perspective', 'F.vision.warp_perspective', (['x', 'M', '(2, 2)'], {}), '(x, M, (2, 2))\n', (10329, 10343), True, 'import megengine.functional as F\n'), ((11247, 11271), 'numpy.random.randn', 'np.random.randn', (['(3)', '(1)', '(1)'], {}), '(3, 1, 1)\n', (11262, 11271), True, 'import numpy as np\n'), ((11289, 11313), 'numpy.random.randn', 'np.random.randn', (['(1)', '(4)', '(1)'], {}), '(1, 4, 1)\n', (11304, 11313), True, 'import numpy as np\n'), ((11331, 11355), 'numpy.random.randn', 'np.random.randn', (['(1)', '(1)', '(5)'], {}), '(1, 1, 5)\n', (11346, 11355), True, 'import numpy as np\n'), ((11439, 11467), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['x', '(3, 4, 5)'], {}), '(x, (3, 4, 5))\n', (11453, 11467), True, 'import megengine.functional as F\n'), ((11580, 11596), 'numpy.zeros', 'np.zeros', (['(n, 4)'], {}), '((n, 4))\n', (11588, 11596), True, 'import numpy as np\n'), ((11721, 11738), 'numpy.random.rand', 'np.random.rand', (['n'], {}), '(n)\n', (11735, 11738), True, 'import numpy as np\n'), ((11910, 11975), 'megengine.functional.vision.nms', 'F.vision.nms', (['boxes'], {'scores': 'scores', 'iou_thresh': '(0.5)', 'max_output': '(20)'}), '(boxes, scores=scores, iou_thresh=0.5, max_output=20)\n', (11922, 11975), True, 'import megengine.functional as F\n'), ((12291, 12312), 'numpy.random.randn', 'np.random.randn', (['(1)', '(1)'], {}), '(1, 1)\n', (12306, 12312), True, 'import numpy as np\n'), ((12330, 12351), 'numpy.random.randn', 'np.random.randn', (['(1)', '(2)'], {}), '(1, 2)\n', (12345, 12351), True, 'import numpy as np\n'), ((12366, 12377), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (12372, 12377), False, 'from megengine import Parameter, tensor\n'), ((12379, 12390), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (12385, 12390), False, 'from megengine import Parameter, tensor\n'), ((12453, 12477), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['x', 'shape'], {}), '(x, shape)\n', (12467, 12477), True, 'import megengine.functional as F\n'), ((12564, 12587), 'numpy.random.randn', 'np.random.randn', (['(10)', '(10)'], {}), '(10, 10)\n', (12579, 12587), True, 'import numpy as np\n'), ((12656, 12679), 'megengine.functional.clip', 'F.clip', (['x', 'lower', 'upper'], {}), '(x, lower, upper)\n', (12662, 12679), True, 'import megengine.functional as F\n'), ((13128, 13175), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'symbolic_shape': 'shape_mode'}), '(symbolic=True, symbolic_shape=shape_mode)\n', (13133, 13175), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((14365, 14385), 'inspect.signature', 'inspect.signature', (['f'], {}), '(f)\n', (14382, 14385), False, 'import inspect\n'), ((14499, 14550), 'megengine.jit.trace', 'trace', (['f'], {'symbolic': '(False)', 'symbolic_shape': 'shape_mode'}), '(f, symbolic=False, symbolic_shape=shape_mode)\n', (14504, 14550), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((2072, 2106), 'megengine.Parameter', 'Parameter', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (2081, 2106), False, 'from megengine import Parameter, tensor\n'), ((2237, 2245), 'megengine.functional.exp', 'F.exp', (['x'], {}), '(x)\n', (2242, 2245), True, 'import megengine.functional as F\n'), ((3108, 3128), 'megengine.jit.exclude_from_trace', 'exclude_from_trace', ([], {}), '()\n', (3126, 3128), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((3789, 3804), 'numpy.ones', 'np.ones', (['(7, 2)'], {}), '((7, 2))\n', (3796, 3804), True, 'import numpy as np\n'), ((4048, 4061), 'megengine.autodiff.GradManager', 'GradManager', ([], {}), '()\n', (4059, 4061), False, 'from megengine.autodiff import GradManager\n'), ((4944, 4975), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['z', 'buf'], {}), '(z, buf)\n', (4967, 4975), True, 'import numpy as np\n'), ((7974, 7980), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (7977, 7980), False, 'from megengine.functional import exp, log\n'), ((8078, 8084), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (8081, 8084), False, 'from megengine.functional import exp, log\n'), ((8972, 9003), 'megengine.tensor', 'tensor', (['[1, 10]'], {'dtype': 'np.int32'}), '([1, 10], dtype=np.int32)\n', (8978, 9003), False, 'from megengine import Parameter, tensor\n'), ((9870, 9883), 'numpy.array', 'np.array', (['[3]'], {}), '([3])\n', (9878, 9883), True, 'import numpy as np\n'), ((10395, 10417), 'numpy.array', 'np.array', (['[1, 1, 2, 2]'], {}), '([1, 1, 2, 2])\n', (10403, 10417), True, 'import numpy as np\n'), ((11620, 11640), 'numpy.random.rand', 'np.random.rand', (['n', '(2)'], {}), '(n, 2)\n', (11634, 11640), True, 'import numpy as np\n'), ((11755, 11768), 'megengine.tensor', 'tensor', (['boxes'], {}), '(boxes)\n', (11761, 11768), False, 'from megengine import Parameter, tensor\n'), ((11770, 11784), 'megengine.tensor', 'tensor', (['scores'], {}), '(scores)\n', (11776, 11784), False, 'from megengine import Parameter, tensor\n'), ((12054, 12074), 'megengine.jit.exclude_from_trace', 'exclude_from_trace', ([], {}), '()\n', (12072, 12074), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((12092, 12142), 'megengine.functional.vision.nms', 'F.vision.nms', (['boxes'], {'scores': 'scores', 'iou_thresh': '(0.5)'}), '(boxes, scores=scores, iou_thresh=0.5)\n', (12104, 12142), True, 'import megengine.functional as F\n'), ((12734, 12745), 'megengine.tensor', 'tensor', (['[0]'], {}), '([0])\n', (12740, 12745), False, 'from megengine import Parameter, tensor\n'), ((12747, 12758), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (12753, 12758), False, 'from megengine import Parameter, tensor\n'), ((12889, 12900), 'megengine.functional.arange', 'F.arange', (['(8)'], {}), '(8)\n', (12897, 12900), True, 'import megengine.functional as F\n'), ((14288, 14318), 'numpy.random.randn', 'np.random.randn', (['(5)', '(5)', '(5)', '(5)', '(5)'], {}), '(5, 5, 5, 5, 5)\n', (14303, 14318), True, 'import numpy as np\n'), ((14611, 14631), 'megengine.tensor', 'tensor', (['inputs[name]'], {}), '(inputs[name])\n', (14617, 14631), False, 'from megengine import Parameter, tensor\n'), ((2371, 2384), 'megengine.autodiff.GradManager', 'GradManager', ([], {}), '()\n', (2382, 2384), False, 'from megengine.autodiff import GradManager\n'), ((4272, 4293), 'megengine.functional.sum', 'F.sum', (['(w ** 2)'], {'axis': '(1)'}), '(w ** 2, axis=1)\n', (4277, 4293), True, 'import megengine.functional as F\n'), ((6552, 6585), 'megengine.utils.comp_graph_tools.get_owner_opr_inputs', 'cgtools.get_owner_opr_inputs', (['out'], {}), '(out)\n', (6580, 6585), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((7565, 7571), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (7568, 7571), False, 'from megengine.functional import exp, log\n'), ((7574, 7580), 'megengine.functional.exp', 'exp', (['y'], {}), '(y)\n', (7577, 7580), False, 'from megengine.functional import exp, log\n'), ((7681, 7687), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (7684, 7687), False, 'from megengine.functional import exp, log\n'), ((7690, 7696), 'megengine.functional.exp', 'exp', (['y'], {}), '(y)\n', (7693, 7696), False, 'from megengine.functional import exp, log\n'), ((10021, 10052), 'numpy.arange', 'np.arange', (['(16)'], {'dtype': 'np.float32'}), '(16, dtype=np.float32)\n', (10030, 10052), True, 'import numpy as np\n'), ((10121, 10200), 'numpy.array', 'np.array', (['[[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]]'], {'dtype': 'np.float32'}), '([[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]], dtype=np.float32)\n', (10129, 10200), True, 'import numpy as np\n'), ((11670, 11690), 'numpy.random.rand', 'np.random.rand', (['n', '(2)'], {}), '(n, 2)\n', (11684, 11690), True, 'import numpy as np\n'), ((14126, 14156), 'numpy.random.randn', 'np.random.randn', (['(5)', '(5)', '(5)', '(5)', '(5)'], {}), '(5, 5, 5, 5, 5)\n', (14141, 14156), True, 'import numpy as np\n'), ((2494, 2506), 'numpy.arange', 'np.arange', (['(4)'], {}), '(4)\n', (2503, 2506), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import os
import re
import subprocess
import sys
import numpy as np
import megengine as mge
import megengine.functional as F
from megengine import jit, tensor
from megengine.functional.debug_param import set_conv_execution_strategy
from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module
from megengine.optimizer import SGD
from megengine.test import assertTensorClose
def get_gpu_name():
try:
gpu_info = subprocess.check_output(
["nvidia-smi", "--query-gpu=gpu_name", "--format=csv,noheader"]
)
gpu_info = gpu_info.decode("ascii").split("\n")[0]
except:
gpu_info = "None"
return gpu_info
def get_cpu_name():
cpu_info = "None"
try:
cpu_info = subprocess.check_output(["cat", "/proc/cpuinfo"]).decode("ascii")
for line in cpu_info.split("\n"):
if "model name" in line:
return re.sub(".*model name.*:", "", line, 1).strip()
except:
pass
return cpu_info
def get_xpu_name():
if mge.is_cuda_available():
return get_gpu_name()
else:
return get_cpu_name()
class MnistNet(Module):
def __init__(self, has_bn=False):
super().__init__()
self.conv0 = Conv2d(1, 20, kernel_size=5, bias=True)
self.pool0 = AvgPool2d(2)
self.conv1 = Conv2d(20, 20, kernel_size=5, bias=True)
self.pool1 = AvgPool2d(2)
self.fc0 = Linear(20 * 4 * 4, 500, bias=True)
self.fc1 = Linear(500, 10, bias=True)
self.bn0 = None
self.bn1 = None
if has_bn:
self.bn0 = BatchNorm2d(20)
self.bn1 = BatchNorm2d(20)
def forward(self, x):
x = self.conv0(x)
if self.bn0:
x = self.bn0(x)
x = F.relu(x)
x = self.pool0(x)
x = self.conv1(x)
if self.bn1:
x = self.bn1(x)
x = F.relu(x)
x = self.pool1(x)
x = F.flatten(x, 1)
x = self.fc0(x)
x = F.relu(x)
x = self.fc1(x)
return x
def train(data, label, net, opt):
pred = net(data)
loss = F.cross_entropy_with_softmax(pred, label)
opt.backward(loss)
return loss
def update_model(model_path):
"""
Update the dumped model with test cases for new reference values.
The model with pre-trained weights is trained for one iter with the test data attached.
The loss and updated net state dict is dumped.
.. code-block:: python
from test_correctness import update_model
update_model('mnist_model_with_test.mge') # for gpu
update_model('mnist_model_with_test_cpu.mge') # for cpu
"""
net = MnistNet(has_bn=True)
checkpoint = mge.load(model_path)
net.load_state_dict(checkpoint["net_init"])
lr = checkpoint["sgd_lr"]
opt = SGD(net.parameters(), lr=lr)
data = tensor(dtype=np.float32)
label = tensor(dtype=np.int32)
data.set_value(checkpoint["data"])
label.set_value(checkpoint["label"])
opt.zero_grad()
loss = train(data, label, net=net, opt=opt)
opt.step()
xpu_name = get_xpu_name()
checkpoint.update(
{"net_updated": net.state_dict(), "loss": loss.numpy(), "xpu": xpu_name}
)
mge.save(checkpoint, model_path)
def run_test(model_path, use_jit, use_symbolic):
"""
Load the model with test cases and run the training for one iter.
The loss and updated weights are compared with reference value to verify the correctness.
Dump a new file with updated result by calling update_model
if you think the test fails due to numerical rounding errors instead of bugs.
Please think twice before you do so.
"""
net = MnistNet(has_bn=True)
checkpoint = mge.load(model_path)
net.load_state_dict(checkpoint["net_init"])
lr = checkpoint["sgd_lr"]
opt = SGD(net.parameters(), lr=lr)
data = tensor(dtype=np.float32)
label = tensor(dtype=np.int32)
data.set_value(checkpoint["data"])
label.set_value(checkpoint["label"])
max_err = 1e-5
train_func = train
if use_jit:
train_func = jit.trace(train_func, symbolic=use_symbolic)
opt.zero_grad()
loss = train_func(data, label, net=net, opt=opt)
opt.step()
assertTensorClose(loss.numpy(), checkpoint["loss"], max_err=max_err)
for param, param_ref in zip(
net.state_dict().items(), checkpoint["net_updated"].items()
):
assert param[0] == param_ref[0]
assertTensorClose(param[1], param_ref[1], max_err=max_err)
def test_correctness():
if mge.is_cuda_available():
model_name = "mnist_model_with_test.mge"
else:
model_name = "mnist_model_with_test_cpu.mge"
model_path = os.path.join(os.path.dirname(__file__), model_name)
set_conv_execution_strategy("HEURISTIC_REPRODUCIBLE")
run_test(model_path, False, False)
run_test(model_path, True, False)
run_test(model_path, True, True)
|
[
"megengine.test.assertTensorClose",
"megengine.save",
"megengine.tensor",
"megengine.functional.relu",
"megengine.functional.flatten",
"megengine.functional.debug_param.set_conv_execution_strategy",
"megengine.module.Conv2d",
"megengine.module.AvgPool2d",
"megengine.functional.cross_entropy_with_softmax",
"megengine.is_cuda_available",
"megengine.jit.trace",
"megengine.module.Linear",
"megengine.module.BatchNorm2d",
"megengine.load"
] |
[((1407, 1430), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (1428, 1430), True, 'import megengine as mge\n'), ((2486, 2527), 'megengine.functional.cross_entropy_with_softmax', 'F.cross_entropy_with_softmax', (['pred', 'label'], {}), '(pred, label)\n', (2514, 2527), True, 'import megengine.functional as F\n'), ((3082, 3102), 'megengine.load', 'mge.load', (['model_path'], {}), '(model_path)\n', (3090, 3102), True, 'import megengine as mge\n'), ((3232, 3256), 'megengine.tensor', 'tensor', ([], {'dtype': 'np.float32'}), '(dtype=np.float32)\n', (3238, 3256), False, 'from megengine import jit, tensor\n'), ((3269, 3291), 'megengine.tensor', 'tensor', ([], {'dtype': 'np.int32'}), '(dtype=np.int32)\n', (3275, 3291), False, 'from megengine import jit, tensor\n'), ((3602, 3634), 'megengine.save', 'mge.save', (['checkpoint', 'model_path'], {}), '(checkpoint, model_path)\n', (3610, 3634), True, 'import megengine as mge\n'), ((4105, 4125), 'megengine.load', 'mge.load', (['model_path'], {}), '(model_path)\n', (4113, 4125), True, 'import megengine as mge\n'), ((4255, 4279), 'megengine.tensor', 'tensor', ([], {'dtype': 'np.float32'}), '(dtype=np.float32)\n', (4261, 4279), False, 'from megengine import jit, tensor\n'), ((4292, 4314), 'megengine.tensor', 'tensor', ([], {'dtype': 'np.int32'}), '(dtype=np.int32)\n', (4298, 4314), False, 'from megengine import jit, tensor\n'), ((4934, 4957), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (4955, 4957), True, 'import megengine as mge\n'), ((5144, 5197), 'megengine.functional.debug_param.set_conv_execution_strategy', 'set_conv_execution_strategy', (['"""HEURISTIC_REPRODUCIBLE"""'], {}), "('HEURISTIC_REPRODUCIBLE')\n", (5171, 5197), False, 'from megengine.functional.debug_param import set_conv_execution_strategy\n'), ((818, 910), 'subprocess.check_output', 'subprocess.check_output', (["['nvidia-smi', '--query-gpu=gpu_name', '--format=csv,noheader']"], {}), "(['nvidia-smi', '--query-gpu=gpu_name',\n '--format=csv,noheader'])\n", (841, 910), False, 'import subprocess\n'), ((1614, 1653), 'megengine.module.Conv2d', 'Conv2d', (['(1)', '(20)'], {'kernel_size': '(5)', 'bias': '(True)'}), '(1, 20, kernel_size=5, bias=True)\n', (1620, 1653), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((1675, 1687), 'megengine.module.AvgPool2d', 'AvgPool2d', (['(2)'], {}), '(2)\n', (1684, 1687), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((1709, 1749), 'megengine.module.Conv2d', 'Conv2d', (['(20)', '(20)'], {'kernel_size': '(5)', 'bias': '(True)'}), '(20, 20, kernel_size=5, bias=True)\n', (1715, 1749), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((1771, 1783), 'megengine.module.AvgPool2d', 'AvgPool2d', (['(2)'], {}), '(2)\n', (1780, 1783), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((1803, 1837), 'megengine.module.Linear', 'Linear', (['(20 * 4 * 4)', '(500)'], {'bias': '(True)'}), '(20 * 4 * 4, 500, bias=True)\n', (1809, 1837), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((1857, 1883), 'megengine.module.Linear', 'Linear', (['(500)', '(10)'], {'bias': '(True)'}), '(500, 10, bias=True)\n', (1863, 1883), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((2143, 2152), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (2149, 2152), True, 'import megengine.functional as F\n'), ((2266, 2275), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (2272, 2275), True, 'import megengine.functional as F\n'), ((2314, 2329), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (2323, 2329), True, 'import megengine.functional as F\n'), ((2366, 2375), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (2372, 2375), True, 'import megengine.functional as F\n'), ((4476, 4520), 'megengine.jit.trace', 'jit.trace', (['train_func'], {'symbolic': 'use_symbolic'}), '(train_func, symbolic=use_symbolic)\n', (4485, 4520), False, 'from megengine import jit, tensor\n'), ((4841, 4899), 'megengine.test.assertTensorClose', 'assertTensorClose', (['param[1]', 'param_ref[1]'], {'max_err': 'max_err'}), '(param[1], param_ref[1], max_err=max_err)\n', (4858, 4899), False, 'from megengine.test import assertTensorClose\n'), ((5101, 5126), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (5116, 5126), False, 'import os\n'), ((1974, 1989), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['(20)'], {}), '(20)\n', (1985, 1989), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((2013, 2028), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['(20)'], {}), '(20)\n', (2024, 2028), False, 'from megengine.module import AvgPool2d, BatchNorm2d, Conv2d, Linear, Module\n'), ((1118, 1167), 'subprocess.check_output', 'subprocess.check_output', (["['cat', '/proc/cpuinfo']"], {}), "(['cat', '/proc/cpuinfo'])\n", (1141, 1167), False, 'import subprocess\n'), ((1286, 1324), 're.sub', 're.sub', (['""".*model name.*:"""', '""""""', 'line', '(1)'], {}), "('.*model name.*:', '', line, 1)\n", (1292, 1324), False, 'import re\n')]
|
import math
import megengine.module as M
import megengine.functional as F
import megengine as mge
class PositionalEncoding(M.Module):
"""Positional encoding.
:param int d_model: embedding dim
:param float dropout_rate: dropout rate
:param int max_len: maximum input length
"""
def __init__(self, d_model, dropout_rate, max_len=5000):
"""Construct an PositionalEncoding object."""
super(PositionalEncoding, self).__init__()
self.d_model = d_model
self.xscale = math.sqrt(self.d_model)
self.dropout = M.dropout.Dropout(dropout_rate)
self.pe = mge.Tensor(0.0)
self.extend_pe(F.tensor.zeros([1, max_len]))
def extend_pe(self, x):
"""Reset the positional encodings."""
if len(self.pe.shape):
if self.pe.shape[1] >= x.shape[1]:
if self.pe.dtype != x.dtype or self.pe.device != x.device:
self.pe = self.pe.to(dtype=x.dtype, device=x.device)
return
pe = F.tensor.zeros([x.shape[1], self.d_model])
position = mge.Tensor(F.arange(0, x.shape[1], dtype="float32")).reshape(
x.shape[1], -1
)
div_term = F.exp(
mge.Tensor(F.arange(0, self.d_model, 2, dtype="float32"))
* -(math.log(10000.0) / self.d_model)
)
pe[:, 0::2] = F.sin(position * div_term)
pe[:, 1::2] = F.cos(position * div_term)
h, w = pe.shape
pe = pe.reshape(-1, h, w)
self.pe[...] = pe.to(device=x.device)
def forward(self, x: mge.Tensor):
"""Add positional encoding.
Args:
x (megengine.Tensor): Input. Its shape is (batch, time, ...)
Returns:
megengine.Tensor: Encoded tensor. Its shape is (batch, time, ...)
"""
self.extend_pe(x)
x = x * self.xscale + self.pe[:, : x.shape[1]]
return self.dropout(x)
|
[
"megengine.functional.arange",
"megengine.module.dropout.Dropout",
"megengine.functional.cos",
"megengine.Tensor",
"megengine.functional.tensor.zeros",
"megengine.functional.sin"
] |
[((521, 544), 'math.sqrt', 'math.sqrt', (['self.d_model'], {}), '(self.d_model)\n', (530, 544), False, 'import math\n'), ((568, 599), 'megengine.module.dropout.Dropout', 'M.dropout.Dropout', (['dropout_rate'], {}), '(dropout_rate)\n', (585, 599), True, 'import megengine.module as M\n'), ((618, 633), 'megengine.Tensor', 'mge.Tensor', (['(0.0)'], {}), '(0.0)\n', (628, 633), True, 'import megengine as mge\n'), ((1024, 1066), 'megengine.functional.tensor.zeros', 'F.tensor.zeros', (['[x.shape[1], self.d_model]'], {}), '([x.shape[1], self.d_model])\n', (1038, 1066), True, 'import megengine.functional as F\n'), ((1363, 1389), 'megengine.functional.sin', 'F.sin', (['(position * div_term)'], {}), '(position * div_term)\n', (1368, 1389), True, 'import megengine.functional as F\n'), ((1412, 1438), 'megengine.functional.cos', 'F.cos', (['(position * div_term)'], {}), '(position * div_term)\n', (1417, 1438), True, 'import megengine.functional as F\n'), ((657, 685), 'megengine.functional.tensor.zeros', 'F.tensor.zeros', (['[1, max_len]'], {}), '([1, max_len])\n', (671, 685), True, 'import megengine.functional as F\n'), ((1097, 1137), 'megengine.functional.arange', 'F.arange', (['(0)', 'x.shape[1]'], {'dtype': '"""float32"""'}), "(0, x.shape[1], dtype='float32')\n", (1105, 1137), True, 'import megengine.functional as F\n'), ((1234, 1279), 'megengine.functional.arange', 'F.arange', (['(0)', 'self.d_model', '(2)'], {'dtype': '"""float32"""'}), "(0, self.d_model, 2, dtype='float32')\n", (1242, 1279), True, 'import megengine.functional as F\n'), ((1297, 1314), 'math.log', 'math.log', (['(10000.0)'], {}), '(10000.0)\n', (1305, 1314), False, 'import math\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import copy
from typing import Any, Mapping
import megengine as mge
import megengine.functional as F
import megengine.module as M
from .modules import SE, activation, conv2d, gap2d, linear, norm2d
__all__ = ["build_head", "ClsHead", "MBV3Head", "VGGHead"]
def build_head(
w_in: int, head_args: Mapping[str, Any] = None, norm_name: str = "BN", act_name: str = "relu"
) -> M.Module:
"""The factory function to build head.
Note:
if ``head_args`` is ``None`` or ``head_args["name"]`` is ``None``, this function will do
nothing and return ``None``.
Args:
w_in: input width.
head_args: head args. Default: ``None``
norm_name: default normalization function, will be overridden by the same key in
``head_args``. Default: ``"BN"``
act_name: default activation function, will be overridden by the same key in ``head_args``.
Default: ``"relu"``
Returns:
A head.
"""
if head_args is None:
return None
head_args = copy.deepcopy(head_args)
head_name = head_args.pop("name", None)
if head_name is None:
return None
head_args["w_in"] = w_in
head_args.setdefault("norm_name", norm_name)
head_args.setdefault("act_name", act_name)
if callable(head_name):
return head_name(**head_args)
if isinstance(head_name, str):
head_funcs = {
"ClsHead": ClsHead,
"MBV3Head": MBV3Head,
"VGGHead": VGGHead,
}
if head_name in head_funcs:
return head_funcs[head_name](**head_args)
raise ValueError(f"Head '{head_name}' not supported")
class ClsHead(M.Module):
"""Cls head: Conv, BN, Act, AvgPool, FC.
Args:
w_in: input width.
w_out: output width, normally the number of classes. Default: ``1000``
width: width for first conv in head, conv will be omitted if set to 0. Default: ``0``
dropout_prob: dropout probability. Default: ``0.0``
norm_name: normalization function. Default: ``"BN"``
act_name: activation function. Default: ``"relu"``
bias: whether fc has bias. Default: ``True``
"""
def __init__(
self,
w_in: int,
w_out: int = 1000,
width: int = 0,
dropout_prob: float = 0.0,
norm_name: str = "BN",
act_name: str = "relu",
bias: bool = True,
):
super().__init__()
self.width = width
if self.width > 0:
self.conv = conv2d(w_in, self.width, 1)
self.bn = norm2d(norm_name, self.width)
self.act = activation(act_name)
w_in = self.width
self.avg_pool = gap2d()
if dropout_prob > 0.0:
self.dropout = M.Dropout(dropout_prob)
self.fc = linear(w_in, w_out, bias=bias)
def forward(self, x: mge.Tensor) -> mge.Tensor:
if self.width > 0:
x = self.conv(x)
x = self.bn(x)
x = self.act(x)
x = self.avg_pool(x)
x = F.flatten(x, 1)
if getattr(self, "dropout", None) is not None:
x = self.dropout(x)
x = self.fc(x)
return x
class MBV3Head(M.Module):
"""MobileNet V3 head: Conv, BN, Act, AvgPool, SE, FC, Act, FC.
Args:
w_in: input width.
w_out: output width, normally the number of classes.
width: width for first conv in head.
w_h: width for first linear in head.
dropout_prob: dropout probability. Default: ``0.0``
se_r: Squeeze-and-Excitation (SE) ratio. Default: ``0.0``
norm_name: normalization function. Default: ``"BN"``
act_name: activation function. Default: ``"hswish"``
bias: whether fc has bias. Default: ``True``
"""
def __init__(
self,
w_in: int,
w_out: int = 1000,
width: int = 960,
w_h: int = 1280,
dropout_prob: float = 0.0,
se_r: float = 0.0,
norm_name: str = "BN",
act_name: str = "hswish",
bias: bool = True,
):
super().__init__()
self.conv = conv2d(w_in, width, 1)
self.bn = norm2d(norm_name, width)
self.act = activation(act_name)
self.avg_pool = gap2d()
if se_r > 0.0:
self.se = SE(width, int(se_r * width), act_name)
self.h_fc = linear(width, w_h, bias=bias)
self.h_act = activation(act_name)
if dropout_prob > 0.0:
self.dropout = M.Dropout(dropout_prob)
self.fc = linear(w_h, w_out, bias=bias)
def forward(self, x: mge.Tensor) -> mge.Tensor:
x = self.conv(x)
x = self.bn(x)
x = self.act(x)
x = self.avg_pool(x)
if getattr(self, "se", None) is not None:
x = self.se(x)
x = F.flatten(x, 1)
x = self.h_fc(x)
x = self.h_act(x)
if getattr(self, "dropout", None) is not None:
x = self.dropout(x)
x = self.fc(x)
return x
class VGGHead(M.Module):
"""VGG head: AvgPool, [FC, Act, Dropout] x2, FC.
Args:
w_in: input width.
w_out: output width, normally the number of classes. Default: ``1000``
width: width for linear in head. Default: ``4096``
dropout_prob: dropout probability. Default: ``0.5``
act_name: activation function. Default: ``"relu"``
"""
def __init__(
self,
w_in: int,
w_out: int = 1000,
width: int = 4096,
dropout_prob: float = 0.5,
act_name: str = "relu",
**kwargs,
):
super().__init__()
self.avg_pool = gap2d(7)
self.classifier = M.Sequential(
linear(w_in * 7 * 7, width, bias=True),
activation(act_name),
M.Dropout(dropout_prob),
linear(width, width, bias=True),
activation(act_name),
M.Dropout(dropout_prob),
linear(width, w_out, bias=True),
)
def forward(self, x: mge.Tensor) -> mge.Tensor:
x = self.avg_pool(x)
x = F.flatten(x, 1)
x = self.classifier(x)
return x
|
[
"megengine.module.Dropout",
"megengine.functional.flatten"
] |
[((1112, 1136), 'copy.deepcopy', 'copy.deepcopy', (['head_args'], {}), '(head_args)\n', (1125, 1136), False, 'import copy\n'), ((3120, 3135), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (3129, 3135), True, 'import megengine.functional as F\n'), ((4881, 4896), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (4890, 4896), True, 'import megengine.functional as F\n'), ((6144, 6159), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (6153, 6159), True, 'import megengine.functional as F\n'), ((2842, 2865), 'megengine.module.Dropout', 'M.Dropout', (['dropout_prob'], {}), '(dropout_prob)\n', (2851, 2865), True, 'import megengine.module as M\n'), ((4566, 4589), 'megengine.module.Dropout', 'M.Dropout', (['dropout_prob'], {}), '(dropout_prob)\n', (4575, 4589), True, 'import megengine.module as M\n'), ((5854, 5877), 'megengine.module.Dropout', 'M.Dropout', (['dropout_prob'], {}), '(dropout_prob)\n', (5863, 5877), True, 'import megengine.module as M\n'), ((5970, 5993), 'megengine.module.Dropout', 'M.Dropout', (['dropout_prob'], {}), '(dropout_prob)\n', (5979, 5993), True, 'import megengine.module as M\n')]
|
import numpy as np
from megengine import Tensor
import megengine.functional as F
import pdb
class AnchorGenerator():
"""default anchor generator for fpn.
This class generate anchors by feature map in level.
"""
def __init__(self, base_size=16, ratios=[0.5, 1, 2],
base_scale=2):
self.base_size = base_size
self.base_scale = np.array(base_scale)
self.anchor_ratios = ratios
def _whctrs(self, anchor):
"""convert anchor box into (w, h, ctr_x, ctr_y)
"""
w = anchor[:, 2] - anchor[:, 0] + 1
h = anchor[:, 3] - anchor[:, 1] + 1
x_ctr = anchor[:, 0] + 0.5 * (w - 1)
y_ctr = anchor[:, 1] + 0.5 * (h - 1)
return w, h, x_ctr, y_ctr
def get_plane_anchors(self, anchor_scales: np.ndarray):
"""get anchors per location on feature map.
The anchor number is anchor_scales x anchor_ratios
"""
base_anchor = Tensor([0, 0, self.base_size - 1, self.base_size - 1])
base_anchor = base_anchor.reshape(1, -1)
w, h, x_ctr, y_ctr = self._whctrs(base_anchor)
# ratio enumerate
size = w * h
size_ratios = size / self.anchor_ratios
#pdb.set_trace()
ws = F.sqrt(size_ratios)
hs = ws * self.anchor_ratios
# ws = size_ratios.sqrt().round()
# hs = (ws * self.anchor_ratios).round()
# scale enumerate
anchor_scales = anchor_scales.reshape(1, -1).astype(np.float32)
ws = F.expand_dims(ws, 1)
hs = F.expand_dims(hs, 1)
ws = (ws * anchor_scales).reshape(-1, 1)
hs = (hs * anchor_scales).reshape(-1, 1)
# make anchors
anchors = F.concat(
[
x_ctr - 0.5 * (ws - 1),
y_ctr - 0.5 * (hs - 1),
x_ctr + 0.5 * (ws - 1),
y_ctr + 0.5 * (hs - 1),
],
axis=1,
)
return anchors.astype(np.float32)
def get_center_offsets(self, featmap, stride):
# f_shp = featmap.shape
# fm_height, fm_width = f_shp[-2], f_shp[-1]
fm_height, fm_width = featmap.shape[2:]
shift_x = F.linspace(0, fm_width - 1, fm_width) * stride
shift_y = F.linspace(0, fm_height - 1, fm_height) * stride
# make the mesh grid of shift_x and shift_y
mesh_shape = (fm_height, fm_width)
broad_shift_x = F.broadcast_to(shift_x.reshape(1, -1), mesh_shape)
broad_shift_y = F.broadcast_to(shift_y.reshape(-1, 1), mesh_shape)
# broad_shift_x = shift_x.reshape(-1, shift_x.shape[0]).broadcast_to(*mesh_shape)
# broad_shift_y = shift_y.reshape(shift_y.shape[0], -1).broadcast_to(*mesh_shape)
flatten_shift_x = broad_shift_x.flatten()
flatten_shift_y = broad_shift_y.flatten()
shifts = F.stack([flatten_shift_x, flatten_shift_y, flatten_shift_x, flatten_shift_y], axis=1)
# flatten_shift_x = F.add_axis(broad_shift_x.reshape(-1), 1)
# flatten_shift_y = F.add_axis(broad_shift_y.reshape(-1), 1)
# shifts = F.concat(
# [flatten_shift_x, flatten_shift_y, flatten_shift_x, flatten_shift_y,],
# axis=1)
return shifts
def get_anchors_by_feature(self, featmap, stride):
# shifts shape: [A, 4]
shifts = self.get_center_offsets(featmap, stride)
# plane_anchors shape: [B, 4], e.g. B=3
plane_anchors = self.get_plane_anchors(self.base_scale * stride)
# all_anchors = shifts.repeat(1,3) + cell_anchors.flatten()
all_anchors = F.expand_dims(plane_anchors, 0) + F.expand_dims(shifts, 1)
all_anchors = all_anchors.reshape(-1, 4)
return all_anchors
def __call__(self, featmap, stride):
return self.get_anchors_by_feature(featmap, stride)
|
[
"megengine.functional.linspace",
"megengine.Tensor",
"megengine.functional.stack",
"megengine.functional.sqrt",
"megengine.functional.expand_dims",
"megengine.functional.concat"
] |
[((364, 384), 'numpy.array', 'np.array', (['base_scale'], {}), '(base_scale)\n', (372, 384), True, 'import numpy as np\n'), ((939, 993), 'megengine.Tensor', 'Tensor', (['[0, 0, self.base_size - 1, self.base_size - 1]'], {}), '([0, 0, self.base_size - 1, self.base_size - 1])\n', (945, 993), False, 'from megengine import Tensor\n'), ((1231, 1250), 'megengine.functional.sqrt', 'F.sqrt', (['size_ratios'], {}), '(size_ratios)\n', (1237, 1250), True, 'import megengine.functional as F\n'), ((1490, 1510), 'megengine.functional.expand_dims', 'F.expand_dims', (['ws', '(1)'], {}), '(ws, 1)\n', (1503, 1510), True, 'import megengine.functional as F\n'), ((1524, 1544), 'megengine.functional.expand_dims', 'F.expand_dims', (['hs', '(1)'], {}), '(hs, 1)\n', (1537, 1544), True, 'import megengine.functional as F\n'), ((1684, 1802), 'megengine.functional.concat', 'F.concat', (['[x_ctr - 0.5 * (ws - 1), y_ctr - 0.5 * (hs - 1), x_ctr + 0.5 * (ws - 1), \n y_ctr + 0.5 * (hs - 1)]'], {'axis': '(1)'}), '([x_ctr - 0.5 * (ws - 1), y_ctr - 0.5 * (hs - 1), x_ctr + 0.5 * (ws -\n 1), y_ctr + 0.5 * (hs - 1)], axis=1)\n', (1692, 1802), True, 'import megengine.functional as F\n'), ((2826, 2916), 'megengine.functional.stack', 'F.stack', (['[flatten_shift_x, flatten_shift_y, flatten_shift_x, flatten_shift_y]'], {'axis': '(1)'}), '([flatten_shift_x, flatten_shift_y, flatten_shift_x, flatten_shift_y\n ], axis=1)\n', (2833, 2916), True, 'import megengine.functional as F\n'), ((2159, 2196), 'megengine.functional.linspace', 'F.linspace', (['(0)', '(fm_width - 1)', 'fm_width'], {}), '(0, fm_width - 1, fm_width)\n', (2169, 2196), True, 'import megengine.functional as F\n'), ((2224, 2263), 'megengine.functional.linspace', 'F.linspace', (['(0)', '(fm_height - 1)', 'fm_height'], {}), '(0, fm_height - 1, fm_height)\n', (2234, 2263), True, 'import megengine.functional as F\n'), ((3566, 3597), 'megengine.functional.expand_dims', 'F.expand_dims', (['plane_anchors', '(0)'], {}), '(plane_anchors, 0)\n', (3579, 3597), True, 'import megengine.functional as F\n'), ((3600, 3624), 'megengine.functional.expand_dims', 'F.expand_dims', (['shifts', '(1)'], {}), '(shifts, 1)\n', (3613, 3624), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import argparse
import json
import os
from tqdm import tqdm
import megengine as mge
import megengine.distributed as dist
from megengine.data import DataLoader
from official.vision.detection.tools.utils import (
DetEvaluator,
InferenceSampler,
PseudoDetectionDataset,
import_from_file
)
logger = mge.get_logger(__name__)
logger.setLevel("INFO")
def make_parser():
parser = argparse.ArgumentParser()
parser.add_argument(
"-f", "--file", default="net.py", type=str, help="net description file"
)
parser.add_argument(
"-w", "--weight_file", default=None, type=str, help="weights file",
)
parser.add_argument(
"-n", "--devices", default=1, type=int, help="total number of gpus for testing",
)
parser.add_argument(
"-d", "--dataset_dir", default="/data/datasets", type=str,
)
parser.add_argument("-se", "--start_epoch", default=-1, type=int)
parser.add_argument("-ee", "--end_epoch", default=-1, type=int)
return parser
def main():
# pylint: disable=import-outside-toplevel,too-many-branches,too-many-statements
from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval
parser = make_parser()
args = parser.parse_args()
current_network = import_from_file(args.file)
cfg = current_network.Cfg()
if args.weight_file:
args.start_epoch = args.end_epoch = -1
else:
if args.start_epoch == -1:
args.start_epoch = cfg.max_epoch - 1
if args.end_epoch == -1:
args.end_epoch = args.start_epoch
assert 0 <= args.start_epoch <= args.end_epoch < cfg.max_epoch
for epoch_num in range(args.start_epoch, args.end_epoch + 1):
if args.weight_file:
weight_file = args.weight_file
else:
weight_file = "log-of-{}/epoch_{}.pkl".format(
os.path.basename(args.file).split(".")[0], epoch_num
)
if args.devices > 1:
dist_worker = dist.launcher(n_gpus=args.devices)(worker)
result_list = dist_worker(current_network, weight_file, args.dataset_dir)
result_list = sum(result_list, [])
else:
result_list = worker(current_network, weight_file, args.dataset_dir)
all_results = DetEvaluator.format(result_list, cfg)
if args.weight_file:
json_path = "{}_{}.json".format(
os.path.basename(args.file).split(".")[0],
os.path.basename(args.weight_file).split(".")[0],
)
else:
json_path = "log-of-{}/epoch_{}.json".format(
os.path.basename(args.file).split(".")[0], epoch_num
)
all_results = json.dumps(all_results)
with open(json_path, "w") as fo:
fo.write(all_results)
logger.info("Save results to %s, start evaluation!", json_path)
eval_gt = COCO(
os.path.join(
args.dataset_dir, cfg.test_dataset["name"], cfg.test_dataset["ann_file"]
)
)
eval_dt = eval_gt.loadRes(json_path)
cocoEval = COCOeval(eval_gt, eval_dt, iouType="bbox")
cocoEval.evaluate()
cocoEval.accumulate()
cocoEval.summarize()
metrics = [
"AP",
"[email protected]",
"[email protected]",
"APs",
"APm",
"APl",
"AR@1",
"AR@10",
"AR@100",
"ARs",
"ARm",
"ARl",
]
logger.info("mmAP".center(32, "-"))
for i, m in enumerate(metrics):
logger.info("|\t%s\t|\t%.03f\t|", m, cocoEval.stats[i])
logger.info("-" * 32)
def worker(current_network, weight_file, dataset_dir):
cfg = current_network.Cfg()
cfg.backbone_pretrained = False
model = current_network.Net(cfg)
model.eval()
state_dict = mge.load(weight_file)
if "state_dict" in state_dict:
state_dict = state_dict["state_dict"]
model.load_state_dict(state_dict)
evaluator = DetEvaluator(model)
test_loader = build_dataloader(dataset_dir, model.cfg)
if dist.get_rank() == 0:
test_loader = tqdm(test_loader)
result_list = []
for data in test_loader:
image, im_info = DetEvaluator.process_inputs(
data[0][0],
model.cfg.test_image_short_size,
model.cfg.test_image_max_size,
)
pred_res = evaluator.predict(
image=mge.tensor(image),
im_info=mge.tensor(im_info)
)
result = {
"pred_boxes": pred_res,
"image_id": int(data[1][2][0].split(".")[0].split("_")[-1]),
}
result_list.append(result)
return result_list
# pylint: disable=unused-argument
def build_dataloader(dataset_dir, cfg):
val_dataset = PseudoDetectionDataset(length=5000, order=["image", "info"])
val_sampler = InferenceSampler(val_dataset, 1)
val_dataloader = DataLoader(val_dataset, sampler=val_sampler, num_workers=2)
return val_dataloader
if __name__ == "__main__":
main()
|
[
"megengine.get_logger",
"megengine.distributed.get_rank",
"megengine.data.DataLoader",
"megengine.tensor",
"megengine.distributed.launcher",
"megengine.load"
] |
[((691, 715), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (705, 715), True, 'import megengine as mge\n'), ((774, 799), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (797, 799), False, 'import argparse\n'), ((1656, 1683), 'official.vision.detection.tools.utils.import_from_file', 'import_from_file', (['args.file'], {}), '(args.file)\n', (1672, 1683), False, 'from official.vision.detection.tools.utils import DetEvaluator, InferenceSampler, PseudoDetectionDataset, import_from_file\n'), ((4286, 4307), 'megengine.load', 'mge.load', (['weight_file'], {}), '(weight_file)\n', (4294, 4307), True, 'import megengine as mge\n'), ((4444, 4463), 'official.vision.detection.tools.utils.DetEvaluator', 'DetEvaluator', (['model'], {}), '(model)\n', (4456, 4463), False, 'from official.vision.detection.tools.utils import DetEvaluator, InferenceSampler, PseudoDetectionDataset, import_from_file\n'), ((5235, 5295), 'official.vision.detection.tools.utils.PseudoDetectionDataset', 'PseudoDetectionDataset', ([], {'length': '(5000)', 'order': "['image', 'info']"}), "(length=5000, order=['image', 'info'])\n", (5257, 5295), False, 'from official.vision.detection.tools.utils import DetEvaluator, InferenceSampler, PseudoDetectionDataset, import_from_file\n'), ((5314, 5346), 'official.vision.detection.tools.utils.InferenceSampler', 'InferenceSampler', (['val_dataset', '(1)'], {}), '(val_dataset, 1)\n', (5330, 5346), False, 'from official.vision.detection.tools.utils import DetEvaluator, InferenceSampler, PseudoDetectionDataset, import_from_file\n'), ((5368, 5427), 'megengine.data.DataLoader', 'DataLoader', (['val_dataset'], {'sampler': 'val_sampler', 'num_workers': '(2)'}), '(val_dataset, sampler=val_sampler, num_workers=2)\n', (5378, 5427), False, 'from megengine.data import DataLoader\n'), ((2678, 2715), 'official.vision.detection.tools.utils.DetEvaluator.format', 'DetEvaluator.format', (['result_list', 'cfg'], {}), '(result_list, cfg)\n', (2697, 2715), False, 'from official.vision.detection.tools.utils import DetEvaluator, InferenceSampler, PseudoDetectionDataset, import_from_file\n'), ((3106, 3129), 'json.dumps', 'json.dumps', (['all_results'], {}), '(all_results)\n', (3116, 3129), False, 'import json\n'), ((3506, 3548), 'pycocotools.cocoeval.COCOeval', 'COCOeval', (['eval_gt', 'eval_dt'], {'iouType': '"""bbox"""'}), "(eval_gt, eval_dt, iouType='bbox')\n", (3514, 3548), False, 'from pycocotools.cocoeval import COCOeval\n'), ((4531, 4546), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (4544, 4546), True, 'import megengine.distributed as dist\n'), ((4575, 4592), 'tqdm.tqdm', 'tqdm', (['test_loader'], {}), '(test_loader)\n', (4579, 4592), False, 'from tqdm import tqdm\n'), ((4669, 4776), 'official.vision.detection.tools.utils.DetEvaluator.process_inputs', 'DetEvaluator.process_inputs', (['data[0][0]', 'model.cfg.test_image_short_size', 'model.cfg.test_image_max_size'], {}), '(data[0][0], model.cfg.test_image_short_size,\n model.cfg.test_image_max_size)\n', (4696, 4776), False, 'from official.vision.detection.tools.utils import DetEvaluator, InferenceSampler, PseudoDetectionDataset, import_from_file\n'), ((3315, 3406), 'os.path.join', 'os.path.join', (['args.dataset_dir', "cfg.test_dataset['name']", "cfg.test_dataset['ann_file']"], {}), "(args.dataset_dir, cfg.test_dataset['name'], cfg.test_dataset[\n 'ann_file'])\n", (3327, 3406), False, 'import os\n'), ((2384, 2418), 'megengine.distributed.launcher', 'dist.launcher', ([], {'n_gpus': 'args.devices'}), '(n_gpus=args.devices)\n', (2397, 2418), True, 'import megengine.distributed as dist\n'), ((4876, 4893), 'megengine.tensor', 'mge.tensor', (['image'], {}), '(image)\n', (4886, 4893), True, 'import megengine as mge\n'), ((4915, 4934), 'megengine.tensor', 'mge.tensor', (['im_info'], {}), '(im_info)\n', (4925, 4934), True, 'import megengine as mge\n'), ((2261, 2288), 'os.path.basename', 'os.path.basename', (['args.file'], {}), '(args.file)\n', (2277, 2288), False, 'import os\n'), ((2806, 2833), 'os.path.basename', 'os.path.basename', (['args.file'], {}), '(args.file)\n', (2822, 2833), False, 'import os\n'), ((2865, 2899), 'os.path.basename', 'os.path.basename', (['args.weight_file'], {}), '(args.weight_file)\n', (2881, 2899), False, 'import os\n'), ((3017, 3044), 'os.path.basename', 'os.path.basename', (['args.file'], {}), '(args.file)\n', (3033, 3044), False, 'import os\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.module as M
import numpy as np
import pytest
from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d
@pytest.mark.parametrize("w_in", [4])
@pytest.mark.parametrize("w_out", [8])
@pytest.mark.parametrize("k", [3, 5])
@pytest.mark.parametrize("stride", [1, 2])
@pytest.mark.parametrize("dilation", [1, 2])
@pytest.mark.parametrize("groups", [1, 2])
@pytest.mark.parametrize("bias", [True, False])
def test_conv2d(w_in, w_out, k, stride, dilation, groups, bias):
m = conv2d(w_in, w_out, k, stride=stride, dilation=dilation, groups=groups, bias=bias)
assert isinstance(m, M.Conv2d)
m(mge.random.normal(size=(2, 4, 8, 8)))
@pytest.mark.parametrize("drop_prob", [0.0, 0.5])
def test_drop_path(drop_prob):
m = DropPath(drop_prob)
assert isinstance(m, M.Module)
m.training = True
m(mge.random.normal(size=(2, 4, 8, 8)))
m.training = False
x = np.random.rand(2, 4, 8, 8).astype("float32")
y = m(mge.Tensor(x)).numpy()
np.testing.assert_allclose(y, x, rtol=1e-4, atol=1e-6)
@pytest.mark.parametrize("shape", [1, (7, 7)])
def test_gap2d(shape):
m = gap2d(shape)
assert isinstance(m, M.AdaptiveAvgPool2d)
m(mge.random.normal(size=(2, 4, 8, 8)))
@pytest.mark.parametrize("w_in", [4])
@pytest.mark.parametrize("w_out", [8])
@pytest.mark.parametrize("bias", [True, False])
def test_linear(w_in, w_out, bias):
m = linear(w_in, w_out, bias=bias)
assert isinstance(m, M.Linear)
m(mge.random.normal(size=(2, 8, 4)))
# TODO: "GN", "IN" and "LN" need different hyper-parameters
@pytest.mark.parametrize("name", [None, "BN", "SyncBN"])
@pytest.mark.parametrize("w_in", [4])
def test_norm2d(name, w_in):
m = norm2d(name, w_in)
assert isinstance(m, M.Module)
m(mge.random.normal(size=(2, 4, 8, 8)))
@pytest.mark.parametrize("k", [3, 5])
@pytest.mark.parametrize("stride", [1, 2])
@pytest.mark.parametrize("name", ["avg", "max"])
def test_pool2d(k, stride, name):
m = pool2d(k, stride=stride, name=name)
assert isinstance(m, M.Module)
m(mge.random.normal(size=(2, 4, 8, 8)))
@pytest.mark.parametrize("w_in", [8])
@pytest.mark.parametrize("w_se", [4])
@pytest.mark.parametrize("act_name", ["relu", "silu"])
def test_se(w_in, w_se, act_name):
m = SE(w_in, w_se, act_name)
assert isinstance(m, M.Module)
m(mge.random.normal(size=(2, 8, 8, 8)))
|
[
"megengine.random.normal",
"megengine.Tensor"
] |
[((251, 287), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[4]'], {}), "('w_in', [4])\n", (274, 287), False, 'import pytest\n'), ((289, 326), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[8]'], {}), "('w_out', [8])\n", (312, 326), False, 'import pytest\n'), ((328, 364), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""k"""', '[3, 5]'], {}), "('k', [3, 5])\n", (351, 364), False, 'import pytest\n'), ((366, 407), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""stride"""', '[1, 2]'], {}), "('stride', [1, 2])\n", (389, 407), False, 'import pytest\n'), ((409, 452), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dilation"""', '[1, 2]'], {}), "('dilation', [1, 2])\n", (432, 452), False, 'import pytest\n'), ((454, 495), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""groups"""', '[1, 2]'], {}), "('groups', [1, 2])\n", (477, 495), False, 'import pytest\n'), ((497, 543), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""bias"""', '[True, False]'], {}), "('bias', [True, False])\n", (520, 543), False, 'import pytest\n'), ((783, 831), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""drop_prob"""', '[0.0, 0.5]'], {}), "('drop_prob', [0.0, 0.5])\n", (806, 831), False, 'import pytest\n'), ((1165, 1210), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape"""', '[1, (7, 7)]'], {}), "('shape', [1, (7, 7)])\n", (1188, 1210), False, 'import pytest\n'), ((1349, 1385), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[4]'], {}), "('w_in', [4])\n", (1372, 1385), False, 'import pytest\n'), ((1387, 1424), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[8]'], {}), "('w_out', [8])\n", (1410, 1424), False, 'import pytest\n'), ((1426, 1472), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""bias"""', '[True, False]'], {}), "('bias', [True, False])\n", (1449, 1472), False, 'import pytest\n'), ((1688, 1743), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""name"""', "[None, 'BN', 'SyncBN']"], {}), "('name', [None, 'BN', 'SyncBN'])\n", (1711, 1743), False, 'import pytest\n'), ((1745, 1781), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[4]'], {}), "('w_in', [4])\n", (1768, 1781), False, 'import pytest\n'), ((1921, 1957), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""k"""', '[3, 5]'], {}), "('k', [3, 5])\n", (1944, 1957), False, 'import pytest\n'), ((1959, 2000), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""stride"""', '[1, 2]'], {}), "('stride', [1, 2])\n", (1982, 2000), False, 'import pytest\n'), ((2002, 2049), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""name"""', "['avg', 'max']"], {}), "('name', ['avg', 'max'])\n", (2025, 2049), False, 'import pytest\n'), ((2211, 2247), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[8]'], {}), "('w_in', [8])\n", (2234, 2247), False, 'import pytest\n'), ((2249, 2285), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_se"""', '[4]'], {}), "('w_se', [4])\n", (2272, 2285), False, 'import pytest\n'), ((2287, 2340), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""act_name"""', "['relu', 'silu']"], {}), "('act_name', ['relu', 'silu'])\n", (2310, 2340), False, 'import pytest\n'), ((617, 703), 'basecls.layers.conv2d', 'conv2d', (['w_in', 'w_out', 'k'], {'stride': 'stride', 'dilation': 'dilation', 'groups': 'groups', 'bias': 'bias'}), '(w_in, w_out, k, stride=stride, dilation=dilation, groups=groups,\n bias=bias)\n', (623, 703), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((871, 890), 'basecls.layers.DropPath', 'DropPath', (['drop_prob'], {}), '(drop_prob)\n', (879, 890), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((1107, 1164), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['y', 'x'], {'rtol': '(0.0001)', 'atol': '(1e-06)'}), '(y, x, rtol=0.0001, atol=1e-06)\n', (1133, 1164), True, 'import numpy as np\n'), ((1242, 1254), 'basecls.layers.gap2d', 'gap2d', (['shape'], {}), '(shape)\n', (1247, 1254), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((1517, 1547), 'basecls.layers.linear', 'linear', (['w_in', 'w_out'], {'bias': 'bias'}), '(w_in, w_out, bias=bias)\n', (1523, 1547), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((1819, 1837), 'basecls.layers.norm2d', 'norm2d', (['name', 'w_in'], {}), '(name, w_in)\n', (1825, 1837), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((2092, 2127), 'basecls.layers.pool2d', 'pool2d', (['k'], {'stride': 'stride', 'name': 'name'}), '(k, stride=stride, name=name)\n', (2098, 2127), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((2384, 2408), 'basecls.layers.SE', 'SE', (['w_in', 'w_se', 'act_name'], {}), '(w_in, w_se, act_name)\n', (2386, 2408), False, 'from basecls.layers import SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d\n'), ((742, 778), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 4, 8, 8)'}), '(size=(2, 4, 8, 8))\n', (759, 778), True, 'import megengine as mge\n'), ((955, 991), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 4, 8, 8)'}), '(size=(2, 4, 8, 8))\n', (972, 991), True, 'import megengine as mge\n'), ((1308, 1344), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 4, 8, 8)'}), '(size=(2, 4, 8, 8))\n', (1325, 1344), True, 'import megengine as mge\n'), ((1590, 1623), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 8, 4)'}), '(size=(2, 8, 4))\n', (1607, 1623), True, 'import megengine as mge\n'), ((1880, 1916), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 4, 8, 8)'}), '(size=(2, 4, 8, 8))\n', (1897, 1916), True, 'import megengine as mge\n'), ((2170, 2206), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 4, 8, 8)'}), '(size=(2, 4, 8, 8))\n', (2187, 2206), True, 'import megengine as mge\n'), ((2451, 2487), 'megengine.random.normal', 'mge.random.normal', ([], {'size': '(2, 8, 8, 8)'}), '(size=(2, 8, 8, 8))\n', (2468, 2487), True, 'import megengine as mge\n'), ((1025, 1051), 'numpy.random.rand', 'np.random.rand', (['(2)', '(4)', '(8)', '(8)'], {}), '(2, 4, 8, 8)\n', (1039, 1051), True, 'import numpy as np\n'), ((1080, 1093), 'megengine.Tensor', 'mge.Tensor', (['x'], {}), '(x)\n', (1090, 1093), True, 'import megengine as mge\n')]
|
import platform
import numpy as np
import pytest
import megengine as mge
import megengine.distributed as dist
from megengine.distributed.helper import get_device_count_by_fork
from megengine.quantization.observer import (
ExponentialMovingAverageObserver,
MinMaxObserver,
Observer,
PassiveObserver,
SyncExponentialMovingAverageObserver,
SyncMinMaxObserver,
)
def test_observer():
with pytest.raises(TypeError):
Observer("qint8")
def test_min_max_observer():
x = np.random.rand(3, 3, 3, 3).astype("float32")
np_min, np_max = x.min(), x.max()
x = mge.tensor(x)
m = MinMaxObserver()
m(x)
np.testing.assert_allclose(m.min_val.numpy(), np_min)
np.testing.assert_allclose(m.max_val.numpy(), np_max)
def test_exponential_moving_average_observer():
t = np.random.rand()
x1 = np.random.rand(3, 3, 3, 3).astype("float32")
x2 = np.random.rand(3, 3, 3, 3).astype("float32")
expected_min = x1.min() * t + x2.min() * (1 - t)
expected_max = x1.max() * t + x2.max() * (1 - t)
m = ExponentialMovingAverageObserver(momentum=t)
m(mge.tensor(x1, dtype=np.float32))
m(mge.tensor(x2, dtype=np.float32))
np.testing.assert_allclose(m.min_val.numpy(), expected_min)
np.testing.assert_allclose(m.max_val.numpy(), expected_max)
def test_passive_observer():
q_dict = {"scale": mge.tensor(1.0)}
m = PassiveObserver(q_dict, "qint8")
assert m.orig_scale == 1.0
assert m.scale == 1.0
m.scale = 2.0
assert m.scale == 2.0
assert m.get_qparams() == {"scale": mge.tensor(2.0)}
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="windows disable MGB_ENABLE_OPR_MM"
)
@pytest.mark.skipif(get_device_count_by_fork("gpu") < 2, reason="need more gpu device")
@pytest.mark.isolated_distributed
def test_sync_min_max_observer():
word_size = get_device_count_by_fork("gpu")
x = np.random.rand(3 * word_size, 3, 3, 3).astype("float32")
np_min, np_max = x.min(), x.max()
@dist.launcher
def worker():
rank = dist.get_rank()
m = SyncMinMaxObserver()
y = mge.tensor(x[rank * 3 : (rank + 1) * 3])
m(y)
assert m.min_val == np_min and m.max_val == np_max
worker()
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.skipif(
platform.system() == "Windows", reason="windows disable MGB_ENABLE_OPR_MM"
)
@pytest.mark.skipif(get_device_count_by_fork("gpu") < 2, reason="need more gpu device")
@pytest.mark.isolated_distributed
def test_sync_exponential_moving_average_observer():
word_size = get_device_count_by_fork("gpu")
t = np.random.rand()
x1 = np.random.rand(3 * word_size, 3, 3, 3).astype("float32")
x2 = np.random.rand(3 * word_size, 3, 3, 3).astype("float32")
expected_min = x1.min() * t + x2.min() * (1 - t)
expected_max = x1.max() * t + x2.max() * (1 - t)
@dist.launcher
def worker():
rank = dist.get_rank()
m = SyncExponentialMovingAverageObserver(momentum=t)
y1 = mge.tensor(x1[rank * 3 : (rank + 1) * 3])
y2 = mge.tensor(x2[rank * 3 : (rank + 1) * 3])
m(y1)
m(y2)
np.testing.assert_allclose(m.min_val.numpy(), expected_min, atol=1e-6)
np.testing.assert_allclose(m.max_val.numpy(), expected_max, atol=1e-6)
worker()
|
[
"megengine.quantization.observer.Observer",
"megengine.tensor",
"megengine.distributed.get_rank",
"megengine.quantization.observer.SyncMinMaxObserver",
"megengine.distributed.helper.get_device_count_by_fork",
"megengine.quantization.observer.PassiveObserver",
"megengine.quantization.observer.ExponentialMovingAverageObserver",
"megengine.quantization.observer.SyncExponentialMovingAverageObserver",
"megengine.quantization.observer.MinMaxObserver"
] |
[((599, 612), 'megengine.tensor', 'mge.tensor', (['x'], {}), '(x)\n', (609, 612), True, 'import megengine as mge\n'), ((621, 637), 'megengine.quantization.observer.MinMaxObserver', 'MinMaxObserver', ([], {}), '()\n', (635, 637), False, 'from megengine.quantization.observer import ExponentialMovingAverageObserver, MinMaxObserver, Observer, PassiveObserver, SyncExponentialMovingAverageObserver, SyncMinMaxObserver\n'), ((821, 837), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (835, 837), True, 'import numpy as np\n'), ((1060, 1104), 'megengine.quantization.observer.ExponentialMovingAverageObserver', 'ExponentialMovingAverageObserver', ([], {'momentum': 't'}), '(momentum=t)\n', (1092, 1104), False, 'from megengine.quantization.observer import ExponentialMovingAverageObserver, MinMaxObserver, Observer, PassiveObserver, SyncExponentialMovingAverageObserver, SyncMinMaxObserver\n'), ((1392, 1424), 'megengine.quantization.observer.PassiveObserver', 'PassiveObserver', (['q_dict', '"""qint8"""'], {}), "(q_dict, 'qint8')\n", (1407, 1424), False, 'from megengine.quantization.observer import ExponentialMovingAverageObserver, MinMaxObserver, Observer, PassiveObserver, SyncExponentialMovingAverageObserver, SyncMinMaxObserver\n'), ((1959, 1990), 'megengine.distributed.helper.get_device_count_by_fork', 'get_device_count_by_fork', (['"""gpu"""'], {}), "('gpu')\n", (1983, 1990), False, 'from megengine.distributed.helper import get_device_count_by_fork\n'), ((2730, 2761), 'megengine.distributed.helper.get_device_count_by_fork', 'get_device_count_by_fork', (['"""gpu"""'], {}), "('gpu')\n", (2754, 2761), False, 'from megengine.distributed.helper import get_device_count_by_fork\n'), ((2770, 2786), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2784, 2786), True, 'import numpy as np\n'), ((417, 441), 'pytest.raises', 'pytest.raises', (['TypeError'], {}), '(TypeError)\n', (430, 441), False, 'import pytest\n'), ((451, 468), 'megengine.quantization.observer.Observer', 'Observer', (['"""qint8"""'], {}), "('qint8')\n", (459, 468), False, 'from megengine.quantization.observer import ExponentialMovingAverageObserver, MinMaxObserver, Observer, PassiveObserver, SyncExponentialMovingAverageObserver, SyncMinMaxObserver\n'), ((1111, 1143), 'megengine.tensor', 'mge.tensor', (['x1'], {'dtype': 'np.float32'}), '(x1, dtype=np.float32)\n', (1121, 1143), True, 'import megengine as mge\n'), ((1151, 1183), 'megengine.tensor', 'mge.tensor', (['x2'], {'dtype': 'np.float32'}), '(x2, dtype=np.float32)\n', (1161, 1183), True, 'import megengine as mge\n'), ((1367, 1382), 'megengine.tensor', 'mge.tensor', (['(1.0)'], {}), '(1.0)\n', (1377, 1382), True, 'import megengine as mge\n'), ((2147, 2162), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2160, 2162), True, 'import megengine.distributed as dist\n'), ((2175, 2195), 'megengine.quantization.observer.SyncMinMaxObserver', 'SyncMinMaxObserver', ([], {}), '()\n', (2193, 2195), False, 'from megengine.quantization.observer import ExponentialMovingAverageObserver, MinMaxObserver, Observer, PassiveObserver, SyncExponentialMovingAverageObserver, SyncMinMaxObserver\n'), ((2208, 2246), 'megengine.tensor', 'mge.tensor', (['x[rank * 3:(rank + 1) * 3]'], {}), '(x[rank * 3:(rank + 1) * 3])\n', (2218, 2246), True, 'import megengine as mge\n'), ((1610, 1627), 'platform.system', 'platform.system', ([], {}), '()\n', (1625, 1627), False, 'import platform\n'), ((1710, 1727), 'platform.system', 'platform.system', ([], {}), '()\n', (1725, 1727), False, 'import platform\n'), ((1807, 1838), 'megengine.distributed.helper.get_device_count_by_fork', 'get_device_count_by_fork', (['"""gpu"""'], {}), "('gpu')\n", (1831, 1838), False, 'from megengine.distributed.helper import get_device_count_by_fork\n'), ((3078, 3093), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (3091, 3093), True, 'import megengine.distributed as dist\n'), ((3106, 3154), 'megengine.quantization.observer.SyncExponentialMovingAverageObserver', 'SyncExponentialMovingAverageObserver', ([], {'momentum': 't'}), '(momentum=t)\n', (3142, 3154), False, 'from megengine.quantization.observer import ExponentialMovingAverageObserver, MinMaxObserver, Observer, PassiveObserver, SyncExponentialMovingAverageObserver, SyncMinMaxObserver\n'), ((3168, 3207), 'megengine.tensor', 'mge.tensor', (['x1[rank * 3:(rank + 1) * 3]'], {}), '(x1[rank * 3:(rank + 1) * 3])\n', (3178, 3207), True, 'import megengine as mge\n'), ((3223, 3262), 'megengine.tensor', 'mge.tensor', (['x2[rank * 3:(rank + 1) * 3]'], {}), '(x2[rank * 3:(rank + 1) * 3])\n', (3233, 3262), True, 'import megengine as mge\n'), ((2362, 2379), 'platform.system', 'platform.system', ([], {}), '()\n', (2377, 2379), False, 'import platform\n'), ((2462, 2479), 'platform.system', 'platform.system', ([], {}), '()\n', (2477, 2479), False, 'import platform\n'), ((2559, 2590), 'megengine.distributed.helper.get_device_count_by_fork', 'get_device_count_by_fork', (['"""gpu"""'], {}), "('gpu')\n", (2583, 2590), False, 'from megengine.distributed.helper import get_device_count_by_fork\n'), ((508, 534), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)', '(3)', '(3)'], {}), '(3, 3, 3, 3)\n', (522, 534), True, 'import numpy as np\n'), ((847, 873), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)', '(3)', '(3)'], {}), '(3, 3, 3, 3)\n', (861, 873), True, 'import numpy as np\n'), ((901, 927), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)', '(3)', '(3)'], {}), '(3, 3, 3, 3)\n', (915, 927), True, 'import numpy as np\n'), ((1566, 1581), 'megengine.tensor', 'mge.tensor', (['(2.0)'], {}), '(2.0)\n', (1576, 1581), True, 'import megengine as mge\n'), ((1999, 2037), 'numpy.random.rand', 'np.random.rand', (['(3 * word_size)', '(3)', '(3)', '(3)'], {}), '(3 * word_size, 3, 3, 3)\n', (2013, 2037), True, 'import numpy as np\n'), ((2796, 2834), 'numpy.random.rand', 'np.random.rand', (['(3 * word_size)', '(3)', '(3)', '(3)'], {}), '(3 * word_size, 3, 3, 3)\n', (2810, 2834), True, 'import numpy as np\n'), ((2862, 2900), 'numpy.random.rand', 'np.random.rand', (['(3 * word_size)', '(3)', '(3)', '(3)'], {}), '(3 * word_size, 3, 3, 3)\n', (2876, 2900), True, 'import numpy as np\n')]
|
import random
from megengine.data.transform import RandomResizedCrop as mge_RRC
from megengine.data.transform import Resize as mge_resize
from ..registry import PIPELINES
from edit.utils import interp_codes
@PIPELINES.register_module()
class Resize(object):
"""
Args:
size (int|list|tuple): Desired output size. If size is a sequence like
(h, w), output size will be matched to this. If size is an int,
smaller edge of the image will be matched to this number.
i.e, if height > width, then image will be rescaled to
(size * height / width, size)
interpolation (int): Interpolation mode of resize. Default: cv2.INTER_LINEAR.
"""
def __init__(self, keys, size, interpolation='bilinear'):
assert interpolation in interp_codes
self.keys = keys
self.size = size
self.interpolation_str = interpolation
self.resize = mge_resize(output_size=self.size, interpolation=interp_codes[interpolation])
def __call__(self, results):
"""Call function.
Args:
results (dict): A dict containing the necessary information and data for augmentation.
Returns:
dict: A dict containing the processed data and information.
"""
for key in self.keys:
if isinstance(results[key], list):
results[key] = [
self.resize.apply(v) for v in results[key]
]
else:
results[key] = self.resize.apply(results[key])
return results
def __repr__(self):
interpolate_str = self.interpolation_str
format_string = self.__class__.__name__ + '(size={0}'.format(self.size)
format_string += ', interpolation={0})'.format(interpolate_str)
return format_string
@PIPELINES.register_module()
class RandomResizedCrop(object):
"""
Crop the input data to random size and aspect ratio.
A crop of random size (default: of 0.08 to 1.0) of the original size and a random
aspect ratio (default: of 3/4 to 1.33) of the original aspect ratio is made.
After applying crop transfrom, the input data will be resized to given size.
Args:
output_size (int|list|tuple): Target size of output image, with (height, width) shape.
scale (list|tuple): Range of size of the origin size cropped. Default: (0.08, 1.0)
ratio (list|tuple): Range of aspect ratio of the origin aspect ratio cropped. Default: (0.75, 1.33)
interpolation:
'nearest': cv2.INTER_NEAREST,
'bilinear': cv2.INTER_LINEAR,
'bicubic': cv2.INTER_CUBIC,
'area': cv2.INTER_AREA,
'lanczos': cv2.INTER_LANCZOS4
"""
def __init__(self, keys, output_size, scale=(0.08, 1.0), ratio=(3. / 4., 4. / 3.), interpolation='bilinear', do_prob = 0.5):
assert interpolation in interp_codes
self.keys = keys
self.size = output_size
self.interpolation_str = interpolation
self.scale = scale
self.ratio = ratio
self.rrc = mge_RRC(output_size=output_size, scale_range=scale, ratio_range=ratio, interpolation=interp_codes[interpolation])
self.do_prob = do_prob
def __call__(self, results):
"""Call function.
Args:
results (dict): A dict containing the necessary information and data for augmentation.
Returns:
dict: A dict containing the processed data and information.
"""
if random.random() < self.do_prob:
for key in self.keys:
if isinstance(results[key], list):
results[key] = [
self.rrc.apply(v) for v in results[key]
]
else:
results[key] = self.rrc.apply(results[key])
return results
else:
return results
def __repr__(self):
interpolate_str = self.interpolation_str
format_string = self.__class__.__name__ + '(size={0}'.format(self.size)
format_string += ', scale={0}'.format(tuple(round(s, 4) for s in self.scale))
format_string += ', ratio={0}'.format(tuple(round(r, 4) for r in self.ratio))
format_string += ', interpolation={0})'.format(interpolate_str)
return format_string
|
[
"megengine.data.transform.Resize",
"megengine.data.transform.RandomResizedCrop"
] |
[((935, 1011), 'megengine.data.transform.Resize', 'mge_resize', ([], {'output_size': 'self.size', 'interpolation': 'interp_codes[interpolation]'}), '(output_size=self.size, interpolation=interp_codes[interpolation])\n', (945, 1011), True, 'from megengine.data.transform import Resize as mge_resize\n'), ((3160, 3277), 'megengine.data.transform.RandomResizedCrop', 'mge_RRC', ([], {'output_size': 'output_size', 'scale_range': 'scale', 'ratio_range': 'ratio', 'interpolation': 'interp_codes[interpolation]'}), '(output_size=output_size, scale_range=scale, ratio_range=ratio,\n interpolation=interp_codes[interpolation])\n', (3167, 3277), True, 'from megengine.data.transform import RandomResizedCrop as mge_RRC\n'), ((3592, 3607), 'random.random', 'random.random', ([], {}), '()\n', (3605, 3607), False, 'import random\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import bisect
import datetime
import math
import os
import pickle
import time
from typing import Optional
import megengine as mge
import megengine.distributed as dist
import megengine.module as M
from basecore.config import ConfigDict
from basecore.engine import BaseHook, BaseTrainer
from basecore.utils import (
Checkpoint,
MeterBuffer,
cached_property,
ensure_dir,
get_last_call_deltatime,
)
from loguru import logger
from tensorboardX import SummaryWriter
from basecls.layers import compute_precise_bn_stats
from basecls.models import sync_model
from basecls.utils import default_logging, registers
from .tester import ClsTester
__all__ = [
"CheckpointHook",
"EvalHook",
"LoggerHook",
"LRSchedulerHook",
"PreciseBNHook",
"ResumeHook",
"TensorboardHook",
]
def _create_checkpoint(trainer: BaseTrainer, save_dir: str) -> Checkpoint:
"""Create a checkpoint for save and resume"""
model = trainer.model
ema = trainer.ema
ckpt_kws = {"ema": ema} if ema is not None else {}
optim = trainer.solver.optimizer
scaler = trainer.solver.grad_scaler
progress = trainer.progress
ckpt = Checkpoint(
save_dir,
model,
tag_file=None,
optimizer=optim,
scaler=scaler,
progress=progress,
**ckpt_kws,
)
return ckpt
class CheckpointHook(BaseHook):
"""Hook for managing checkpoints during training.
Effect during ``after_epoch`` and ``after_train`` procedure.
Args:
save_dir: checkpoint directory.
save_every_n_epoch: interval for saving checkpoint. Default: ``1``
"""
def __init__(self, save_dir: str = None, save_every_n_epoch: int = 1):
super().__init__()
ensure_dir(save_dir)
self.save_dir = save_dir
self.save_every_n_epoch = save_every_n_epoch
def after_epoch(self):
progress = self.trainer.progress
ckpt = _create_checkpoint(self.trainer, self.save_dir)
ckpt.save("latest.pkl")
if progress.epoch % self.save_every_n_epoch == 0:
progress_str = progress.progress_str_list()
save_name = "_".join(progress_str[:-1]) + ".pkl"
ckpt.save(save_name)
logger.info(f"Save checkpoint {save_name} to {self.save_dir}")
def after_train(self):
# NOTE: usually final ema is not the best so we dont save it
mge.save(
{"state_dict": self.trainer.model.state_dict()},
os.path.join(self.save_dir, "dumped_model.pkl"),
pickle_protocol=pickle.DEFAULT_PROTOCOL,
)
class EvalHook(BaseHook):
"""Hook for evaluating during training.
Effect during ``after_epoch`` and ``after_train`` procedure.
Args:
save_dir: checkpoint directory.
eval_every_n_epoch: interval for evaluating. Default: ``1``
"""
def __init__(self, save_dir: str = None, eval_every_n_epoch: int = 1):
super().__init__()
ensure_dir(save_dir)
self.save_dir = save_dir
self.eval_every_n_epoch = eval_every_n_epoch
self.best_acc1 = 0
self.best_ema_acc1 = 0
def after_epoch(self):
trainer = self.trainer
cfg = trainer.cfg
model = trainer.model
ema = trainer.ema
progress = trainer.progress
if progress.epoch % self.eval_every_n_epoch == 0 and progress.epoch != progress.max_epoch:
self.test(cfg, model, ema)
def after_train(self):
trainer = self.trainer
cfg = trainer.cfg
model = trainer.model
ema = trainer.ema
# TODO: actually useless maybe when precise_bn is on
sync_model(model)
if ema is not None:
sync_model(ema)
self.test(cfg, model, ema)
def test(self, cfg: ConfigDict, model: M.Module, ema: Optional[M.Module] = None):
dataloader = registers.dataloaders.get(cfg.data.name).build(cfg, False)
# FIXME: need atomic user_pop, maybe in MegEngine 1.5?
# tester = BaseTester(model, dataloader, AccEvaluator())
tester = ClsTester(cfg, model, dataloader)
acc1, _ = tester.test()
if acc1 > self.best_acc1:
self.best_acc1 = acc1
if dist.get_rank() == 0:
mge.save(
{"state_dict": model.state_dict(), "acc1": self.best_acc1},
os.path.join(self.save_dir, "best_model.pkl"),
pickle_protocol=pickle.DEFAULT_PROTOCOL,
)
logger.info(
f"Epoch: {self.trainer.progress.epoch}, Test Acc@1: {acc1:.3f}, "
f"Best Test Acc@1: {self.best_acc1:.3f}"
)
if ema is None:
return
tester_ema = ClsTester(cfg, ema, dataloader)
ema_acc1, _ = tester_ema.test()
if ema_acc1 > self.best_ema_acc1:
self.best_ema_acc1 = ema_acc1
if dist.get_rank() == 0:
mge.save(
{"state_dict": ema.state_dict(), "acc1": self.best_ema_acc1},
os.path.join(self.save_dir, "best_ema_model.pkl"),
pickle_protocol=pickle.DEFAULT_PROTOCOL,
)
logger.info(
f"Epoch: {self.trainer.progress.epoch}, EMA Acc@1: {ema_acc1:.3f}, "
f"Best EMA Acc@1: {self.best_ema_acc1:.3f}"
)
class LoggerHook(BaseHook):
"""Hook for logging during training.
Effect during ``before_train``, ``after_train``, ``before_iter`` and ``after_iter`` procedure.
Args:
log_every_n_iter: interval for logging. Default: ``20``
"""
def __init__(self, log_every_n_iter: int = 20):
super().__init__()
self.log_every_n_iter = log_every_n_iter
self.meter = MeterBuffer(self.log_every_n_iter)
def before_train(self):
trainer = self.trainer
progress = trainer.progress
default_logging(trainer.cfg, trainer.model)
logger.info(f"Starting training from epoch {progress.epoch}, iteration {progress.iter}")
self.start_training_time = time.perf_counter()
def after_train(self):
total_training_time = time.perf_counter() - self.start_training_time
total_time_str = str(datetime.timedelta(seconds=total_training_time))
logger.info(
"Total training time: {} ({:.4f} s / iter)".format(
total_time_str, self.meter["iters_time"].global_avg
)
)
def before_iter(self):
self.iter_start_time = time.perf_counter()
def after_iter(self):
single_iter_time = time.perf_counter() - self.iter_start_time
delta_time = get_last_call_deltatime()
if delta_time is None:
delta_time = single_iter_time
self.meter.update(
{
"iters_time": single_iter_time, # to get global average iter time
"eta_iter_time": delta_time, # to get ETA time
"extra_time": delta_time - single_iter_time, # to get extra time
}
)
trainer = self.trainer
progress = trainer.progress
epoch_id, iter_id = progress.epoch, progress.iter
max_epoch, max_iter = progress.max_epoch, progress.max_iter
if iter_id % self.log_every_n_iter == 0 or (iter_id == 1 and epoch_id == 1):
log_str_list = []
# step info string
log_str_list.append(str(progress))
# loss string
log_str_list.append(self.get_loss_str(trainer.meter))
# stat string
log_str_list.append(self.get_stat_str(trainer.meter))
# other training info like learning rate.
log_str_list.append(self.get_train_info_str())
# memory useage.
log_str_list.append(self.get_memory_str(trainer.meter))
# time string
left_iters = max_iter - iter_id + (max_epoch - epoch_id) * max_iter
time_str = self.get_time_str(left_iters)
log_str_list.append(time_str)
# filter empty strings
log_str_list = [s for s in log_str_list if len(s) > 0]
log_str = ", ".join(log_str_list)
logger.info(log_str)
# reset meters in trainer
trainer.meter.reset()
def get_loss_str(self, meter):
"""Get loss information during trainging process."""
loss_dict = meter.get_filtered_meter(filter_key="loss")
loss_str = ", ".join(
[f"{name}:{value.latest:.3f}({value.avg:.3f})" for name, value in loss_dict.items()]
)
return loss_str
def get_stat_str(self, meter):
"""Get stat information during trainging process."""
stat_dict = meter.get_filtered_meter(filter_key="stat")
stat_str = ", ".join(
[f"{name}:{value.latest:.3f}({value.avg:.3f})" for name, value in stat_dict.items()]
)
return stat_str
def get_memory_str(self, meter):
"""Get memory information during trainging process."""
def mem_in_Mb(mem_value):
return math.ceil(mem_value / 1024 / 1024)
mem_dict = meter.get_filtered_meter(filter_key="memory")
mem_str = ", ".join(
[
f"{name}:{mem_in_Mb(value.latest)}({mem_in_Mb(value.avg)})Mb"
for name, value in mem_dict.items()
]
)
return mem_str
def get_train_info_str(self):
"""Get training process related information such as learning rate."""
# extra info to display, such as learning rate
trainer = self.trainer
lr = trainer.solver.optimizer.param_groups[0]["lr"]
lr_str = f"lr:{lr:.3e}"
loss_scale = trainer.solver.grad_scaler.scale_factor
loss_scale_str = f", amp_loss_scale:{loss_scale:.1f}" if trainer.cfg.amp.enabled else ""
return lr_str + loss_scale_str
def get_time_str(self, left_iters: int) -> str:
"""Get time related information sucn as data_time, train_time, ETA and so on."""
# time string
trainer = self.trainer
time_dict = trainer.meter.get_filtered_meter(filter_key="time")
train_time_str = ", ".join(
[f"{name}:{value.avg:.3f}s" for name, value in time_dict.items()]
)
train_time_str += ", extra_time:{:.3f}s, ".format(self.meter["extra_time"].avg)
eta_seconds = self.meter["eta_iter_time"].global_avg * left_iters
eta_string = "ETA:{}".format(datetime.timedelta(seconds=int(eta_seconds)))
time_str = train_time_str + eta_string
return time_str
class LRSchedulerHook(BaseHook):
"""Hook for learning rate scheduling during training.
Effect during ``before_epoch`` procedure.
"""
def before_epoch(self):
trainer = self.trainer
epoch_id = trainer.progress.epoch
cfg = trainer.cfg.solver
lr_factor = self.get_lr_factor(cfg, epoch_id)
if epoch_id <= cfg.warmup_epochs:
alpha = (epoch_id - 1) / cfg.warmup_epochs
lr_factor *= cfg.warmup_factor * (1 - alpha) + alpha
scaled_lr = self.total_lr * lr_factor
for param_group in trainer.solver.optimizer.param_groups:
param_group["lr"] = scaled_lr
def get_lr_factor(self, cfg: ConfigDict, epoch_id: int) -> float:
"""Calculate learning rate factor.
It supports ``"step"``, ``"linear"``, ``"cosine"``, ``"exp"``, and ``"rel_exp"`` schedule.
Args:
cfg: config for training.
epoch_id: current epoch.
Returns:
Learning rate factor.
"""
if cfg.lr_schedule == "step":
return cfg.lr_decay_factor ** bisect.bisect_left(cfg.lr_decay_steps, epoch_id)
elif cfg.lr_schedule == "linear":
alpha = 1 - (epoch_id - 1) / cfg.max_epoch
return (1 - cfg.lr_min_factor) * alpha + cfg.lr_min_factor
elif cfg.lr_schedule == "cosine":
alpha = 0.5 * (1 + math.cos(math.pi * (epoch_id - 1) / cfg.max_epoch))
return (1 - cfg.lr_min_factor) * alpha + cfg.lr_min_factor
elif cfg.lr_schedule == "exp":
return cfg.lr_decay_factor ** (epoch_id - 1)
elif cfg.lr_schedule == "rel_exp":
if cfg.lr_min_factor <= 0:
raise ValueError(
"Exponential lr schedule requires lr_min_factor to be greater than 0"
)
return cfg.lr_min_factor ** ((epoch_id - 1) / cfg.max_epoch)
else:
raise NotImplementedError(f"Learning rate schedule '{cfg.lr_schedule}' not supported")
@cached_property
def total_lr(self) -> float:
"""Total learning rate."""
cfg = self.trainer.cfg.solver
total_lr = cfg.basic_lr * dist.get_world_size() # linear scaling rule
return total_lr
class PreciseBNHook(BaseHook):
"""Hook for precising BN during training.
Effect during ``after_epoch`` procedure.
Args:
precise_every_n_epoch: interval for precising BN. Default: ``1``
"""
def __init__(self, precise_every_n_epoch: int = 1):
super().__init__()
self.precise_every_n_epoch = precise_every_n_epoch
def before_train(self):
if self.precise_every_n_epoch == -1:
self.precise_every_n_epoch = self.trainer.progress.max_epoch
def after_epoch(self):
trainer = self.trainer
if (
trainer.progress.epoch % self.precise_every_n_epoch == 0
and trainer.cfg.bn.num_samples_precise > 0
):
logger.info(f"Apply Precising BN at epoch{trainer.progress.epoch}")
compute_precise_bn_stats(trainer.cfg, trainer.model, trainer.dataloader)
if trainer.ema is not None:
logger.info(f"Apply Precising BN for EMA at epoch{trainer.progress.epoch}")
compute_precise_bn_stats(trainer.cfg, trainer.ema, trainer.dataloader)
class ResumeHook(BaseHook):
"""Hook for resuming training process.
Effect during ``before_train`` procedure.
Args:
save_dir: checkpoint directory.
resume: enable resume or not. Default: ``False``
"""
def __init__(self, save_dir: int = None, resume: bool = False):
super().__init__()
ensure_dir(save_dir)
self.save_dir = save_dir
self.resume = resume
def before_train(self):
trainer = self.trainer
if self.resume:
progress = trainer.progress
ckpt = _create_checkpoint(self.trainer, self.save_dir)
filename = ckpt.get_checkpoint_file("latest.pkl")
logger.info(f"Load checkpoint from {filename}")
ckpt.resume(filename)
# since ckpt is dumped after every epoch,
# resume training requires epoch + 1 and set iter to 1
progress.epoch += 1
progress.iter = 1
class TensorboardHook(BaseHook):
"""Hook for tensorboard during training.
Effect during ``before_train``, ``after_train`` and ``after_iter`` procedure.
Args:
log_dir: tensorboard directory.
log_every_n_iter: interval for logging. Default: ``20``
scalar_type: statistic to record, supports ``"latest"``, ``"avg"``, ``"global_avg"`` and
``"median"``. Default: ``"latest"``
"""
def __init__(self, log_dir: str, log_every_n_iter: int = 20, scalar_type: str = "latest"):
super().__init__()
if scalar_type not in ("latest", "avg", "global_avg", "median"):
raise ValueError(f"Tensorboard scalar type '{scalar_type}' not supported")
ensure_dir(log_dir)
self.log_dir = log_dir
self.log_every_n_iter = log_every_n_iter
self.scalar_type = scalar_type
def before_train(self):
self.writer = SummaryWriter(self.log_dir)
def after_train(self):
self.writer.close()
def after_iter(self):
trainer = self.trainer
epoch_id, iter_id = trainer.progress.epoch, trainer.progress.iter
if iter_id % self.log_every_n_iter == 0 or (iter_id == 1 and epoch_id == 1):
self.write(context=trainer)
def write(self, context):
cur_iter = self.calc_iter(context.progress)
for key, meter in context.meter.items():
value = getattr(meter, self.scalar_type, meter.latest)
for prefix in ("loss", "stat", "time", "memory"):
if prefix in key:
key = f"{prefix}/{key}"
break
self.writer.add_scalar(key, value, cur_iter)
# write lr into tensorboard
lr = context.solver.optimizer.param_groups[0]["lr"]
self.writer.add_scalar("lr", lr, cur_iter)
# write loss_scale into tensorboard
if context.cfg.amp.enabled:
loss_scale = context.solver.grad_scaler.scale_factor
self.writer.add_scalar("amp_loss_scale", loss_scale, cur_iter)
@classmethod
def calc_iter(cls, progress):
return (progress.epoch - 1) * progress.max_iter + progress.iter - 1
|
[
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size"
] |
[((1244, 1353), 'basecore.utils.Checkpoint', 'Checkpoint', (['save_dir', 'model'], {'tag_file': 'None', 'optimizer': 'optim', 'scaler': 'scaler', 'progress': 'progress'}), '(save_dir, model, tag_file=None, optimizer=optim, scaler=scaler,\n progress=progress, **ckpt_kws)\n', (1254, 1353), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((1828, 1848), 'basecore.utils.ensure_dir', 'ensure_dir', (['save_dir'], {}), '(save_dir)\n', (1838, 1848), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((3059, 3079), 'basecore.utils.ensure_dir', 'ensure_dir', (['save_dir'], {}), '(save_dir)\n', (3069, 3079), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((3749, 3766), 'basecls.models.sync_model', 'sync_model', (['model'], {}), '(model)\n', (3759, 3766), False, 'from basecls.models import sync_model\n'), ((4603, 4728), 'loguru.logger.info', 'logger.info', (['f"""Epoch: {self.trainer.progress.epoch}, Test Acc@1: {acc1:.3f}, Best Test Acc@1: {self.best_acc1:.3f}"""'], {}), "(\n f'Epoch: {self.trainer.progress.epoch}, Test Acc@1: {acc1:.3f}, Best Test Acc@1: {self.best_acc1:.3f}'\n )\n", (4614, 4728), False, 'from loguru import logger\n'), ((5284, 5415), 'loguru.logger.info', 'logger.info', (['f"""Epoch: {self.trainer.progress.epoch}, EMA Acc@1: {ema_acc1:.3f}, Best EMA Acc@1: {self.best_ema_acc1:.3f}"""'], {}), "(\n f'Epoch: {self.trainer.progress.epoch}, EMA Acc@1: {ema_acc1:.3f}, Best EMA Acc@1: {self.best_ema_acc1:.3f}'\n )\n", (5295, 5415), False, 'from loguru import logger\n'), ((5848, 5882), 'basecore.utils.MeterBuffer', 'MeterBuffer', (['self.log_every_n_iter'], {}), '(self.log_every_n_iter)\n', (5859, 5882), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((5988, 6031), 'basecls.utils.default_logging', 'default_logging', (['trainer.cfg', 'trainer.model'], {}), '(trainer.cfg, trainer.model)\n', (6003, 6031), False, 'from basecls.utils import default_logging, registers\n'), ((6041, 6139), 'loguru.logger.info', 'logger.info', (['f"""Starting training from epoch {progress.epoch}, iteration {progress.iter}"""'], {}), "(\n f'Starting training from epoch {progress.epoch}, iteration {progress.iter}'\n )\n", (6052, 6139), False, 'from loguru import logger\n'), ((6166, 6185), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (6183, 6185), False, 'import time\n'), ((6605, 6624), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (6622, 6624), False, 'import time\n'), ((6744, 6769), 'basecore.utils.get_last_call_deltatime', 'get_last_call_deltatime', ([], {}), '()\n', (6767, 6769), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((14390, 14410), 'basecore.utils.ensure_dir', 'ensure_dir', (['save_dir'], {}), '(save_dir)\n', (14400, 14410), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((15725, 15744), 'basecore.utils.ensure_dir', 'ensure_dir', (['log_dir'], {}), '(log_dir)\n', (15735, 15744), False, 'from basecore.utils import Checkpoint, MeterBuffer, cached_property, ensure_dir, get_last_call_deltatime\n'), ((15915, 15942), 'tensorboardX.SummaryWriter', 'SummaryWriter', (['self.log_dir'], {}), '(self.log_dir)\n', (15928, 15942), False, 'from tensorboardX import SummaryWriter\n'), ((2320, 2382), 'loguru.logger.info', 'logger.info', (['f"""Save checkpoint {save_name} to {self.save_dir}"""'], {}), "(f'Save checkpoint {save_name} to {self.save_dir}')\n", (2331, 2382), False, 'from loguru import logger\n'), ((2571, 2618), 'os.path.join', 'os.path.join', (['self.save_dir', '"""dumped_model.pkl"""'], {}), "(self.save_dir, 'dumped_model.pkl')\n", (2583, 2618), False, 'import os\n'), ((3807, 3822), 'basecls.models.sync_model', 'sync_model', (['ema'], {}), '(ema)\n', (3817, 3822), False, 'from basecls.models import sync_model\n'), ((6244, 6263), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (6261, 6263), False, 'import time\n'), ((6320, 6367), 'datetime.timedelta', 'datetime.timedelta', ([], {'seconds': 'total_training_time'}), '(seconds=total_training_time)\n', (6338, 6367), False, 'import datetime\n'), ((6679, 6698), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (6696, 6698), False, 'import time\n'), ((8288, 8308), 'loguru.logger.info', 'logger.info', (['log_str'], {}), '(log_str)\n', (8299, 8308), False, 'from loguru import logger\n'), ((9181, 9215), 'math.ceil', 'math.ceil', (['(mem_value / 1024 / 1024)'], {}), '(mem_value / 1024 / 1024)\n', (9190, 9215), False, 'import math\n'), ((12883, 12904), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (12902, 12904), True, 'import megengine.distributed as dist\n'), ((13678, 13745), 'loguru.logger.info', 'logger.info', (['f"""Apply Precising BN at epoch{trainer.progress.epoch}"""'], {}), "(f'Apply Precising BN at epoch{trainer.progress.epoch}')\n", (13689, 13745), False, 'from loguru import logger\n'), ((13758, 13830), 'basecls.layers.compute_precise_bn_stats', 'compute_precise_bn_stats', (['trainer.cfg', 'trainer.model', 'trainer.dataloader'], {}), '(trainer.cfg, trainer.model, trainer.dataloader)\n', (13782, 13830), False, 'from basecls.layers import compute_precise_bn_stats\n'), ((14738, 14785), 'loguru.logger.info', 'logger.info', (['f"""Load checkpoint from {filename}"""'], {}), "(f'Load checkpoint from {filename}')\n", (14749, 14785), False, 'from loguru import logger\n'), ((3966, 4006), 'basecls.utils.registers.dataloaders.get', 'registers.dataloaders.get', (['cfg.data.name'], {}), '(cfg.data.name)\n', (3991, 4006), False, 'from basecls.utils import default_logging, registers\n'), ((4320, 4335), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (4333, 4335), True, 'import megengine.distributed as dist\n'), ((4995, 5010), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (5008, 5010), True, 'import megengine.distributed as dist\n'), ((11802, 11850), 'bisect.bisect_left', 'bisect.bisect_left', (['cfg.lr_decay_steps', 'epoch_id'], {}), '(cfg.lr_decay_steps, epoch_id)\n', (11820, 11850), False, 'import bisect\n'), ((13887, 13962), 'loguru.logger.info', 'logger.info', (['f"""Apply Precising BN for EMA at epoch{trainer.progress.epoch}"""'], {}), "(f'Apply Precising BN for EMA at epoch{trainer.progress.epoch}')\n", (13898, 13962), False, 'from loguru import logger\n'), ((13979, 14049), 'basecls.layers.compute_precise_bn_stats', 'compute_precise_bn_stats', (['trainer.cfg', 'trainer.ema', 'trainer.dataloader'], {}), '(trainer.cfg, trainer.ema, trainer.dataloader)\n', (14003, 14049), False, 'from basecls.layers import compute_precise_bn_stats\n'), ((4468, 4513), 'os.path.join', 'os.path.join', (['self.save_dir', '"""best_model.pkl"""'], {}), "(self.save_dir, 'best_model.pkl')\n", (4480, 4513), False, 'import os\n'), ((5145, 5194), 'os.path.join', 'os.path.join', (['self.save_dir', '"""best_ema_model.pkl"""'], {}), "(self.save_dir, 'best_ema_model.pkl')\n", (5157, 5194), False, 'import os\n'), ((12092, 12142), 'math.cos', 'math.cos', (['(math.pi * (epoch_id - 1) / cfg.max_epoch)'], {}), '(math.pi * (epoch_id - 1) / cfg.max_epoch)\n', (12100, 12142), False, 'import math\n')]
|
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
import math
from config import config
from backbone.resnet50 import ResNet50
from module.generate_anchors import generate_anchors
from det_opr.bbox_opr import bbox_transform_inv_opr, box_overlap_opr
from det_opr.utils import get_padded_tensor
from rpn_anchor_target_opr import rpn_anchor_target_opr
from det_opr.loss_opr import sigmoid_cross_entropy_retina, smooth_l1_loss_retina, iou_l1_loss
import pdb
class RetinaNetAnchorV2(M.Module):
def __init__(self):
super().__init__()
def generate_anchors_opr(self, fm_3x3, fm_stride,
anchor_scales=(8, 16, 32, 64, 128),
anchor_ratios=(1, 2, 3), base_size = 4):
np_anchors = generate_anchors(
base_size=base_size,
ratios=np.array(anchor_ratios),
scales=np.array(anchor_scales))
device = fm_3x3.device
anchors = mge.tensor(np_anchors).to(device)
height, width = fm_3x3.shape[2], fm_3x3.shape[3]
shift_x = F.linspace(0, width-1, width).to(device) * fm_stride
shift_y = F.linspace(0, height -1, height).to(device) * fm_stride
broad_shift_x = F.broadcast_to(shift_x.reshape(1, -1), (height, width)).flatten()
broad_shift_y = F.broadcast_to(shift_y.reshape(-1, 1), (height, width)).flatten()
shifts = F.stack([broad_shift_x, broad_shift_y, broad_shift_x, broad_shift_y], axis=1)
c = anchors.shape[1]
all_anchors = F.expand_dims(anchors, axis=0) + F.expand_dims(shifts, axis=1)
all_anchors = all_anchors.reshape(-1, c).detach()
return all_anchors
def forward(self, fpn_fms):
all_anchors_list = []
fm_stride = [8, 16, 32, 64, 128]
fm_stride.reverse()
for i, fm_3x3 in enumerate(fpn_fms):
anchor_scales = np.array(config.anchor_base_scale) * fm_stride[i]
all_anchors = self.generate_anchors_opr(fm_3x3, fm_stride[i], anchor_scales,
config.anchor_aspect_ratios, base_size = 4)
all_anchors_list.append(all_anchors)
return all_anchors_list
class Network(M.Module):
def __init__(self):
super().__init__()
# ----------------------- build the backbone ------------------------ #
self.resnet50 = ResNet50()
# ------------ freeze the weights of resnet stage1 and stage 2 ------ #
if config.backbone_freeze_at >= 1:
for p in self.resnet50.conv1.parameters():
# p.requires_grad = False
p = p.detach()
if config.backbone_freeze_at >= 2:
for p in self.resnet50.layer1.parameters():
# p.requires_grad = False
p = p.detach()
# -------------------------- build the FPN -------------------------- #
self.backbone = FPN(self.resnet50)
# -------------------------- build the RPN -------------------------- #
# self.RPN = RPN(config.rpn_channel)
self.head = RetinaNetHead()
# -------------------------- buid the anchor generator -------------- #
self.anchor_generator = RetinaNetAnchorV2()
# -------------------------- buid the criteria ---------------------- #
self.criteria = RetinaNetCriteriaV2()
# -------------------------- input Tensor --------------------------- #
self.inputs = {
"image": mge.tensor(
np.random.random([2, 3, 756, 1400]).astype(np.float32), dtype="float32",
),
"im_info": mge.tensor(
np.random.random([2, 6]).astype(np.float32), dtype="float32",
),
"gt_boxes": mge.tensor(
np.random.random([2, 500, 5]).astype(np.float32), dtype="float32",
),
}
def pre_process(self, images):
mean = config.image_mean.reshape(1, -1, 1, 1).astype(np.float32)
std = config.image_std.reshape(1, -1, 1, 1).astype(np.float32)
mean = mge.tensor(mean).to(images.device)
std = mge.tensor(std).to(images.device)
normed_images = (images - mean) / std
normed_images = get_padded_tensor(normed_images, 64)
return normed_images
def forward(self, inputs):
im_info = inputs['im_info']
# process the images
normed_images = self.pre_process(inputs['image'])
if self.training:
gt_boxes = inputs['gt_boxes']
return self._forward_train(normed_images, im_info, gt_boxes)
else:
return self._forward_test(normed_images, im_info)
def _forward_train(self, image, im_info, gt_boxes):
loss_dict = {}
# stride: 128,64,32,16,8, p6->p2
fpn_fms = self.backbone(image)
pred_cls_list, rpn_num_prob_list, pred_reg_list, rpn_iou_list = self.head(fpn_fms)
anchors_list = self.anchor_generator(fpn_fms)
loss_dict = self.criteria(
pred_cls_list, rpn_num_prob_list, pred_reg_list, anchors_list,
rpn_iou_list, gt_boxes, im_info)
return loss_dict
def _forward_test(self, image, im_info):
fpn_fms = self.backbone(image)
pred_cls_list, rpn_num_prob_list, pred_reg_list, rpn_iou_list = self.head(fpn_fms)
anchors_list = self.anchor_generator(fpn_fms)
pred_boxes = self._recover_dtboxes(anchors_list, pred_cls_list,
pred_reg_list, rpn_iou_list)
return pred_boxes
def _recover_dtboxes(self, anchors_list, rpn_cls_list, rpn_bbox_list, rpn_iou_list):
assert rpn_cls_list[0].shape[0] == 1
all_anchors = F.concat(anchors_list, axis = 0)
rpn_cls_scores_final = F.concat(rpn_cls_list, axis=1)[0]
rpn_bbox_offsets_final = F.concat(rpn_bbox_list,axis=1)[0]
rpn_iou_prob_final = F.concat(rpn_iou_list, axis=1)[0]
rpn_bbox_offsets = rpn_bbox_offsets_final.reshape(-1, 4)
rpn_cls_scores = rpn_cls_scores_final.reshape(-1, 1)
rpn_iou_prob = rpn_iou_prob_final.reshape(-1, 1)
n, c = all_anchors.shape[0], all_anchors.shape[1]
anchors = F.broadcast_to(F.expand_dims(all_anchors, 1), (n, 1, c)).reshape(-1, c)
rpn_bbox = bbox_transform_inv_opr(anchors, rpn_bbox_offsets)
pred_boxes = F.concat([rpn_bbox, rpn_cls_scores, rpn_iou_prob], axis=1)
return pred_boxes
class RetinaNetCriteriaV2(M.Module):
def __init__(self):
super().__init__()
def anchor_iou_target_opr(self, boxes, im_info, all_anchors,
rpn_bbox_offsets):
n = rpn_bbox_offsets.shape[0]
res = []
for i in range(n):
gtboxes = boxes[i, :im_info[i, 5].astype(np.int32)]
offsets = rpn_bbox_offsets[i].reshape(-1, 4).detach()
m = offsets.shape[0]
an, ac = all_anchors.shape[0], all_anchors.shape[1]
anchors = F.broadcast_to(F.expand_dims(all_anchors, 1), (an, 1, ac)).reshape(-1, ac)
dtboxes = bbox_transform_inv_opr(anchors[:,:4], offsets[:, :4])
overlaps = box_overlap_opr(dtboxes, gtboxes[:, :4])
ignore_mask = 1 - F.equal(gtboxes[:, 4], config.anchor_ignore_label).astype(np.float32)
ignore_mask = F.expand_dims(ignore_mask, axis=0)
overlaps = overlaps * ignore_mask
index = F.argmax(overlaps, axis = 1)
value = F.nn.indexing_one_hot(overlaps, index, 1)
value = F.expand_dims(F.expand_dims(value, axis=1), axis=0)
res.append(value)
result = F.concat(res, 0)
return result
def forward(self, pred_cls_list, rpn_num_prob_list, pred_reg_list,
anchors_list, rpn_iou_list, boxes, im_info):
all_anchors_list = [F.concat([a, i*F.ones([a.shape[0], 1]).to(a.device)], axis=1)
for i, a in enumerate(anchors_list)]
all_anchors_final = F.concat(all_anchors_list, axis = 0)
rpn_bbox_offset_final = F.concat(pred_reg_list, axis = 1)
rpn_cls_prob_final = F.concat(pred_cls_list, axis = 1)
rpn_iou_prob_final = F.concat(rpn_iou_list, axis = 1)
rpn_num_per_points_final = F.concat(rpn_num_prob_list, axis = 1)
rpn_labels, rpn_target_boxes = rpn_anchor_target_opr(boxes, im_info, all_anchors_final)
ious_target = self.anchor_iou_target_opr(boxes, im_info, all_anchors_final,
rpn_bbox_offset_final)
n = rpn_labels.shape[0]
target_boxes = rpn_target_boxes.reshape(n, -1, 2, 4).transpose(2, 0, 1, 3)
rpn_cls_prob_final = rpn_cls_prob_final
offsets_final = rpn_bbox_offset_final
target_boxes = target_boxes[0]
rpn_labels = rpn_labels.transpose(2, 0, 1)
labels = rpn_labels[0]
cls_loss = sigmoid_cross_entropy_retina(rpn_cls_prob_final,
labels, alpha = config.focal_loss_alpha, gamma = config.focal_loss_gamma)
rpn_bbox_loss = smooth_l1_loss_retina(offsets_final, target_boxes, labels)
rpn_labels = F.expand_dims(labels, axis=2)
rpn_iou_loss = iou_l1_loss(rpn_iou_prob_final, ious_target, rpn_labels)
loss_dict = {}
loss_dict['rpn_cls_loss'] = cls_loss
loss_dict['rpn_bbox_loss'] = 2 * rpn_bbox_loss
loss_dict['rpn_iou_loss'] = 2 * rpn_iou_loss
return loss_dict
class RetinaNetHead(M.Module):
def __init__(self):
super().__init__()
num_convs = 4
in_channels = 256
cls_subnet, bbox_subnet = [], []
for _ in range(num_convs):
cls_subnet.append(
M.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
)
cls_subnet.append(M.ReLU())
bbox_subnet.append(
M.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
)
bbox_subnet.append(M.ReLU())
self.cls_subnet = M.Sequential(*cls_subnet)
self.bbox_subnet = M.Sequential(*bbox_subnet)
# predictor
self.cls_score = M.Conv2d(
in_channels, config.num_cell_anchors * (config.num_classes-1) * 1,
kernel_size=3, stride=1, padding=1)
self.bbox_pred = M.Conv2d(
in_channels, config.num_cell_anchors * 4 * 1,
kernel_size=3, stride=1, padding=1)
self.iou_pred = M.Conv2d(
in_channels, config.num_cell_anchors * 1,
kernel_size = 3, stride=1, padding = 1)
self.num_pred = M.Conv2d(in_channels,
config.num_cell_anchors * 1,
kernel_size = 3, stride=1, padding = 1)
self._init_weights()
def _init_weights(self):
# Initialization
for modules in [self.cls_subnet, self.bbox_subnet, self.num_pred,
self.cls_score, self.bbox_pred, self.iou_pred]:
for layer in modules.modules():
if isinstance(layer, M.Conv2d):
M.init.normal_(layer.weight, std=0.01)
M.init.fill_(layer.bias, 0)
prior_prob = 0.01
# Use prior in model initialization to improve stability
bias_value = -(math.log((1 - prior_prob) / prior_prob))
M.init.fill_(self.cls_score.bias, bias_value)
def forward(self, features):
cls_prob_list, rpn_num_prob_list, pred_bbox_list, rpn_iou_prob_list = [], [], [], []
for feature in features:
rpn_cls_conv = self.cls_subnet(feature)
cls_score = self.cls_score(rpn_cls_conv)
rpn_num_prob = self.num_pred(rpn_cls_conv)
cls_prob = F.sigmoid(cls_score)
rpn_box_conv = self.bbox_subnet(feature)
offsets = self.bbox_pred(rpn_box_conv)
rpn_iou_prob = self.iou_pred(rpn_box_conv)
cls_prob_list.append(cls_prob)
pred_bbox_list.append(offsets)
rpn_iou_prob_list.append(rpn_iou_prob)
rpn_num_prob_list.append(rpn_num_prob)
assert cls_prob_list[0].ndim == 4
pred_cls_list = [
_.transpose(0, 2, 3, 1).reshape(_.shape[0], -1, (config.num_classes-1))
for _ in cls_prob_list]
pred_reg_list = [
_.transpose(0, 2, 3, 1).reshape(_.shape[0], -1, 4)
for _ in pred_bbox_list]
rpn_iou_list = [
_.transpose(0, 2, 3, 1).reshape(_.shape[0], -1, (config.num_classes-1))
for _ in rpn_iou_prob_list]
rpn_num_prob_list = [
_.transpose(0, 2, 3, 1).reshape(_.shape[0], -1, (config.num_classes-1))
for _ in rpn_num_prob_list]
return pred_cls_list, rpn_num_prob_list, pred_reg_list, rpn_iou_list
class FPN(M.Module):
"""
This module implements Feature Pyramid Network.
It creates pyramid features built on top of some input feature maps.
"""
def __init__(self, bottom_up):
super(FPN, self).__init__()
in_channels = [512, 1024, 2048]
fpn_dim = 256
use_bias =True
lateral_convs, output_convs = [], []
for idx, in_channels in enumerate(in_channels):
lateral_conv = M.Conv2d(
in_channels, fpn_dim, kernel_size=1, bias=use_bias)
output_conv = M.Conv2d(
fpn_dim, fpn_dim, kernel_size=3, stride=1, padding=1, bias=use_bias)
M.init.msra_normal_(lateral_conv.weight, mode="fan_in")
M.init.msra_normal_(output_conv.weight, mode="fan_in")
if use_bias:
M.init.fill_(lateral_conv.bias, 0)
M.init.fill_(output_conv.bias, 0)
lateral_convs.append(lateral_conv)
output_convs.append(output_conv)
self.p6 = M.Conv2d(fpn_dim, fpn_dim, kernel_size=3, stride=2, padding=1, bias=use_bias)
self.p7 = M.Conv2d(fpn_dim, fpn_dim, kernel_size=3, stride=2, padding=1, bias=use_bias)
self.relu = M.ReLU()
lateral_convs.reverse()
output_convs.reverse()
self.lateral_convs = lateral_convs
self.output_convs = output_convs
self.bottom_up = bottom_up
def forward(self, x):
bottom_up_features = self.bottom_up(x)
# bottom_up_features = bottom_up_features[::-1]
bottom_up_features.reverse()
results = []
prev_features = self.lateral_convs[0](bottom_up_features[0])
results.append(self.output_convs[0](prev_features))
for features, lateral_conv, output_conv in zip(
bottom_up_features[1:], self.lateral_convs[1:], self.output_convs[1:]
):
fh, fw = features.shape[2:]
top_down_features = F.nn.interpolate(
prev_features, size = (fh, fw), mode="BILINEAR")
lateral_features = lateral_conv(features)
prev_features = lateral_features + top_down_features
results.append(output_conv(prev_features))
# p6
p6 = self.p6(results[0])
results.insert(0, p6)
p7 = self.p7(self.relu(p6))
results.insert(0, p7)
return results
|
[
"megengine.module.init.fill_",
"megengine.module.ReLU",
"megengine.functional.sigmoid",
"megengine.functional.ones",
"megengine.module.Conv2d",
"megengine.functional.expand_dims",
"megengine.functional.nn.interpolate",
"megengine.functional.stack",
"megengine.functional.concat",
"megengine.functional.argmax",
"megengine.tensor",
"megengine.module.Sequential",
"megengine.functional.equal",
"megengine.module.init.normal_",
"megengine.functional.linspace",
"megengine.module.init.msra_normal_",
"megengine.functional.nn.indexing_one_hot"
] |
[((1393, 1470), 'megengine.functional.stack', 'F.stack', (['[broad_shift_x, broad_shift_y, broad_shift_x, broad_shift_y]'], {'axis': '(1)'}), '([broad_shift_x, broad_shift_y, broad_shift_x, broad_shift_y], axis=1)\n', (1400, 1470), True, 'import megengine.functional as F\n'), ((2352, 2362), 'backbone.resnet50.ResNet50', 'ResNet50', ([], {}), '()\n', (2360, 2362), False, 'from backbone.resnet50 import ResNet50\n'), ((4203, 4239), 'det_opr.utils.get_padded_tensor', 'get_padded_tensor', (['normed_images', '(64)'], {}), '(normed_images, 64)\n', (4220, 4239), False, 'from det_opr.utils import get_padded_tensor\n'), ((5673, 5703), 'megengine.functional.concat', 'F.concat', (['anchors_list'], {'axis': '(0)'}), '(anchors_list, axis=0)\n', (5681, 5703), True, 'import megengine.functional as F\n'), ((6253, 6302), 'det_opr.bbox_opr.bbox_transform_inv_opr', 'bbox_transform_inv_opr', (['anchors', 'rpn_bbox_offsets'], {}), '(anchors, rpn_bbox_offsets)\n', (6275, 6302), False, 'from det_opr.bbox_opr import bbox_transform_inv_opr, box_overlap_opr\n'), ((6324, 6382), 'megengine.functional.concat', 'F.concat', (['[rpn_bbox, rpn_cls_scores, rpn_iou_prob]'], {'axis': '(1)'}), '([rpn_bbox, rpn_cls_scores, rpn_iou_prob], axis=1)\n', (6332, 6382), True, 'import megengine.functional as F\n'), ((7613, 7629), 'megengine.functional.concat', 'F.concat', (['res', '(0)'], {}), '(res, 0)\n', (7621, 7629), True, 'import megengine.functional as F\n'), ((7947, 7981), 'megengine.functional.concat', 'F.concat', (['all_anchors_list'], {'axis': '(0)'}), '(all_anchors_list, axis=0)\n', (7955, 7981), True, 'import megengine.functional as F\n'), ((8025, 8056), 'megengine.functional.concat', 'F.concat', (['pred_reg_list'], {'axis': '(1)'}), '(pred_reg_list, axis=1)\n', (8033, 8056), True, 'import megengine.functional as F\n'), ((8088, 8119), 'megengine.functional.concat', 'F.concat', (['pred_cls_list'], {'axis': '(1)'}), '(pred_cls_list, axis=1)\n', (8096, 8119), True, 'import megengine.functional as F\n'), ((8151, 8181), 'megengine.functional.concat', 'F.concat', (['rpn_iou_list'], {'axis': '(1)'}), '(rpn_iou_list, axis=1)\n', (8159, 8181), True, 'import megengine.functional as F\n'), ((8219, 8254), 'megengine.functional.concat', 'F.concat', (['rpn_num_prob_list'], {'axis': '(1)'}), '(rpn_num_prob_list, axis=1)\n', (8227, 8254), True, 'import megengine.functional as F\n'), ((8298, 8354), 'rpn_anchor_target_opr.rpn_anchor_target_opr', 'rpn_anchor_target_opr', (['boxes', 'im_info', 'all_anchors_final'], {}), '(boxes, im_info, all_anchors_final)\n', (8319, 8354), False, 'from rpn_anchor_target_opr import rpn_anchor_target_opr\n'), ((8834, 8957), 'det_opr.loss_opr.sigmoid_cross_entropy_retina', 'sigmoid_cross_entropy_retina', (['rpn_cls_prob_final', 'labels'], {'alpha': 'config.focal_loss_alpha', 'gamma': 'config.focal_loss_gamma'}), '(rpn_cls_prob_final, labels, alpha=config.\n focal_loss_alpha, gamma=config.focal_loss_gamma)\n', (8862, 8957), False, 'from det_opr.loss_opr import sigmoid_cross_entropy_retina, smooth_l1_loss_retina, iou_l1_loss\n'), ((8998, 9056), 'det_opr.loss_opr.smooth_l1_loss_retina', 'smooth_l1_loss_retina', (['offsets_final', 'target_boxes', 'labels'], {}), '(offsets_final, target_boxes, labels)\n', (9019, 9056), False, 'from det_opr.loss_opr import sigmoid_cross_entropy_retina, smooth_l1_loss_retina, iou_l1_loss\n'), ((9079, 9108), 'megengine.functional.expand_dims', 'F.expand_dims', (['labels'], {'axis': '(2)'}), '(labels, axis=2)\n', (9092, 9108), True, 'import megengine.functional as F\n'), ((9132, 9188), 'det_opr.loss_opr.iou_l1_loss', 'iou_l1_loss', (['rpn_iou_prob_final', 'ious_target', 'rpn_labels'], {}), '(rpn_iou_prob_final, ious_target, rpn_labels)\n', (9143, 9188), False, 'from det_opr.loss_opr import sigmoid_cross_entropy_retina, smooth_l1_loss_retina, iou_l1_loss\n'), ((9983, 10008), 'megengine.module.Sequential', 'M.Sequential', (['*cls_subnet'], {}), '(*cls_subnet)\n', (9995, 10008), True, 'import megengine.module as M\n'), ((10036, 10062), 'megengine.module.Sequential', 'M.Sequential', (['*bbox_subnet'], {}), '(*bbox_subnet)\n', (10048, 10062), True, 'import megengine.module as M\n'), ((10108, 10226), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', '(config.num_cell_anchors * (config.num_classes - 1) * 1)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, config.num_cell_anchors * (config.num_classes - 1) * \n 1, kernel_size=3, stride=1, padding=1)\n', (10116, 10226), True, 'import megengine.module as M\n'), ((10270, 10364), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', '(config.num_cell_anchors * 4 * 1)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, config.num_cell_anchors * 4 * 1, kernel_size=3,\n stride=1, padding=1)\n', (10278, 10364), True, 'import megengine.module as M\n'), ((10411, 10501), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', '(config.num_cell_anchors * 1)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, config.num_cell_anchors * 1, kernel_size=3, stride=1,\n padding=1)\n', (10419, 10501), True, 'import megengine.module as M\n'), ((10552, 10642), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', '(config.num_cell_anchors * 1)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, config.num_cell_anchors * 1, kernel_size=3, stride=1,\n padding=1)\n', (10560, 10642), True, 'import megengine.module as M\n'), ((11253, 11298), 'megengine.module.init.fill_', 'M.init.fill_', (['self.cls_score.bias', 'bias_value'], {}), '(self.cls_score.bias, bias_value)\n', (11265, 11298), True, 'import megengine.module as M\n'), ((13742, 13819), 'megengine.module.Conv2d', 'M.Conv2d', (['fpn_dim', 'fpn_dim'], {'kernel_size': '(3)', 'stride': '(2)', 'padding': '(1)', 'bias': 'use_bias'}), '(fpn_dim, fpn_dim, kernel_size=3, stride=2, padding=1, bias=use_bias)\n', (13750, 13819), True, 'import megengine.module as M\n'), ((13838, 13915), 'megengine.module.Conv2d', 'M.Conv2d', (['fpn_dim', 'fpn_dim'], {'kernel_size': '(3)', 'stride': '(2)', 'padding': '(1)', 'bias': 'use_bias'}), '(fpn_dim, fpn_dim, kernel_size=3, stride=2, padding=1, bias=use_bias)\n', (13846, 13915), True, 'import megengine.module as M\n'), ((13936, 13944), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (13942, 13944), True, 'import megengine.module as M\n'), ((1523, 1553), 'megengine.functional.expand_dims', 'F.expand_dims', (['anchors'], {'axis': '(0)'}), '(anchors, axis=0)\n', (1536, 1553), True, 'import megengine.functional as F\n'), ((1556, 1585), 'megengine.functional.expand_dims', 'F.expand_dims', (['shifts'], {'axis': '(1)'}), '(shifts, axis=1)\n', (1569, 1585), True, 'import megengine.functional as F\n'), ((5737, 5767), 'megengine.functional.concat', 'F.concat', (['rpn_cls_list'], {'axis': '(1)'}), '(rpn_cls_list, axis=1)\n', (5745, 5767), True, 'import megengine.functional as F\n'), ((5804, 5835), 'megengine.functional.concat', 'F.concat', (['rpn_bbox_list'], {'axis': '(1)'}), '(rpn_bbox_list, axis=1)\n', (5812, 5835), True, 'import megengine.functional as F\n'), ((5867, 5897), 'megengine.functional.concat', 'F.concat', (['rpn_iou_list'], {'axis': '(1)'}), '(rpn_iou_list, axis=1)\n', (5875, 5897), True, 'import megengine.functional as F\n'), ((7044, 7098), 'det_opr.bbox_opr.bbox_transform_inv_opr', 'bbox_transform_inv_opr', (['anchors[:, :4]', 'offsets[:, :4]'], {}), '(anchors[:, :4], offsets[:, :4])\n', (7066, 7098), False, 'from det_opr.bbox_opr import bbox_transform_inv_opr, box_overlap_opr\n'), ((7121, 7161), 'det_opr.bbox_opr.box_overlap_opr', 'box_overlap_opr', (['dtboxes', 'gtboxes[:, :4]'], {}), '(dtboxes, gtboxes[:, :4])\n', (7136, 7161), False, 'from det_opr.bbox_opr import bbox_transform_inv_opr, box_overlap_opr\n'), ((7288, 7322), 'megengine.functional.expand_dims', 'F.expand_dims', (['ignore_mask'], {'axis': '(0)'}), '(ignore_mask, axis=0)\n', (7301, 7322), True, 'import megengine.functional as F\n'), ((7402, 7428), 'megengine.functional.argmax', 'F.argmax', (['overlaps'], {'axis': '(1)'}), '(overlaps, axis=1)\n', (7410, 7428), True, 'import megengine.functional as F\n'), ((7451, 7492), 'megengine.functional.nn.indexing_one_hot', 'F.nn.indexing_one_hot', (['overlaps', 'index', '(1)'], {}), '(overlaps, index, 1)\n', (7472, 7492), True, 'import megengine.functional as F\n'), ((11204, 11243), 'math.log', 'math.log', (['((1 - prior_prob) / prior_prob)'], {}), '((1 - prior_prob) / prior_prob)\n', (11212, 11243), False, 'import math\n'), ((11648, 11668), 'megengine.functional.sigmoid', 'F.sigmoid', (['cls_score'], {}), '(cls_score)\n', (11657, 11668), True, 'import megengine.functional as F\n'), ((13163, 13223), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'fpn_dim'], {'kernel_size': '(1)', 'bias': 'use_bias'}), '(in_channels, fpn_dim, kernel_size=1, bias=use_bias)\n', (13171, 13223), True, 'import megengine.module as M\n'), ((13267, 13344), 'megengine.module.Conv2d', 'M.Conv2d', (['fpn_dim', 'fpn_dim'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)', 'bias': 'use_bias'}), '(fpn_dim, fpn_dim, kernel_size=3, stride=1, padding=1, bias=use_bias)\n', (13275, 13344), True, 'import megengine.module as M\n'), ((13374, 13429), 'megengine.module.init.msra_normal_', 'M.init.msra_normal_', (['lateral_conv.weight'], {'mode': '"""fan_in"""'}), "(lateral_conv.weight, mode='fan_in')\n", (13393, 13429), True, 'import megengine.module as M\n'), ((13442, 13496), 'megengine.module.init.msra_normal_', 'M.init.msra_normal_', (['output_conv.weight'], {'mode': '"""fan_in"""'}), "(output_conv.weight, mode='fan_in')\n", (13461, 13496), True, 'import megengine.module as M\n'), ((14669, 14732), 'megengine.functional.nn.interpolate', 'F.nn.interpolate', (['prev_features'], {'size': '(fh, fw)', 'mode': '"""BILINEAR"""'}), "(prev_features, size=(fh, fw), mode='BILINEAR')\n", (14685, 14732), True, 'import megengine.functional as F\n'), ((841, 864), 'numpy.array', 'np.array', (['anchor_ratios'], {}), '(anchor_ratios)\n', (849, 864), True, 'import numpy as np\n'), ((885, 908), 'numpy.array', 'np.array', (['anchor_scales'], {}), '(anchor_scales)\n', (893, 908), True, 'import numpy as np\n'), ((959, 981), 'megengine.tensor', 'mge.tensor', (['np_anchors'], {}), '(np_anchors)\n', (969, 981), True, 'import megengine as mge\n'), ((1891, 1925), 'numpy.array', 'np.array', (['config.anchor_base_scale'], {}), '(config.anchor_base_scale)\n', (1899, 1925), True, 'import numpy as np\n'), ((3906, 3944), 'config.config.image_mean.reshape', 'config.image_mean.reshape', (['(1)', '(-1)', '(1)', '(1)'], {}), '(1, -1, 1, 1)\n', (3931, 3944), False, 'from config import config\n'), ((3978, 4015), 'config.config.image_std.reshape', 'config.image_std.reshape', (['(1)', '(-1)', '(1)', '(1)'], {}), '(1, -1, 1, 1)\n', (4002, 4015), False, 'from config import config\n'), ((4050, 4066), 'megengine.tensor', 'mge.tensor', (['mean'], {}), '(mean)\n', (4060, 4066), True, 'import megengine as mge\n'), ((4099, 4114), 'megengine.tensor', 'mge.tensor', (['std'], {}), '(std)\n', (4109, 4114), True, 'import megengine as mge\n'), ((7527, 7555), 'megengine.functional.expand_dims', 'F.expand_dims', (['value'], {'axis': '(1)'}), '(value, axis=1)\n', (7540, 7555), True, 'import megengine.functional as F\n'), ((9658, 9728), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'in_channels'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, in_channels, kernel_size=3, stride=1, padding=1)\n', (9666, 9728), True, 'import megengine.module as M\n'), ((9773, 9781), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (9779, 9781), True, 'import megengine.module as M\n'), ((9831, 9901), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'in_channels'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(in_channels, in_channels, kernel_size=3, stride=1, padding=1)\n', (9839, 9901), True, 'import megengine.module as M\n'), ((9947, 9955), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (9953, 9955), True, 'import megengine.module as M\n'), ((13538, 13572), 'megengine.module.init.fill_', 'M.init.fill_', (['lateral_conv.bias', '(0)'], {}), '(lateral_conv.bias, 0)\n', (13550, 13572), True, 'import megengine.module as M\n'), ((13589, 13622), 'megengine.module.init.fill_', 'M.init.fill_', (['output_conv.bias', '(0)'], {}), '(output_conv.bias, 0)\n', (13601, 13622), True, 'import megengine.module as M\n'), ((1068, 1099), 'megengine.functional.linspace', 'F.linspace', (['(0)', '(width - 1)', 'width'], {}), '(0, width - 1, width)\n', (1078, 1099), True, 'import megengine.functional as F\n'), ((1139, 1172), 'megengine.functional.linspace', 'F.linspace', (['(0)', '(height - 1)', 'height'], {}), '(0, height - 1, height)\n', (1149, 1172), True, 'import megengine.functional as F\n'), ((6177, 6206), 'megengine.functional.expand_dims', 'F.expand_dims', (['all_anchors', '(1)'], {}), '(all_anchors, 1)\n', (6190, 6206), True, 'import megengine.functional as F\n'), ((11002, 11040), 'megengine.module.init.normal_', 'M.init.normal_', (['layer.weight'], {'std': '(0.01)'}), '(layer.weight, std=0.01)\n', (11016, 11040), True, 'import megengine.module as M\n'), ((11061, 11088), 'megengine.module.init.fill_', 'M.init.fill_', (['layer.bias', '(0)'], {}), '(layer.bias, 0)\n', (11073, 11088), True, 'import megengine.module as M\n'), ((3490, 3525), 'numpy.random.random', 'np.random.random', (['[2, 3, 756, 1400]'], {}), '([2, 3, 756, 1400])\n', (3506, 3525), True, 'import numpy as np\n'), ((3629, 3653), 'numpy.random.random', 'np.random.random', (['[2, 6]'], {}), '([2, 6])\n', (3645, 3653), True, 'import numpy as np\n'), ((3758, 3787), 'numpy.random.random', 'np.random.random', (['[2, 500, 5]'], {}), '([2, 500, 5])\n', (3774, 3787), True, 'import numpy as np\n'), ((6962, 6991), 'megengine.functional.expand_dims', 'F.expand_dims', (['all_anchors', '(1)'], {}), '(all_anchors, 1)\n', (6975, 6991), True, 'import megengine.functional as F\n'), ((7192, 7242), 'megengine.functional.equal', 'F.equal', (['gtboxes[:, 4]', 'config.anchor_ignore_label'], {}), '(gtboxes[:, 4], config.anchor_ignore_label)\n', (7199, 7242), True, 'import megengine.functional as F\n'), ((7821, 7844), 'megengine.functional.ones', 'F.ones', (['[a.shape[0], 1]'], {}), '([a.shape[0], 1])\n', (7827, 7844), True, 'import megengine.functional as F\n')]
|
import os
import time
import numpy as np
import megengine.distributed as dist
import megengine as mge
import megengine.functional as F
from megengine.autodiff import GradManager
from edit.core.hook.evaluation import psnr, ssim
from edit.utils import imwrite, tensor2img, bgr2ycbcr, img_multi_padding, img_de_multi_padding, ensemble_forward, ensemble_back
from edit.utils import img_multi_padding, img_de_multi_padding, flow_to_image
from ..base import BaseModel
from ..builder import build_backbone, build_loss
from ..registry import MODELS
from tqdm import tqdm
def get_bilinear(image):
B,T,C,h,w = image.shape
image = image.reshape(-1, C,h,w)
return F.nn.interpolate(image, scale_factor=4).reshape(B,T,C,4*h, 4*w)
def train_generator_batch(image, label, *, gm, netG, netloss):
B,T,_,h,w = image.shape
biup = get_bilinear(image)
netG.train()
with gm:
forward_hiddens = []
backward_hiddens = []
res = []
hidden = F.zeros((2*B, netG.hidden_channels, h, w))
for i in range(T):
now_frame = F.concat([image[:, i, ...], image[:, T-i-1, ...]], axis=0)
if i==0:
flow = netG.flownet(now_frame, now_frame)
else:
ref = F.concat([image[:, i-1, ...], image[:, T-i, ...]], axis=0)
flow = netG.flownet(now_frame, ref)
hidden = netG(hidden, flow, now_frame)
forward_hiddens.append(hidden[0:B, ...])
backward_hiddens.append(hidden[B:2*B, ...])
for i in range(T):
res.append(netG.do_upsample(forward_hiddens[i], backward_hiddens[T-i-1]))
res = F.stack(res, axis = 1) # [B,T,3,H,W]
loss = netloss(res+biup, label)
gm.backward(loss)
if dist.is_distributed():
loss = dist.functional.all_reduce_sum(loss) / dist.get_world_size()
return loss
def test_generator_batch(image, *, netG):
# image: [1,100,3,180,320]
B,T,_,h,w = image.shape
biup = get_bilinear(image)
netG.eval()
forward_hiddens = []
backward_hiddens = []
res = []
hidden = F.zeros((2*B, netG.hidden_channels, h, w))
for i in range(T):
now_frame = F.concat([image[:, i, ...], image[:, T-i-1, ...]], axis=0)
if i==0:
flow = netG.flownet(now_frame, now_frame)
else:
ref = F.concat([image[:, i-1, ...], image[:, T-i, ...]], axis=0)
flow = netG.flownet(now_frame, ref)
hidden = netG(hidden, flow, now_frame)
forward_hiddens.append(hidden[0:B, ...])
backward_hiddens.append(hidden[B:2*B, ...])
for i in range(T):
res.append(netG.do_upsample(forward_hiddens[i], backward_hiddens[T-i-1]))
res = F.stack(res, axis = 1) # [B,T,3,H,W]
return res + biup
epoch_dict = {}
def adjust_learning_rate(optimizer, epoch):
if epoch>=8 and epoch % 1 == 0 and epoch_dict.get(epoch, None) is None:
epoch_dict[epoch] = True
for param_group in optimizer.param_groups:
param_group["lr"] = param_group["lr"] * 0.8
print("adjust lr! , now lr: {}".format(param_group["lr"]))
# TODO 可以再写一个父类，抽象一些公共方法，当大于1个模型时，代码重复了，如getimdid和test step
@MODELS.register_module()
class BidirectionalRestorer(BaseModel):
allowed_metrics = {'PSNR': psnr, 'SSIM': ssim}
def __init__(self, generator, pixel_loss, train_cfg=None, eval_cfg=None, pretrained=None, Fidelity_loss=None):
super(BidirectionalRestorer, self).__init__()
self.train_cfg = train_cfg
self.eval_cfg = eval_cfg
# generator
self.generator = build_backbone(generator)
# loss
self.pixel_loss = build_loss(pixel_loss)
if Fidelity_loss:
self.Fidelity_loss = build_loss(Fidelity_loss)
else:
self.Fidelity_loss = None
# load pretrained
self.init_weights(pretrained)
def init_weights(self, pretrained=None):
self.generator.init_weights(pretrained)
def train_step(self, batchdata, now_epoch, now_iter):
LR_tensor = mge.tensor(batchdata['lq'], dtype="float32")
HR_tensor = mge.tensor(batchdata['gt'], dtype="float32")
loss = train_generator_batch(LR_tensor, HR_tensor, gm=self.gms['generator'], netG=self.generator, netloss=self.pixel_loss)
adjust_learning_rate(self.optimizers['generator'], now_epoch)
self.optimizers['generator'].step()
self.optimizers['generator'].clear_grad()
return loss
def get_img_id(self, key):
shift = self.eval_cfg.get('save_shift', 0)
assert isinstance(key, str)
L = key.split("/")
return int(L[-1][:-4]), str(int(L[-2]) - shift).zfill(3) # id, clip
def test_step(self, batchdata, **kwargs):
"""
possible kwargs:
save_image
save_path
ensemble
"""
lq = batchdata['lq'] # [B,3,h,w]
gt = batchdata.get('gt', None) # if not None: [B,3,4*h,4*w]
assert len(batchdata['lq_path']) == 1 # 每个sample所带的lq_path列表长度仅为1， 即自己
lq_paths = batchdata['lq_path'][0] # length 为batch长度
now_start_id, clip = self.get_img_id(lq_paths[0])
now_end_id, _ = self.get_img_id(lq_paths[-1])
assert clip == _
if now_start_id==0:
print("first frame: {}".format(lq_paths[0]))
self.LR_list = []
self.HR_list = []
# pad lq
B ,_ ,origin_H, origin_W = lq.shape
lq = img_multi_padding(lq, padding_multi=self.eval_cfg.multi_pad, pad_method = "edge") # edge constant
self.LR_list.append(lq) # [1,3,h,w]
if gt is not None:
for i in range(B):
self.HR_list.append(gt[i:i+1, ...])
if now_end_id == 99:
print("start to forward all frames....")
if self.eval_cfg.gap == 1:
# do ensemble (8 times)
ensemble_res = []
self.LR_list = np.concatenate(self.LR_list, axis=0) # [100, 3,h,w]
for item in tqdm(range(8)): # do not have flip
inp = mge.tensor(ensemble_forward(self.LR_list, Type=item), dtype="float32")
oup = test_generator_batch(F.expand_dims(inp, axis=0), netG=self.generator)
ensemble_res.append(ensemble_back(oup.numpy(), Type=item))
self.HR_G = sum(ensemble_res) / len(ensemble_res) # ensemble_res 结果取平均
elif self.eval_cfg.gap == 2:
raise NotImplementedError("not implement gap != 1 now")
# self.HR_G_1 = test_generator_batch(F.stack(self.LR_list[::2], axis=1), netG=self.generator)
# self.HR_G_2 = test_generator_batch(F.stack(self.LR_list[1::2], axis=1), netG=self.generator) # [B,T,C,H,W]
# # 交叉组成HR_G
# res = []
# _,T1,_,_,_ = self.HR_G_1.shape
# _,T2,_,_,_ = self.HR_G_2.shape
# assert T1 == T2
# for i in range(T1):
# res.append(self.HR_G_1[:, i, ...])
# res.append(self.HR_G_2[:, i, ...])
# self.HR_G = F.stack(res, axis=1) # [B,T,C,H,W]
else:
raise NotImplementedError("do not support eval&test gap value")
scale = self.generator.upscale_factor
# get numpy
self.HR_G = img_de_multi_padding(self.HR_G, origin_H=origin_H * scale, origin_W=origin_W * scale) # depad for HR_G [B,T,C,H,W]
if kwargs.get('save_image', False):
print("saving images to disk ...")
save_path = kwargs.get('save_path')
B,T,_,_,_ = self.HR_G.shape
assert B == 1
assert T == 100
for i in range(T):
img = tensor2img(self.HR_G[0, i, ...], min_max=(0, 1))
if (i+1)%10 == 0:
imwrite(img, file_path=os.path.join(save_path, "partframes", f"{clip}_{str(i).zfill(8)}.png"))
imwrite(img, file_path=os.path.join(save_path, "allframes", f"{clip}_{str(i).zfill(8)}.png"))
return now_end_id == 99
def cal_for_eval(self, gathered_outputs, gathered_batchdata):
if gathered_outputs:
crop_border = self.eval_cfg.crop_border
assert len(self.HR_list) == 100
res = []
for i in range(len(self.HR_list)):
G = tensor2img(self.HR_G[0, i, ...], min_max=(0, 1))
gt = tensor2img(self.HR_list[i][0], min_max=(0, 1))
eval_result = dict()
for metric in self.eval_cfg.metrics:
eval_result[metric+"_RGB"] = self.allowed_metrics[metric](G, gt, crop_border)
# eval_result[metric+"_Y"] = self.allowed_metrics[metric](G_key_y, gt_y, crop_border)
res.append(eval_result)
return res
else:
return []
|
[
"megengine.tensor",
"megengine.functional.nn.interpolate",
"megengine.distributed.functional.all_reduce_sum",
"megengine.functional.zeros",
"megengine.functional.stack",
"megengine.functional.expand_dims",
"megengine.distributed.is_distributed",
"megengine.distributed.get_world_size",
"megengine.functional.concat"
] |
[((2104, 2148), 'megengine.functional.zeros', 'F.zeros', (['(2 * B, netG.hidden_channels, h, w)'], {}), '((2 * B, netG.hidden_channels, h, w))\n', (2111, 2148), True, 'import megengine.functional as F\n'), ((2722, 2742), 'megengine.functional.stack', 'F.stack', (['res'], {'axis': '(1)'}), '(res, axis=1)\n', (2729, 2742), True, 'import megengine.functional as F\n'), ((975, 1019), 'megengine.functional.zeros', 'F.zeros', (['(2 * B, netG.hidden_channels, h, w)'], {}), '((2 * B, netG.hidden_channels, h, w))\n', (982, 1019), True, 'import megengine.functional as F\n'), ((1645, 1665), 'megengine.functional.stack', 'F.stack', (['res'], {'axis': '(1)'}), '(res, axis=1)\n', (1652, 1665), True, 'import megengine.functional as F\n'), ((1759, 1780), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (1778, 1780), True, 'import megengine.distributed as dist\n'), ((2190, 2252), 'megengine.functional.concat', 'F.concat', (['[image[:, i, ...], image[:, T - i - 1, ...]]'], {'axis': '(0)'}), '([image[:, i, ...], image[:, T - i - 1, ...]], axis=0)\n', (2198, 2252), True, 'import megengine.functional as F\n'), ((4055, 4099), 'megengine.tensor', 'mge.tensor', (["batchdata['lq']"], {'dtype': '"""float32"""'}), "(batchdata['lq'], dtype='float32')\n", (4065, 4099), True, 'import megengine as mge\n'), ((4120, 4164), 'megengine.tensor', 'mge.tensor', (["batchdata['gt']"], {'dtype': '"""float32"""'}), "(batchdata['gt'], dtype='float32')\n", (4130, 4164), True, 'import megengine as mge\n'), ((5499, 5578), 'edit.utils.img_multi_padding', 'img_multi_padding', (['lq'], {'padding_multi': 'self.eval_cfg.multi_pad', 'pad_method': '"""edge"""'}), "(lq, padding_multi=self.eval_cfg.multi_pad, pad_method='edge')\n", (5516, 5578), False, 'from edit.utils import img_multi_padding, img_de_multi_padding, flow_to_image\n'), ((665, 704), 'megengine.functional.nn.interpolate', 'F.nn.interpolate', (['image'], {'scale_factor': '(4)'}), '(image, scale_factor=4)\n', (681, 704), True, 'import megengine.functional as F\n'), ((1069, 1131), 'megengine.functional.concat', 'F.concat', (['[image[:, i, ...], image[:, T - i - 1, ...]]'], {'axis': '(0)'}), '([image[:, i, ...], image[:, T - i - 1, ...]], axis=0)\n', (1077, 1131), True, 'import megengine.functional as F\n'), ((2352, 2414), 'megengine.functional.concat', 'F.concat', (['[image[:, i - 1, ...], image[:, T - i, ...]]'], {'axis': '(0)'}), '([image[:, i - 1, ...], image[:, T - i, ...]], axis=0)\n', (2360, 2414), True, 'import megengine.functional as F\n'), ((7418, 7508), 'edit.utils.img_de_multi_padding', 'img_de_multi_padding', (['self.HR_G'], {'origin_H': '(origin_H * scale)', 'origin_W': '(origin_W * scale)'}), '(self.HR_G, origin_H=origin_H * scale, origin_W=\n origin_W * scale)\n', (7438, 7508), False, 'from edit.utils import img_multi_padding, img_de_multi_padding, flow_to_image\n'), ((1247, 1309), 'megengine.functional.concat', 'F.concat', (['[image[:, i - 1, ...], image[:, T - i, ...]]'], {'axis': '(0)'}), '([image[:, i - 1, ...], image[:, T - i, ...]], axis=0)\n', (1255, 1309), True, 'import megengine.functional as F\n'), ((1801, 1837), 'megengine.distributed.functional.all_reduce_sum', 'dist.functional.all_reduce_sum', (['loss'], {}), '(loss)\n', (1831, 1837), True, 'import megengine.distributed as dist\n'), ((1840, 1861), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (1859, 1861), True, 'import megengine.distributed as dist\n'), ((5982, 6018), 'numpy.concatenate', 'np.concatenate', (['self.LR_list'], {'axis': '(0)'}), '(self.LR_list, axis=0)\n', (5996, 6018), True, 'import numpy as np\n'), ((8507, 8555), 'edit.utils.tensor2img', 'tensor2img', (['self.HR_G[0, i, ...]'], {'min_max': '(0, 1)'}), '(self.HR_G[0, i, ...], min_max=(0, 1))\n', (8517, 8555), False, 'from edit.utils import imwrite, tensor2img, bgr2ycbcr, img_multi_padding, img_de_multi_padding, ensemble_forward, ensemble_back\n'), ((8577, 8623), 'edit.utils.tensor2img', 'tensor2img', (['self.HR_list[i][0]'], {'min_max': '(0, 1)'}), '(self.HR_list[i][0], min_max=(0, 1))\n', (8587, 8623), False, 'from edit.utils import imwrite, tensor2img, bgr2ycbcr, img_multi_padding, img_de_multi_padding, ensemble_forward, ensemble_back\n'), ((7854, 7902), 'edit.utils.tensor2img', 'tensor2img', (['self.HR_G[0, i, ...]'], {'min_max': '(0, 1)'}), '(self.HR_G[0, i, ...], min_max=(0, 1))\n', (7864, 7902), False, 'from edit.utils import imwrite, tensor2img, bgr2ycbcr, img_multi_padding, img_de_multi_padding, ensemble_forward, ensemble_back\n'), ((6134, 6175), 'edit.utils.ensemble_forward', 'ensemble_forward', (['self.LR_list'], {'Type': 'item'}), '(self.LR_list, Type=item)\n', (6150, 6175), False, 'from edit.utils import imwrite, tensor2img, bgr2ycbcr, img_multi_padding, img_de_multi_padding, ensemble_forward, ensemble_back\n'), ((6241, 6267), 'megengine.functional.expand_dims', 'F.expand_dims', (['inp'], {'axis': '(0)'}), '(inp, axis=0)\n', (6254, 6267), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import megengine.functional as F
import megengine.module as M
import official.vision.classification.resnet.model as resnet
class ASPP(M.Module):
def __init__(self, in_channels, out_channels, dr=1):
super().__init__()
self.conv1 = M.Sequential(
M.Conv2d(
in_channels, out_channels, 1, 1, padding=0, dilation=dr, bias=False
),
M.BatchNorm2d(out_channels),
M.ReLU(),
)
self.conv2 = M.Sequential(
M.Conv2d(
in_channels,
out_channels,
3,
1,
padding=6 * dr,
dilation=6 * dr,
bias=False,
),
M.BatchNorm2d(out_channels),
M.ReLU(),
)
self.conv3 = M.Sequential(
M.Conv2d(
in_channels,
out_channels,
3,
1,
padding=12 * dr,
dilation=12 * dr,
bias=False,
),
M.BatchNorm2d(out_channels),
M.ReLU(),
)
self.conv4 = M.Sequential(
M.Conv2d(
in_channels,
out_channels,
3,
1,
padding=18 * dr,
dilation=18 * dr,
bias=False,
),
M.BatchNorm2d(out_channels),
M.ReLU(),
)
self.conv_gp = M.Sequential(
M.Conv2d(in_channels, out_channels, 1, 1, 0, bias=False),
M.BatchNorm2d(out_channels),
M.ReLU(),
)
self.conv_out = M.Sequential(
M.Conv2d(out_channels * 5, out_channels, 1, 1, padding=0, bias=False),
M.BatchNorm2d(out_channels),
M.ReLU(),
)
def forward(self, x):
conv1 = self.conv1(x)
conv31 = self.conv2(x)
conv32 = self.conv3(x)
conv33 = self.conv4(x)
gp = F.mean(x, [2, 3], True)
gp = self.conv_gp(gp)
gp = F.nn.interpolate(gp, (x.shape[2], x.shape[3]))
out = F.concat([conv1, conv31, conv32, conv33, gp], axis=1)
out = self.conv_out(out)
return out
class DeepLabV3Plus(M.Module):
def __init__(self, cfg):
super().__init__()
self.cfg = cfg
self.output_stride = 16
self.sub_output_stride = self.output_stride // 4
self.num_classes = cfg.num_classes
self.aspp = ASPP(
in_channels=2048, out_channels=256, dr=16 // self.output_stride
)
self.dropout = M.Dropout(0.5)
self.upstage1 = M.Sequential(
M.Conv2d(256, 48, 1, 1, padding=1 // 2, bias=False),
M.BatchNorm2d(48),
M.ReLU(),
)
self.upstage2 = M.Sequential(
M.Conv2d(256 + 48, 256, 3, 1, padding=1, bias=False),
M.BatchNorm2d(256),
M.ReLU(),
M.Dropout(0.5),
M.Conv2d(256, 256, 3, 1, padding=1, bias=False),
M.BatchNorm2d(256),
M.ReLU(),
M.Dropout(0.1),
)
self.conv_out = M.Conv2d(256, self.num_classes, 1, 1, padding=0)
for m in self.modules():
if isinstance(m, M.Conv2d):
M.init.msra_normal_(m.weight, mode="fan_out", nonlinearity="relu")
elif isinstance(m, M.BatchNorm2d):
M.init.ones_(m.weight)
M.init.zeros_(m.bias)
self.backbone = getattr(resnet, cfg.backbone)(
replace_stride_with_dilation=[False, False, True],
pretrained=cfg.backbone_pretrained,
)
del self.backbone.fc
def forward(self, x):
layers = self.backbone.extract_features(x)
up0 = self.aspp(layers["res5"])
up0 = self.dropout(up0)
up0 = F.nn.interpolate(up0, scale_factor=self.sub_output_stride)
up1 = self.upstage1(layers["res2"])
up1 = F.concat([up0, up1], 1)
up2 = self.upstage2(up1)
out = self.conv_out(up2)
out = F.nn.interpolate(out, scale_factor=4)
return out
|
[
"megengine.module.ReLU",
"megengine.module.init.ones_",
"megengine.module.init.msra_normal_",
"megengine.functional.nn.interpolate",
"megengine.module.init.zeros_",
"megengine.module.Conv2d",
"megengine.functional.mean",
"megengine.module.Dropout",
"megengine.module.BatchNorm2d",
"megengine.functional.concat"
] |
[((2386, 2409), 'megengine.functional.mean', 'F.mean', (['x', '[2, 3]', '(True)'], {}), '(x, [2, 3], True)\n', (2392, 2409), True, 'import megengine.functional as F\n'), ((2453, 2499), 'megengine.functional.nn.interpolate', 'F.nn.interpolate', (['gp', '(x.shape[2], x.shape[3])'], {}), '(gp, (x.shape[2], x.shape[3]))\n', (2469, 2499), True, 'import megengine.functional as F\n'), ((2515, 2568), 'megengine.functional.concat', 'F.concat', (['[conv1, conv31, conv32, conv33, gp]'], {'axis': '(1)'}), '([conv1, conv31, conv32, conv33, gp], axis=1)\n', (2523, 2568), True, 'import megengine.functional as F\n'), ((3002, 3016), 'megengine.module.Dropout', 'M.Dropout', (['(0.5)'], {}), '(0.5)\n', (3011, 3016), True, 'import megengine.module as M\n'), ((3548, 3596), 'megengine.module.Conv2d', 'M.Conv2d', (['(256)', 'self.num_classes', '(1)', '(1)'], {'padding': '(0)'}), '(256, self.num_classes, 1, 1, padding=0)\n', (3556, 3596), True, 'import megengine.module as M\n'), ((4249, 4307), 'megengine.functional.nn.interpolate', 'F.nn.interpolate', (['up0'], {'scale_factor': 'self.sub_output_stride'}), '(up0, scale_factor=self.sub_output_stride)\n', (4265, 4307), True, 'import megengine.functional as F\n'), ((4367, 4390), 'megengine.functional.concat', 'F.concat', (['[up0, up1]', '(1)'], {}), '([up0, up1], 1)\n', (4375, 4390), True, 'import megengine.functional as F\n'), ((4473, 4510), 'megengine.functional.nn.interpolate', 'F.nn.interpolate', (['out'], {'scale_factor': '(4)'}), '(out, scale_factor=4)\n', (4489, 4510), True, 'import megengine.functional as F\n'), ((657, 734), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'out_channels', '(1)', '(1)'], {'padding': '(0)', 'dilation': 'dr', 'bias': '(False)'}), '(in_channels, out_channels, 1, 1, padding=0, dilation=dr, bias=False)\n', (665, 734), True, 'import megengine.module as M\n'), ((778, 805), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['out_channels'], {}), '(out_channels)\n', (791, 805), True, 'import megengine.module as M\n'), ((819, 827), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (825, 827), True, 'import megengine.module as M\n'), ((886, 976), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'out_channels', '(3)', '(1)'], {'padding': '(6 * dr)', 'dilation': '(6 * dr)', 'bias': '(False)'}), '(in_channels, out_channels, 3, 1, padding=6 * dr, dilation=6 * dr,\n bias=False)\n', (894, 976), True, 'import megengine.module as M\n'), ((1113, 1140), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['out_channels'], {}), '(out_channels)\n', (1126, 1140), True, 'import megengine.module as M\n'), ((1154, 1162), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1160, 1162), True, 'import megengine.module as M\n'), ((1221, 1313), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'out_channels', '(3)', '(1)'], {'padding': '(12 * dr)', 'dilation': '(12 * dr)', 'bias': '(False)'}), '(in_channels, out_channels, 3, 1, padding=12 * dr, dilation=12 * dr,\n bias=False)\n', (1229, 1313), True, 'import megengine.module as M\n'), ((1450, 1477), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['out_channels'], {}), '(out_channels)\n', (1463, 1477), True, 'import megengine.module as M\n'), ((1491, 1499), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1497, 1499), True, 'import megengine.module as M\n'), ((1558, 1650), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'out_channels', '(3)', '(1)'], {'padding': '(18 * dr)', 'dilation': '(18 * dr)', 'bias': '(False)'}), '(in_channels, out_channels, 3, 1, padding=18 * dr, dilation=18 * dr,\n bias=False)\n', (1566, 1650), True, 'import megengine.module as M\n'), ((1787, 1814), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['out_channels'], {}), '(out_channels)\n', (1800, 1814), True, 'import megengine.module as M\n'), ((1828, 1836), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (1834, 1836), True, 'import megengine.module as M\n'), ((1897, 1953), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'out_channels', '(1)', '(1)', '(0)'], {'bias': '(False)'}), '(in_channels, out_channels, 1, 1, 0, bias=False)\n', (1905, 1953), True, 'import megengine.module as M\n'), ((1967, 1994), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['out_channels'], {}), '(out_channels)\n', (1980, 1994), True, 'import megengine.module as M\n'), ((2008, 2016), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (2014, 2016), True, 'import megengine.module as M\n'), ((2078, 2147), 'megengine.module.Conv2d', 'M.Conv2d', (['(out_channels * 5)', 'out_channels', '(1)', '(1)'], {'padding': '(0)', 'bias': '(False)'}), '(out_channels * 5, out_channels, 1, 1, padding=0, bias=False)\n', (2086, 2147), True, 'import megengine.module as M\n'), ((2161, 2188), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['out_channels'], {}), '(out_channels)\n', (2174, 2188), True, 'import megengine.module as M\n'), ((2202, 2210), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (2208, 2210), True, 'import megengine.module as M\n'), ((3068, 3119), 'megengine.module.Conv2d', 'M.Conv2d', (['(256)', '(48)', '(1)', '(1)'], {'padding': '(1 // 2)', 'bias': '(False)'}), '(256, 48, 1, 1, padding=1 // 2, bias=False)\n', (3076, 3119), True, 'import megengine.module as M\n'), ((3133, 3150), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(48)'], {}), '(48)\n', (3146, 3150), True, 'import megengine.module as M\n'), ((3164, 3172), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (3170, 3172), True, 'import megengine.module as M\n'), ((3235, 3287), 'megengine.module.Conv2d', 'M.Conv2d', (['(256 + 48)', '(256)', '(3)', '(1)'], {'padding': '(1)', 'bias': '(False)'}), '(256 + 48, 256, 3, 1, padding=1, bias=False)\n', (3243, 3287), True, 'import megengine.module as M\n'), ((3301, 3319), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(256)'], {}), '(256)\n', (3314, 3319), True, 'import megengine.module as M\n'), ((3333, 3341), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (3339, 3341), True, 'import megengine.module as M\n'), ((3355, 3369), 'megengine.module.Dropout', 'M.Dropout', (['(0.5)'], {}), '(0.5)\n', (3364, 3369), True, 'import megengine.module as M\n'), ((3383, 3430), 'megengine.module.Conv2d', 'M.Conv2d', (['(256)', '(256)', '(3)', '(1)'], {'padding': '(1)', 'bias': '(False)'}), '(256, 256, 3, 1, padding=1, bias=False)\n', (3391, 3430), True, 'import megengine.module as M\n'), ((3444, 3462), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(256)'], {}), '(256)\n', (3457, 3462), True, 'import megengine.module as M\n'), ((3476, 3484), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (3482, 3484), True, 'import megengine.module as M\n'), ((3498, 3512), 'megengine.module.Dropout', 'M.Dropout', (['(0.1)'], {}), '(0.1)\n', (3507, 3512), True, 'import megengine.module as M\n'), ((3687, 3753), 'megengine.module.init.msra_normal_', 'M.init.msra_normal_', (['m.weight'], {'mode': '"""fan_out"""', 'nonlinearity': '"""relu"""'}), "(m.weight, mode='fan_out', nonlinearity='relu')\n", (3706, 3753), True, 'import megengine.module as M\n'), ((3817, 3839), 'megengine.module.init.ones_', 'M.init.ones_', (['m.weight'], {}), '(m.weight)\n', (3829, 3839), True, 'import megengine.module as M\n'), ((3856, 3877), 'megengine.module.init.zeros_', 'M.init.zeros_', (['m.bias'], {}), '(m.bias)\n', (3869, 3877), True, 'import megengine.module as M\n')]
|
import math
import megengine as mge
import megengine.functional as F
import numpy as np
from megengine import Tensor
import pdb
def restore_bbox(rois, deltas, unnormalize=True, config = None):
assert deltas.ndim == 3
if unnormalize:
std_opr = mge.tensor(config.bbox_normalize_stds.reshape(1, 1, -1))
mean_opr = mge.tensor(config.bbox_normalize_means.reshape(1, 1, -1))
deltas = deltas * std_opr
deltas = deltas + mean_opr
# n = deltas.shape[1]
n, c = deltas.shape[0], deltas.shape[1]
all_rois = F.broadcast_to(F.expand_dims(rois, 1), (n, c, rois.shape[1])).reshape(-1, rois.shape[1])
deltas = deltas.reshape(-1, deltas.shape[2])
pred_bbox = bbox_transform_inv_opr(all_rois, deltas)
pred_bbox = pred_bbox.reshape(-1, c, pred_bbox.shape[1])
return pred_bbox
def filter_boxes_opr(boxes, min_size):
"""Remove all boxes with any side smaller than min_size."""
wh = boxes[:, 2:4] - boxes[:, 0:2] + 1
keep_mask = F.prod(wh >= min_size, axis = 1).astype(np.float32)
keep_mask = keep_mask + F.equal(keep_mask.sum(), 0).astype(np.float32)
return keep
def clip_boxes_opr(boxes, im_info):
""" Clip the boxes into the image region."""
w = im_info[1] - 1
h = im_info[0] - 1
boxes[:, 0::4] = boxes[:, 0::4].clamp(min=0, max=w)
boxes[:, 1::4] = boxes[:, 1::4].clamp(min=0, max=h)
boxes[:, 2::4] = boxes[:, 2::4].clamp(min=0, max=w)
boxes[:, 3::4] = boxes[:, 3::4].clamp(min=0, max=h)
return boxes
def bbox_transform_inv_opr(bbox, deltas):
max_delta = math.log(1000.0 / 16)
""" Transforms the learned deltas to the final bbox coordinates, the axis is 1"""
bbox_width = bbox[:, 2] - bbox[:, 0] + 1
bbox_height = bbox[:, 3] - bbox[:, 1] + 1
bbox_ctr_x = bbox[:, 0] + 0.5 * bbox_width
bbox_ctr_y = bbox[:, 1] + 0.5 * bbox_height
pred_ctr_x = bbox_ctr_x + deltas[:, 0] * bbox_width
pred_ctr_y = bbox_ctr_y + deltas[:, 1] * bbox_height
dw = deltas[:, 2]
dh = deltas[:, 3]
dw = F.minimum(dw, max_delta)
dh = F.minimum(dh, max_delta)
pred_width = bbox_width * F.exp(dw)
pred_height = bbox_height * F.exp(dh)
pred_x1 = pred_ctr_x - 0.5 * pred_width
pred_y1 = pred_ctr_y - 0.5 * pred_height
pred_x2 = pred_ctr_x + 0.5 * pred_width
pred_y2 = pred_ctr_y + 0.5 * pred_height
# pred_boxes = F.concat((pred_x1.reshape(-1, 1), pred_y1.reshape(-1, 1),
# pred_x2.reshape(-1, 1), pred_y2.reshape(-1, 1)), axis=1)
pred_boxes = F.stack([pred_x1, pred_y1, pred_x2, pred_y2], axis = 1)
return pred_boxes
def bbox_transform_opr(bbox, gt):
""" Transform the bounding box and ground truth to the loss targets.
The 4 box coordinates are in axis 1"""
bbox_width = bbox[:, 2] - bbox[:, 0] + 1
bbox_height = bbox[:, 3] - bbox[:, 1] + 1
bbox_ctr_x = bbox[:, 0] + 0.5 * bbox_width
bbox_ctr_y = bbox[:, 1] + 0.5 * bbox_height
gt_width = gt[:, 2] - gt[:, 0] + 1
gt_height = gt[:, 3] - gt[:, 1] + 1
gt_ctr_x = gt[:, 0] + 0.5 * gt_width
gt_ctr_y = gt[:, 1] + 0.5 * gt_height
target_dx = (gt_ctr_x - bbox_ctr_x) / bbox_width
target_dy = (gt_ctr_y - bbox_ctr_y) / bbox_height
target_dw = F.log(gt_width / bbox_width)
target_dh = F.log(gt_height / bbox_height)
target = F.stack([target_dx, target_dy, target_dw, target_dh], axis=1)
return target
def box_overlap_opr(box: Tensor, gt: Tensor) -> Tensor:
"""
Given two lists of boxes of size N and M,
compute the IoU (intersection over union)
between __all__ N x M pairs of boxes.
The box order must be (xmin, ymin, xmax, ymax).
Args:
boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
Returns:
Tensor: IoU, sized [N,M].
"""
# box = boxes1
# gt = boxes2
# target_shape = (boxes1.shape[0], boxes2.shape[0], 4)
N, K = box.shape[0], gt.shape[0]
b_box = F.broadcast_to(F.expand_dims(box, 1),(N, K, box.shape[1]))
b_gt = F.broadcast_to(F.expand_dims(gt, 0), (N, K, gt.shape[1]))
# b_gt = F.expand_dims(gt, 0).broadcast_to(N, K, gt.shape[1])
# b_box = F.expand_dims(boxes1, 1).broadcast(*target_shape)
# b_gt = F.expand_dims(boxes2, 0).broadcast(*target_shape)
iw = F.minimum(b_box[:, :, 2], b_gt[:, :, 2]) - F.maximum(
b_box[:, :, 0], b_gt[:, :, 0]
)
ih = F.minimum(b_box[:, :, 3], b_gt[:, :, 3]) - F.maximum(
b_box[:, :, 1], b_gt[:, :, 1]
)
inter = F.maximum(iw, 0) * F.maximum(ih, 0)
area_box = F.maximum(box[:, 2] - box[:, 0], 0) * F.maximum(box[:, 3] - box[:, 1], 0)
area_gt = F.maximum(gt[:, 2] - gt[:, 0], 0) * F.maximum(gt[:, 3] - gt[:, 1], 0)
# area_target_shape = (box.shape[0], gt.shapeof()[0])
b_area_box = F.broadcast_to(F.expand_dims(area_box, 1), (N, K))
b_area_gt = F.broadcast_to(F.expand_dims(area_gt, 0), (N, K))
# b_area_box = F.expand_dims(area_box, 1).broadcast_to(N, K)
# b_area_gt = F.expand_dims(area_gt, 0).broadcast_to(N, K)
# b_area_box = F.add_axis(area_box, 1).broadcast(*area_target_shape)
# b_area_gt = F.add_axis(area_gt, 0).broadcast(*area_target_shape)
union = b_area_box + b_area_gt - inter
overlaps = F.maximum(inter / union, 0)
return overlaps
def box_overlap_ignore_opr(box: Tensor, gt: Tensor, ignore_label=-1) -> Tensor:
"""
Given two lists of boxes of size N and M,
compute the IoU (intersection over union)
between __all__ N x M pairs of boxes.
The box order must be (xmin, ymin, xmax, ymax).
Args:
boxes1,boxes2 (Boxes): two `Boxes`. Contains N & M boxes, respectively.
Returns:
Tensor: IoU, sized [N,M].
"""
# box = boxes1
# gt = boxes2
# target_shape = (boxes1.shapeof()[0], boxes2.shapeof()[0], 4)
eps = 1e-5
N, K = box.shape[0], gt.shape[0]
b_box = F.broadcast_to(F.expand_dims(box, 1), (N, K, box.shape[1]))
b_gt = F.broadcast_to(F.expand_dims(gt, 0), (N, K, gt.shape[1]))
# b_box = F.add_axis(boxes1, 1).broadcast(*target_shape)
# b_gt = F.add_axis(boxes2[:, :4], 0).broadcast(*target_shape)
iw = F.minimum(b_box[:, :, 2], b_gt[:, :, 2]) - F.maximum(
b_box[:, :, 0], b_gt[:, :, 0]
)
ih = F.minimum(b_box[:, :, 3], b_gt[:, :, 3]) - F.maximum(
b_box[:, :, 1], b_gt[:, :, 1]
)
inter = F.maximum(iw, 0) * F.maximum(ih, 0)
area_box = F.maximum(box[:, 2] - box[:, 0], 0) * F.maximum(box[:, 3] - box[:, 1], 0)
area_gt = F.maximum(gt[:, 2] - gt[:, 0], 0) * F.maximum(gt[:, 3] - gt[:, 1], 0)
# area_target_shape = (box.shapeof()[0], gt.shapeof()[0])
# b_area_box = F.add_axis(area_box, 1).broadcast(*area_target_shape)
# b_area_gt = F.add_axis(area_gt, 0).broadcast(*area_target_shape)
b_area_box = F.broadcast_to(F.expand_dims(area_box, 1), (N, K)) + eps
b_area_gt = F.broadcast_to(F.expand_dims(area_gt, 0), (N, K))
union = b_area_box + b_area_gt - inter + eps
overlaps_normal = F.maximum(inter / union, 0)
overlaps_ignore = F.maximum(inter / b_area_box, 0)
overlaps = F.maximum(inter / union, 0)
# gt_ignore_mask = F.add_axis(F.equal(gt[:, 4], ignore_label), 0).broadcast(*area_target_shape)
ignore_mask = F.equal(gt[:, 4], ignore_label)
gt_ignore_mask = F.expand_dims(ignore_mask, 0)
overlaps_normal *= (1 - gt_ignore_mask)
overlaps_ignore *= gt_ignore_mask
return overlaps_normal, overlaps_ignore
|
[
"megengine.functional.exp",
"megengine.functional.maximum",
"megengine.functional.equal",
"megengine.functional.stack",
"megengine.functional.expand_dims",
"megengine.functional.minimum",
"megengine.functional.prod",
"megengine.functional.log"
] |
[((1566, 1587), 'math.log', 'math.log', (['(1000.0 / 16)'], {}), '(1000.0 / 16)\n', (1574, 1587), False, 'import math\n'), ((2027, 2051), 'megengine.functional.minimum', 'F.minimum', (['dw', 'max_delta'], {}), '(dw, max_delta)\n', (2036, 2051), True, 'import megengine.functional as F\n'), ((2061, 2085), 'megengine.functional.minimum', 'F.minimum', (['dh', 'max_delta'], {}), '(dh, max_delta)\n', (2070, 2085), True, 'import megengine.functional as F\n'), ((2528, 2581), 'megengine.functional.stack', 'F.stack', (['[pred_x1, pred_y1, pred_x2, pred_y2]'], {'axis': '(1)'}), '([pred_x1, pred_y1, pred_x2, pred_y2], axis=1)\n', (2535, 2581), True, 'import megengine.functional as F\n'), ((3230, 3258), 'megengine.functional.log', 'F.log', (['(gt_width / bbox_width)'], {}), '(gt_width / bbox_width)\n', (3235, 3258), True, 'import megengine.functional as F\n'), ((3275, 3305), 'megengine.functional.log', 'F.log', (['(gt_height / bbox_height)'], {}), '(gt_height / bbox_height)\n', (3280, 3305), True, 'import megengine.functional as F\n'), ((3319, 3380), 'megengine.functional.stack', 'F.stack', (['[target_dx, target_dy, target_dw, target_dh]'], {'axis': '(1)'}), '([target_dx, target_dy, target_dw, target_dh], axis=1)\n', (3326, 3380), True, 'import megengine.functional as F\n'), ((5226, 5253), 'megengine.functional.maximum', 'F.maximum', (['(inter / union)', '(0)'], {}), '(inter / union, 0)\n', (5235, 5253), True, 'import megengine.functional as F\n'), ((6978, 7005), 'megengine.functional.maximum', 'F.maximum', (['(inter / union)', '(0)'], {}), '(inter / union, 0)\n', (6987, 7005), True, 'import megengine.functional as F\n'), ((7028, 7060), 'megengine.functional.maximum', 'F.maximum', (['(inter / b_area_box)', '(0)'], {}), '(inter / b_area_box, 0)\n', (7037, 7060), True, 'import megengine.functional as F\n'), ((7076, 7103), 'megengine.functional.maximum', 'F.maximum', (['(inter / union)', '(0)'], {}), '(inter / union, 0)\n', (7085, 7103), True, 'import megengine.functional as F\n'), ((7223, 7254), 'megengine.functional.equal', 'F.equal', (['gt[:, 4]', 'ignore_label'], {}), '(gt[:, 4], ignore_label)\n', (7230, 7254), True, 'import megengine.functional as F\n'), ((7276, 7305), 'megengine.functional.expand_dims', 'F.expand_dims', (['ignore_mask', '(0)'], {}), '(ignore_mask, 0)\n', (7289, 7305), True, 'import megengine.functional as F\n'), ((2116, 2125), 'megengine.functional.exp', 'F.exp', (['dw'], {}), '(dw)\n', (2121, 2125), True, 'import megengine.functional as F\n'), ((2158, 2167), 'megengine.functional.exp', 'F.exp', (['dh'], {}), '(dh)\n', (2163, 2167), True, 'import megengine.functional as F\n'), ((3958, 3979), 'megengine.functional.expand_dims', 'F.expand_dims', (['box', '(1)'], {}), '(box, 1)\n', (3971, 3979), True, 'import megengine.functional as F\n'), ((4028, 4048), 'megengine.functional.expand_dims', 'F.expand_dims', (['gt', '(0)'], {}), '(gt, 0)\n', (4041, 4048), True, 'import megengine.functional as F\n'), ((4275, 4315), 'megengine.functional.minimum', 'F.minimum', (['b_box[:, :, 2]', 'b_gt[:, :, 2]'], {}), '(b_box[:, :, 2], b_gt[:, :, 2])\n', (4284, 4315), True, 'import megengine.functional as F\n'), ((4318, 4358), 'megengine.functional.maximum', 'F.maximum', (['b_box[:, :, 0]', 'b_gt[:, :, 0]'], {}), '(b_box[:, :, 0], b_gt[:, :, 0])\n', (4327, 4358), True, 'import megengine.functional as F\n'), ((4382, 4422), 'megengine.functional.minimum', 'F.minimum', (['b_box[:, :, 3]', 'b_gt[:, :, 3]'], {}), '(b_box[:, :, 3], b_gt[:, :, 3])\n', (4391, 4422), True, 'import megengine.functional as F\n'), ((4425, 4465), 'megengine.functional.maximum', 'F.maximum', (['b_box[:, :, 1]', 'b_gt[:, :, 1]'], {}), '(b_box[:, :, 1], b_gt[:, :, 1])\n', (4434, 4465), True, 'import megengine.functional as F\n'), ((4492, 4508), 'megengine.functional.maximum', 'F.maximum', (['iw', '(0)'], {}), '(iw, 0)\n', (4501, 4508), True, 'import megengine.functional as F\n'), ((4511, 4527), 'megengine.functional.maximum', 'F.maximum', (['ih', '(0)'], {}), '(ih, 0)\n', (4520, 4527), True, 'import megengine.functional as F\n'), ((4544, 4579), 'megengine.functional.maximum', 'F.maximum', (['(box[:, 2] - box[:, 0])', '(0)'], {}), '(box[:, 2] - box[:, 0], 0)\n', (4553, 4579), True, 'import megengine.functional as F\n'), ((4582, 4617), 'megengine.functional.maximum', 'F.maximum', (['(box[:, 3] - box[:, 1])', '(0)'], {}), '(box[:, 3] - box[:, 1], 0)\n', (4591, 4617), True, 'import megengine.functional as F\n'), ((4632, 4665), 'megengine.functional.maximum', 'F.maximum', (['(gt[:, 2] - gt[:, 0])', '(0)'], {}), '(gt[:, 2] - gt[:, 0], 0)\n', (4641, 4665), True, 'import megengine.functional as F\n'), ((4668, 4701), 'megengine.functional.maximum', 'F.maximum', (['(gt[:, 3] - gt[:, 1])', '(0)'], {}), '(gt[:, 3] - gt[:, 1], 0)\n', (4677, 4701), True, 'import megengine.functional as F\n'), ((4793, 4819), 'megengine.functional.expand_dims', 'F.expand_dims', (['area_box', '(1)'], {}), '(area_box, 1)\n', (4806, 4819), True, 'import megengine.functional as F\n'), ((4860, 4885), 'megengine.functional.expand_dims', 'F.expand_dims', (['area_gt', '(0)'], {}), '(area_gt, 0)\n', (4873, 4885), True, 'import megengine.functional as F\n'), ((5880, 5901), 'megengine.functional.expand_dims', 'F.expand_dims', (['box', '(1)'], {}), '(box, 1)\n', (5893, 5901), True, 'import megengine.functional as F\n'), ((5951, 5971), 'megengine.functional.expand_dims', 'F.expand_dims', (['gt', '(0)'], {}), '(gt, 0)\n', (5964, 5971), True, 'import megengine.functional as F\n'), ((6133, 6173), 'megengine.functional.minimum', 'F.minimum', (['b_box[:, :, 2]', 'b_gt[:, :, 2]'], {}), '(b_box[:, :, 2], b_gt[:, :, 2])\n', (6142, 6173), True, 'import megengine.functional as F\n'), ((6176, 6216), 'megengine.functional.maximum', 'F.maximum', (['b_box[:, :, 0]', 'b_gt[:, :, 0]'], {}), '(b_box[:, :, 0], b_gt[:, :, 0])\n', (6185, 6216), True, 'import megengine.functional as F\n'), ((6240, 6280), 'megengine.functional.minimum', 'F.minimum', (['b_box[:, :, 3]', 'b_gt[:, :, 3]'], {}), '(b_box[:, :, 3], b_gt[:, :, 3])\n', (6249, 6280), True, 'import megengine.functional as F\n'), ((6283, 6323), 'megengine.functional.maximum', 'F.maximum', (['b_box[:, :, 1]', 'b_gt[:, :, 1]'], {}), '(b_box[:, :, 1], b_gt[:, :, 1])\n', (6292, 6323), True, 'import megengine.functional as F\n'), ((6350, 6366), 'megengine.functional.maximum', 'F.maximum', (['iw', '(0)'], {}), '(iw, 0)\n', (6359, 6366), True, 'import megengine.functional as F\n'), ((6369, 6385), 'megengine.functional.maximum', 'F.maximum', (['ih', '(0)'], {}), '(ih, 0)\n', (6378, 6385), True, 'import megengine.functional as F\n'), ((6402, 6437), 'megengine.functional.maximum', 'F.maximum', (['(box[:, 2] - box[:, 0])', '(0)'], {}), '(box[:, 2] - box[:, 0], 0)\n', (6411, 6437), True, 'import megengine.functional as F\n'), ((6440, 6475), 'megengine.functional.maximum', 'F.maximum', (['(box[:, 3] - box[:, 1])', '(0)'], {}), '(box[:, 3] - box[:, 1], 0)\n', (6449, 6475), True, 'import megengine.functional as F\n'), ((6490, 6523), 'megengine.functional.maximum', 'F.maximum', (['(gt[:, 2] - gt[:, 0])', '(0)'], {}), '(gt[:, 2] - gt[:, 0], 0)\n', (6499, 6523), True, 'import megengine.functional as F\n'), ((6526, 6559), 'megengine.functional.maximum', 'F.maximum', (['(gt[:, 3] - gt[:, 1])', '(0)'], {}), '(gt[:, 3] - gt[:, 1], 0)\n', (6535, 6559), True, 'import megengine.functional as F\n'), ((6871, 6896), 'megengine.functional.expand_dims', 'F.expand_dims', (['area_gt', '(0)'], {}), '(area_gt, 0)\n', (6884, 6896), True, 'import megengine.functional as F\n'), ((991, 1021), 'megengine.functional.prod', 'F.prod', (['(wh >= min_size)'], {'axis': '(1)'}), '(wh >= min_size, axis=1)\n', (997, 1021), True, 'import megengine.functional as F\n'), ((6798, 6824), 'megengine.functional.expand_dims', 'F.expand_dims', (['area_box', '(1)'], {}), '(area_box, 1)\n', (6811, 6824), True, 'import megengine.functional as F\n'), ((565, 587), 'megengine.functional.expand_dims', 'F.expand_dims', (['rois', '(1)'], {}), '(rois, 1)\n', (578, 587), True, 'import megengine.functional as F\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
from collections import OrderedDict
from enum import Enum
from functools import cmp_to_key
from typing import Set # pylint: disable=unused-import
from typing import Callable, Dict, Sequence
import numpy as np
from megengine import Tensor
from megengine.functional import sqrt
from ..converter_ir.ir_graph import IRGraph
from .ir_op import (
AddOpr,
Conv2dOpr,
ConvRelu2dOpr,
Deconv2dOpr,
DropoutOpr,
ExpOpr,
FlattenOpr,
FuseMulAdd3Opr,
GetSubTensorOpr,
HardSigmoidOpr,
HardSwishOpr,
IdentityOpr,
LeakyReluOpr,
MulOpr,
OpBase,
PadOpr,
ReduceOpr,
ReluOpr,
ReshapeOpr,
ResizeOpr,
SoftmaxOpr,
SqueezeOpr,
SubOpr,
TanHOpr,
TransposeOpr,
TrueDivOpr,
_PoolOpr,
)
from .ir_tensor import AxisOrder, IRTensor
class TransformerRule(Enum):
# general rules
NOPE = 1
# for TFLite
REDUCE_AXIS_AS_INPUT = 100
REMOVE_RESHAPE_INPUT = 101
# FUSE_FOR_RELU6 pass should happen before FUSE_ACTIVATION
FUSE_FOR_RELU6 = 102 ##
EXPAND_CONVRELU = 102.1
CONV_ADD_ZERO_BIAS = 103
FUSE_FOR_CONV_BIAS = 103.1
FUSE_CONV_BN = 104
DECONV_ADD_ZERO_BIAS = 105
# DEPTHWISE_CONV_RESHAPE_WEIGHT requirs RESHAPE_BIAS_TO_1DIM
DEPTHWISE_CONV_RESHAPE_WEIGHT = 106
FUSE_SOFTMAX = 107
# RESHAPE_BIAS_TO_1DIM should happen before DECONV_SHAPE_AS_INPUT
RESHAPE_BIAS_TO_1DIM = 108
DECONV_SHAPE_AS_INPUT = 109
FUSE_ASTYPE = 110 ##
PADDING_FOR_CONV_AND_POOLING = 111
TRANSPOSE_PATTERN_AS_INPUT = 112
# FUSE_FOR_LEAKY_RELU should happen before EXPAND_MUL_ADD3
FUSE_FOR_LEAKY_RELU = 113
EXPAND_MUL_ADD3 = 114
EXPAND_ADD_SIGMOID = 115 ##
FUSE_FOR_DECONV_BIAS = 117
FUSE_FOR_FULLY_CONNECTED = 118 ##
# for TFLite Converter
SLICE_PARAMS_AS_INPUTS_AND_MAKE_SQUEEZE = 119
RESIZE_PARAMS_AS_INPUT = 120
REPLACE_FLATTEN_TO_RESHAPE = 120.1
# remove reshape
REMOVE_RESHAPE_REALTED_OP = 121
REMOVE_DROPOUT = 122
FUSE_ACTIVATION = 123
REMOVE_IDENTITY = 124
REMOVE_RELU = 125
REMOVE_UNRELATED_IROP = 130
ADD_FAKE_HSIGMOID_OUT = 131
RENAME_CAFFE_LAYER_TENSOR = 132
def cmp_rules(a, b):
if a.value < b.value:
return -1
if a.value > b.value:
return 1
return 0
class IRTransform:
def __init__(self, transformer_options):
if not isinstance(transformer_options, Sequence):
transformer_options = [
transformer_options,
]
# bias of depthwise_conv must be 1 dim
if TransformerRule.DEPTHWISE_CONV_RESHAPE_WEIGHT in transformer_options:
if TransformerRule.RESHAPE_BIAS_TO_1DIM not in transformer_options:
transformer_options.append(TransformerRule.RESHAPE_BIAS_TO_1DIM)
self.trans_options = sorted(transformer_options, key=cmp_to_key(cmp_rules))
def transform(self, ir_graph):
for option in self.trans_options:
TRANSFORMMAP[option](ir_graph)
return ir_graph
TRANSFORMMAP: Dict[Enum, Callable] = {}
def _register_tranformation_rule(transformer_option):
def callback(impl):
TRANSFORMMAP[transformer_option] = impl
return callback
def cal_pad_mode(tm_opr):
out_shape = tm_opr.out_tensors[0].shape
inp_shape = tm_opr.inp_tensors[0].shape
if out_shape[2:] == inp_shape[2:]:
return "SAME"
else:
return "VALID"
@_register_tranformation_rule(TransformerRule.REMOVE_RESHAPE_INPUT)
def _remove_reshape_input(net):
for op in net.all_oprs:
if not isinstance(op, ReshapeOpr):
continue
if len(op.inp_tensors) == 2:
del op.inp_tensors[1]
@_register_tranformation_rule(TransformerRule.TRANSPOSE_PATTERN_AS_INPUT)
def _transpose_pattern_as_input(net):
for op in net.all_oprs:
if not isinstance(op, TransposeOpr):
continue
perm_tensor = IRTensor(
name=op.inp_tensors[0].name + "_perm",
shape=np.array(op.pattern).shape,
dtype=np.int32,
np_data=np.array(op.pattern, dtype=np.int32),
owner_opr=op,
q_type=np.int32,
axis=None,
)
op.add_inp_tensors(perm_tensor)
@_register_tranformation_rule(TransformerRule.REDUCE_AXIS_AS_INPUT)
def _reduce_axis_as_input(net):
for op in net.all_oprs:
if not isinstance(op, ReduceOpr):
continue
axis_tensor = IRTensor(
name=op.inp_tensors[0].name + "_axis",
shape=[1],
dtype=np.int32,
np_data=np.array(op.axis, dtype=np.int32),
owner_opr=op,
q_type=np.int32,
axis=None,
)
op.add_inp_tensors(axis_tensor)
@_register_tranformation_rule(TransformerRule.PADDING_FOR_CONV_AND_POOLING)
def _make_padding(net: IRGraph):
def have_padding(opr):
if isinstance(opr, Conv2dOpr):
if cal_pad_mode(opr) == "SAME":
return False
if hasattr(opr, "padding") and (opr.padding[0] > 0 or opr.padding[1] > 0):
return True
return False
insert_intended = OrderedDict() # type: OrderedDict
for op in net.all_oprs:
if not isinstance(op, (Conv2dOpr, _PoolOpr)):
continue
if have_padding(op):
assert op.inp_tensors[0].ndim == 4, "ERROR: unsupported padding mode"
np_data = np.array(
[
0,
0,
op.padding[0],
op.padding[0],
op.padding[1],
op.padding[1],
0,
0,
],
dtype=np.int32,
)
new_tensor_id = max(net._tensor_ids) + 1
pad_in_tensor = IRTensor(
name=op.inp_tensors[0].name + "_paddings",
shape=[4, 2],
dtype=np.int32,
owner_opr=None,
np_data=np_data,
q_type=np.int32,
axis=None,
)
net.add_tensor(new_tensor_id, pad_in_tensor)
shape = list(op.inp_tensors[0].shape)
new_tensor_id = max(net._tensor_ids) + 1
pad_out_tensor = IRTensor(
name=op.inp_tensors[0].name + "_pad_out",
shape=[
shape[0],
shape[1],
shape[2] + op.padding[0] * 2,
shape[3] + op.padding[1] * 2,
],
dtype=op.inp_tensors[0].dtype,
)
if (
hasattr(op.inp_tensors[0], "scale")
and op.inp_tensors[0].scale is not None
):
pad_out_tensor.scale = op.inp_tensors[0].scale
pad_out_tensor.q_dtype = op.inp_tensors[0].q_dtype
if hasattr(op.inp_tensors[0], "zero_point"):
pad_out_tensor.zero_point = op.inp_tensors[0].zero_point
net.add_tensor(new_tensor_id, pad_out_tensor)
pad_opr = PadOpr()
pad_opr.inp_tensors = [op.inp_tensors[0], pad_in_tensor]
index = op.inp_tensors[0].user_opr.index(op)
op.inp_tensors[0].user_opr[index] = pad_opr
pad_opr.out_tensors = [pad_out_tensor]
pad_out_tensor.owner_opr = pad_opr
op.inp_tensors = [pad_out_tensor] + op.inp_tensors[1:]
pad_out_tensor.user_opr.append(op)
index = net._opr_ids.index(id(op))
insert_intended[index] = (id(pad_opr), pad_opr)
for index, generated_pair in list(insert_intended.items())[::-1]:
net._opr_ids.insert(index, generated_pair[0])
net.all_oprs.insert(index, generated_pair[1])
@_register_tranformation_rule(TransformerRule.DECONV_SHAPE_AS_INPUT)
def _deconv_shape_as_input(net: IRGraph):
for op in net.all_oprs:
if not isinstance(op, Deconv2dOpr):
continue
result_shape = op.out_tensors[0].shape
np_data = np.array(
[result_shape[0], result_shape[2], result_shape[3], result_shape[1],],
dtype=np.int32,
)
new_tensor_id = max(net._tensor_ids) + 1
shape_symvar = IRTensor(
name=op.inp_tensors[0].name + "_deconv_out_shape",
shape=[4],
dtype=np.int32,
owner_opr=op,
np_data=np_data,
q_type=np.int32,
axis=None,
)
shape_tensor = net.get_tensor(new_tensor_id, shape_symvar)
if len(op.inp_tensors) == 2:
op.inp_tensors = [
shape_tensor,
op.inp_tensors[1],
op.inp_tensors[0],
]
else:
op.inp_tensors = [
shape_tensor,
op.inp_tensors[1],
op.inp_tensors[0],
op.inp_tensors[2],
]
@_register_tranformation_rule(TransformerRule.RESIZE_PARAMS_AS_INPUT)
def _resize_params_as_input(net):
for op in net.all_oprs:
if not isinstance(op, ResizeOpr):
continue
if len(op.inp_tensors) == 2:
continue
out_size_tensor = IRTensor(
name=op.inp_tensors[0].name + "_out_size",
shape=(2,),
dtype=np.int32,
np_data=np.array(op.out_size, dtype=np.int32),
q_type=np.int32,
axis=None,
)
op.add_inp_tensors(out_size_tensor)
@_register_tranformation_rule(TransformerRule.CONV_ADD_ZERO_BIAS)
def _add_bias_for_conv(net: IRGraph):
for op in net.all_oprs:
if not isinstance(op, Conv2dOpr):
continue
if len(op.inp_tensors) == 3:
continue
weight_shape = op.inp_tensors[1].shape
bias_shape = (
weight_shape[0]
if len(weight_shape) == 4
else weight_shape[0] * weight_shape[1]
)
bias_shape = (1, bias_shape, 1, 1)
bias = np.zeros(bias_shape, dtype=np.float32)
bias_tensor = IRTensor(
name=op.inp_tensors[0].name + "_bias",
shape=bias_shape,
dtype=np.float32,
np_data=bias,
axis=AxisOrder.NCHW,
)
if op.inp_tensors[0].scale and op.inp_tensors[1].scale:
bias_tensor.set_qparams(
op.inp_tensors[0].scale * op.inp_tensors[1].scale, 0
)
bias_tensor.q_dtype = "int32"
op.inp_tensors.append(bias_tensor)
@_register_tranformation_rule(TransformerRule.DECONV_ADD_ZERO_BIAS)
def _add_bias_for_deconv(net: IRGraph):
for op in net.all_oprs:
if not isinstance(op, Deconv2dOpr):
continue
if len(op.inp_tensors) == 3:
continue
weight_shape = op.inp_tensors[1].shape
bias_shape = (
weight_shape[1]
if len(weight_shape) == 4
else weight_shape[0] * weight_shape[2]
)
bias_shape = (1, bias_shape, 1, 1)
bias = np.zeros(bias_shape, dtype=np.float32)
bias_tensor = IRTensor(
name=op.inp_tensors[0].name + "_bias",
shape=bias_shape,
dtype=np.float32,
np_data=bias,
axis=AxisOrder.NCHW,
)
if op.inp_tensors[0].scale and op.inp_tensors[1].scale:
bias_tensor.set_qparams(
op.inp_tensors[0].scale * op.inp_tensors[1].scale, 0
)
bias_tensor.q_dtype = "int32"
op.inp_tensors.append(bias_tensor)
@_register_tranformation_rule(TransformerRule.RESHAPE_BIAS_TO_1DIM)
def _reshape_bias_to_1dim(net: IRGraph):
for op in net.all_oprs:
if not isinstance(op, (Deconv2dOpr, Conv2dOpr)):
continue
if len(op.inp_tensors) == 2:
continue
bias = op.inp_tensors[2]
if bias.ndim == 4:
bias.shape = (bias.shape[1],)
bias.np_data = bias.np_data.reshape(-1)
@_register_tranformation_rule(TransformerRule.DEPTHWISE_CONV_RESHAPE_WEIGHT)
def _depthwise_conv_reshape_weight(net: IRGraph):
# general group conv is not supported for TFLite
for op in net.all_oprs:
if not isinstance(op, Conv2dOpr):
continue
if op.groups == 1:
continue
weight = op.inp_tensors[1] # G, oc/G, ic/G, kh, kw
ic, cm = weight.shape[1] * op.groups, weight.shape[2]
h, w = weight.shape[3:5]
weight.shape = (ic, cm, h, w) # oc, ic/G, kh, kw
weight.np_data = weight.np_data.reshape(ic, cm, h, w)
@_register_tranformation_rule(TransformerRule.FUSE_ACTIVATION)
def _fuse_activation(net):
delete_intended = []
for op_id, op in zip(net._opr_ids, net.all_oprs):
if isinstance(op, (ReluOpr, TanHOpr)):
prev_ops = net.find_inp_oprs(op)
if len(prev_ops) == 0:
continue
prev_op = prev_ops[0]
if not isinstance(prev_op, OpBase):
continue
if prev_op.activation != "IDENTITY" or prev_op.name == "Deconv2d":
continue
activation = op.name.upper()
prev_op.activation = activation
prev_op.out_tensors = op.out_tensors
for t in prev_op.out_tensors:
t.owner_opr = prev_op
delete_intended.append(net._opr_ids.index(op_id))
for delete_idx in delete_intended[::-1]:
net.delete_ops(delete_idx)
@_register_tranformation_rule(TransformerRule.SLICE_PARAMS_AS_INPUTS_AND_MAKE_SQUEEZE)
def _make_slice_as_inputs(net: IRGraph):
for op in net.all_oprs:
if not isinstance(op, GetSubTensorOpr):
continue
ndim = op.inp_tensors[0].ndim
def make_input(axis, param, init_value):
# make inputs: begin, end and step.
ret = [init_value] * ndim # pylint:disable=cell-var-from-loop
for k, v in zip(axis, param):
ret[k] = v
ret = IRTensor(
name=op.name + "_fake_input", # pylint:disable=cell-var-from-loop
shape=[len(ret)],
dtype=np.int32,
np_data=np.array(ret, dtype=np.int32),
owner_opr=op, # pylint:disable=cell-var-from-loop
q_type=np.int32,
)
return ret
begins_tensor = make_input(op.axis, op.begin_params, 0)
ends_tensor = make_input(op.axis, op.end_params, np.iinfo(np.int32).max)
steps_tensor = make_input(op.axis, op.step_params, 1)
op.inp_tensors = [op.inp_tensors[0], begins_tensor, ends_tensor, steps_tensor]
# TFLite slice do not support squeeze axis, so insert a squeeze opr here.
# infer actual output shape of tflite slice
desired_out_shape = op.out_tensors[0].shape
actual_out_shape = [1] * ndim
idx = 0
for i in range(ndim):
if i in op.squeeze_axis:
continue
actual_out_shape[i] = desired_out_shape[idx]
idx += 1
slice_out_tensor = IRTensor(
name=op.name + "fake_output",
shape=actual_out_shape,
dtype=op.out_tensors[0].dtype,
q_type=op.out_tensors[0].q_dtype,
owner_opr=op,
)
old_out = op.out_tensors
op.out_tensors = [slice_out_tensor]
squeeze = SqueezeOpr(op.squeeze_axis)
squeeze.inp_tensors = [slice_out_tensor]
squeeze.out_tensors = old_out
idx = net._opr_ids.index(id(op)) + 1
net.add_op(squeeze, idx)
# caffe transormer rules
class PatternNode:
def __init__(self, type, is_output=False, const_value=None):
self.op = None
self.type = type
self.inp_oprs = []
self.inp_const = []
self.inp_tensors = []
self.is_output = is_output
self.const_value = const_value
def check_const_value(self, op):
inp_tensors = [v.np_data for v in op.inp_tensors]
for const in self.const_value:
idx = const[0]
if idx == -1:
find = False
for index, v in enumerate(inp_tensors):
if np.array_equal(const[1], v):
find = True
del inp_tensors[index]
break
if not find:
return False
elif not np.array_equal(const[1], inp_tensors[idx]):
return False
return True
get_type = lambda op: type(op).__name__
def match(node, opr):
node_queue = [node]
opr_queue = [opr]
matched_opr = set()
matched_node = set()
while len(node_queue) != 0:
cur_node = node_queue.pop(0)
cur_opr = opr_queue.pop(0)
if cur_node.type != get_type(cur_opr) and cur_node.type != "*" or cur_opr.skip:
return False
if cur_node.op == None:
cur_node.op = cur_opr
if cur_node.const_value != None:
if not cur_node.check_const_value(cur_opr):
return False
elif cur_node.op != cur_opr:
return False
matched_opr.add(cur_opr)
matched_node.add(cur_node)
for i, var in enumerate(cur_opr.inp_tensors):
if var.np_data is not None:
cur_node.inp_const.append([i, var.np_data])
else:
cur_node.inp_tensors.append([i, var])
if len(cur_node.inp_oprs) == 0:
continue
if len(cur_node.inp_oprs) != len(cur_opr.inp_oprs):
return False
for i, j in zip(cur_node.inp_oprs, cur_opr.inp_oprs):
node_queue.append(i)
opr_queue.append(j)
for n in matched_node:
if n.is_output:
continue
for op in n.op.out_oprs:
if op not in matched_opr:
return False
return True
def get_softmax_axis(ndim: int) -> int:
if ndim in (0, 1, 3):
return 0
return 1
@_register_tranformation_rule(TransformerRule.FUSE_SOFTMAX)
def _fuse_softmax(net: IRGraph):
matches = OrderedDict() # type: OrderedDict
for op in net.all_oprs:
if not isinstance(op, TrueDivOpr):
continue
try:
prev_op = net.find_inp_oprs(op)[1]
cur_index = net._opr_ids.index(id(op))
if (
not isinstance(prev_op, ReduceOpr)
or prev_op.mode != "SUM"
or prev_op.axis != get_softmax_axis(prev_op.inp_tensors[0].ndim)
or net._opr_ids.index(id(prev_op)) != cur_index - 1
):
continue
prev_op = net.find_inp_oprs(op)[0]
if (
not isinstance(prev_op, ExpOpr)
or net._opr_ids.index(id(prev_op)) != cur_index - 2
):
continue
prev_op = net.find_inp_oprs(prev_op)[0]
if (
not isinstance(prev_op, SubOpr)
or net._opr_ids.index(id(prev_op)) != cur_index - 3
):
continue
prev_op = net.find_inp_oprs(prev_op)[1]
if (
not isinstance(prev_op, ReduceOpr)
or prev_op.mode != "MAX"
or prev_op.axis != get_softmax_axis(prev_op.inp_tensors[0].ndim)
or net._opr_ids.index(id(prev_op)) != cur_index - 4
):
continue
except IndexError: # doesn't match
continue
softmax_opr = SoftmaxOpr(axis=get_softmax_axis(prev_op.inp_tensors[0].ndim))
softmax_opr.beta = 1
softmax_opr.inp_tensors = prev_op.inp_tensors[:1]
for i in softmax_opr.inp_tensors:
i.user_opr.append(softmax_opr)
softmax_opr.out_tensors = op.out_tensors
softmax_out_oprs = net.find_out_oprs(op)
matches[id(prev_op)] = (id(prev_op), softmax_opr, softmax_out_oprs)
for original_id, generated_pair in list(matches.items())[::-1]:
index = net._opr_ids.index(original_id)
for out_op in generated_pair[2]:
generated_pair[1].out_tensors[0].user_opr.append(out_op)
del net._opr_ids[index : index + 5]
del net.all_oprs[index : index + 5]
net._opr_ids.insert(index, generated_pair[0])
net.all_oprs.insert(index, generated_pair[1])
@_register_tranformation_rule(TransformerRule.FUSE_FOR_LEAKY_RELU)
def _fuse_leaky_relu(net: IRGraph):
"""
Elemwise(ADD) + Elemwise(MUL) + Elemwise(MAX) + Elemwise(MIN) -> LeakyRelu
"""
for opr in net.all_oprs:
if (
opr.name == "Add"
and len(net.find_inp_oprs(opr)) == 2
and net.find_inp_oprs(opr)[0].name == "Max"
and net.find_inp_oprs(opr)[1].name == "Mul"
):
max_op = net.find_inp_oprs(opr)[0]
mul_op = net.find_inp_oprs(opr)[1]
if not mul_op.inp_tensors[1].shape == (1,):
continue
if not max_op.inp_tensors[1].shape == (1,):
continue
if (
len(net.find_inp_oprs(mul_op)) != 1
or net.find_inp_oprs(mul_op)[0].name != "Min"
or net.find_inp_oprs(mul_op)[0].inp_tensors[1].shape != (1,)
):
continue
min_op = net.find_inp_oprs(mul_op)[0]
if not min_op.inp_tensors[1].shape == (1,):
continue
if max_op.inp_tensors[0] != min_op.inp_tensors[0]:
continue
leaky_relu = LeakyReluOpr(
negative_slope=float(mul_op.inp_tensors[1].np_data)
)
leaky_relu.inp_tensors = [max_op.inp_tensors[0]]
max_op.inp_tensors[0].user_opr.remove(max_op)
max_op.inp_tensors[0].user_opr.remove(min_op)
max_op.inp_tensors[0].user_opr.append(leaky_relu)
leaky_relu.out_tensors = opr.out_tensors
opr.out_tensors[0].owner_opr = leaky_relu
index = net.all_oprs.index(max_op)
del net.all_oprs[index : index + 4]
del net._opr_ids[index : index + 4]
net.add_op(leaky_relu, index)
@_register_tranformation_rule(TransformerRule.FUSE_FOR_CONV_BIAS)
def _fuse_for_conv_bias(net: IRGraph):
"""
ConvolutionForward + Elemwise(ADD) -> ConvForwardBias
"""
for opr in net.all_oprs:
if (
opr.name == "Conv2d"
and len(net.find_out_oprs(opr)) == 1
and net.find_out_oprs(opr)[0].name == "Add"
):
bias_op = net.find_out_oprs(opr)[0]
if not (
(
bias_op.inp_tensors[1].np_data is not None
and len(bias_op.inp_tensors[1].np_data.reshape(-1))
== opr.inp_tensors[1].shape[0]
)
or (
(
bias_op.inp_tensors[0].np_data is not None
and len(bias_op.inp_tensors[0].np_data.reshape(-1))
== opr.inp_tensors[1].shape[0]
)
)
):
continue
bias_idx = 0 if bias_op.inp_tensors[0].np_data is not None else 1
if len(opr.inp_tensors) == 2:
opr.inp_tensors.append(bias_op.inp_tensors[bias_idx])
else:
bias_shape = opr.inp_tensors[2].np_data.shape
add_tensor = bias_op.inp_tensors[bias_idx].np_data
if add_tensor.shape != bias_shape:
add_tensor = add_tensor.reshape(bias_shape)
opr.inp_tensors[2].np_data += add_tensor
if bias_op in opr.out_tensors[0].user_opr:
opr.out_tensors[0].user_opr.remove(bias_op)
bias_out_op = net.find_out_oprs(bias_op)
if len(bias_out_op) > 0:
for op in bias_out_op:
op.inp_tensors[0] = opr.out_tensors[0]
opr.out_tensors[0].user_opr.append(op)
else:
# last op of the graph
assert bias_op.out_tensors[0] in net.graph_outputs
index = net.graph_outputs.index(bias_op.out_tensors[0])
net.graph_outputs[index] = opr.out_tensors[0]
opr.activation = bias_op.activation
index = net.all_oprs.index(bias_op)
del net.all_oprs[index]
del net._opr_ids[index]
@_register_tranformation_rule(TransformerRule.FUSE_FOR_DECONV_BIAS)
def _fuse_for_deconv_bias(net: IRGraph):
for opr in net.all_oprs:
if (
opr.name == "Deconv2d"
and len(net.find_out_oprs(opr)) == 1
and net.find_out_oprs(opr)[0].name == "Add"
):
bias_op = net.find_out_oprs(opr)[0]
if not (
(
bias_op.inp_tensors[1].np_data is not None
and len(bias_op.inp_tensors[1].np_data.reshape(-1))
== opr.inp_tensors[1].shape[1]
)
or (
(
bias_op.inp_tensors[0].np_data is not None
and len(bias_op.inp_tensors[0].np_data.reshape(-1))
== opr.inp_tensors[1].shape[1]
)
)
):
continue
bias_idx = 0 if bias_op.inp_tensors[0].np_data is not None else 1
if len(opr.inp_tensors) == 3: # shape, weight, input, bias
opr.inp_tensors.append(bias_op.inp_tensors[bias_idx])
else:
bias_shape = opr.inp_tensors[3].np_data.shape
add_tensor = bias_op.inp_tensors[bias_idx].np_data
if add_tensor.shape != bias_shape:
add_tensor = add_tensor.reshape(bias_shape)
opr.inp_tensors[3].np_data += add_tensor
if bias_op in opr.out_tensors[0].user_opr:
opr.out_tensors[0].user_opr.remove(bias_op)
bias_out_op = net.find_out_oprs(bias_op)
if len(bias_out_op) > 0:
for op in bias_out_op:
op.inp_tensors[0] = opr.out_tensors[0]
opr.out_tensors[0].user_opr.append(op)
else:
# last op of the graph
assert bias_op.out_tensors[0] in net.graph_outputs
index = net.graph_outputs.index(bias_op.out_tensors[0])
net.graph_outputs[index] = opr.out_tensors[0]
opr.activation = bias_op.activation
index = net.all_oprs.index(bias_op)
del net.all_oprs[index]
del net._opr_ids[index]
@_register_tranformation_rule(TransformerRule.EXPAND_MUL_ADD3)
def _expand_mul_add3(net: IRGraph):
for op in net.all_oprs:
if not isinstance(op, FuseMulAdd3Opr):
continue
last_op = net.find_inp_oprs(op)
assert len(last_op) == 1
mul_out_tensor = IRTensor(
name=op.inp_tensors[0].name + "_mul_out",
shape=op.inp_tensors[0].shape,
dtype=op.inp_tensors[0].dtype,
)
new_tensor_id = max(net._tensor_ids) + 1
net.add_tensor(new_tensor_id, mul_out_tensor)
mul_op = MulOpr()
mul_out_tensor.owner_opr = mul_op
mul_op.inp_tensors = op.inp_tensors[:2]
for o in mul_op.inp_tensors:
index = o.user_opr.index(op)
o.user_opr[index] = mul_op
mul_op.out_tensors = [mul_out_tensor]
add_op = AddOpr()
add_op.inp_tensors = [mul_out_tensor, op.inp_tensors[2]]
mul_out_tensor.user_opr.append(add_op)
add_op.out_tensors = op.out_tensors
index = net._opr_ids.index(id(op))
net.delete_ops(index)
net.add_op(mul_op, index)
net.add_op(add_op, index + 1)
@_register_tranformation_rule(TransformerRule.REPLACE_FLATTEN_TO_RESHAPE)
def _replace_flatten_to_reshape(net: IRGraph):
for opr in net.all_oprs:
if isinstance(opr, FlattenOpr):
out_shape = tuple(list(opr.inp_tensors[0].shape[: opr.start_axis]) + [-1])
reshape_op = ReshapeOpr(out_shape=out_shape)
reshape_op.inp_tensors = opr.inp_tensors
for t in reshape_op.inp_tensors:
idx = t.user_opr.index(opr)
t.user_opr[idx] = reshape_op
reshape_op.out_tensors = opr.out_tensors
for t in reshape_op.out_tensors:
t.owner_opr = reshape_op
net.replace_op(opr, reshape_op)
@_register_tranformation_rule(TransformerRule.REMOVE_RESHAPE_REALTED_OP)
def _remove_reshape_tensors(net: IRGraph):
for opr in net.all_oprs:
if isinstance(opr, ReshapeOpr) and len(opr.inp_tensors) > 1:
opr.inp_tensors = opr.inp_tensors[:1]
@_register_tranformation_rule(TransformerRule.REMOVE_DROPOUT)
def _remove_dropout(net: IRGraph):
for opr in net.all_oprs:
for idx, inp in enumerate(opr.inp_tensors):
owner_opr = inp.owner_opr
if isinstance(owner_opr, DropoutOpr) and owner_opr.drop_prob == 0:
opr.inp_tensors[idx] = owner_opr.inp_tensors[0]
for idx, out in enumerate(net.graph_outputs):
owner_opr = out.owner_opr
if isinstance(owner_opr, DropoutOpr) and owner_opr.drop_prob == 0:
net.graph_outputs[idx] = owner_opr.inp_tensors[0]
@_register_tranformation_rule(TransformerRule.REMOVE_RELU)
def _remove_relu(net: IRGraph):
for opr in net.all_oprs:
for idx, inp in enumerate(opr.inp_tensors):
owner_opr = inp.owner_opr
if isinstance(owner_opr, ReluOpr):
opr.inp_tensors[idx] = owner_opr.inp_tensors[0]
for idx, out in enumerate(net.graph_outputs):
owner_opr = out.owner_opr
if isinstance(owner_opr, ReluOpr):
net.graph_outputs[idx] = owner_opr.inp_tensors[0]
visited_tensor = set() # type: set
def _dfs_recursive(op_set, tensor):
owner_opr = tensor.owner_opr
op_set.add(owner_opr)
if tensor in visited_tensor:
return
visited_tensor.add(tensor)
if isinstance(owner_opr, IRGraph) or owner_opr is None:
return
for tt in owner_opr.inp_tensors:
_dfs_recursive(op_set, tt)
@_register_tranformation_rule(TransformerRule.REMOVE_UNRELATED_IROP)
def _remove_unrelated_op(net: IRGraph):
match_sets = set() # type: Set[OpBase]
for out_tensor in net.graph_outputs:
_dfs_recursive(match_sets, out_tensor)
remove_idx = []
for opr in net.all_oprs:
if opr not in match_sets:
index = net._opr_ids.index(id(opr))
remove_idx.append(index)
for i in remove_idx[::-1]:
net.delete_ops(i)
@_register_tranformation_rule(TransformerRule.ADD_FAKE_HSIGMOID_OUT)
def _add_fake_hsigmoid_tensor(net: IRGraph):
for opr in net.all_oprs:
if isinstance(opr, (HardSwishOpr, HardSigmoidOpr)):
add_3_out_tensor = IRTensor(
opr.out_tensors[0].name + "_fake_add3_out",
opr.inp_tensors[0].shape,
opr.inp_tensors[0].dtype,
q_type=opr.inp_tensors[0].q_dtype,
scale=opr.inp_tensors[0].scale,
zero_point=opr.inp_tensors[0].zero_point,
)
opr.add_inp_tensors(add_3_out_tensor)
relu6_out_tensor = IRTensor(
opr.out_tensors[0].name + "_relu6_out",
opr.inp_tensors[0].shape,
opr.inp_tensors[0].dtype,
q_type=opr.inp_tensors[0].q_dtype,
scale=opr.inp_tensors[0].scale,
zero_point=opr.inp_tensors[0].zero_point,
)
opr.add_inp_tensors(relu6_out_tensor)
if isinstance(opr, HardSwishOpr):
div6_out_tensor = IRTensor(
opr.out_tensors[0].name + "_div_out",
opr.inp_tensors[0].shape,
opr.inp_tensors[0].dtype,
q_type=opr.inp_tensors[0].q_dtype,
scale=opr.inp_tensors[0].scale,
zero_point=opr.inp_tensors[0].zero_point,
)
opr.add_inp_tensors(div6_out_tensor)
def fold_conv_bn(
conv_weight, conv_bias, conv_groups, gamma, beta, bn_mean, bn_var, eps
):
conv_bias = conv_bias.reshape(1, -1, 1, 1)
gamma = gamma.reshape(1, -1, 1, 1)
beta = beta.reshape(1, -1, 1, 1)
bn_mean = bn_mean.reshape(1, -1, 1, 1)
bn_var = bn_var.reshape(1, -1, 1, 1)
# bn_istd = 1 / bn_std
bn_istd = 1.0 / sqrt(bn_var + eps) # type: ignore[attr-defined]
# w_fold = gamma / bn_std * W
scale_factor = gamma * bn_istd
if conv_groups == 1:
w_fold = conv_weight * scale_factor.reshape(-1, 1, 1, 1)
else:
w_fold = conv_weight * scale_factor.reshape(conv_groups, -1, 1, 1, 1)
# b_fold = gamma * (b - bn_mean) / bn_std + beta
b_fold = beta + gamma * (conv_bias - bn_mean) * bn_istd
return w_fold, b_fold
@_register_tranformation_rule(TransformerRule.FUSE_CONV_BN)
def _fuse_conv_bn(net: IRGraph):
for opr in net.all_oprs:
if (
opr.name == "BatchNormalization"
and len(net.find_inp_oprs(opr)) == 1
and net.find_inp_oprs(opr)[0].name == "Conv2d"
and len(net.find_out_oprs(net.find_inp_oprs(opr)[0])) == 1
and net.find_out_oprs(net.find_inp_oprs(opr)[0])[0] == opr
):
gamma = (
Tensor(opr.weight) # type: ignore[attr-defined]
if opr.weight is not None # type: ignore[attr-defined]
else Tensor(opr.inp_tensors[1].np_data)
)
beta = (
Tensor(opr.bias) # type: ignore[attr-defined]
if opr.bias is not None # type: ignore[attr-defined]
else Tensor(opr.inp_tensors[2].np_data)
)
bn_mean = (
Tensor(opr.mean) # type: ignore[attr-defined]
if opr.mean is not None # type: ignore[attr-defined]
else Tensor(opr.inp_tensors[3].np_data)
)
bn_var = (
Tensor(opr.var) # type: ignore[attr-defined]
if opr.var is not None # type: ignore[attr-defined]
else Tensor(opr.inp_tensors[4].np_data)
)
conv_op = net.find_inp_oprs(opr)[0]
conv_weight = conv_op.inp_tensors[1].np_data
if len(conv_op.inp_tensors) == 2:
# add conv bias tensor
weight_shape = conv_op.inp_tensors[1].shape
bias_shape = (
weight_shape[0]
if len(weight_shape) == 4
else weight_shape[0] * weight_shape[1]
)
bias_shape = (1, bias_shape, 1, 1)
conv_bias = IRTensor(
name=conv_op.inp_tensors[0].name + "_bias",
shape=bias_shape,
dtype=np.float32,
np_data=np.zeros(bias_shape, dtype=np.float32),
owner_opr=conv_op,
)
if conv_op.inp_tensors[0].scale and conv_op.inp_tensors[1].scale:
conv_bias.set_qparams(
conv_op.inp_tensors[0].scale * conv_op.inp_tensors[1].scale, 0
)
conv_bias.q_dtype = "int32"
conv_op.inp_tensors.append(conv_bias)
conv_bias = conv_op.inp_tensors[2].np_data.reshape(1, -1, 1, 1)
w_fold, b_fold = fold_conv_bn(
conv_weight,
conv_bias,
conv_op.groups,
gamma,
beta,
bn_mean,
bn_var,
opr.eps, # type: ignore[attr-defined]
)
conv_op.inp_tensors[1].np_data = w_fold.numpy()
conv_op.inp_tensors[2].np_data = b_fold.numpy()
# delete bn opr
conv_op.out_tensors[0] = opr.out_tensors[-1]
conv_op.out_tensors[0].owner_opr = conv_op
index = net._opr_ids.index(id(opr))
net.delete_ops(index)
@_register_tranformation_rule(TransformerRule.REMOVE_IDENTITY)
def _remove_identity(net: IRGraph):
delete_intended = []
for op_id, opr in zip(net._opr_ids, net.all_oprs):
if not isinstance(opr, IdentityOpr):
continue
user_ops = net.find_out_oprs(opr)
for user in user_ops:
idx = user.inp_tensors.index(opr.out_tensors[0])
user.inp_tensors[idx] = opr.inp_tensors[0]
idx = opr.inp_tensors[0].user_opr.index(opr)
opr.inp_tensors[0].user_opr[idx] = user
delete_intended.append(net._opr_ids.index(op_id))
for delete_idx in delete_intended[::-1]:
net.delete_ops(delete_idx)
@_register_tranformation_rule(TransformerRule.EXPAND_CONVRELU)
def _expand_conv_relu(net: IRGraph):
for opr in net.all_oprs:
if not isinstance(opr, ConvRelu2dOpr):
continue
conv_op = Conv2dOpr(
stride=opr.stride,
padding=opr.padding,
dilation=opr.dilation,
groups=opr.groups,
)
conv_op.inp_tensors = opr.inp_tensors
for t in conv_op.inp_tensors:
idx = t.user_opr.index(opr)
t.user_opr[idx] = conv_op
conv_out_tensor = IRTensor(
name=opr.inp_tensors[0].name + "_conv_out",
shape=opr.out_tensors[0].shape,
dtype=opr.out_tensors[0].dtype,
scale=opr.out_tensors[0].scale,
zero_point=opr.out_tensors[0].zero_point,
q_type=opr.out_tensors[0].q_dtype,
owner_opr=conv_op,
)
conv_op.out_tensors = [conv_out_tensor]
conv_out_tensor.owner_opr = conv_op
idx = net.all_oprs.index(opr)
net.add_op(conv_op, idx)
relu_op = ReluOpr()
relu_op.inp_tensors = conv_op.out_tensors
conv_out_tensor.user_opr.append(relu_op)
relu_op.out_tensors = opr.out_tensors
for t in relu_op.out_tensors:
t.owner_opr = relu_op
net.replace_op(opr, relu_op)
|
[
"megengine.Tensor",
"megengine.functional.sqrt"
] |
[((5519, 5532), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (5530, 5532), False, 'from collections import OrderedDict\n'), ((18529, 18542), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (18540, 18542), False, 'from collections import OrderedDict\n'), ((8433, 8532), 'numpy.array', 'np.array', (['[result_shape[0], result_shape[2], result_shape[3], result_shape[1]]'], {'dtype': 'np.int32'}), '([result_shape[0], result_shape[2], result_shape[3], result_shape[1\n ]], dtype=np.int32)\n', (8441, 8532), True, 'import numpy as np\n'), ((10396, 10434), 'numpy.zeros', 'np.zeros', (['bias_shape'], {'dtype': 'np.float32'}), '(bias_shape, dtype=np.float32)\n', (10404, 10434), True, 'import numpy as np\n'), ((11433, 11471), 'numpy.zeros', 'np.zeros', (['bias_shape'], {'dtype': 'np.float32'}), '(bias_shape, dtype=np.float32)\n', (11441, 11471), True, 'import numpy as np\n'), ((33030, 33048), 'megengine.functional.sqrt', 'sqrt', (['(bn_var + eps)'], {}), '(bn_var + eps)\n', (33034, 33048), False, 'from megengine.functional import sqrt\n'), ((5791, 5893), 'numpy.array', 'np.array', (['[0, 0, op.padding[0], op.padding[0], op.padding[1], op.padding[1], 0, 0]'], {'dtype': 'np.int32'}), '([0, 0, op.padding[0], op.padding[0], op.padding[1], op.padding[1],\n 0, 0], dtype=np.int32)\n', (5799, 5893), True, 'import numpy as np\n'), ((3220, 3241), 'functools.cmp_to_key', 'cmp_to_key', (['cmp_rules'], {}), '(cmp_rules)\n', (3230, 3241), False, 'from functools import cmp_to_key\n'), ((4441, 4477), 'numpy.array', 'np.array', (['op.pattern'], {'dtype': 'np.int32'}), '(op.pattern, dtype=np.int32)\n', (4449, 4477), True, 'import numpy as np\n'), ((4955, 4988), 'numpy.array', 'np.array', (['op.axis'], {'dtype': 'np.int32'}), '(op.axis, dtype=np.int32)\n', (4963, 4988), True, 'import numpy as np\n'), ((9740, 9777), 'numpy.array', 'np.array', (['op.out_size'], {'dtype': 'np.int32'}), '(op.out_size, dtype=np.int32)\n', (9748, 9777), True, 'import numpy as np\n'), ((14872, 14890), 'numpy.iinfo', 'np.iinfo', (['np.int32'], {}), '(np.int32)\n', (14880, 14890), True, 'import numpy as np\n'), ((33947, 33965), 'megengine.Tensor', 'Tensor', (['opr.weight'], {}), '(opr.weight)\n', (33953, 33965), False, 'from megengine import Tensor\n'), ((34089, 34123), 'megengine.Tensor', 'Tensor', (['opr.inp_tensors[1].np_data'], {}), '(opr.inp_tensors[1].np_data)\n', (34095, 34123), False, 'from megengine import Tensor\n'), ((34175, 34191), 'megengine.Tensor', 'Tensor', (['opr.bias'], {}), '(opr.bias)\n', (34181, 34191), False, 'from megengine import Tensor\n'), ((34313, 34347), 'megengine.Tensor', 'Tensor', (['opr.inp_tensors[2].np_data'], {}), '(opr.inp_tensors[2].np_data)\n', (34319, 34347), False, 'from megengine import Tensor\n'), ((34402, 34418), 'megengine.Tensor', 'Tensor', (['opr.mean'], {}), '(opr.mean)\n', (34408, 34418), False, 'from megengine import Tensor\n'), ((34540, 34574), 'megengine.Tensor', 'Tensor', (['opr.inp_tensors[3].np_data'], {}), '(opr.inp_tensors[3].np_data)\n', (34546, 34574), False, 'from megengine import Tensor\n'), ((34628, 34643), 'megengine.Tensor', 'Tensor', (['opr.var'], {}), '(opr.var)\n', (34634, 34643), False, 'from megengine import Tensor\n'), ((34764, 34798), 'megengine.Tensor', 'Tensor', (['opr.inp_tensors[4].np_data'], {}), '(opr.inp_tensors[4].np_data)\n', (34770, 34798), False, 'from megengine import Tensor\n'), ((4365, 4385), 'numpy.array', 'np.array', (['op.pattern'], {}), '(op.pattern)\n', (4373, 4385), True, 'import numpy as np\n'), ((14582, 14611), 'numpy.array', 'np.array', (['ret'], {'dtype': 'np.int32'}), '(ret, dtype=np.int32)\n', (14590, 14611), True, 'import numpy as np\n'), ((16601, 16628), 'numpy.array_equal', 'np.array_equal', (['const[1]', 'v'], {}), '(const[1], v)\n', (16615, 16628), True, 'import numpy as np\n'), ((16826, 16868), 'numpy.array_equal', 'np.array_equal', (['const[1]', 'inp_tensors[idx]'], {}), '(const[1], inp_tensors[idx])\n', (16840, 16868), True, 'import numpy as np\n'), ((35512, 35550), 'numpy.zeros', 'np.zeros', (['bias_shape'], {'dtype': 'np.float32'}), '(bias_shape, dtype=np.float32)\n', (35520, 35550), True, 'import numpy as np\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import pickle
from collections import defaultdict
from itertools import chain
import numpy as np
import megengine.functional as F
import megengine.module as M
import megengine.module.qat as qat
from megengine.module.identity import Identity
from megengine.traced_module import trace_module
from megengine.traced_module.expr import CallFunction, CallMethod, Expr, GetAttr, Input
from megengine.traced_module.node import ModuleNode, Node, TensorNode
class IdentityMod(M.Module):
def forward(self, x):
return x
class MyBlock(M.Module):
def __init__(self, in_channels=3, channels=3):
super(MyBlock, self).__init__()
self.conv1 = M.Conv2d(in_channels, channels, 3, 1, padding=1, bias=False)
self.bn1 = M.BatchNorm2d(channels)
self.nothing = IdentityMod()
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = F.relu(x) + 1
x = self.nothing(x)
return x
class MyModule(M.Module):
def __init__(self):
super(MyModule, self).__init__()
self.block0 = MyBlock()
self.block1 = MyBlock()
self.nothing = IdentityMod()
def forward(self, x):
x = self.block0(x)
x = self.block1(x)
x = self.nothing(x)
return x
class MyBlock1(M.Module):
def forward(self, a):
y = F.concat([a, a])
return a, y
class MyModule1(M.Module):
def __init__(self):
super().__init__()
self.block0 = MyBlock1()
self.block1 = MyBlock1()
def forward(self, a):
a, y1 = self.block0(a)
a = a + 1
a, y2 = self.block1(a)
return a, y1 + y2
class NewModule(M.Module):
def __init__(self, traced_module):
super(NewModule, self).__init__()
self.module = traced_module
def forward(self, x):
x = x - 1
x = self.module(x)
x = x + 1
return x
def _check_expr_users(traced_module):
node_user = defaultdict(list)
for expr in traced_module.graph._exprs:
for node in expr.inputs:
node_user[node].append(expr)
for node in traced_module.graph.nodes():
node.users.sort(key=lambda m: m._id)
node_user[node].sort(key=lambda m: m._id)
assert node.users == node_user[node]
def _init_cls(cls):
module = cls()
x = F.ones((1, 3, 3, 3))
y = module(x)
traced_module = trace_module(module, x)
return traced_module, x, y
def _init_block():
return _init_cls(MyBlock)
def _init_module():
return _init_cls(MyModule)
def test_search():
traced_module, *_ = _init_block()
graph = traced_module.graph
relu_expr = graph.get_function_by_type(F.relu).as_unique()
assert isinstance(relu_expr, CallFunction) and relu_expr.func == F.relu
conv_node = graph.get_module_by_type(M.Conv2d).as_unique()
assert isinstance(conv_node, ModuleNode) and conv_node.module_type == M.Conv2d
add_expr = graph.get_method_by_type("__add__").as_unique()
assert isinstance(add_expr, CallMethod) and add_expr.method == "__add__"
conv_node = graph.get_node_by_name("MyBlock_conv1").as_unique()
assert isinstance(conv_node, ModuleNode) and conv_node.module_type == M.Conv2d
def test_producer_and_users():
traced_module, *_ = _init_module()
def _check(exprs):
for expr in exprs:
for n in chain(expr.inputs, expr.outputs):
if not isinstance(n.expr, Input):
assert n.expr in exprs
for e in n.users:
assert e in exprs
assert n in e.inputs
for mod in traced_module.modules():
if not hasattr(mod, "argdef_graph_map"):
continue
for g in mod.argdef_graph_map.values():
_check(g._exprs)
def test_insert():
traced_module, x, expect = _init_block()
graph = traced_module.graph
relu_out = graph.get_function_by_type(F.relu).as_unique().outputs[0]
with graph.insert_exprs():
neg_out = F.neg(relu_out)
graph.replace_node({relu_out: neg_out})
graph.compile()
np.testing.assert_allclose(expect - 1, 1 - traced_module(x), atol=1e-6)
def test_insert_module():
class Neg(M.Module):
def __init__(self, name):
super().__init__(name)
self.identity = M.Identity()
self.identity_list = [M.Identity(), M.Identity()]
self.identity_dict = {"0": M.Identity(), "1": M.Identity()}
self.param = F.zeros((1,))
def forward(self, x):
x = self.identity(x)
for m in self.identity_dict:
x = self.identity_dict[m](x)
for m in self.identity_list:
x = m(x)
return F.neg(x) + self.param
traced_module, x, expect = _init_block()
graph = traced_module.graph
relu_out = graph.get_function_by_type(F.relu).as_unique().outputs[0]
self = graph.inputs[0]
setattr(traced_module, "neg", Neg(name="neg"))
setattr(traced_module, "neg2", Neg(name="neg"))
setattr(traced_module, "param", F.zeros((1,)))
with graph.insert_exprs():
neg_out = self.neg(relu_out)
neg_out = self.neg2(relu_out)
neg_out = neg_out + self.param
graph.replace_node({relu_out: neg_out})
graph.compile()
np.testing.assert_allclose(expect - 1, 1 - traced_module(x), atol=1e-6)
assert traced_module.neg.graph is not None
assert traced_module.neg2.graph is not None
assert traced_module.neg2.param is not None
assert len(traced_module.neg.graph._exprs) == 13
for n in traced_module.graph.nodes():
if isinstance(n, TensorNode):
assert n.value is None
def test_insert_qat_module():
class concat(qat.Concat):
pass
traced_module, x, expect = _init_block()
graph = traced_module.graph
self = graph.inputs[0]
out = graph.outputs[0]
setattr(traced_module, "cat_0", qat.Concat())
setattr(traced_module, "cat_1", concat())
with graph.insert_exprs():
x_0 = self.cat_0([out, out])
x_1 = self.cat_1([out, x_0])
graph.replace_node({out: x_1})
graph.compile()
x = F.copy(x)
np.testing.assert_allclose(
F.concat([expect, expect, expect]), traced_module(x), atol=1e-6
)
assert not hasattr(traced_module.cat_0, "graph")
assert traced_module.cat_1.graph is not None
def test_add_input_and_output():
traced_module, x, y = _init_module()
data_node = traced_module.graph.add_input_node(shape=(1, 3, 224, 224), name="data")
traced_module.graph.add_output_node(data_node)
assert data_node.name == "data"
assert traced_module.graph.inputs[-1] == data_node
assert len(traced_module.graph.inputs) == 3
assert len(traced_module.graph.outputs) == 2
y1, y2 = traced_module(x, x)
np.testing.assert_equal(y1.numpy(), y.numpy())
np.testing.assert_equal(y2.numpy(), x.numpy())
y1, y2 = traced_module(x, y)
np.testing.assert_equal(y2.numpy(), y.numpy())
traced_module.graph.reset_outputs(
({"orig_out": traced_module.graph.outputs[0]}, traced_module.graph.outputs[1])
)
out = traced_module(x, x)
assert isinstance(out, tuple)
assert isinstance(out[0], dict)
np.testing.assert_equal(out[0]["orig_out"].numpy(), y.numpy())
np.testing.assert_equal(out[1].numpy(), x.numpy())
def test_delete():
traced_module, x, expect = _init_block()
graph = traced_module.graph
relu_expr = graph.get_function_by_type(F.relu).as_unique()
node = relu_expr.outputs
repl_node = relu_expr.inputs
graph.replace_node({node[0]: repl_node[0]})
graph.compile()
np.testing.assert_allclose(expect - 1, F.relu(traced_module(x) - 1), atol=1e-6)
# clear graph
graph.replace_node({graph.outputs[0]: graph.inputs[1]})
graph.compile()
np.testing.assert_equal(len(list(graph._exprs)), 0)
np.testing.assert_equal(traced_module(x).numpy(), x.numpy())
def test_flatten():
traced_module, x, expect = _init_module()
traced_module = traced_module.flatten()
assert len(traced_module.graph._exprs) == 12
np.testing.assert_equal(expect.numpy(), traced_module(x).numpy())
traced_module = traced_module.flatten()
assert len(traced_module.graph._exprs) == 12
np.testing.assert_equal(expect.numpy(), traced_module(x).numpy())
traced_module, x, expect = _init_cls(MyModule1)
traced_module = traced_module.flatten()
_check_expr_users(traced_module)
def test_id_and_name():
def _check_id(traced_module):
_total_ids = traced_module.graph._total_ids
node_ids = [n._id for n in traced_module.graph.nodes().as_list()]
assert len(set(node_ids)) == len(node_ids)
assert max(node_ids) + 1 == _total_ids[0]
expr_ids = [n._id for n in traced_module.graph.exprs().as_list()]
assert len(set(expr_ids)) == len(expr_ids)
assert max(expr_ids) + 1 == _total_ids[1]
def _check_name(flatened_module):
node_names = [n._name for n in flatened_module.graph.nodes().as_list()]
assert len(set(node_names)) == len(node_names)
traced_module, x, expect = _init_module()
_check_id(traced_module)
flattened_module = traced_module.flatten()
_check_id(flattened_module)
_check_name(flattened_module)
# pickle check
obj = pickle.dumps(traced_module)
traced_module = pickle.loads(obj)
Node._set_next_id(159)
Expr._set_next_id(1024)
graph = traced_module.graph
for expr in graph.get_function_by_type(F.relu).as_list():
relu_out = expr.outputs[0]
cur_graph = expr.top_graph
with cur_graph.insert_exprs():
neg_out = F.neg(relu_out)
cur_graph.replace_node({relu_out: neg_out})
cur_graph.compile()
_check_id(traced_module)
flattened_module = traced_module.flatten()
_check_id(flattened_module)
_check_name(flattened_module)
# check trace TracedModule
obj = pickle.dumps(traced_module)
traced_module = pickle.loads(obj)
module = NewModule(traced_module)
traced_module = trace_module(module, x)
_check_id(traced_module)
flattened_module = traced_module.flatten()
_check_id(flattened_module)
_check_name(flattened_module)
def test_set_node_name():
traced_module, x, expect = _init_module()
graph = traced_module.graph
output_node = graph.outputs[0]
def rename(name):
output_node.name = name
np.testing.assert_raises(AssertionError, rename, "block1_out")
rename("output")
np.testing.assert_equal(str(graph.outputs[0]), "output")
def test_set_graph_name():
traced_module, x, expect = _init_module()
graph = traced_module.graph
output_node = graph.outputs[0]
node_name = output_node.name
graph.name = "Top"
node = graph.get_node_by_name("{}_{}".format("Top", node_name)).as_unique()
assert node is output_node
def test_extra_block():
class PostProcess(M.Module):
def forward(self, x):
return x * 2
class Net(M.Module):
def __init__(self, traced_module):
super().__init__()
self.post_process = PostProcess()
self.traced_module = traced_module
def forward(self, x):
x = self.traced_module(x)
x = self.post_process(x)
return x
traced_module, x, expect = _init_block()
module = Net(traced_module)
np.testing.assert_allclose(2 * expect, module(x), atol=1e-6)
traced_module = trace_module(module, x)
np.testing.assert_allclose(2 * expect, traced_module(x), atol=1e-6)
|
[
"megengine.functional.relu",
"megengine.traced_module.trace_module",
"megengine.traced_module.node.Node._set_next_id",
"megengine.functional.zeros",
"megengine.functional.ones",
"megengine.functional.neg",
"megengine.module.Conv2d",
"megengine.module.qat.Concat",
"megengine.traced_module.expr.Expr._set_next_id",
"megengine.functional.copy",
"megengine.module.Identity",
"megengine.module.BatchNorm2d",
"megengine.functional.concat"
] |
[((2316, 2333), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (2327, 2333), False, 'from collections import defaultdict\n'), ((2686, 2706), 'megengine.functional.ones', 'F.ones', (['(1, 3, 3, 3)'], {}), '((1, 3, 3, 3))\n', (2692, 2706), True, 'import megengine.functional as F\n'), ((2745, 2768), 'megengine.traced_module.trace_module', 'trace_module', (['module', 'x'], {}), '(module, x)\n', (2757, 2768), False, 'from megengine.traced_module import trace_module\n'), ((6518, 6527), 'megengine.functional.copy', 'F.copy', (['x'], {}), '(x)\n', (6524, 6527), True, 'import megengine.functional as F\n'), ((9703, 9730), 'pickle.dumps', 'pickle.dumps', (['traced_module'], {}), '(traced_module)\n', (9715, 9730), False, 'import pickle\n'), ((9751, 9768), 'pickle.loads', 'pickle.loads', (['obj'], {}), '(obj)\n', (9763, 9768), False, 'import pickle\n'), ((9773, 9795), 'megengine.traced_module.node.Node._set_next_id', 'Node._set_next_id', (['(159)'], {}), '(159)\n', (9790, 9795), False, 'from megengine.traced_module.node import ModuleNode, Node, TensorNode\n'), ((9800, 9823), 'megengine.traced_module.expr.Expr._set_next_id', 'Expr._set_next_id', (['(1024)'], {}), '(1024)\n', (9817, 9823), False, 'from megengine.traced_module.expr import CallFunction, CallMethod, Expr, GetAttr, Input\n'), ((10331, 10358), 'pickle.dumps', 'pickle.dumps', (['traced_module'], {}), '(traced_module)\n', (10343, 10358), False, 'import pickle\n'), ((10379, 10396), 'pickle.loads', 'pickle.loads', (['obj'], {}), '(obj)\n', (10391, 10396), False, 'import pickle\n'), ((10455, 10478), 'megengine.traced_module.trace_module', 'trace_module', (['module', 'x'], {}), '(module, x)\n', (10467, 10478), False, 'from megengine.traced_module import trace_module\n'), ((10823, 10885), 'numpy.testing.assert_raises', 'np.testing.assert_raises', (['AssertionError', 'rename', '"""block1_out"""'], {}), "(AssertionError, rename, 'block1_out')\n", (10847, 10885), True, 'import numpy as np\n'), ((11876, 11899), 'megengine.traced_module.trace_module', 'trace_module', (['module', 'x'], {}), '(module, x)\n', (11888, 11899), False, 'from megengine.traced_module import trace_module\n'), ((1016, 1076), 'megengine.module.Conv2d', 'M.Conv2d', (['in_channels', 'channels', '(3)', '(1)'], {'padding': '(1)', 'bias': '(False)'}), '(in_channels, channels, 3, 1, padding=1, bias=False)\n', (1024, 1076), True, 'import megengine.module as M\n'), ((1096, 1119), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['channels'], {}), '(channels)\n', (1109, 1119), True, 'import megengine.module as M\n'), ((1691, 1707), 'megengine.functional.concat', 'F.concat', (['[a, a]'], {}), '([a, a])\n', (1699, 1707), True, 'import megengine.functional as F\n'), ((4366, 4381), 'megengine.functional.neg', 'F.neg', (['relu_out'], {}), '(relu_out)\n', (4371, 4381), True, 'import megengine.functional as F\n'), ((5432, 5445), 'megengine.functional.zeros', 'F.zeros', (['(1,)'], {}), '((1,))\n', (5439, 5445), True, 'import megengine.functional as F\n'), ((6288, 6300), 'megengine.module.qat.Concat', 'qat.Concat', ([], {}), '()\n', (6298, 6300), True, 'import megengine.module.qat as qat\n'), ((6568, 6602), 'megengine.functional.concat', 'F.concat', (['[expect, expect, expect]'], {}), '([expect, expect, expect])\n', (6576, 6602), True, 'import megengine.functional as F\n'), ((1246, 1255), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (1252, 1255), True, 'import megengine.functional as F\n'), ((3718, 3750), 'itertools.chain', 'chain', (['expr.inputs', 'expr.outputs'], {}), '(expr.inputs, expr.outputs)\n', (3723, 3750), False, 'from itertools import chain\n'), ((4672, 4684), 'megengine.module.Identity', 'M.Identity', ([], {}), '()\n', (4682, 4684), True, 'import megengine.module as M\n'), ((4844, 4857), 'megengine.functional.zeros', 'F.zeros', (['(1,)'], {}), '((1,))\n', (4851, 4857), True, 'import megengine.functional as F\n'), ((10050, 10065), 'megengine.functional.neg', 'F.neg', (['relu_out'], {}), '(relu_out)\n', (10055, 10065), True, 'import megengine.functional as F\n'), ((4719, 4731), 'megengine.module.Identity', 'M.Identity', ([], {}), '()\n', (4729, 4731), True, 'import megengine.module as M\n'), ((4733, 4745), 'megengine.module.Identity', 'M.Identity', ([], {}), '()\n', (4743, 4745), True, 'import megengine.module as M\n'), ((4786, 4798), 'megengine.module.Identity', 'M.Identity', ([], {}), '()\n', (4796, 4798), True, 'import megengine.module as M\n'), ((4805, 4817), 'megengine.module.Identity', 'M.Identity', ([], {}), '()\n', (4815, 4817), True, 'import megengine.module as M\n'), ((5093, 5101), 'megengine.functional.neg', 'F.neg', (['x'], {}), '(x)\n', (5098, 5101), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import gc
import platform
import weakref
import numpy as np
import pytest
import megengine as mge
import megengine.distributed as dist
import megengine.functional as F
from megengine.core._imperative_rt import TensorAttr, imperative
from megengine.core._imperative_rt.imperative import sync
from megengine.core.autodiff.grad import Grad
from megengine.core.ops.builtin import Elemwise
from megengine.core.tensor.raw_tensor import as_raw_tensor
from megengine.core.tensor.tensor import Tensor, apply
from megengine.core.tensor.tensor_wrapper import TensorWrapper
from megengine.functional.distributed import remote_recv, remote_send
def _elwise(mode):
op = Elemwise(mode)
def f(*args):
(result,) = apply(op, *args)
return result
return f
add = _elwise(Elemwise.Mode.ADD)
mul = _elwise(Elemwise.Mode.MUL)
cos = _elwise(Elemwise.Mode.COS)
relu = _elwise(Elemwise.Mode.RELU)
def as_tensor(x):
return Tensor(as_raw_tensor(x, device=mge.device.get_default_device()))
def save_to(self, name="grad"):
def callback(tensor, grad):
setattr(self, name, grad)
return callback
@pytest.mark.isolated_distributed
@pytest.mark.skipif(
platform.system() == "Windows", reason="windows disable MGB_ENABLE_OPR_MM"
)
def test_dist_grad():
world_size = 2
x_np = np.random.rand(10).astype("float32")
port = dist.get_free_ports(1)[0]
server = dist.Server(port)
def worker0():
dist.init_process_group("localhost", port, world_size, 0, 0)
mge.device.set_default_device("gpu0")
grad = Grad()
x = as_tensor(x_np)
grad.wrt(x, callback=save_to(x))
# need a placeholder to trace operator
send_x = remote_send(x, 1)
recv_x = remote_recv(1, x_np.shape, x_np.dtype, "gpu0")
y = recv_x * recv_x
grad([y], [as_tensor(np.ones_like(x_np))])
np.testing.assert_almost_equal(x.grad.numpy(), x.numpy() * 2)
def worker1():
dist.init_process_group("localhost", port, world_size, 1, 1)
mge.device.set_default_device("gpu1")
grad = Grad()
recv_x = remote_recv(0, x_np.shape, x_np.dtype, "gpu1")
send_x = remote_send(recv_x, 0)
grad([], [])
# sync because grad has a send operator
sync()
send_x.device._cn._sync_all()
import multiprocessing as mp
p0 = mp.Process(target=worker0)
p1 = mp.Process(target=worker1)
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
def test_grad():
x_np = np.random.rand(10).astype("float32")
x = as_tensor(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = cos(x)
grad(y, as_tensor(np.ones_like(x_np)))
np.testing.assert_almost_equal(x.grad.numpy(), -np.sin(x_np))
def test_grad_2():
x_np = np.random.rand(10).astype("float32")
x = as_tensor(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = mul(x, x)
y = mul(y, y)
grad(y, as_tensor(np.ones_like(x_np)))
np.testing.assert_almost_equal(x.grad.numpy(), 4 * x_np ** 3, decimal=6)
@pytest.mark.skip(reason="high order gradient was not implemented yet")
def test_2nd_grad():
x_np = np.random.rand(10).astype("float32")
x = as_tensor(x_np)
ones = as_tensor(np.ones_like(x_np))
grad = Grad().wrt(x, callback=save_to(x))
grad2 = Grad().wrt(x, callback=save_to(x))
y = cos(x)
grad(y, ones)
np.testing.assert_almost_equal(x.grad.numpy(), -np.sin(x_np), decimal=5)
grad2(x.grad, ones)
np.testing.assert_almost_equal(x.grad.numpy(), -np.cos(x_np))
def test_grad_with_tensor_wrapper():
x_np = np.random.rand(10).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = mul(x, x)
y = mul(y, y)
grad(y, TensorWrapper(np.ones_like(x_np)))
np.testing.assert_almost_equal(x.grad.numpy(), 4 * x_np ** 3, decimal=6)
def test_release():
def check(f):
n = 0
d = None
gc.disable()
try:
for i in range(3):
f()
m = len(gc.get_objects())
d = m - n
n = m
assert d == 0
finally:
gc.enable()
x = TensorWrapper([0.0])
dy = TensorWrapper(np.ones_like(x.numpy()))
@check
def _():
g = Grad().wrt(x)
y = x * x
g(y, dy)
@check
def _():
with Grad().wrt(x) as g:
pass
@check
def _():
with Grad().wrt(x) as g:
y = x * x
def test_grad_inplace():
x_np = np.random.rand(10).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = mul(x, x)
y *= y
grad(y, TensorWrapper(np.ones_like(x_np)))
np.testing.assert_almost_equal(x.grad.numpy(), 4 * x_np ** 3, decimal=6)
def test_elemwise_add():
x_np = np.random.rand(10).astype("float32")
y_np = np.random.rand(10, 10).astype("float32")
dz_np = np.random.rand(10, 10).astype("float32")
x = TensorWrapper(x_np)
y = TensorWrapper(y_np)
dz = TensorWrapper(dz_np)
refs = {}
def f(x, y):
x = x * 2
refs["x"] = weakref.ref(x.__wrapped__)
refs["y"] = weakref.ref(y.__wrapped__)
return x + y
grad = Grad().wrt(x, callback=save_to(x))
z = f(x, y)
del y
for k, r in refs.items():
assert r() is None
grad(z, dz)
np.testing.assert_almost_equal(x.grad.numpy(), dz_np.sum(0) * 2, decimal=5)
def test_elemwise_relu():
x_np = [1.0, -1.0]
dz_np = [1.0]
x = TensorWrapper(x_np)
dz = TensorWrapper(dz_np)
refs = {}
def f(x):
x = x * 2
refs["x"] = weakref.ref(x.__wrapped__)
return relu(x)
grad = Grad().wrt(x, callback=save_to(x))
z = f(x)
assert refs["x"]() is None
grad(z, dz)
np.testing.assert_almost_equal(x.grad.numpy(), [2.0, 0])
def test_elemwise_relu_backward_fn():
op = Elemwise(Elemwise.Mode.RELU)
attr = TensorAttr()
attr.dtype = "float32"
attr.comp_node = "xpux"
result = imperative.make_backward_graph(op, [attr], [True], [True])
backward_graph, save_for_backward_mask, input_has_grad = result
assert save_for_backward_mask == [False, True, True], save_for_backward_mask
def test_reshape():
x_np = np.random.rand(2, 5).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = x.reshape(5, 2)
grad(y, F.ones_like(y))
np.testing.assert_equal(np.ones((2, 5), dtype=np.float32), x.grad.numpy())
def test_subtensor():
x_np = np.random.rand(3, 3).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = x[1:-1, :2]
grad(y, F.ones_like(y))
np.testing.assert_equal(
np.array([[0, 0, 0], [1, 1, 0], [0, 0, 0]], dtype=np.float32), x.grad.numpy()
)
def test_IndexingMultiAxisVec():
x_np = np.random.rand(3, 3).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = x[[0, 2], [0, 2]]
grad(y, F.ones_like(y))
np.testing.assert_equal(
np.array([[1, 0, 0], [0, 0, 0], [0, 0, 1]], dtype=np.float32), x.grad.numpy()
)
def test_AxisAddRemove():
x_np = np.random.rand(1, 5).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = F.squeeze(F.expand_dims(x, 2), 0)
grad(y, F.ones_like(y))
np.testing.assert_equal(
np.array([[1, 1, 1, 1, 1]], dtype=np.float32), x.grad.numpy()
)
def test_Broadcast():
x_np = np.random.rand(3, 3, 1).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = F.broadcast_to(x, (3, 3, 10))
grad(y, F.ones_like(y))
np.testing.assert_equal(np.ones((3, 3, 1), dtype=np.float32) * 10, x.grad.numpy())
def test_Reduce_sum():
x_np = np.random.rand(3, 3).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = x.sum(axis=0)
grad(y, F.ones_like(y))
np.testing.assert_equal(np.ones((3, 3), dtype=np.float32), x.grad.numpy())
def test_Reduce_mean():
x_np = np.random.rand(3, 3).astype("float32")
x = TensorWrapper(x_np)
grad = Grad().wrt(x, callback=save_to(x))
y = x.mean(axis=0)
grad(y, F.ones_like(y))
np.testing.assert_equal(np.ones((3, 3), dtype=np.float32) / 3, x.grad.numpy())
|
[
"megengine.core._imperative_rt.imperative.make_backward_graph",
"megengine.functional.distributed.remote_send",
"megengine.functional.expand_dims",
"megengine.functional.distributed.remote_recv",
"megengine.core._imperative_rt.imperative.sync",
"megengine.distributed.init_process_group",
"megengine.functional.ones_like",
"megengine.core.tensor.tensor.apply",
"megengine.core.autodiff.grad.Grad",
"megengine.distributed.Server",
"megengine.core.tensor.tensor_wrapper.TensorWrapper",
"megengine.core._imperative_rt.TensorAttr",
"megengine.device.set_default_device",
"megengine.functional.broadcast_to",
"megengine.distributed.get_free_ports",
"megengine.device.get_default_device",
"megengine.core.ops.builtin.Elemwise"
] |
[((3488, 3558), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""high order gradient was not implemented yet"""'}), "(reason='high order gradient was not implemented yet')\n", (3504, 3558), False, 'import pytest\n'), ((1041, 1055), 'megengine.core.ops.builtin.Elemwise', 'Elemwise', (['mode'], {}), '(mode)\n', (1049, 1055), False, 'from megengine.core.ops.builtin import Elemwise\n'), ((1778, 1795), 'megengine.distributed.Server', 'dist.Server', (['port'], {}), '(port)\n', (1789, 1795), True, 'import megengine.distributed as dist\n'), ((2749, 2775), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker0'}), '(target=worker0)\n', (2759, 2775), True, 'import multiprocessing as mp\n'), ((2785, 2811), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker1'}), '(target=worker1)\n', (2795, 2811), True, 'import multiprocessing as mp\n'), ((4085, 4104), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (4098, 4104), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((4636, 4656), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['[0.0]'], {}), '([0.0])\n', (4649, 4656), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((5029, 5048), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (5042, 5048), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((5439, 5458), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (5452, 5458), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((5467, 5486), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['y_np'], {}), '(y_np)\n', (5480, 5486), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((5496, 5516), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['dz_np'], {}), '(dz_np)\n', (5509, 5516), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((5989, 6008), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (6002, 6008), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((6018, 6038), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['dz_np'], {}), '(dz_np)\n', (6031, 6038), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((6377, 6405), 'megengine.core.ops.builtin.Elemwise', 'Elemwise', (['Elemwise.Mode.RELU'], {}), '(Elemwise.Mode.RELU)\n', (6385, 6405), False, 'from megengine.core.ops.builtin import Elemwise\n'), ((6417, 6429), 'megengine.core._imperative_rt.TensorAttr', 'TensorAttr', ([], {}), '()\n', (6427, 6429), False, 'from megengine.core._imperative_rt import TensorAttr, imperative\n'), ((6498, 6556), 'megengine.core._imperative_rt.imperative.make_backward_graph', 'imperative.make_backward_graph', (['op', '[attr]', '[True]', '[True]'], {}), '(op, [attr], [True], [True])\n', (6528, 6556), False, 'from megengine.core._imperative_rt import TensorAttr, imperative\n'), ((6786, 6805), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (6799, 6805), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((7067, 7086), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (7080, 7086), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((7397, 7416), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (7410, 7416), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((7726, 7745), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (7739, 7745), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((8054, 8073), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (8067, 8073), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((8129, 8158), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['x', '(3, 3, 10)'], {}), '(x, (3, 3, 10))\n', (8143, 8158), True, 'import megengine.functional as F\n'), ((8358, 8377), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (8371, 8377), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((8639, 8658), 'megengine.core.tensor.tensor_wrapper.TensorWrapper', 'TensorWrapper', (['x_np'], {}), '(x_np)\n', (8652, 8658), False, 'from megengine.core.tensor.tensor_wrapper import TensorWrapper\n'), ((1095, 1111), 'megengine.core.tensor.tensor.apply', 'apply', (['op', '*args'], {}), '(op, *args)\n', (1100, 1111), False, 'from megengine.core.tensor.tensor import Tensor, apply\n'), ((1739, 1761), 'megengine.distributed.get_free_ports', 'dist.get_free_ports', (['(1)'], {}), '(1)\n', (1758, 1761), True, 'import megengine.distributed as dist\n'), ((1824, 1884), 'megengine.distributed.init_process_group', 'dist.init_process_group', (['"""localhost"""', 'port', 'world_size', '(0)', '(0)'], {}), "('localhost', port, world_size, 0, 0)\n", (1847, 1884), True, 'import megengine.distributed as dist\n'), ((1893, 1930), 'megengine.device.set_default_device', 'mge.device.set_default_device', (['"""gpu0"""'], {}), "('gpu0')\n", (1922, 1930), True, 'import megengine as mge\n'), ((1946, 1952), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (1950, 1952), False, 'from megengine.core.autodiff.grad import Grad\n'), ((2087, 2104), 'megengine.functional.distributed.remote_send', 'remote_send', (['x', '(1)'], {}), '(x, 1)\n', (2098, 2104), False, 'from megengine.functional.distributed import remote_recv, remote_send\n'), ((2122, 2168), 'megengine.functional.distributed.remote_recv', 'remote_recv', (['(1)', 'x_np.shape', 'x_np.dtype', '"""gpu0"""'], {}), "(1, x_np.shape, x_np.dtype, 'gpu0')\n", (2133, 2168), False, 'from megengine.functional.distributed import remote_recv, remote_send\n'), ((2347, 2407), 'megengine.distributed.init_process_group', 'dist.init_process_group', (['"""localhost"""', 'port', 'world_size', '(1)', '(1)'], {}), "('localhost', port, world_size, 1, 1)\n", (2370, 2407), True, 'import megengine.distributed as dist\n'), ((2416, 2453), 'megengine.device.set_default_device', 'mge.device.set_default_device', (['"""gpu1"""'], {}), "('gpu1')\n", (2445, 2453), True, 'import megengine as mge\n'), ((2469, 2475), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (2473, 2475), False, 'from megengine.core.autodiff.grad import Grad\n'), ((2494, 2540), 'megengine.functional.distributed.remote_recv', 'remote_recv', (['(0)', 'x_np.shape', 'x_np.dtype', '"""gpu1"""'], {}), "(0, x_np.shape, x_np.dtype, 'gpu1')\n", (2505, 2540), False, 'from megengine.functional.distributed import remote_recv, remote_send\n'), ((2558, 2580), 'megengine.functional.distributed.remote_send', 'remote_send', (['recv_x', '(0)'], {}), '(recv_x, 0)\n', (2569, 2580), False, 'from megengine.functional.distributed import remote_recv, remote_send\n'), ((2660, 2666), 'megengine.core._imperative_rt.imperative.sync', 'sync', ([], {}), '()\n', (2664, 2666), False, 'from megengine.core._imperative_rt.imperative import sync\n'), ((1562, 1579), 'platform.system', 'platform.system', ([], {}), '()\n', (1577, 1579), False, 'import platform\n'), ((3673, 3691), 'numpy.ones_like', 'np.ones_like', (['x_np'], {}), '(x_np)\n', (3685, 3691), True, 'import numpy as np\n'), ((4393, 4405), 'gc.disable', 'gc.disable', ([], {}), '()\n', (4403, 4405), False, 'import gc\n'), ((5588, 5614), 'weakref.ref', 'weakref.ref', (['x.__wrapped__'], {}), '(x.__wrapped__)\n', (5599, 5614), False, 'import weakref\n'), ((5635, 5661), 'weakref.ref', 'weakref.ref', (['y.__wrapped__'], {}), '(y.__wrapped__)\n', (5646, 5661), False, 'import weakref\n'), ((6107, 6133), 'weakref.ref', 'weakref.ref', (['x.__wrapped__'], {}), '(x.__wrapped__)\n', (6118, 6133), False, 'import weakref\n'), ((6890, 6904), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (6901, 6904), True, 'import megengine.functional as F\n'), ((6934, 6967), 'numpy.ones', 'np.ones', (['(2, 5)'], {'dtype': 'np.float32'}), '((2, 5), dtype=np.float32)\n', (6941, 6967), True, 'import numpy as np\n'), ((7167, 7181), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (7178, 7181), True, 'import megengine.functional as F\n'), ((7220, 7281), 'numpy.array', 'np.array', (['[[0, 0, 0], [1, 1, 0], [0, 0, 0]]'], {'dtype': 'np.float32'}), '([[0, 0, 0], [1, 1, 0], [0, 0, 0]], dtype=np.float32)\n', (7228, 7281), True, 'import numpy as np\n'), ((7503, 7517), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (7514, 7517), True, 'import megengine.functional as F\n'), ((7556, 7617), 'numpy.array', 'np.array', (['[[1, 0, 0], [0, 0, 0], [0, 0, 1]]'], {'dtype': 'np.float32'}), '([[1, 0, 0], [0, 0, 0], [0, 0, 1]], dtype=np.float32)\n', (7564, 7617), True, 'import numpy as np\n'), ((7811, 7830), 'megengine.functional.expand_dims', 'F.expand_dims', (['x', '(2)'], {}), '(x, 2)\n', (7824, 7830), True, 'import megengine.functional as F\n'), ((7848, 7862), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (7859, 7862), True, 'import megengine.functional as F\n'), ((7901, 7946), 'numpy.array', 'np.array', (['[[1, 1, 1, 1, 1]]'], {'dtype': 'np.float32'}), '([[1, 1, 1, 1, 1]], dtype=np.float32)\n', (7909, 7946), True, 'import numpy as np\n'), ((8172, 8186), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (8183, 8186), True, 'import megengine.functional as F\n'), ((8460, 8474), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (8471, 8474), True, 'import megengine.functional as F\n'), ((8504, 8537), 'numpy.ones', 'np.ones', (['(3, 3)'], {'dtype': 'np.float32'}), '((3, 3), dtype=np.float32)\n', (8511, 8537), True, 'import numpy as np\n'), ((8742, 8756), 'megengine.functional.ones_like', 'F.ones_like', (['y'], {}), '(y)\n', (8753, 8756), True, 'import megengine.functional as F\n'), ((1691, 1709), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (1705, 1709), True, 'import numpy as np\n'), ((2953, 2971), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (2967, 2971), True, 'import numpy as np\n'), ((3026, 3032), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (3030, 3032), False, 'from megengine.core.autodiff.grad import Grad\n'), ((3100, 3118), 'numpy.ones_like', 'np.ones_like', (['x_np'], {}), '(x_np)\n', (3112, 3118), True, 'import numpy as np\n'), ((3173, 3185), 'numpy.sin', 'np.sin', (['x_np'], {}), '(x_np)\n', (3179, 3185), True, 'import numpy as np\n'), ((3219, 3237), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (3233, 3237), True, 'import numpy as np\n'), ((3292, 3298), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (3296, 3298), False, 'from megengine.core.autodiff.grad import Grad\n'), ((3387, 3405), 'numpy.ones_like', 'np.ones_like', (['x_np'], {}), '(x_np)\n', (3399, 3405), True, 'import numpy as np\n'), ((3591, 3609), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (3605, 3609), True, 'import numpy as np\n'), ((3705, 3711), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (3709, 3711), False, 'from megengine.core.autodiff.grad import Grad\n'), ((3752, 3758), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (3756, 3758), False, 'from megengine.core.autodiff.grad import Grad\n'), ((3874, 3886), 'numpy.sin', 'np.sin', (['x_np'], {}), '(x_np)\n', (3880, 3886), True, 'import numpy as np\n'), ((3976, 3988), 'numpy.cos', 'np.cos', (['x_np'], {}), '(x_np)\n', (3982, 3988), True, 'import numpy as np\n'), ((4040, 4058), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (4054, 4058), True, 'import numpy as np\n'), ((4117, 4123), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4121, 4123), False, 'from megengine.core.autodiff.grad import Grad\n'), ((4216, 4234), 'numpy.ones_like', 'np.ones_like', (['x_np'], {}), '(x_np)\n', (4228, 4234), True, 'import numpy as np\n'), ((4615, 4626), 'gc.enable', 'gc.enable', ([], {}), '()\n', (4624, 4626), False, 'import gc\n'), ((4984, 5002), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (4998, 5002), True, 'import numpy as np\n'), ((5061, 5067), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (5065, 5067), False, 'from megengine.core.autodiff.grad import Grad\n'), ((5153, 5171), 'numpy.ones_like', 'np.ones_like', (['x_np'], {}), '(x_np)\n', (5165, 5171), True, 'import numpy as np\n'), ((5289, 5307), 'numpy.random.rand', 'np.random.rand', (['(10)'], {}), '(10)\n', (5303, 5307), True, 'import numpy as np\n'), ((5337, 5359), 'numpy.random.rand', 'np.random.rand', (['(10)', '(10)'], {}), '(10, 10)\n', (5351, 5359), True, 'import numpy as np\n'), ((5390, 5412), 'numpy.random.rand', 'np.random.rand', (['(10)', '(10)'], {}), '(10, 10)\n', (5404, 5412), True, 'import numpy as np\n'), ((5695, 5701), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (5699, 5701), False, 'from megengine.core.autodiff.grad import Grad\n'), ((6169, 6175), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (6173, 6175), False, 'from megengine.core.autodiff.grad import Grad\n'), ((6739, 6759), 'numpy.random.rand', 'np.random.rand', (['(2)', '(5)'], {}), '(2, 5)\n', (6753, 6759), True, 'import numpy as np\n'), ((6818, 6824), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (6822, 6824), False, 'from megengine.core.autodiff.grad import Grad\n'), ((7020, 7040), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)'], {}), '(3, 3)\n', (7034, 7040), True, 'import numpy as np\n'), ((7099, 7105), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (7103, 7105), False, 'from megengine.core.autodiff.grad import Grad\n'), ((7350, 7370), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)'], {}), '(3, 3)\n', (7364, 7370), True, 'import numpy as np\n'), ((7429, 7435), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (7433, 7435), False, 'from megengine.core.autodiff.grad import Grad\n'), ((7679, 7699), 'numpy.random.rand', 'np.random.rand', (['(1)', '(5)'], {}), '(1, 5)\n', (7693, 7699), True, 'import numpy as np\n'), ((7758, 7764), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (7762, 7764), False, 'from megengine.core.autodiff.grad import Grad\n'), ((8004, 8027), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)', '(1)'], {}), '(3, 3, 1)\n', (8018, 8027), True, 'import numpy as np\n'), ((8086, 8092), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (8090, 8092), False, 'from megengine.core.autodiff.grad import Grad\n'), ((8216, 8252), 'numpy.ones', 'np.ones', (['(3, 3, 1)'], {'dtype': 'np.float32'}), '((3, 3, 1), dtype=np.float32)\n', (8223, 8252), True, 'import numpy as np\n'), ((8311, 8331), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)'], {}), '(3, 3)\n', (8325, 8331), True, 'import numpy as np\n'), ((8390, 8396), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (8394, 8396), False, 'from megengine.core.autodiff.grad import Grad\n'), ((8592, 8612), 'numpy.random.rand', 'np.random.rand', (['(3)', '(3)'], {}), '(3, 3)\n', (8606, 8612), True, 'import numpy as np\n'), ((8671, 8677), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (8675, 8677), False, 'from megengine.core.autodiff.grad import Grad\n'), ((8786, 8819), 'numpy.ones', 'np.ones', (['(3, 3)'], {'dtype': 'np.float32'}), '((3, 3), dtype=np.float32)\n', (8793, 8819), True, 'import numpy as np\n'), ((1346, 1377), 'megengine.device.get_default_device', 'mge.device.get_default_device', ([], {}), '()\n', (1375, 1377), True, 'import megengine as mge\n'), ((4742, 4748), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4746, 4748), False, 'from megengine.core.autodiff.grad import Grad\n'), ((2227, 2245), 'numpy.ones_like', 'np.ones_like', (['x_np'], {}), '(x_np)\n', (2239, 2245), True, 'import numpy as np\n'), ((4494, 4510), 'gc.get_objects', 'gc.get_objects', ([], {}), '()\n', (4508, 4510), False, 'import gc\n'), ((4829, 4835), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4833, 4835), False, 'from megengine.core.autodiff.grad import Grad\n'), ((4904, 4910), 'megengine.core.autodiff.grad.Grad', 'Grad', ([], {}), '()\n', (4908, 4910), False, 'from megengine.core.autodiff.grad import Grad\n')]
|
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import multiprocessing as mp
import platform
import queue
from time import sleep
import pytest
import megengine as mge
import megengine._internal as mgb
import megengine.distributed as dist
_LOCALHOST = "127.0.0.1"
def _assert_q_empty(q):
try:
res = q.get(timeout=1)
except Exception as e:
assert isinstance(e, queue.Empty)
else:
assert False, "queue is not empty"
def _assert_q_val(q, val):
ret = q.get()
assert ret == val
def _init_process_group_wrapper(world_size, rank, dev, backend, q):
if rank == 0:
dist.init_process_group(_LOCALHOST, 0, world_size, rank, dev, backend)
q.put(dist.get_master_port())
else:
port = q.get()
dist.init_process_group(_LOCALHOST, port, world_size, rank, dev, backend)
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.isolated_distributed
def test_create_mm_server():
def worker():
if not mge.is_cuda_available():
return
port = mgb.config.create_mm_server("0.0.0.0", 0)
assert port > 0
res = mgb.config.create_mm_server("0.0.0.0", port)
assert res == -1
p = mp.Process(target=worker)
p.start()
p.join(10)
assert p.exitcode == 0
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.isolated_distributed
def test_init_process_group():
world_size = 2
def worker(rank, backend, q):
if not mge.is_cuda_available():
return
_init_process_group_wrapper(world_size, rank, rank, backend, q)
assert dist.is_distributed() == True
assert dist.get_master_ip() == _LOCALHOST
assert dist.get_master_port() > 0
assert dist.get_world_size() == world_size
assert dist.get_rank() == rank
assert dist.get_backend() == backend
def check(backend):
Q = mp.Queue()
p0 = mp.Process(target=worker, args=(0, backend, Q))
p1 = mp.Process(target=worker, args=(1, backend, Q))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
check("nccl")
check("ucx")
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.isolated_distributed
def test_group_barrier():
world_size = 2
ip = "127.0.0.1"
backend = "nccl"
def worker(rank, q):
if not mge.is_cuda_available():
return
_init_process_group_wrapper(world_size, rank, rank, backend, q)
dist.group_barrier()
if rank == 0:
dist.group_barrier()
q.put(0) # to be observed in rank 1
else:
_assert_q_empty(q) # q.put(0) is not executed in rank 0
dist.group_barrier()
_assert_q_val(q, 0) # q.put(0) executed in rank 0
Q = mp.Queue()
p0 = mp.Process(target=worker, args=(0, Q))
p1 = mp.Process(target=worker, args=(1, Q))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
@pytest.mark.skipif(
platform.system() == "Darwin", reason="do not imp GPU mode at macos now"
)
@pytest.mark.isolated_distributed
def test_synchronized():
world_size = 2
backend = "nccl"
@dist.synchronized
def func(rank, q):
q.put(rank)
def worker(rank, q):
if not mge.is_cuda_available():
return
_init_process_group_wrapper(world_size, rank, rank, backend, q)
dist.group_barrier()
if rank == 0:
func(0, q) # q.put(0)
q.put(2)
else:
_assert_q_val(q, 0) # func executed in rank 0
_assert_q_empty(q) # q.put(2) is not executed
func(1, q)
_assert_q_val(
q, 1
) # func in rank 1 executed earlier than q.put(2) in rank 0
_assert_q_val(q, 2) # q.put(2) executed in rank 0
Q = mp.Queue()
p0 = mp.Process(target=worker, args=(0, Q))
p1 = mp.Process(target=worker, args=(1, Q))
p0.start()
p1.start()
p0.join(10)
p1.join(10)
assert p0.exitcode == 0 and p1.exitcode == 0
|
[
"megengine.distributed.group_barrier",
"megengine.distributed.get_backend",
"megengine.distributed.get_master_ip",
"megengine.distributed.get_master_port",
"megengine.distributed.get_rank",
"megengine.distributed.init_process_group",
"megengine.distributed.is_distributed",
"megengine.distributed.get_world_size",
"megengine.is_cuda_available",
"megengine._internal.config.create_mm_server"
] |
[((1564, 1589), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker'}), '(target=worker)\n', (1574, 1589), True, 'import multiprocessing as mp\n'), ((3314, 3324), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (3322, 3324), True, 'import multiprocessing as mp\n'), ((3334, 3372), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, Q)'}), '(target=worker, args=(0, Q))\n', (3344, 3372), True, 'import multiprocessing as mp\n'), ((3382, 3420), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, Q)'}), '(target=worker, args=(1, Q))\n', (3392, 3420), True, 'import multiprocessing as mp\n'), ((4415, 4425), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (4423, 4425), True, 'import multiprocessing as mp\n'), ((4435, 4473), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, Q)'}), '(target=worker, args=(0, Q))\n', (4445, 4473), True, 'import multiprocessing as mp\n'), ((4483, 4521), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, Q)'}), '(target=worker, args=(1, Q))\n', (4493, 4521), True, 'import multiprocessing as mp\n'), ((924, 994), 'megengine.distributed.init_process_group', 'dist.init_process_group', (['_LOCALHOST', '(0)', 'world_size', 'rank', 'dev', 'backend'], {}), '(_LOCALHOST, 0, world_size, rank, dev, backend)\n', (947, 994), True, 'import megengine.distributed as dist\n'), ((1074, 1147), 'megengine.distributed.init_process_group', 'dist.init_process_group', (['_LOCALHOST', 'port', 'world_size', 'rank', 'dev', 'backend'], {}), '(_LOCALHOST, port, world_size, rank, dev, backend)\n', (1097, 1147), True, 'import megengine.distributed as dist\n'), ((1405, 1446), 'megengine._internal.config.create_mm_server', 'mgb.config.create_mm_server', (['"""0.0.0.0"""', '(0)'], {}), "('0.0.0.0', 0)\n", (1432, 1446), True, 'import megengine._internal as mgb\n'), ((1485, 1529), 'megengine._internal.config.create_mm_server', 'mgb.config.create_mm_server', (['"""0.0.0.0"""', 'port'], {}), "('0.0.0.0', port)\n", (1512, 1529), True, 'import megengine._internal as mgb\n'), ((1175, 1192), 'platform.system', 'platform.system', ([], {}), '()\n', (1190, 1192), False, 'import platform\n'), ((2310, 2320), 'multiprocessing.Queue', 'mp.Queue', ([], {}), '()\n', (2318, 2320), True, 'import multiprocessing as mp\n'), ((2334, 2381), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(0, backend, Q)'}), '(target=worker, args=(0, backend, Q))\n', (2344, 2381), True, 'import multiprocessing as mp\n'), ((2395, 2442), 'multiprocessing.Process', 'mp.Process', ([], {'target': 'worker', 'args': '(1, backend, Q)'}), '(target=worker, args=(1, backend, Q))\n', (2405, 2442), True, 'import multiprocessing as mp\n'), ((1676, 1693), 'platform.system', 'platform.system', ([], {}), '()\n', (1691, 1693), False, 'import platform\n'), ((3001, 3021), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (3019, 3021), True, 'import megengine.distributed as dist\n'), ((2640, 2657), 'platform.system', 'platform.system', ([], {}), '()\n', (2655, 2657), False, 'import platform\n'), ((3968, 3988), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (3986, 3988), True, 'import megengine.distributed as dist\n'), ((3562, 3579), 'platform.system', 'platform.system', ([], {}), '()\n', (3577, 3579), False, 'import platform\n'), ((1009, 1031), 'megengine.distributed.get_master_port', 'dist.get_master_port', ([], {}), '()\n', (1029, 1031), True, 'import megengine.distributed as dist\n'), ((1346, 1369), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (1367, 1369), True, 'import megengine as mge\n'), ((1885, 1908), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (1906, 1908), True, 'import megengine as mge\n'), ((2016, 2037), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (2035, 2037), True, 'import megengine.distributed as dist\n'), ((2061, 2081), 'megengine.distributed.get_master_ip', 'dist.get_master_ip', ([], {}), '()\n', (2079, 2081), True, 'import megengine.distributed as dist\n'), ((2111, 2133), 'megengine.distributed.get_master_port', 'dist.get_master_port', ([], {}), '()\n', (2131, 2133), True, 'import megengine.distributed as dist\n'), ((2153, 2174), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (2172, 2174), True, 'import megengine.distributed as dist\n'), ((2204, 2219), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2217, 2219), True, 'import megengine.distributed as dist\n'), ((2243, 2261), 'megengine.distributed.get_backend', 'dist.get_backend', ([], {}), '()\n', (2259, 2261), True, 'import megengine.distributed as dist\n'), ((2877, 2900), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (2898, 2900), True, 'import megengine as mge\n'), ((3056, 3076), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (3074, 3076), True, 'import megengine.distributed as dist\n'), ((3221, 3241), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (3239, 3241), True, 'import megengine.distributed as dist\n'), ((3844, 3867), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (3865, 3867), True, 'import megengine as mge\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import io
from tempfile import mkstemp
import numpy as np
import pytest
import megengine.core.tensor.megbrain_graph as G
import megengine.functional as F
import megengine.optimizer as optim
import megengine.utils.comp_graph_tools as cgtools
from megengine import Parameter, tensor
from megengine.autodiff import GradManager
from megengine.core._trace_option import set_symbolic_shape
from megengine.core.ops import builtin as ops
from megengine.core.ops.builtin import Elemwise
from megengine.core.tensor.utils import isscalar
from megengine.functional import exp, log
from megengine.jit import exclude_from_trace, trace
from megengine.module import Module
from megengine.random import normal, uniform
def test_trace():
for symbolic in [False, True]:
@trace(symbolic=symbolic)
def f(x):
return -x
x = tensor([1])
y = f(x).numpy()
for i in range(3):
np.testing.assert_equal(f(x).numpy(), y)
def test_output_copy_trace():
class Simple(Module):
def __init__(self):
super().__init__()
self.a = Parameter([1.0], dtype=np.float32)
def forward(self, x):
x = x * self.a
# will result into a copy of output in grad
x = F.exp(x)
return x
net = Simple()
gm = GradManager().attach(net.parameters())
opt = optim.SGD(net.parameters(), 1e-3, momentum=0.9)
data = tensor(np.arange(4).reshape(2, 2), dtype="float32")
@trace(symbolic=False)
def train_f1(d):
with gm:
loss = net(d)
gm.backward(loss)
opt.step().clear_grad()
return loss
@trace(symbolic=True)
def train_f2(d):
with gm:
loss = net(d)
gm.backward(loss)
opt.step().clear_grad()
return loss
for i in range(2):
y1 = train_f1(data).numpy()
y2 = train_f2(data).numpy()
np.testing.assert_equal(y1, y2)
def test_exclude_from_trace():
for symbolic in [False, True]:
@trace(symbolic=symbolic)
def f(x):
x = -x
with exclude_from_trace():
if i % 2:
x = -x
x = -x
return x
x = tensor([1])
for i in range(3):
y = f(x).numpy()
np.testing.assert_equal(f(x).numpy(), y)
def test_print_in_trace():
for symbolic in [False]: # cannot read value in symbolic mode
@trace(symbolic=symbolic)
def f(x):
nonlocal buf
x = -x
buf = x.numpy()
x = -x
return x
buf = None
x = tensor([1])
for i in range(3):
y = f(x).numpy()
z = buf
buf = None
np.testing.assert_equal(f(x).numpy(), y)
np.testing.assert_equal(z, buf)
def test_dump():
@trace(symbolic=True, capture_as_const=True)
def f(a, b):
return a + b
a = tensor([2])
b = tensor([4])
y = f(a, b).numpy()
for i in range(3):
np.testing.assert_equal(f(a, b).numpy(), y)
file = io.BytesIO()
dump_info = f.dump(file)
assert dump_info.nr_opr == 3
np.testing.assert_equal(dump_info.inputs, ["arg_0", "arg_1"])
np.testing.assert_equal(dump_info.outputs, ["ADD(arg_0,arg_1)[4]"])
file.seek(0)
result = cgtools.load_and_inference(file, [a, b])
np.testing.assert_equal(result[0], y)
def test_capture_dump():
a = tensor([2])
@trace(symbolic=True, capture_as_const=True)
def f(x):
return x * a
x = tensor([3])
y = f(x).numpy()
for i in range(3):
np.testing.assert_equal(f(x).numpy(), y)
file = io.BytesIO()
f.dump(file)
file.seek(0)
result = cgtools.load_and_inference(file, [x])
np.testing.assert_equal(result[0], y)
def test_dump_volatile():
p = tensor([2])
@trace(symbolic=True, capture_as_const=True)
def f(x):
return x * p
x = tensor([3])
y = f(x).numpy()
for i in range(3):
np.testing.assert_equal(f(x).numpy(), y)
file = io.BytesIO()
f.dump(file, optimize_for_inference=False)
file.seek(0)
cg, _, outputs = G.load_graph(file)
(out,) = outputs
assert (
cgtools.get_owner_opr_type(cgtools.get_owner_opr_inputs(out)[1])
== "ImmutableTensor"
)
def test_trace_profiler():
for symbolic in [False, True]:
@trace(symbolic=symbolic, profiling=True)
def f(x):
return -x
x = tensor([1])
y = f(x).numpy()
f(x)
f(x) # XXX: has to run twice
out = f.get_profile()
assert out.get("profiler")
@pytest.mark.skip(reason="force opt_level=0 when building graph")
def test_goptions():
@trace(symbolic=True, opt_level=0, capture_as_const=True)
def f(x):
# directly return x / x will not trigger gopt
# since there's no way to tell the two x are the same
y = 2.0 * x
return y / y
@trace(symbolic=True, opt_level=1, capture_as_const=True)
def g(x):
y = 2.0 * x
return y / y
d = tensor(0.0)
assert not np.isfinite(f(d).numpy())
np.testing.assert_equal(g(d).numpy().item(), 1.0)
@pytest.mark.skip(reason="force opt_level=0 when building graph")
def test_goptions_log_sum_exp():
@trace(symbolic=True, opt_level=0, capture_as_const=True)
def f(x, y):
return log(exp(x) + exp(y))
@trace(symbolic=True, opt_level=1, capture_as_const=True)
def g(x, y):
return log(exp(x) + exp(y))
val = 1.0e4
d = tensor(val)
o = tensor(0.0)
assert not np.isfinite(f(d, o).numpy())
np.testing.assert_almost_equal(g(d, o), val)
@pytest.mark.skip(reason="could not use opt_level=0 with dump")
def test_goptions_log_exp():
@trace(symbolic=True, opt_level=0, capture_as_const=True)
def f(x):
return log(exp(x))
@trace(symbolic=True, opt_level=1, capture_as_const=True)
def g(x):
return log(exp(x))
f(tensor(1.0))
_, out = mkstemp()
f.dump(out, optimize_for_inference=False)
*_, outputs = G.load_graph(out)
oprs_1 = cgtools.get_oprs_seq(outputs)
g(tensor(1.0))
g.dump(out, optimize_for_inference=False)
*_, outputs = G.load_graph(out)
oprs_2 = cgtools.get_oprs_seq(outputs)
assert len(oprs_1) - len(oprs_2) == 2
def test_optimize_for_inference():
@trace(symbolic=True, capture_as_const=True)
def f(x):
return exp(x)
_, out = mkstemp()
f(tensor(5.0))
f.dump(out, enable_io16xc32=True)
res = G.load_graph(out)
computing_input = res.output_vars_list[0].owner.inputs[0]
assert computing_input.dtype == np.float16
def test_optimize_for_inference_broadcast():
a = tensor(np.ones(1, dtype=np.float32))
@trace(capture_as_const=True, symbolic_shape=True)
def f():
return a._broadcast(tensor([1, 10], dtype=np.int32))
f()
f.dump(io.BytesIO())
def test_trace_cvt_bool():
x = tensor([0], dtype=np.int32)
@trace(symbolic=True)
def f(x):
a = x.shape
b = a[0]
assert isscalar(b)
return b == 0
for i in range(3):
np.testing.assert_equal(f(x).numpy(), False)
def test_trace_reshape():
for symbolic in [False, True]:
x1 = tensor(np.random.randn(2, 10, 10))
x2 = tensor(np.random.randn(4, 10, 10))
x3 = tensor(np.random.randn(8, 10, 10))
@trace(symbolic=symbolic, capture_as_const=True)
def f(x):
y = x.reshape(x.shape[0], 100)
return y
f(x1)
f(x2)
f(x3)
def test_trace_topk():
x = tensor([5, 2, 7, 1, 0, 3, 2])
@trace(symbolic=True)
def f(x):
y = F.topk(x, 3)
np.testing.assert_equal(y[0].shape.numpy(), np.array([3,]))
return y
for i in range(3):
f(x)
def test_trace_warp_perspective():
inp_shape = (1, 1, 4, 4)
x = tensor(np.arange(16, dtype=np.float32).reshape(inp_shape))
M_shape = (1, 3, 3)
M = tensor(
np.array(
[[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]], dtype=np.float32
).reshape(M_shape)
)
@trace(symbolic=True)
def f(x, M):
out = F.warp_perspective(x, M, (2, 2))
np.testing.assert_equal(out.shape.numpy(), np.array([1, 1, 2, 2]))
return out
for i in range(1):
f(x, M)
def test_raise_on_trace():
step_count = 0
catch_count = 0
bad_step = 10
class CatchMe(Exception):
pass
a = tensor([1, 2, 3, 4])
b = tensor([5, 6, 7, 8])
c = tensor([9, 0, 1, 2])
@trace
def add_abc(a, b, c):
ps = a + b
result = ps + c
if step_count == bad_step:
raise CatchMe("catch me")
return result
for i in range(100):
try:
d = add_abc(a, b, c)
except CatchMe as e:
catch_count += 1
else:
np.testing.assert_equal(d.numpy(), (a + b + c).numpy())
step_count += 1
assert catch_count == 1
def test_trace_broadcast():
for symbolic in [False, True]:
x1 = tensor(np.random.randn(3, 1, 1))
x2 = tensor(np.random.randn(1, 4, 1))
x3 = tensor(np.random.randn(1, 1, 5))
@trace(symbolic=symbolic, capture_as_const=True)
def f(x):
y = F.broadcast_to(x, (3, 4, 5))
return y
f(x1)
f(x2)
f(x3)
def test_trace_nms():
def make_inputs(n):
boxes = np.zeros((n, 4))
boxes[:, :2] = np.random.rand(n, 2) * 100
boxes[:, 2:] = np.random.rand(n, 2) * 100 + 100
scores = np.random.rand(n)
return tensor(boxes), tensor(scores)
@trace(symbolic=False)
def f(boxes, scores):
# with tracing, max_output must be specified
results = F.nn.nms(boxes, scores=scores, iou_thresh=0.5, max_output=20)
# without tracing, max output can be inferred inside nms
with exclude_from_trace():
_ = F.nn.nms(boxes, scores=scores, iou_thresh=0.5)
return results
f(*make_inputs(10))
f(*make_inputs(20))
f(*make_inputs(30))
def test_trace_valid_broadcast():
x1 = tensor(np.random.randn(1, 1))
x2 = tensor(np.random.randn(1, 2))
shape = (tensor([2]), tensor([2]))
@trace(symbolic=False)
def f(x, shape):
y = F.broadcast_to(x, shape)
return y
f(x1, shape)
f(x2, shape)
def test_clip():
x = tensor(np.random.randn(10, 10))
@trace(symbolic=True)
def f(x, lower, upper):
y = F.clip(x, lower, upper)
return y
for i in range(3):
f(x, tensor([0]), tensor([1]))
# test returning noncontiguous tensor from trace
def test_slice():
@trace
def f(x):
return x[:, 1::2]
x = F.arange(8).reshape(2, 4)
f(x)
y = f(x)
np.testing.assert_array_equal(y.numpy(), x.numpy()[:, 1::2])
y + y
def test_random():
def run_test(op):
for symbolic_shape in [True, False]:
@trace(symbolic=True, symbolic_shape=symbolic_shape)
def f():
out = op(size=[10, 10])
out_shape = out.shape
assert out_shape is not None
if not isinstance(out_shape, tuple):
assert out.shape.numpy() is not None
return out
for _ in range(3):
f()
run_test(uniform)
run_test(normal)
|
[
"megengine.utils.comp_graph_tools.load_and_inference",
"megengine.functional.arange",
"megengine.autodiff.GradManager",
"megengine.jit.trace",
"megengine.functional.clip",
"megengine.core.tensor.utils.isscalar",
"megengine.utils.comp_graph_tools.get_owner_opr_inputs",
"megengine.tensor",
"megengine.functional.nn.nms",
"megengine.core.tensor.megbrain_graph.load_graph",
"megengine.functional.topk",
"megengine.functional.exp",
"megengine.functional.broadcast_to",
"megengine.jit.exclude_from_trace",
"megengine.Parameter",
"megengine.utils.comp_graph_tools.get_oprs_seq",
"megengine.functional.warp_perspective"
] |
[((5110, 5174), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""force opt_level=0 when building graph"""'}), "(reason='force opt_level=0 when building graph')\n", (5126, 5174), False, 'import pytest\n'), ((5666, 5730), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""force opt_level=0 when building graph"""'}), "(reason='force opt_level=0 when building graph')\n", (5682, 5730), False, 'import pytest\n'), ((6148, 6210), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""could not use opt_level=0 with dump"""'}), "(reason='could not use opt_level=0 with dump')\n", (6164, 6210), False, 'import pytest\n'), ((1871, 1892), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(False)'}), '(symbolic=False)\n', (1876, 1892), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((2049, 2069), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (2054, 2069), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((3305, 3348), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (3310, 3348), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((3396, 3407), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (3402, 3407), False, 'from megengine import Parameter, tensor\n'), ((3416, 3427), 'megengine.tensor', 'tensor', (['[4]'], {}), '([4])\n', (3422, 3427), False, 'from megengine import Parameter, tensor\n'), ((3540, 3552), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (3550, 3552), False, 'import io\n'), ((3619, 3680), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['dump_info.inputs', "['arg_0', 'arg_1']"], {}), "(dump_info.inputs, ['arg_0', 'arg_1'])\n", (3642, 3680), True, 'import numpy as np\n'), ((3685, 3752), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['dump_info.outputs', "['ADD(arg_0,arg_1)[4]']"], {}), "(dump_info.outputs, ['ADD(arg_0,arg_1)[4]'])\n", (3708, 3752), True, 'import numpy as np\n'), ((3783, 3823), 'megengine.utils.comp_graph_tools.load_and_inference', 'cgtools.load_and_inference', (['file', '[a, b]'], {}), '(file, [a, b])\n', (3809, 3823), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((3828, 3865), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['result[0]', 'y'], {}), '(result[0], y)\n', (3851, 3865), True, 'import numpy as np\n'), ((3901, 3912), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (3907, 3912), False, 'from megengine import Parameter, tensor\n'), ((3919, 3962), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (3924, 3962), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((4007, 4018), 'megengine.tensor', 'tensor', (['[3]'], {}), '([3])\n', (4013, 4018), False, 'from megengine import Parameter, tensor\n'), ((4125, 4137), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (4135, 4137), False, 'import io\n'), ((4185, 4222), 'megengine.utils.comp_graph_tools.load_and_inference', 'cgtools.load_and_inference', (['file', '[x]'], {}), '(file, [x])\n', (4211, 4222), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((4227, 4264), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['result[0]', 'y'], {}), '(result[0], y)\n', (4250, 4264), True, 'import numpy as np\n'), ((4301, 4312), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (4307, 4312), False, 'from megengine import Parameter, tensor\n'), ((4319, 4362), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (4324, 4362), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((4407, 4418), 'megengine.tensor', 'tensor', (['[3]'], {}), '([3])\n', (4413, 4418), False, 'from megengine import Parameter, tensor\n'), ((4525, 4537), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (4535, 4537), False, 'import io\n'), ((4623, 4641), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['file'], {}), '(file)\n', (4635, 4641), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((5201, 5257), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(0)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=0, capture_as_const=True)\n', (5206, 5257), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((5435, 5491), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(1)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=1, capture_as_const=True)\n', (5440, 5491), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((5556, 5567), 'megengine.tensor', 'tensor', (['(0.0)'], {}), '(0.0)\n', (5562, 5567), False, 'from megengine import Parameter, tensor\n'), ((5769, 5825), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(0)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=0, capture_as_const=True)\n', (5774, 5825), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((5885, 5941), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(1)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=1, capture_as_const=True)\n', (5890, 5941), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((6020, 6031), 'megengine.tensor', 'tensor', (['val'], {}), '(val)\n', (6026, 6031), False, 'from megengine import Parameter, tensor\n'), ((6040, 6051), 'megengine.tensor', 'tensor', (['(0.0)'], {}), '(0.0)\n', (6046, 6051), False, 'from megengine import Parameter, tensor\n'), ((6245, 6301), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(0)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=0, capture_as_const=True)\n', (6250, 6301), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((6349, 6405), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'opt_level': '(1)', 'capture_as_const': '(True)'}), '(symbolic=True, opt_level=1, capture_as_const=True)\n', (6354, 6405), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((6480, 6489), 'tempfile.mkstemp', 'mkstemp', ([], {}), '()\n', (6487, 6489), False, 'from tempfile import mkstemp\n'), ((6554, 6571), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['out'], {}), '(out)\n', (6566, 6571), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((6585, 6614), 'megengine.utils.comp_graph_tools.get_oprs_seq', 'cgtools.get_oprs_seq', (['outputs'], {}), '(outputs)\n', (6605, 6614), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((6699, 6716), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['out'], {}), '(out)\n', (6711, 6716), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((6730, 6759), 'megengine.utils.comp_graph_tools.get_oprs_seq', 'cgtools.get_oprs_seq', (['outputs'], {}), '(outputs)\n', (6750, 6759), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((6845, 6888), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (6850, 6888), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((6939, 6948), 'tempfile.mkstemp', 'mkstemp', ([], {}), '()\n', (6946, 6948), False, 'from tempfile import mkstemp\n'), ((7017, 7034), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['out'], {}), '(out)\n', (7029, 7034), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((7242, 7291), 'megengine.jit.trace', 'trace', ([], {'capture_as_const': '(True)', 'symbolic_shape': '(True)'}), '(capture_as_const=True, symbolic_shape=True)\n', (7247, 7291), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((7437, 7464), 'megengine.tensor', 'tensor', (['[0]'], {'dtype': 'np.int32'}), '([0], dtype=np.int32)\n', (7443, 7464), False, 'from megengine import Parameter, tensor\n'), ((7471, 7491), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (7476, 7491), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((8092, 8121), 'megengine.tensor', 'tensor', (['[5, 2, 7, 1, 0, 3, 2]'], {}), '([5, 2, 7, 1, 0, 3, 2])\n', (8098, 8121), False, 'from megengine import Parameter, tensor\n'), ((8128, 8148), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (8133, 8148), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((8622, 8642), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (8627, 8642), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((8980, 9000), 'megengine.tensor', 'tensor', (['[1, 2, 3, 4]'], {}), '([1, 2, 3, 4])\n', (8986, 9000), False, 'from megengine import Parameter, tensor\n'), ((9009, 9029), 'megengine.tensor', 'tensor', (['[5, 6, 7, 8]'], {}), '([5, 6, 7, 8])\n', (9015, 9029), False, 'from megengine import Parameter, tensor\n'), ((9038, 9058), 'megengine.tensor', 'tensor', (['[9, 0, 1, 2]'], {}), '([9, 0, 1, 2])\n', (9044, 9058), False, 'from megengine import Parameter, tensor\n'), ((10163, 10184), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(False)'}), '(symbolic=False)\n', (10168, 10184), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((10762, 10783), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(False)'}), '(symbolic=False)\n', (10767, 10783), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((10959, 10979), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (10964, 10979), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((1146, 1170), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (1151, 1170), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((1224, 1235), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (1230, 1235), False, 'from megengine import Parameter, tensor\n'), ((2450, 2474), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (2455, 2474), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((2657, 2668), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (2663, 2668), False, 'from megengine import Parameter, tensor\n'), ((2885, 2909), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic'}), '(symbolic=symbolic)\n', (2890, 2909), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((3072, 3083), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (3078, 3083), False, 'from megengine import Parameter, tensor\n'), ((4858, 4898), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic', 'profiling': '(True)'}), '(symbolic=symbolic, profiling=True)\n', (4863, 4898), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((4952, 4963), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (4958, 4963), False, 'from megengine import Parameter, tensor\n'), ((6454, 6465), 'megengine.tensor', 'tensor', (['(1.0)'], {}), '(1.0)\n', (6460, 6465), False, 'from megengine import Parameter, tensor\n'), ((6622, 6633), 'megengine.tensor', 'tensor', (['(1.0)'], {}), '(1.0)\n', (6628, 6633), False, 'from megengine import Parameter, tensor\n'), ((6918, 6924), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (6921, 6924), False, 'from megengine.functional import exp, log\n'), ((6955, 6966), 'megengine.tensor', 'tensor', (['(5.0)'], {}), '(5.0)\n', (6961, 6966), False, 'from megengine import Parameter, tensor\n'), ((7206, 7234), 'numpy.ones', 'np.ones', (['(1)'], {'dtype': 'np.float32'}), '(1, dtype=np.float32)\n', (7213, 7234), True, 'import numpy as np\n'), ((7386, 7398), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (7396, 7398), False, 'import io\n'), ((7558, 7569), 'megengine.core.tensor.utils.isscalar', 'isscalar', (['b'], {}), '(b)\n', (7566, 7569), False, 'from megengine.core.tensor.utils import isscalar\n'), ((7886, 7933), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic', 'capture_as_const': '(True)'}), '(symbolic=symbolic, capture_as_const=True)\n', (7891, 7933), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((8175, 8187), 'megengine.functional.topk', 'F.topk', (['x', '(3)'], {}), '(x, 3)\n', (8181, 8187), True, 'import megengine.functional as F\n'), ((8674, 8706), 'megengine.functional.warp_perspective', 'F.warp_perspective', (['x', 'M', '(2, 2)'], {}), '(x, M, (2, 2))\n', (8692, 8706), True, 'import megengine.functional as F\n'), ((9713, 9760), 'megengine.jit.trace', 'trace', ([], {'symbolic': 'symbolic', 'capture_as_const': '(True)'}), '(symbolic=symbolic, capture_as_const=True)\n', (9718, 9760), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((9952, 9968), 'numpy.zeros', 'np.zeros', (['(n, 4)'], {}), '((n, 4))\n', (9960, 9968), True, 'import numpy as np\n'), ((10093, 10110), 'numpy.random.rand', 'np.random.rand', (['n'], {}), '(n)\n', (10107, 10110), True, 'import numpy as np\n'), ((10282, 10343), 'megengine.functional.nn.nms', 'F.nn.nms', (['boxes'], {'scores': 'scores', 'iou_thresh': '(0.5)', 'max_output': '(20)'}), '(boxes, scores=scores, iou_thresh=0.5, max_output=20)\n', (10290, 10343), True, 'import megengine.functional as F\n'), ((10655, 10676), 'numpy.random.randn', 'np.random.randn', (['(1)', '(1)'], {}), '(1, 1)\n', (10670, 10676), True, 'import numpy as np\n'), ((10694, 10715), 'numpy.random.randn', 'np.random.randn', (['(1)', '(2)'], {}), '(1, 2)\n', (10709, 10715), True, 'import numpy as np\n'), ((10730, 10741), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (10736, 10741), False, 'from megengine import Parameter, tensor\n'), ((10743, 10754), 'megengine.tensor', 'tensor', (['[2]'], {}), '([2])\n', (10749, 10754), False, 'from megengine import Parameter, tensor\n'), ((10817, 10841), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['x', 'shape'], {}), '(x, shape)\n', (10831, 10841), True, 'import megengine.functional as F\n'), ((10928, 10951), 'numpy.random.randn', 'np.random.randn', (['(10)', '(10)'], {}), '(10, 10)\n', (10943, 10951), True, 'import numpy as np\n'), ((11020, 11043), 'megengine.functional.clip', 'F.clip', (['x', 'lower', 'upper'], {}), '(x, lower, upper)\n', (11026, 11043), True, 'import megengine.functional as F\n'), ((1480, 1514), 'megengine.Parameter', 'Parameter', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (1489, 1514), False, 'from megengine import Parameter, tensor\n'), ((1645, 1653), 'megengine.functional.exp', 'F.exp', (['x'], {}), '(x)\n', (1650, 1653), True, 'import megengine.functional as F\n'), ((1705, 1718), 'megengine.autodiff.GradManager', 'GradManager', ([], {}), '()\n', (1716, 1718), False, 'from megengine.autodiff import GradManager\n'), ((2340, 2371), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['y1', 'y2'], {}), '(y1, y2)\n', (2363, 2371), True, 'import numpy as np\n'), ((3249, 3280), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['z', 'buf'], {}), '(z, buf)\n', (3272, 3280), True, 'import numpy as np\n'), ((6335, 6341), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (6338, 6341), False, 'from megengine.functional import exp, log\n'), ((6439, 6445), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (6442, 6445), False, 'from megengine.functional import exp, log\n'), ((7333, 7364), 'megengine.tensor', 'tensor', (['[1, 10]'], {'dtype': 'np.int32'}), '([1, 10], dtype=np.int32)\n', (7339, 7364), False, 'from megengine import Parameter, tensor\n'), ((7752, 7778), 'numpy.random.randn', 'np.random.randn', (['(2)', '(10)', '(10)'], {}), '(2, 10, 10)\n', (7767, 7778), True, 'import numpy as np\n'), ((7800, 7826), 'numpy.random.randn', 'np.random.randn', (['(4)', '(10)', '(10)'], {}), '(4, 10, 10)\n', (7815, 7826), True, 'import numpy as np\n'), ((7848, 7874), 'numpy.random.randn', 'np.random.randn', (['(8)', '(10)', '(10)'], {}), '(8, 10, 10)\n', (7863, 7874), True, 'import numpy as np\n'), ((8240, 8253), 'numpy.array', 'np.array', (['[3]'], {}), '([3])\n', (8248, 8253), True, 'import numpy as np\n'), ((8758, 8780), 'numpy.array', 'np.array', (['[1, 1, 2, 2]'], {}), '([1, 1, 2, 2])\n', (8766, 8780), True, 'import numpy as np\n'), ((9585, 9609), 'numpy.random.randn', 'np.random.randn', (['(3)', '(1)', '(1)'], {}), '(3, 1, 1)\n', (9600, 9609), True, 'import numpy as np\n'), ((9631, 9655), 'numpy.random.randn', 'np.random.randn', (['(1)', '(4)', '(1)'], {}), '(1, 4, 1)\n', (9646, 9655), True, 'import numpy as np\n'), ((9677, 9701), 'numpy.random.randn', 'np.random.randn', (['(1)', '(1)', '(5)'], {}), '(1, 1, 5)\n', (9692, 9701), True, 'import numpy as np\n'), ((9795, 9823), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['x', '(3, 4, 5)'], {}), '(x, (3, 4, 5))\n', (9809, 9823), True, 'import megengine.functional as F\n'), ((9992, 10012), 'numpy.random.rand', 'np.random.rand', (['n', '(2)'], {}), '(n, 2)\n', (10006, 10012), True, 'import numpy as np\n'), ((10127, 10140), 'megengine.tensor', 'tensor', (['boxes'], {}), '(boxes)\n', (10133, 10140), False, 'from megengine import Parameter, tensor\n'), ((10142, 10156), 'megengine.tensor', 'tensor', (['scores'], {}), '(scores)\n', (10148, 10156), False, 'from megengine import Parameter, tensor\n'), ((10422, 10442), 'megengine.jit.exclude_from_trace', 'exclude_from_trace', ([], {}), '()\n', (10440, 10442), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((10460, 10506), 'megengine.functional.nn.nms', 'F.nn.nms', (['boxes'], {'scores': 'scores', 'iou_thresh': '(0.5)'}), '(boxes, scores=scores, iou_thresh=0.5)\n', (10468, 10506), True, 'import megengine.functional as F\n'), ((11098, 11109), 'megengine.tensor', 'tensor', (['[0]'], {}), '([0])\n', (11104, 11109), False, 'from megengine import Parameter, tensor\n'), ((11111, 11122), 'megengine.tensor', 'tensor', (['[1]'], {}), '([1])\n', (11117, 11122), False, 'from megengine import Parameter, tensor\n'), ((11253, 11264), 'megengine.functional.arange', 'F.arange', (['(8)'], {}), '(8)\n', (11261, 11264), True, 'import megengine.functional as F\n'), ((11478, 11529), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'symbolic_shape': 'symbolic_shape'}), '(symbolic=True, symbolic_shape=symbolic_shape)\n', (11483, 11529), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((1820, 1832), 'numpy.arange', 'np.arange', (['(4)'], {}), '(4)\n', (1829, 1832), True, 'import numpy as np\n'), ((2529, 2549), 'megengine.jit.exclude_from_trace', 'exclude_from_trace', ([], {}), '()\n', (2547, 2549), False, 'from megengine.jit import exclude_from_trace, trace\n'), ((4711, 4744), 'megengine.utils.comp_graph_tools.get_owner_opr_inputs', 'cgtools.get_owner_opr_inputs', (['out'], {}), '(out)\n', (4739, 4744), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((5862, 5868), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (5865, 5868), False, 'from megengine.functional import exp, log\n'), ((5871, 5877), 'megengine.functional.exp', 'exp', (['y'], {}), '(y)\n', (5874, 5877), False, 'from megengine.functional import exp, log\n'), ((5978, 5984), 'megengine.functional.exp', 'exp', (['x'], {}), '(x)\n', (5981, 5984), False, 'from megengine.functional import exp, log\n'), ((5987, 5993), 'megengine.functional.exp', 'exp', (['y'], {}), '(y)\n', (5990, 5993), False, 'from megengine.functional import exp, log\n'), ((8391, 8422), 'numpy.arange', 'np.arange', (['(16)'], {'dtype': 'np.float32'}), '(16, dtype=np.float32)\n', (8400, 8422), True, 'import numpy as np\n'), ((8491, 8570), 'numpy.array', 'np.array', (['[[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]]'], {'dtype': 'np.float32'}), '([[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]], dtype=np.float32)\n', (8499, 8570), True, 'import numpy as np\n'), ((10042, 10062), 'numpy.random.rand', 'np.random.rand', (['n', '(2)'], {}), '(n, 2)\n', (10056, 10062), True, 'import numpy as np\n')]
|
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# Copyright (c) 2020 <NAME>
# This file has been modified by Megvii ("Megvii Modifications").
# All Megvii Modifications are Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
"""EfficientNet Series
EfficientNet: `"EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks"
<https://arxiv.org/abs/1905.11946>`_
References:
https://github.com/facebookresearch/pycls/blob/main/pycls/models/effnet.py
https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/efficientnet.py
https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/mobilenetv3.py
"""
import math
from numbers import Real
from typing import Any, Callable, Mapping, Sequence, Union
import megengine.hub as hub
import megengine.module as M
from basecls.layers import (
SE,
DropPath,
activation,
build_head,
conv2d,
init_weights,
make_divisible,
norm2d,
)
from basecls.utils import recursive_update, registers
from .mbnet import MBConv
from .resnet import AnyStage, SimpleStem
__all__ = ["FuseMBConv", "EffNet"]
class FuseMBConv(M.Module):
"""Fusing the proj conv1x1 and depthwise conv into a conv2d.
Args:
w_in: input width.
w_out: output width.
stride: stride of conv.
kernel: kernel of conv.
exp_r: expansion ratio.
se_r: SE ratio.
has_skip: whether apply skip connection.
drop_path_prob: drop path probability.
norm_name: normalization function.
act_name: activation function.
"""
def __init__(
self,
w_in: int,
w_out: int,
stride: int,
kernel: int,
exp_r: float,
se_r: float,
has_skip: bool,
drop_path_prob: float,
norm_name: str,
act_name: str,
**kwargs,
):
super().__init__()
# Expansion
w_mid = w_in
w_exp = int(w_in * exp_r)
if exp_r != 1.0:
self.exp = conv2d(w_in, w_exp, kernel, stride=stride)
self.exp_bn = norm2d(norm_name, w_exp)
self.exp_act = activation(act_name)
w_mid = w_exp
# SE
if se_r > 0.0:
w_se = int(w_in * se_r)
self.se = SE(w_mid, w_se, act_name)
# PWConv
self.proj = conv2d(
w_mid, w_out, 1 if exp_r != 1.0 else kernel, stride=1 if exp_r != 1.0 else stride
)
self.proj_bn = norm2d(norm_name, w_out)
self.has_proj_act = exp_r == 1.0
if self.has_proj_act:
self.proj_act = activation(act_name)
# Skip
self.has_skip = has_skip and w_in == w_out and stride == 1
if self.has_skip:
self.drop_path = DropPath(drop_path_prob)
def forward(self, x):
x_p = x
if getattr(self, "exp", None) is not None:
x = self.exp(x)
x = self.exp_bn(x)
x = self.exp_act(x)
if getattr(self, "se", None) is not None:
x = self.se(x)
x = self.proj(x)
x = self.proj_bn(x)
if self.has_proj_act:
x = self.proj_act(x)
if self.has_skip:
x = self.drop_path(x)
x = x + x_p
return x
@registers.models.register()
class EffNet(M.Module):
"""EfficientNet model.
Args:
stem_w: stem width.
block_name: block name.
depths: depth for each stage (number of blocks in the stage).
widths: width for each stage (width of each block in the stage).
strides: strides for each stage (applies to the first block of each stage).
kernels: kernel sizes for each stage.
exp_rs: expansion ratios for MBConv blocks in each stage.
se_r: Squeeze-and-Excitation (SE) ratio. Default: ``0.25``
drop_path_prob: drop path probability. Default: ``0.0``
depth_mult: depth multiplier. Default: ``1.0``
width_mult: width multiplier. Default: ``1.0``
omit_mult: omit multiplier for stem width, head width, the first stage depth and
the last stage depth, enabled in EfficientNet-Lite. Default: ``False``
norm_name: normalization function. Default: ``"BN"``
act_name: activation function. Default: ``"silu"``
head: head args. Default: ``None``
"""
def __init__(
self,
stem_w: int,
block_name: Union[Union[str, Callable], Sequence[Union[str, Callable]]],
depths: Sequence[int],
widths: Sequence[int],
strides: Sequence[int],
kernels: Sequence[int],
exp_rs: Union[float, Sequence[Union[float, Sequence[float]]]] = 1.0,
se_rs: Union[float, Sequence[Union[float, Sequence[float]]]] = 0.0,
drop_path_prob: float = 0.0,
depth_mult: float = 1.0,
width_mult: float = 1.0,
omit_mult: bool = False,
norm_name: str = "BN",
act_name: str = "silu",
head: Mapping[str, Any] = None,
):
super().__init__()
depths = [
d if omit_mult and i in (0, len(depths) - 1) else math.ceil(d * depth_mult)
for i, d in enumerate(depths)
]
self.depths = depths
stem_w = stem_w if omit_mult else make_divisible(stem_w * width_mult, round_limit=0.9)
self.stem = SimpleStem(3, stem_w, norm_name, act_name)
if isinstance(block_name, (str, Callable)):
block_name = [block_name] * len(depths)
block_func = [self.get_block_func(bn) for bn in block_name]
widths = [make_divisible(w * width_mult, round_limit=0.9) for w in widths]
if isinstance(exp_rs, Real):
exp_rs = [exp_rs] * len(depths)
if isinstance(se_rs, Real):
se_rs = [se_rs] * len(depths)
drop_path_prob_iter = (i / sum(depths) * drop_path_prob for i in range(sum(depths)))
drop_path_probs = [[next(drop_path_prob_iter) for _ in range(d)] for d in depths]
model_args = [depths, widths, strides, block_func, kernels, exp_rs, se_rs, drop_path_probs]
prev_w = stem_w
for i, (d, w, s, bf, k, exp_r, se_r, dp_p) in enumerate(zip(*model_args)):
stage = AnyStage(
prev_w,
w,
s,
d,
bf,
kernel=k,
exp_r=exp_r,
se_r=se_r,
se_from_exp=False,
se_act_name=act_name,
se_approx=False,
se_rd_fn=int,
has_proj_act=False,
has_skip=True,
drop_path_prob=dp_p,
norm_name=norm_name,
act_name=act_name,
)
setattr(self, f"s{i + 1}", stage)
prev_w = w
if head:
if head.get("width", 0) > 0 and not omit_mult:
head["width"] = make_divisible(head["width"] * width_mult, round_limit=0.9)
self.head = build_head(prev_w, head, norm_name, act_name)
self.apply(init_weights)
def forward(self, x):
x = self.stem(x)
for i in range(len(self.depths)):
stage = getattr(self, f"s{i + 1}")
x = stage(x)
if getattr(self, "head", None) is not None:
x = self.head(x)
return x
@staticmethod
def get_block_func(name: Union[str, Callable]):
"""Retrieves the block function by name."""
if callable(name):
return name
if isinstance(name, str):
block_funcs = {
"FuseMBConv": FuseMBConv,
"MBConv": MBConv,
}
if name in block_funcs.keys():
return block_funcs[name]
raise ValueError(f"Block '{name}' not supported")
def _build_effnet(**kwargs):
model_args = dict(
stem_w=32,
block_name=MBConv,
depths=[1, 2, 2, 3, 3, 4, 1],
widths=[16, 24, 40, 80, 112, 192, 320],
strides=[1, 2, 2, 2, 1, 2, 1],
kernels=[3, 3, 5, 3, 5, 5, 3],
exp_rs=[1, 6, 6, 6, 6, 6, 6],
se_rs=0.25,
drop_path_prob=0.2,
head=dict(name="ClsHead", width=1280, dropout_prob=0.2),
)
recursive_update(model_args, kwargs)
return EffNet(**model_args)
def _build_effnet_lite(**kwargs):
model_args = dict(se_rs=0.0, omit_mult=True, act_name="relu6")
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
def _build_effnetv2(**kwargs):
model_args = dict(
stem_w=32,
block_name=[FuseMBConv, FuseMBConv, FuseMBConv, MBConv, MBConv, MBConv],
depths=[1, 2, 2, 3, 5, 8],
widths=[16, 32, 48, 96, 112, 192],
strides=[1, 2, 2, 2, 1, 2],
kernels=[3, 3, 3, 3, 3, 3],
exp_rs=[1, 4, 4, 4, 6, 6],
se_rs=[0, 0, 0, 0.25, 0.25, 0.25],
)
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b0/effnet_b0.pkl"
)
def effnet_b0(**kwargs):
model_args = dict(depth_mult=1.0, width_mult=1.0)
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b1/effnet_b1.pkl"
)
def effnet_b1(**kwargs):
model_args = dict(depth_mult=1.1, width_mult=1.0)
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b2/effnet_b2.pkl"
)
def effnet_b2(**kwargs):
model_args = dict(depth_mult=1.2, width_mult=1.1, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b3/effnet_b3.pkl"
)
def effnet_b3(**kwargs):
model_args = dict(depth_mult=1.4, width_mult=1.2, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b4/effnet_b4.pkl"
)
def effnet_b4(**kwargs):
model_args = dict(depth_mult=1.8, width_mult=1.4, head=dict(dropout_prob=0.4))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b5/effnet_b5.pkl"
)
def effnet_b5(**kwargs):
model_args = dict(depth_mult=2.2, width_mult=1.6, head=dict(dropout_prob=0.4))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b6/effnet_b6.pkl"
)
def effnet_b6(**kwargs):
model_args = dict(depth_mult=2.6, width_mult=1.8, head=dict(dropout_prob=0.5))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b7/effnet_b7.pkl"
)
def effnet_b7(**kwargs):
model_args = dict(depth_mult=3.1, width_mult=2.0, head=dict(dropout_prob=0.5))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b8/effnet_b8.pkl"
)
def effnet_b8(**kwargs):
model_args = dict(depth_mult=3.6, width_mult=2.2, head=dict(dropout_prob=0.5))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_l2/effnet_l2.pkl"
)
def effnet_l2(**kwargs):
model_args = dict(depth_mult=5.3, width_mult=4.3, head=dict(dropout_prob=0.5))
recursive_update(model_args, kwargs)
return _build_effnet(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b0_lite/effnet_b0_lite.pkl"
)
def effnet_b0_lite(**kwargs):
model_args = dict(depth_mult=1.0, width_mult=1.0)
recursive_update(model_args, kwargs)
return _build_effnet_lite(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b1_lite/effnet_b1_lite.pkl"
)
def effnet_b1_lite(**kwargs):
model_args = dict(depth_mult=1.1, width_mult=1.0)
recursive_update(model_args, kwargs)
return _build_effnet_lite(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b2_lite/effnet_b2_lite.pkl"
)
def effnet_b2_lite(**kwargs):
model_args = dict(depth_mult=1.2, width_mult=1.1, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnet_lite(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b3_lite/effnet_b3_lite.pkl"
)
def effnet_b3_lite(**kwargs):
model_args = dict(depth_mult=1.4, width_mult=1.2, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnet_lite(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b4_lite/effnet_b4_lite.pkl"
)
def effnet_b4_lite(**kwargs):
model_args = dict(depth_mult=1.8, width_mult=1.4, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnet_lite(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b0/effnetv2_b0.pkl"
)
def effnetv2_b0(**kwargs):
model_args = dict(depth_mult=1.0, width_mult=1.0)
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b1/effnetv2_b1.pkl"
)
def effnetv2_b1(**kwargs):
model_args = dict(depth_mult=1.1, width_mult=1.0)
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b2/effnetv2_b2.pkl"
)
def effnetv2_b2(**kwargs):
model_args = dict(depth_mult=1.2, width_mult=1.1, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b3/effnetv2_b3.pkl"
)
def effnetv2_b3(**kwargs):
model_args = dict(depth_mult=1.4, width_mult=1.2, head=dict(dropout_prob=0.3))
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_s/effnetv2_s.pkl"
)
def effnetv2_s(**kwargs):
model_args = dict(stem_w=24, depths=[2, 4, 4, 6, 9, 15], widths=[24, 48, 64, 128, 160, 256])
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_m/effnetv2_m.pkl"
)
def effnetv2_m(**kwargs):
model_args = dict(
stem_w=24,
block_name=[FuseMBConv, FuseMBConv, FuseMBConv, MBConv, MBConv, MBConv, MBConv],
depths=[3, 5, 5, 7, 14, 18, 5],
widths=[24, 48, 80, 160, 176, 304, 512],
strides=[1, 2, 2, 2, 1, 2, 1],
kernels=[3, 3, 3, 3, 3, 3, 3],
exp_rs=[1, 4, 4, 4, 6, 6, 6],
se_rs=[0, 0, 0, 0.25, 0.25, 0.25, 0.25],
head=dict(dropout_prob=0.3),
)
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
@registers.models.register()
@hub.pretrained(
"https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_l/effnetv2_l.pkl"
)
def effnetv2_l(**kwargs):
model_args = dict(
stem_w=32,
block_name=[FuseMBConv, FuseMBConv, FuseMBConv, MBConv, MBConv, MBConv, MBConv],
depths=[4, 7, 7, 10, 19, 25, 7],
widths=[32, 64, 96, 192, 224, 384, 640],
strides=[1, 2, 2, 2, 1, 2, 1],
kernels=[3, 3, 3, 3, 3, 3, 3],
exp_rs=[1, 4, 4, 4, 6, 6, 6],
se_rs=[0, 0, 0, 0.25, 0.25, 0.25, 0.25],
head=dict(dropout_prob=0.4),
)
recursive_update(model_args, kwargs)
return _build_effnetv2(**model_args)
|
[
"megengine.hub.pretrained"
] |
[((3301, 3328), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (3326, 3328), False, 'from basecls.utils import recursive_update, registers\n'), ((8976, 9003), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9001, 9003), False, 'from basecls.utils import recursive_update, registers\n'), ((9005, 9117), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b0/effnet_b0.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b0/effnet_b0.pkl'\n )\n", (9019, 9117), True, 'import megengine.hub as hub\n'), ((9276, 9303), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9301, 9303), False, 'from basecls.utils import recursive_update, registers\n'), ((9305, 9417), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b1/effnet_b1.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b1/effnet_b1.pkl'\n )\n", (9319, 9417), True, 'import megengine.hub as hub\n'), ((9576, 9603), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9601, 9603), False, 'from basecls.utils import recursive_update, registers\n'), ((9605, 9717), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b2/effnet_b2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b2/effnet_b2.pkl'\n )\n", (9619, 9717), True, 'import megengine.hub as hub\n'), ((9905, 9932), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9930, 9932), False, 'from basecls.utils import recursive_update, registers\n'), ((9934, 10046), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b3/effnet_b3.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b3/effnet_b3.pkl'\n )\n", (9948, 10046), True, 'import megengine.hub as hub\n'), ((10234, 10261), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (10259, 10261), False, 'from basecls.utils import recursive_update, registers\n'), ((10263, 10375), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b4/effnet_b4.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b4/effnet_b4.pkl'\n )\n", (10277, 10375), True, 'import megengine.hub as hub\n'), ((10563, 10590), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (10588, 10590), False, 'from basecls.utils import recursive_update, registers\n'), ((10592, 10704), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b5/effnet_b5.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b5/effnet_b5.pkl'\n )\n", (10606, 10704), True, 'import megengine.hub as hub\n'), ((10892, 10919), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (10917, 10919), False, 'from basecls.utils import recursive_update, registers\n'), ((10921, 11033), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b6/effnet_b6.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b6/effnet_b6.pkl'\n )\n", (10935, 11033), True, 'import megengine.hub as hub\n'), ((11221, 11248), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (11246, 11248), False, 'from basecls.utils import recursive_update, registers\n'), ((11250, 11362), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b7/effnet_b7.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b7/effnet_b7.pkl'\n )\n", (11264, 11362), True, 'import megengine.hub as hub\n'), ((11550, 11577), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (11575, 11577), False, 'from basecls.utils import recursive_update, registers\n'), ((11579, 11691), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b8/effnet_b8.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b8/effnet_b8.pkl'\n )\n", (11593, 11691), True, 'import megengine.hub as hub\n'), ((11879, 11906), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (11904, 11906), False, 'from basecls.utils import recursive_update, registers\n'), ((11908, 12020), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_l2/effnet_l2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_l2/effnet_l2.pkl'\n )\n", (11922, 12020), True, 'import megengine.hub as hub\n'), ((12208, 12235), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (12233, 12235), False, 'from basecls.utils import recursive_update, registers\n'), ((12237, 12359), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b0_lite/effnet_b0_lite.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b0_lite/effnet_b0_lite.pkl'\n )\n", (12251, 12359), True, 'import megengine.hub as hub\n'), ((12528, 12555), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (12553, 12555), False, 'from basecls.utils import recursive_update, registers\n'), ((12557, 12679), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b1_lite/effnet_b1_lite.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b1_lite/effnet_b1_lite.pkl'\n )\n", (12571, 12679), True, 'import megengine.hub as hub\n'), ((12848, 12875), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (12873, 12875), False, 'from basecls.utils import recursive_update, registers\n'), ((12877, 12999), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b2_lite/effnet_b2_lite.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b2_lite/effnet_b2_lite.pkl'\n )\n", (12891, 12999), True, 'import megengine.hub as hub\n'), ((13197, 13224), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (13222, 13224), False, 'from basecls.utils import recursive_update, registers\n'), ((13226, 13348), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b3_lite/effnet_b3_lite.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b3_lite/effnet_b3_lite.pkl'\n )\n", (13240, 13348), True, 'import megengine.hub as hub\n'), ((13546, 13573), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (13571, 13573), False, 'from basecls.utils import recursive_update, registers\n'), ((13575, 13697), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b4_lite/effnet_b4_lite.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnet_b4_lite/effnet_b4_lite.pkl'\n )\n", (13589, 13697), True, 'import megengine.hub as hub\n'), ((13895, 13922), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (13920, 13922), False, 'from basecls.utils import recursive_update, registers\n'), ((13924, 14040), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b0/effnetv2_b0.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b0/effnetv2_b0.pkl'\n )\n", (13938, 14040), True, 'import megengine.hub as hub\n'), ((14203, 14230), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (14228, 14230), False, 'from basecls.utils import recursive_update, registers\n'), ((14232, 14348), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b1/effnetv2_b1.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b1/effnetv2_b1.pkl'\n )\n", (14246, 14348), True, 'import megengine.hub as hub\n'), ((14511, 14538), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (14536, 14538), False, 'from basecls.utils import recursive_update, registers\n'), ((14540, 14656), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b2/effnetv2_b2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b2/effnetv2_b2.pkl'\n )\n", (14554, 14656), True, 'import megengine.hub as hub\n'), ((14848, 14875), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (14873, 14875), False, 'from basecls.utils import recursive_update, registers\n'), ((14877, 14993), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b3/effnetv2_b3.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_b3/effnetv2_b3.pkl'\n )\n", (14891, 14993), True, 'import megengine.hub as hub\n'), ((15185, 15212), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (15210, 15212), False, 'from basecls.utils import recursive_update, registers\n'), ((15214, 15328), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_s/effnetv2_s.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_s/effnetv2_s.pkl'\n )\n", (15228, 15328), True, 'import megengine.hub as hub\n'), ((15533, 15560), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (15558, 15560), False, 'from basecls.utils import recursive_update, registers\n'), ((15562, 15676), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_m/effnetv2_m.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_m/effnetv2_m.pkl'\n )\n", (15576, 15676), True, 'import megengine.hub as hub\n'), ((16212, 16239), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (16237, 16239), False, 'from basecls.utils import recursive_update, registers\n'), ((16241, 16355), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_l/effnetv2_l.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/research/basecls/models/effnet/effnetv2_l/effnetv2_l.pkl'\n )\n", (16255, 16355), True, 'import megengine.hub as hub\n'), ((8251, 8287), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (8267, 8287), False, 'from basecls.utils import recursive_update, registers\n'), ((8427, 8463), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (8443, 8463), False, 'from basecls.utils import recursive_update, registers\n'), ((8897, 8933), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (8913, 8933), False, 'from basecls.utils import recursive_update, registers\n'), ((9197, 9233), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (9213, 9233), False, 'from basecls.utils import recursive_update, registers\n'), ((9497, 9533), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (9513, 9533), False, 'from basecls.utils import recursive_update, registers\n'), ((9826, 9862), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (9842, 9862), False, 'from basecls.utils import recursive_update, registers\n'), ((10155, 10191), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (10171, 10191), False, 'from basecls.utils import recursive_update, registers\n'), ((10484, 10520), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (10500, 10520), False, 'from basecls.utils import recursive_update, registers\n'), ((10813, 10849), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (10829, 10849), False, 'from basecls.utils import recursive_update, registers\n'), ((11142, 11178), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (11158, 11178), False, 'from basecls.utils import recursive_update, registers\n'), ((11471, 11507), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (11487, 11507), False, 'from basecls.utils import recursive_update, registers\n'), ((11800, 11836), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (11816, 11836), False, 'from basecls.utils import recursive_update, registers\n'), ((12129, 12165), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (12145, 12165), False, 'from basecls.utils import recursive_update, registers\n'), ((12444, 12480), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (12460, 12480), False, 'from basecls.utils import recursive_update, registers\n'), ((12764, 12800), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (12780, 12800), False, 'from basecls.utils import recursive_update, registers\n'), ((13113, 13149), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (13129, 13149), False, 'from basecls.utils import recursive_update, registers\n'), ((13462, 13498), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (13478, 13498), False, 'from basecls.utils import recursive_update, registers\n'), ((13811, 13847), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (13827, 13847), False, 'from basecls.utils import recursive_update, registers\n'), ((14122, 14158), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (14138, 14158), False, 'from basecls.utils import recursive_update, registers\n'), ((14430, 14466), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (14446, 14466), False, 'from basecls.utils import recursive_update, registers\n'), ((14767, 14803), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (14783, 14803), False, 'from basecls.utils import recursive_update, registers\n'), ((15104, 15140), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (15120, 15140), False, 'from basecls.utils import recursive_update, registers\n'), ((15452, 15488), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (15468, 15488), False, 'from basecls.utils import recursive_update, registers\n'), ((16131, 16167), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (16147, 16167), False, 'from basecls.utils import recursive_update, registers\n'), ((16811, 16847), 'basecls.utils.recursive_update', 'recursive_update', (['model_args', 'kwargs'], {}), '(model_args, kwargs)\n', (16827, 16847), False, 'from basecls.utils import recursive_update, registers\n'), ((2377, 2471), 'basecls.layers.conv2d', 'conv2d', (['w_mid', 'w_out', '(1 if exp_r != 1.0 else kernel)'], {'stride': '(1 if exp_r != 1.0 else stride)'}), '(w_mid, w_out, 1 if exp_r != 1.0 else kernel, stride=1 if exp_r != \n 1.0 else stride)\n', (2383, 2471), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2512, 2536), 'basecls.layers.norm2d', 'norm2d', (['norm_name', 'w_out'], {}), '(norm_name, w_out)\n', (2518, 2536), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2052, 2094), 'basecls.layers.conv2d', 'conv2d', (['w_in', 'w_exp', 'kernel'], {'stride': 'stride'}), '(w_in, w_exp, kernel, stride=stride)\n', (2058, 2094), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2121, 2145), 'basecls.layers.norm2d', 'norm2d', (['norm_name', 'w_exp'], {}), '(norm_name, w_exp)\n', (2127, 2145), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2173, 2193), 'basecls.layers.activation', 'activation', (['act_name'], {}), '(act_name)\n', (2183, 2193), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2314, 2339), 'basecls.layers.SE', 'SE', (['w_mid', 'w_se', 'act_name'], {}), '(w_mid, w_se, act_name)\n', (2316, 2339), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2636, 2656), 'basecls.layers.activation', 'activation', (['act_name'], {}), '(act_name)\n', (2646, 2656), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((2794, 2818), 'basecls.layers.DropPath', 'DropPath', (['drop_path_prob'], {}), '(drop_path_prob)\n', (2802, 2818), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((5292, 5344), 'basecls.layers.make_divisible', 'make_divisible', (['(stem_w * width_mult)'], {'round_limit': '(0.9)'}), '(stem_w * width_mult, round_limit=0.9)\n', (5306, 5344), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((5599, 5646), 'basecls.layers.make_divisible', 'make_divisible', (['(w * width_mult)'], {'round_limit': '(0.9)'}), '(w * width_mult, round_limit=0.9)\n', (5613, 5646), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((7014, 7059), 'basecls.layers.build_head', 'build_head', (['prev_w', 'head', 'norm_name', 'act_name'], {}), '(prev_w, head, norm_name, act_name)\n', (7024, 7059), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n'), ((5142, 5167), 'math.ceil', 'math.ceil', (['(d * depth_mult)'], {}), '(d * depth_mult)\n', (5151, 5167), False, 'import math\n'), ((6930, 6989), 'basecls.layers.make_divisible', 'make_divisible', (["(head['width'] * width_mult)"], {'round_limit': '(0.9)'}), "(head['width'] * width_mult, round_limit=0.9)\n", (6944, 6989), False, 'from basecls.layers import SE, DropPath, activation, build_head, conv2d, init_weights, make_divisible, norm2d\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
from megengine import tensor
from megengine.module import Conv1d, Conv2d, Conv3d, Linear
from megengine.module.init import calculate_fan_in_and_fan_out, fill_
def test_fill_():
x = tensor(np.zeros((2, 3, 4)), dtype=np.float32)
fill_(x, 5.0)
np.testing.assert_array_equal(
x.numpy(), np.full(shape=(2, 3, 4), fill_value=5.0, dtype=np.float32)
)
def test_calculate_fan_in_and_fan_out():
l = Linear(in_features=3, out_features=8)
fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
assert fanin == 3
assert fanout == 8
with pytest.raises(ValueError):
calculate_fan_in_and_fan_out(l.bias)
l = Conv1d(in_channels=2, out_channels=3, kernel_size=5)
fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
assert fanin == 2 * 5
assert fanout == 3 * 5
# FIXME: will be wrong for group conv1d
# l = Conv1d(in_channels=2, out_channels=4, kernel_size=5, groups=2)
# fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
# assert fanin == 2 // 2 * 5
# assert fanout == 4 // 2 * 5
l = Conv2d(in_channels=2, out_channels=3, kernel_size=(5, 7))
fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
assert fanin == 2 * 5 * 7
assert fanout == 3 * 5 * 7
l = Conv2d(in_channels=2, out_channels=4, kernel_size=(5, 7), groups=2)
fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
assert fanin == 2 // 2 * 5 * 7
assert fanout == 4 // 2 * 5 * 7
# FIXME: will be wrong for conv3d
# l = Conv3d(in_channels=2, out_channels=3, kernel_size=(5, 7, 9))
# fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
# assert fanin == 2 * 5 * 7 * 9
# assert fanout == 3 * 5 * 7 * 9
l = Conv3d(in_channels=2, out_channels=4, kernel_size=(5, 7, 9), groups=2)
fanin, fanout = calculate_fan_in_and_fan_out(l.weight)
assert fanin == 2 // 2 * 5 * 7 * 9
assert fanout == 4 // 2 * 5 * 7 * 9
|
[
"megengine.module.init.fill_",
"megengine.module.Conv3d",
"megengine.module.Conv1d",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.module.Conv2d",
"megengine.module.Linear"
] |
[((648, 661), 'megengine.module.init.fill_', 'fill_', (['x', '(5.0)'], {}), '(x, 5.0)\n', (653, 661), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((833, 870), 'megengine.module.Linear', 'Linear', ([], {'in_features': '(3)', 'out_features': '(8)'}), '(in_features=3, out_features=8)\n', (839, 870), False, 'from megengine.module import Conv1d, Conv2d, Conv3d, Linear\n'), ((891, 929), 'megengine.module.init.calculate_fan_in_and_fan_out', 'calculate_fan_in_and_fan_out', (['l.weight'], {}), '(l.weight)\n', (919, 929), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((1066, 1118), 'megengine.module.Conv1d', 'Conv1d', ([], {'in_channels': '(2)', 'out_channels': '(3)', 'kernel_size': '(5)'}), '(in_channels=2, out_channels=3, kernel_size=5)\n', (1072, 1118), False, 'from megengine.module import Conv1d, Conv2d, Conv3d, Linear\n'), ((1139, 1177), 'megengine.module.init.calculate_fan_in_and_fan_out', 'calculate_fan_in_and_fan_out', (['l.weight'], {}), '(l.weight)\n', (1167, 1177), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((1486, 1543), 'megengine.module.Conv2d', 'Conv2d', ([], {'in_channels': '(2)', 'out_channels': '(3)', 'kernel_size': '(5, 7)'}), '(in_channels=2, out_channels=3, kernel_size=(5, 7))\n', (1492, 1543), False, 'from megengine.module import Conv1d, Conv2d, Conv3d, Linear\n'), ((1564, 1602), 'megengine.module.init.calculate_fan_in_and_fan_out', 'calculate_fan_in_and_fan_out', (['l.weight'], {}), '(l.weight)\n', (1592, 1602), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((1673, 1740), 'megengine.module.Conv2d', 'Conv2d', ([], {'in_channels': '(2)', 'out_channels': '(4)', 'kernel_size': '(5, 7)', 'groups': '(2)'}), '(in_channels=2, out_channels=4, kernel_size=(5, 7), groups=2)\n', (1679, 1740), False, 'from megengine.module import Conv1d, Conv2d, Conv3d, Linear\n'), ((1761, 1799), 'megengine.module.init.calculate_fan_in_and_fan_out', 'calculate_fan_in_and_fan_out', (['l.weight'], {}), '(l.weight)\n', (1789, 1799), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((2124, 2194), 'megengine.module.Conv3d', 'Conv3d', ([], {'in_channels': '(2)', 'out_channels': '(4)', 'kernel_size': '(5, 7, 9)', 'groups': '(2)'}), '(in_channels=2, out_channels=4, kernel_size=(5, 7, 9), groups=2)\n', (2130, 2194), False, 'from megengine.module import Conv1d, Conv2d, Conv3d, Linear\n'), ((2215, 2253), 'megengine.module.init.calculate_fan_in_and_fan_out', 'calculate_fan_in_and_fan_out', (['l.weight'], {}), '(l.weight)\n', (2243, 2253), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((605, 624), 'numpy.zeros', 'np.zeros', (['(2, 3, 4)'], {}), '((2, 3, 4))\n', (613, 624), True, 'import numpy as np\n'), ((717, 775), 'numpy.full', 'np.full', ([], {'shape': '(2, 3, 4)', 'fill_value': '(5.0)', 'dtype': 'np.float32'}), '(shape=(2, 3, 4), fill_value=5.0, dtype=np.float32)\n', (724, 775), True, 'import numpy as np\n'), ((985, 1010), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (998, 1010), False, 'import pytest\n'), ((1020, 1056), 'megengine.module.init.calculate_fan_in_and_fan_out', 'calculate_fan_in_and_fan_out', (['l.bias'], {}), '(l.bias)\n', (1048, 1056), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n')]
|
import io
import numpy as np
import megengine.core.tensor.megbrain_graph as G
import megengine.functional as F
import megengine.module as M
import megengine.utils.network_node as N
from megengine.jit.tracing import trace
from megengine.tensor import Tensor
from megengine.utils.comp_graph_tools import GraphInference
from megengine.utils.network import Network as Net
from megengine.utils.network import as_oprnode, set_symbolic_shape
from megengine.utils.network_node import Host2DeviceCopy, VarNode
def test_metadata():
x = Tensor(0)
@trace(symbolic=True, capture_as_const=True)
def fwd(x):
return x * 2
fwd(x)
orig_model = io.BytesIO()
fwd.dump(orig_model, user_info="test", optimize_for_inference=False)
orig_model.seek(0)
graph = Net.load(orig_model)
assert graph.metadata == {
"user_info": "test",
"graph_modified": False, # False: tracing.dump
"optimized_for_inference": False,
}
orig_model.seek(0)
graph.dump(
orig_model,
user_info={"str": "x", "tensor": x, "module": M.Module, "none": None},
optimize_for_inference=True,
enable_nchw4=True,
enable_ioc16=True,
)
orig_model.seek(0)
graph = Net.load(orig_model)
assert graph.metadata == {
"user_info": {"str": "x", "tensor": x, "module": M.Module, "none": None},
"graph_modified": True, # True: Network.dump
"optimized_for_inference": True,
"enable_nchw4": True,
"enable_ioc16": True,
}
orig_model.seek(0)
fwd.dump(orig_model, enable_metadata=False)
orig_model.seek(0)
graph = Net.load(orig_model)
assert graph.metadata is None
def test_replace_var():
a = Tensor([1, 2])
b = Tensor([3, 4])
@trace(symbolic=True, capture_as_const=True)
def fwd(a, b):
return (a + b) * 2
fwd(a, b)
orig_model = io.BytesIO()
fwd.dump(
orig_model, arg_names=["a", "b"], output_names="o", optimize_for_inference=False
)
orig_model.seek(0)
graph = Net.load(orig_model)
vara = graph.var_filter.name("a").as_unique()
varb = graph.var_filter.name("b").as_unique()
out = F.mul(vara, varb)
out = F.relu(out)
opnode = list(graph.opr_filter.has_input(vara))
repl_dict = {opnode[0].outputs[0]: out}
graph.replace_vars(repl_dict)
modified_model = io.BytesIO()
graph.dump(modified_model)
modified_model.seek(0)
load_graph = GraphInference(modified_model)
out = load_graph.run(a, b)
np.testing.assert_equal(out["o"], [6, 16])
def test_replace_opr():
a = Tensor([1, 2])
b = Tensor([3, 4])
@trace(symbolic=True, capture_as_const=True)
def fwd(a, b):
return (a + b) * 2
fwd(a, b)
orig_model = io.BytesIO()
fwd.dump(
orig_model, arg_names=["a", "b"], output_names="o", optimize_for_inference=False
)
orig_model.seek(0)
graph = Net.load(orig_model)
vara = graph.var_filter.name("a").as_unique()
varb = graph.var_filter.name("b").as_unique()
out1 = F.sub(vara, varb)
out1 = F.relu(out1)
out1 = graph.add_dep_oprs(out1)
orig_opr = graph.opr_filter.has_input(vara).as_unique()
repl_dict = {orig_opr: out1[0].owner}
graph.replace_oprs(repl_dict)
modified_model1 = io.BytesIO()
graph.dump(modified_model1)
modified_model1.seek(0)
load_graph = GraphInference(modified_model1)
out = load_graph.run(a, b)
np.testing.assert_equal(out["o"], [0, 0])
def test_splice_network():
x = F.ones((2,))
y = F.ones((2,))
@trace(symbolic=True, capture_as_const=True)
def fun1(a, b):
return (a + b) * 2
@trace(symbolic=True, capture_as_const=True)
def fun2(a):
return a * 2 - 1
model = io.BytesIO()
fun1(x, y)
fun2(x)
fun1.dump(
model,
arg_names=["net1_i0", "net1_i1"],
output_names=["net1_o0"],
optimize_for_inference=False,
)
model.seek(0)
net1 = Net.load(model)
model.seek(0)
fun2.dump(
model,
arg_names=["net2_i0"],
output_names=["net2_o0"],
optimize_for_inference=False,
)
model.seek(0)
net2 = Net.load(model)
net1.add_output(*net2.output_vars)
var = net1.var_filter.name("net1_i0").as_unique()
repl_var = net2.var_filter.name("net2_o0").as_unique()
net1.replace_vars({var: repl_var})
assert "net1_i0" not in [var.name for var in net1.all_vars]
assert "net2_i0" in [var.name for var in net1.all_vars]
model.seek(0)
net1.dump(model, keep_var_name=2, optimize_for_inference=False)
model.seek(0)
net = Net.load(model)
assert "net1_i0" not in [var.name for var in net.all_vars]
assert "net2_i0" in [var.name for var in net.all_vars]
def test_modify_params():
a = Tensor([1, 2])
b = Tensor([3, 4])
@trace(symbolic=True, capture_as_const=True)
def fwd(a, b):
return (a + b) * 2
fwd(a, b)
orig_model = io.BytesIO()
fwd.dump(
orig_model, arg_names=["a", "b"], output_names="o", optimize_for_inference=False
)
orig_model.seek(0)
graph = Net.load(orig_model)
param_const = graph.params_filter.as_unique()
param_const.set_value(3)
modified_model = io.BytesIO()
graph.dump(modified_model)
modified_model.seek(0)
load_graph = GraphInference(modified_model)
out = load_graph.run(a, b)
np.testing.assert_equal(out["o"], [12, 18])
def test_make_const():
a = Tensor([1, 2])
b = Tensor([3, 4])
@trace(symbolic=True, capture_as_const=True)
def fwd(a, b):
return (a + b) * 2
fwd(a, b)
orig_model = io.BytesIO()
fwd.dump(
orig_model, arg_names=["a", "b"], output_names="o", optimize_for_inference=False
)
orig_model.seek(0)
graph = Net.load(orig_model)
const_b = graph.make_const(np.array([0.0, 0.0]), name="b")
varb = graph.var_filter.name("b").as_unique()
repl_dict = {varb: const_b}
graph.replace_vars(repl_dict)
modified_model = io.BytesIO()
graph.dump(modified_model)
modified_model.seek(0)
load_graph = GraphInference(modified_model)
out = load_graph.run(a)
np.testing.assert_equal(out["o"], [2, 4])
def test_add_input():
a = Tensor([1, 2])
b = Tensor([3, 4])
@trace(symbolic=True, capture_as_const=True)
def fwd(a, b):
return (a + b) * 2
fwd(a, b)
orig_model = io.BytesIO()
fwd.dump(
orig_model, arg_names=["a", "b"], output_names="o", optimize_for_inference=False
)
orig_model.seek(0)
graph = Net.load(orig_model)
inp_c = graph.make_input_node((2,), np.int32, name="c")
varo = graph.var_filter.name("o").as_unique()
out = F.add(varo, inp_c)
out.name = "o1"
graph.remove_output(varo)
graph.add_output(out)
modified_model = io.BytesIO()
graph.dump(modified_model)
modified_model.seek(0)
load_graph = GraphInference(modified_model)
out = load_graph.run(a, b, a)
np.testing.assert_equal(out["o1"], ((a + b) * 2 + a).numpy())
def test_add_remove_output():
a = Tensor([1.0, 2.0])
b = Tensor([3.0, 4.0])
@trace(symbolic=True, capture_as_const=True)
def fwd(a, b):
return (a + b) * 2, (a - b)
fwd(a, b)
orig_model = io.BytesIO()
fwd.dump(
orig_model,
arg_names=["a", "b"],
output_names=["o1", "o2"],
optimize_for_inference=False,
)
orig_model.seek(0)
net = Net.load(orig_model)
var_a = net.var_filter.name("a").as_unique()
var_b = net.var_filter.name("b").as_unique()
y1 = (var_a + var_b) * 3
y2 = F.sigmoid(var_a + var_b)
net.remove_output(*net.output_vars)
y1.name = "new_o1"
y2.name = "new_o2"
net.add_output(y1, y2)
modified_model = io.BytesIO()
net.dump(modified_model)
modified_model.seek(0)
g = GraphInference(modified_model)
out = g.run(a.numpy(), b.numpy())
np.testing.assert_equal(out["new_o1"], ((a + b) * 3).numpy())
np.testing.assert_equal(out["new_o2"], (F.sigmoid((a + b))).numpy())
def test_query():
class Model(M.Module):
def __init__(self):
super().__init__()
self.conv1 = M.Conv2d(3, 32, 3)
self.conv2 = M.Conv2d(32, 32, 3)
self.conv3 = M.Conv2d(32, 32, 3)
def forward(self, data):
x = self.conv1(data)
x = self.conv2(x)
x = self.conv3(x)
return x
n = Model()
@trace(symbolic=True, capture_as_const=True)
def fwd(data):
return n(data)
fwd(Tensor(np.random.random((1, 3, 224, 224))))
orig_model = io.BytesIO()
fwd.dump(
orig_model,
arg_names=["data"],
output_names="o",
keep_opr_name=True,
keep_var_name=True,
optimize_for_inference=False,
)
orig_model.seek(0)
graph = Net.load(orig_model)
r = graph.data_providers_filter.as_count()
assert r == 1
opr = graph.get_opr_by_type(Host2DeviceCopy)
assert isinstance(opr, Host2DeviceCopy)
r1 = graph.params_filter.as_count()
assert r1 == 6
r2 = graph.opr_filter.type(N.ConvolutionForward).as_count()
assert r2 == 3
r3 = graph.opr_filter.not_type(N.ConvolutionForward).as_count()
assert r3 == len(graph.all_oprs) - r2
var = graph.var_filter.name("data").as_unique()
r4 = graph.opr_filter.has_input(var).as_count()
assert r4 == 1
r5 = graph.opr_filter.name("data").as_count()
assert r5 == 1
opr = graph.get_opr_by_name("data")
assert isinstance(opr, Host2DeviceCopy)
var = graph.get_var_by_name("data")
assert isinstance(var, VarNode)
r6 = graph.var_filter.name("*bias").as_count()
assert r6 == 3
def test_optimize_for_inference():
@trace(symbolic=True, capture_as_const=True)
def f(x):
return F.exp(x)
orig_model = io.BytesIO()
f(Tensor(5.0))
f.dump(orig_model, optimize_for_inference=False)
orig_model.seek(0)
optimize_model = io.BytesIO()
net = Net.load(orig_model)
net.dump(optimize_model, enable_io16xc32=True)
optimize_model.seek(0)
res = G.load_graph(optimize_model)
computing_input = res.output_vars_list[0].owner.inputs[0]
assert computing_input.dtype == np.float16
def test_reset_batchsize():
@trace(symbolic=True, capture_as_const=True)
def f(x):
return F.exp(x)
orig_model = io.BytesIO()
f(Tensor(np.random.random((3, 3, 224, 224))))
f.dump(orig_model, optimize_for_inference=False)
orig_model.seek(0)
modified_model = io.BytesIO()
net = Net.load(orig_model)
net.reset_batch_size(1)
net.dump(modified_model, optimize_for_inference=False)
modified_model.seek(0)
net1 = Net.load(modified_model)
assert net1.data_providers_filter.as_unique().shape[0] == 1
def test_modify_opr_name():
@trace(symbolic=True, capture_as_const=True)
def f(x):
return F.exp(x)
orig_model = io.BytesIO()
f(Tensor(np.random.random((3, 3, 224, 224))))
f.dump(orig_model, arg_names=["a"], optimize_for_inference=False)
orig_model.seek(0)
modified_model = io.BytesIO()
net = Net.load(orig_model)
net.modify_opr_names("net")
net.modify_opr_names(lambda x: "net1." + x)
net.dump(modified_model, optimize_for_inference=False)
modified_model.seek(0)
net1 = Net.load(modified_model)
assert net1.data_providers_filter.as_unique().name == "net1.net.a"
def test_dump_cond_take():
a = Tensor([1.0, 2.0])
@trace(symbolic=True, capture_as_const=True)
def fwd(a):
return F.cond_take(a > 1, a)
fwd(a)
orig_model = io.BytesIO()
fwd.dump(
orig_model,
arg_names=["a"],
output_names=["o1", "o2"],
optimize_for_inference=False,
)
orig_model.seek(0)
net = Net.load(orig_model)
var_a = net.input_vars[0]
val, idx = F.cond_take(var_a > 1, var_a)
net.remove_output(*net.output_vars)
val.name = "value"
idx.name = "index"
net.add_output(val, idx)
modified_model = io.BytesIO()
net.dump(modified_model)
modified_model.seek(0)
g = GraphInference(modified_model)
out = g.run(a.numpy())
data = a.numpy()
mask = a.numpy() > 1
np.testing.assert_equal(out["index"], np.where(mask.reshape(-1))[0])
np.testing.assert_equal(out["value"], data[mask])
def test_set_symbolic_shape():
a = Tensor([1.0, 2.0])
@trace(symbolic=True, capture_as_const=True)
def fwd(a):
return F.relu(a * 2)
fwd(a)
orig_model = io.BytesIO()
fwd.dump(
orig_model, arg_names=["a"], output_names=["o"], optimize_for_inference=False,
)
orig_model.seek(0)
net = Net.load(orig_model)
var_a = net.input_vars[0]
saved_symbolic_shape = set_symbolic_shape(True)
assert isinstance(var_a.shape, VarNode)
set_symbolic_shape(False)
assert var_a.shape == var_a.partial_shape
set_symbolic_shape(saved_symbolic_shape)
|
[
"megengine.utils.comp_graph_tools.GraphInference",
"megengine.functional.ones",
"megengine.functional.sigmoid",
"megengine.module.Conv2d",
"megengine.functional.cond_take",
"megengine.utils.network.Network.load",
"megengine.functional.add",
"megengine.jit.tracing.trace",
"megengine.functional.mul",
"megengine.utils.network.set_symbolic_shape",
"megengine.core.tensor.megbrain_graph.load_graph",
"megengine.functional.exp",
"megengine.functional.relu",
"megengine.tensor.Tensor",
"megengine.functional.sub"
] |
[((534, 543), 'megengine.tensor.Tensor', 'Tensor', (['(0)'], {}), '(0)\n', (540, 543), False, 'from megengine.tensor import Tensor\n'), ((550, 593), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (555, 593), False, 'from megengine.jit.tracing import trace\n'), ((661, 673), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (671, 673), False, 'import io\n'), ((782, 802), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (790, 802), True, 'from megengine.utils.network import Network as Net\n'), ((1238, 1258), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (1246, 1258), True, 'from megengine.utils.network import Network as Net\n'), ((1640, 1660), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (1648, 1660), True, 'from megengine.utils.network import Network as Net\n'), ((1730, 1744), 'megengine.tensor.Tensor', 'Tensor', (['[1, 2]'], {}), '([1, 2])\n', (1736, 1744), False, 'from megengine.tensor import Tensor\n'), ((1753, 1767), 'megengine.tensor.Tensor', 'Tensor', (['[3, 4]'], {}), '([3, 4])\n', (1759, 1767), False, 'from megengine.tensor import Tensor\n'), ((1774, 1817), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (1779, 1817), False, 'from megengine.jit.tracing import trace\n'), ((1896, 1908), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (1906, 1908), False, 'import io\n'), ((2054, 2074), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (2062, 2074), True, 'from megengine.utils.network import Network as Net\n'), ((2186, 2203), 'megengine.functional.mul', 'F.mul', (['vara', 'varb'], {}), '(vara, varb)\n', (2191, 2203), True, 'import megengine.functional as F\n'), ((2214, 2225), 'megengine.functional.relu', 'F.relu', (['out'], {}), '(out)\n', (2220, 2225), True, 'import megengine.functional as F\n'), ((2379, 2391), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (2389, 2391), False, 'import io\n'), ((2467, 2497), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model'], {}), '(modified_model)\n', (2481, 2497), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((2534, 2576), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (["out['o']", '[6, 16]'], {}), "(out['o'], [6, 16])\n", (2557, 2576), True, 'import numpy as np\n'), ((2612, 2626), 'megengine.tensor.Tensor', 'Tensor', (['[1, 2]'], {}), '([1, 2])\n', (2618, 2626), False, 'from megengine.tensor import Tensor\n'), ((2635, 2649), 'megengine.tensor.Tensor', 'Tensor', (['[3, 4]'], {}), '([3, 4])\n', (2641, 2649), False, 'from megengine.tensor import Tensor\n'), ((2656, 2699), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (2661, 2699), False, 'from megengine.jit.tracing import trace\n'), ((2778, 2790), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (2788, 2790), False, 'import io\n'), ((2936, 2956), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (2944, 2956), True, 'from megengine.utils.network import Network as Net\n'), ((3069, 3086), 'megengine.functional.sub', 'F.sub', (['vara', 'varb'], {}), '(vara, varb)\n', (3074, 3086), True, 'import megengine.functional as F\n'), ((3098, 3110), 'megengine.functional.relu', 'F.relu', (['out1'], {}), '(out1)\n', (3104, 3110), True, 'import megengine.functional as F\n'), ((3306, 3318), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (3316, 3318), False, 'import io\n'), ((3397, 3428), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model1'], {}), '(modified_model1)\n', (3411, 3428), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((3464, 3505), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (["out['o']", '[0, 0]'], {}), "(out['o'], [0, 0])\n", (3487, 3505), True, 'import numpy as np\n'), ((3543, 3555), 'megengine.functional.ones', 'F.ones', (['(2,)'], {}), '((2,))\n', (3549, 3555), True, 'import megengine.functional as F\n'), ((3564, 3576), 'megengine.functional.ones', 'F.ones', (['(2,)'], {}), '((2,))\n', (3570, 3576), True, 'import megengine.functional as F\n'), ((3583, 3626), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (3588, 3626), False, 'from megengine.jit.tracing import trace\n'), ((3680, 3723), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (3685, 3723), False, 'from megengine.jit.tracing import trace\n'), ((3779, 3791), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (3789, 3791), False, 'import io\n'), ((3998, 4013), 'megengine.utils.network.Network.load', 'Net.load', (['model'], {}), '(model)\n', (4006, 4013), True, 'from megengine.utils.network import Network as Net\n'), ((4200, 4215), 'megengine.utils.network.Network.load', 'Net.load', (['model'], {}), '(model)\n', (4208, 4215), True, 'from megengine.utils.network import Network as Net\n'), ((4645, 4660), 'megengine.utils.network.Network.load', 'Net.load', (['model'], {}), '(model)\n', (4653, 4660), True, 'from megengine.utils.network import Network as Net\n'), ((4820, 4834), 'megengine.tensor.Tensor', 'Tensor', (['[1, 2]'], {}), '([1, 2])\n', (4826, 4834), False, 'from megengine.tensor import Tensor\n'), ((4843, 4857), 'megengine.tensor.Tensor', 'Tensor', (['[3, 4]'], {}), '([3, 4])\n', (4849, 4857), False, 'from megengine.tensor import Tensor\n'), ((4864, 4907), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (4869, 4907), False, 'from megengine.jit.tracing import trace\n'), ((4986, 4998), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (4996, 4998), False, 'import io\n'), ((5144, 5164), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (5152, 5164), True, 'from megengine.utils.network import Network as Net\n'), ((5266, 5278), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (5276, 5278), False, 'import io\n'), ((5354, 5384), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model'], {}), '(modified_model)\n', (5368, 5384), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((5421, 5464), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (["out['o']", '[12, 18]'], {}), "(out['o'], [12, 18])\n", (5444, 5464), True, 'import numpy as np\n'), ((5499, 5513), 'megengine.tensor.Tensor', 'Tensor', (['[1, 2]'], {}), '([1, 2])\n', (5505, 5513), False, 'from megengine.tensor import Tensor\n'), ((5522, 5536), 'megengine.tensor.Tensor', 'Tensor', (['[3, 4]'], {}), '([3, 4])\n', (5528, 5536), False, 'from megengine.tensor import Tensor\n'), ((5543, 5586), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (5548, 5586), False, 'from megengine.jit.tracing import trace\n'), ((5665, 5677), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (5675, 5677), False, 'import io\n'), ((5823, 5843), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (5831, 5843), True, 'from megengine.utils.network import Network as Net\n'), ((6046, 6058), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (6056, 6058), False, 'import io\n'), ((6134, 6164), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model'], {}), '(modified_model)\n', (6148, 6164), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((6198, 6239), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (["out['o']", '[2, 4]'], {}), "(out['o'], [2, 4])\n", (6221, 6239), True, 'import numpy as np\n'), ((6273, 6287), 'megengine.tensor.Tensor', 'Tensor', (['[1, 2]'], {}), '([1, 2])\n', (6279, 6287), False, 'from megengine.tensor import Tensor\n'), ((6296, 6310), 'megengine.tensor.Tensor', 'Tensor', (['[3, 4]'], {}), '([3, 4])\n', (6302, 6310), False, 'from megengine.tensor import Tensor\n'), ((6317, 6360), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (6322, 6360), False, 'from megengine.jit.tracing import trace\n'), ((6439, 6451), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (6449, 6451), False, 'import io\n'), ((6597, 6617), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (6605, 6617), True, 'from megengine.utils.network import Network as Net\n'), ((6739, 6757), 'megengine.functional.add', 'F.add', (['varo', 'inp_c'], {}), '(varo, inp_c)\n', (6744, 6757), True, 'import megengine.functional as F\n'), ((6855, 6867), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (6865, 6867), False, 'import io\n'), ((6944, 6974), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model'], {}), '(modified_model)\n', (6958, 6974), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((7117, 7135), 'megengine.tensor.Tensor', 'Tensor', (['[1.0, 2.0]'], {}), '([1.0, 2.0])\n', (7123, 7135), False, 'from megengine.tensor import Tensor\n'), ((7144, 7162), 'megengine.tensor.Tensor', 'Tensor', (['[3.0, 4.0]'], {}), '([3.0, 4.0])\n', (7150, 7162), False, 'from megengine.tensor import Tensor\n'), ((7169, 7212), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (7174, 7212), False, 'from megengine.jit.tracing import trace\n'), ((7300, 7312), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (7310, 7312), False, 'import io\n'), ((7490, 7510), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (7498, 7510), True, 'from megengine.utils.network import Network as Net\n'), ((7648, 7672), 'megengine.functional.sigmoid', 'F.sigmoid', (['(var_a + var_b)'], {}), '(var_a + var_b)\n', (7657, 7672), True, 'import megengine.functional as F\n'), ((7809, 7821), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (7819, 7821), False, 'import io\n'), ((7887, 7917), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model'], {}), '(modified_model)\n', (7901, 7917), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((8507, 8550), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (8512, 8550), False, 'from megengine.jit.tracing import trace\n'), ((8663, 8675), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (8673, 8675), False, 'import io\n'), ((8900, 8920), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (8908, 8920), True, 'from megengine.utils.network import Network as Net\n'), ((9805, 9848), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (9810, 9848), False, 'from megengine.jit.tracing import trace\n'), ((9905, 9917), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (9915, 9917), False, 'import io\n'), ((10035, 10047), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (10045, 10047), False, 'import io\n'), ((10058, 10078), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (10066, 10078), True, 'from megengine.utils.network import Network as Net\n'), ((10168, 10196), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['optimize_model'], {}), '(optimize_model)\n', (10180, 10196), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((10341, 10384), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (10346, 10384), False, 'from megengine.jit.tracing import trace\n'), ((10441, 10453), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (10451, 10453), False, 'import io\n'), ((10602, 10614), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (10612, 10614), False, 'import io\n'), ((10625, 10645), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (10633, 10645), True, 'from megengine.utils.network import Network as Net\n'), ((10772, 10796), 'megengine.utils.network.Network.load', 'Net.load', (['modified_model'], {}), '(modified_model)\n', (10780, 10796), True, 'from megengine.utils.network import Network as Net\n'), ((10896, 10939), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (10901, 10939), False, 'from megengine.jit.tracing import trace\n'), ((10996, 11008), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (11006, 11008), False, 'import io\n'), ((11174, 11186), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (11184, 11186), False, 'import io\n'), ((11197, 11217), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (11205, 11217), True, 'from megengine.utils.network import Network as Net\n'), ((11396, 11420), 'megengine.utils.network.Network.load', 'Net.load', (['modified_model'], {}), '(modified_model)\n', (11404, 11420), True, 'from megengine.utils.network import Network as Net\n'), ((11530, 11548), 'megengine.tensor.Tensor', 'Tensor', (['[1.0, 2.0]'], {}), '([1.0, 2.0])\n', (11536, 11548), False, 'from megengine.tensor import Tensor\n'), ((11555, 11598), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (11560, 11598), False, 'from megengine.jit.tracing import trace\n'), ((11681, 11693), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (11691, 11693), False, 'import io\n'), ((11866, 11886), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (11874, 11886), True, 'from megengine.utils.network import Network as Net\n'), ((11933, 11962), 'megengine.functional.cond_take', 'F.cond_take', (['(var_a > 1)', 'var_a'], {}), '(var_a > 1, var_a)\n', (11944, 11962), True, 'import megengine.functional as F\n'), ((12101, 12113), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (12111, 12113), False, 'import io\n'), ((12179, 12209), 'megengine.utils.comp_graph_tools.GraphInference', 'GraphInference', (['modified_model'], {}), '(modified_model)\n', (12193, 12209), False, 'from megengine.utils.comp_graph_tools import GraphInference\n'), ((12361, 12410), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (["out['value']", 'data[mask]'], {}), "(out['value'], data[mask])\n", (12384, 12410), True, 'import numpy as np\n'), ((12453, 12471), 'megengine.tensor.Tensor', 'Tensor', (['[1.0, 2.0]'], {}), '([1.0, 2.0])\n', (12459, 12471), False, 'from megengine.tensor import Tensor\n'), ((12478, 12521), 'megengine.jit.tracing.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (12483, 12521), False, 'from megengine.jit.tracing import trace\n'), ((12596, 12608), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (12606, 12608), False, 'import io\n'), ((12749, 12769), 'megengine.utils.network.Network.load', 'Net.load', (['orig_model'], {}), '(orig_model)\n', (12757, 12769), True, 'from megengine.utils.network import Network as Net\n'), ((12828, 12852), 'megengine.utils.network.set_symbolic_shape', 'set_symbolic_shape', (['(True)'], {}), '(True)\n', (12846, 12852), False, 'from megengine.utils.network import as_oprnode, set_symbolic_shape\n'), ((12901, 12926), 'megengine.utils.network.set_symbolic_shape', 'set_symbolic_shape', (['(False)'], {}), '(False)\n', (12919, 12926), False, 'from megengine.utils.network import as_oprnode, set_symbolic_shape\n'), ((12977, 13017), 'megengine.utils.network.set_symbolic_shape', 'set_symbolic_shape', (['saved_symbolic_shape'], {}), '(saved_symbolic_shape)\n', (12995, 13017), False, 'from megengine.utils.network import as_oprnode, set_symbolic_shape\n'), ((5875, 5895), 'numpy.array', 'np.array', (['[0.0, 0.0]'], {}), '([0.0, 0.0])\n', (5883, 5895), True, 'import numpy as np\n'), ((9878, 9886), 'megengine.functional.exp', 'F.exp', (['x'], {}), '(x)\n', (9883, 9886), True, 'import megengine.functional as F\n'), ((9924, 9935), 'megengine.tensor.Tensor', 'Tensor', (['(5.0)'], {}), '(5.0)\n', (9930, 9935), False, 'from megengine.tensor import Tensor\n'), ((10414, 10422), 'megengine.functional.exp', 'F.exp', (['x'], {}), '(x)\n', (10419, 10422), True, 'import megengine.functional as F\n'), ((10969, 10977), 'megengine.functional.exp', 'F.exp', (['x'], {}), '(x)\n', (10974, 10977), True, 'import megengine.functional as F\n'), ((11630, 11651), 'megengine.functional.cond_take', 'F.cond_take', (['(a > 1)', 'a'], {}), '(a > 1, a)\n', (11641, 11651), True, 'import megengine.functional as F\n'), ((12553, 12566), 'megengine.functional.relu', 'F.relu', (['(a * 2)'], {}), '(a * 2)\n', (12559, 12566), True, 'import megengine.functional as F\n'), ((8227, 8245), 'megengine.module.Conv2d', 'M.Conv2d', (['(3)', '(32)', '(3)'], {}), '(3, 32, 3)\n', (8235, 8245), True, 'import megengine.module as M\n'), ((8271, 8290), 'megengine.module.Conv2d', 'M.Conv2d', (['(32)', '(32)', '(3)'], {}), '(32, 32, 3)\n', (8279, 8290), True, 'import megengine.module as M\n'), ((8316, 8335), 'megengine.module.Conv2d', 'M.Conv2d', (['(32)', '(32)', '(3)'], {}), '(32, 32, 3)\n', (8324, 8335), True, 'import megengine.module as M\n'), ((8609, 8643), 'numpy.random.random', 'np.random.random', (['(1, 3, 224, 224)'], {}), '((1, 3, 224, 224))\n', (8625, 8643), True, 'import numpy as np\n'), ((10467, 10501), 'numpy.random.random', 'np.random.random', (['(3, 3, 224, 224)'], {}), '((3, 3, 224, 224))\n', (10483, 10501), True, 'import numpy as np\n'), ((11022, 11056), 'numpy.random.random', 'np.random.random', (['(3, 3, 224, 224)'], {}), '((3, 3, 224, 224))\n', (11038, 11056), True, 'import numpy as np\n'), ((8067, 8083), 'megengine.functional.sigmoid', 'F.sigmoid', (['(a + b)'], {}), '(a + b)\n', (8076, 8083), True, 'import megengine.functional as F\n')]
|
import math
import megengine.module as M
import megengine.functional as F
class PositionEncodingSine(M.Module):
"""
This is a sinusoidal position encoding that generalized to 2-dimensional images
"""
def __init__(self, d_model, max_shape=(256, 256)):
"""
Args:
max_shape (tuple): for 1/8 featmap, the max length of 256 corresponds to 2048 pixels
"""
super().__init__()
pe = F.zeros((d_model, *max_shape))
y_position = F.expand_dims(F.cumsum(F.ones(max_shape), 0), 0)
x_position = F.expand_dims(F.cumsum(F.ones(max_shape), 1), 0)
div_term = F.exp(
F.arange(0, d_model // 2, 2) * (-math.log(10000.0) / d_model // 2)
)
div_term = F.expand_dims(div_term, (1, 2)) # [C//4, 1, 1]
pe[0::4, :, :] = F.sin(x_position * div_term)
pe[1::4, :, :] = F.cos(x_position * div_term)
pe[2::4, :, :] = F.sin(y_position * div_term)
pe[3::4, :, :] = F.cos(y_position * div_term)
self.pe = F.expand_dims(pe, 0)
def forward(self, x):
"""
Args:
x: [N, C, H, W]
"""
return x + self.pe[:, :, : x.shape[2], : x.shape[3]].to(x.device)
|
[
"megengine.functional.arange",
"megengine.functional.cos",
"megengine.functional.zeros",
"megengine.functional.ones",
"megengine.functional.expand_dims",
"megengine.functional.sin"
] |
[((446, 476), 'megengine.functional.zeros', 'F.zeros', (['(d_model, *max_shape)'], {}), '((d_model, *max_shape))\n', (453, 476), True, 'import megengine.functional as F\n'), ((751, 782), 'megengine.functional.expand_dims', 'F.expand_dims', (['div_term', '(1, 2)'], {}), '(div_term, (1, 2))\n', (764, 782), True, 'import megengine.functional as F\n'), ((824, 852), 'megengine.functional.sin', 'F.sin', (['(x_position * div_term)'], {}), '(x_position * div_term)\n', (829, 852), True, 'import megengine.functional as F\n'), ((878, 906), 'megengine.functional.cos', 'F.cos', (['(x_position * div_term)'], {}), '(x_position * div_term)\n', (883, 906), True, 'import megengine.functional as F\n'), ((932, 960), 'megengine.functional.sin', 'F.sin', (['(y_position * div_term)'], {}), '(y_position * div_term)\n', (937, 960), True, 'import megengine.functional as F\n'), ((986, 1014), 'megengine.functional.cos', 'F.cos', (['(y_position * div_term)'], {}), '(y_position * div_term)\n', (991, 1014), True, 'import megengine.functional as F\n'), ((1034, 1054), 'megengine.functional.expand_dims', 'F.expand_dims', (['pe', '(0)'], {}), '(pe, 0)\n', (1047, 1054), True, 'import megengine.functional as F\n'), ((521, 538), 'megengine.functional.ones', 'F.ones', (['max_shape'], {}), '(max_shape)\n', (527, 538), True, 'import megengine.functional as F\n'), ((591, 608), 'megengine.functional.ones', 'F.ones', (['max_shape'], {}), '(max_shape)\n', (597, 608), True, 'import megengine.functional as F\n'), ((655, 683), 'megengine.functional.arange', 'F.arange', (['(0)', '(d_model // 2)', '(2)'], {}), '(0, d_model // 2, 2)\n', (663, 683), True, 'import megengine.functional as F\n'), ((688, 705), 'math.log', 'math.log', (['(10000.0)'], {}), '(10000.0)\n', (696, 705), False, 'import math\n')]
|
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import cv2
import megengine.functional as F
import numpy as np
__all__ = [
"preprocess",
"postprocess",
]
def preprocess(image, input_size, mean, std, swap=(2, 0, 1)):
if len(image.shape) == 3:
padded_img = np.ones((input_size[0], input_size[1], 3)) * 114.0
else:
padded_img = np.ones(input_size) * 114.0
img = np.array(image)
r = min(input_size[0] / img.shape[0], input_size[1] / img.shape[1])
resized_img = cv2.resize(
img,
(int(img.shape[1] * r), int(img.shape[0] * r)),
interpolation=cv2.INTER_LINEAR,
).astype(np.float32)
padded_img[: int(img.shape[0] * r), : int(img.shape[1] * r)] = resized_img
image = padded_img
image = image.astype(np.float32)
image = image[:, :, ::-1]
image /= 255.0
if mean is not None:
image -= mean
if std is not None:
image /= std
image = image.transpose(swap)
image = np.ascontiguousarray(image, dtype=np.float32)
return image, r
def postprocess(prediction, num_classes, conf_thre=0.7, nms_thre=0.45):
box_corner = F.zeros_like(prediction)
box_corner[:, :, 0] = prediction[:, :, 0] - prediction[:, :, 2] / 2
box_corner[:, :, 1] = prediction[:, :, 1] - prediction[:, :, 3] / 2
box_corner[:, :, 2] = prediction[:, :, 0] + prediction[:, :, 2] / 2
box_corner[:, :, 3] = prediction[:, :, 1] + prediction[:, :, 3] / 2
prediction[:, :, :4] = box_corner[:, :, :4]
output = [None for _ in range(len(prediction))]
for i, image_pred in enumerate(prediction):
# If none are remaining => process next image
if not image_pred.shape[0]:
continue
# Get score and class with highest confidence
class_conf = F.max(image_pred[:, 5 : 5 + num_classes], 1, keepdims=True)
class_pred = F.argmax(image_pred[:, 5 : 5 + num_classes], 1, keepdims=True)
class_conf_squeeze = F.squeeze(class_conf)
conf_mask = image_pred[:, 4] * class_conf_squeeze >= conf_thre
detections = F.concat((image_pred[:, :5], class_conf, class_pred), 1)
detections = detections[conf_mask]
if not detections.shape[0]:
continue
nms_out_index = F.vision.nms(
detections[:, :4], detections[:, 4] * detections[:, 5], nms_thre,
)
detections = detections[nms_out_index]
if output[i] is None:
output[i] = detections
else:
output[i] = F.concat((output[i], detections))
return output
|
[
"megengine.functional.vision.nms",
"megengine.functional.argmax",
"megengine.functional.squeeze",
"megengine.functional.zeros_like",
"megengine.functional.concat",
"megengine.functional.max"
] |
[((475, 490), 'numpy.array', 'np.array', (['image'], {}), '(image)\n', (483, 490), True, 'import numpy as np\n'), ((1072, 1117), 'numpy.ascontiguousarray', 'np.ascontiguousarray', (['image'], {'dtype': 'np.float32'}), '(image, dtype=np.float32)\n', (1092, 1117), True, 'import numpy as np\n'), ((1234, 1258), 'megengine.functional.zeros_like', 'F.zeros_like', (['prediction'], {}), '(prediction)\n', (1246, 1258), True, 'import megengine.functional as F\n'), ((1897, 1954), 'megengine.functional.max', 'F.max', (['image_pred[:, 5:5 + num_classes]', '(1)'], {'keepdims': '(True)'}), '(image_pred[:, 5:5 + num_classes], 1, keepdims=True)\n', (1902, 1954), True, 'import megengine.functional as F\n'), ((1979, 2039), 'megengine.functional.argmax', 'F.argmax', (['image_pred[:, 5:5 + num_classes]', '(1)'], {'keepdims': '(True)'}), '(image_pred[:, 5:5 + num_classes], 1, keepdims=True)\n', (1987, 2039), True, 'import megengine.functional as F\n'), ((2074, 2095), 'megengine.functional.squeeze', 'F.squeeze', (['class_conf'], {}), '(class_conf)\n', (2083, 2095), True, 'import megengine.functional as F\n'), ((2190, 2246), 'megengine.functional.concat', 'F.concat', (['(image_pred[:, :5], class_conf, class_pred)', '(1)'], {}), '((image_pred[:, :5], class_conf, class_pred), 1)\n', (2198, 2246), True, 'import megengine.functional as F\n'), ((2377, 2455), 'megengine.functional.vision.nms', 'F.vision.nms', (['detections[:, :4]', '(detections[:, 4] * detections[:, 5])', 'nms_thre'], {}), '(detections[:, :4], detections[:, 4] * detections[:, 5], nms_thre)\n', (2389, 2455), True, 'import megengine.functional as F\n'), ((352, 394), 'numpy.ones', 'np.ones', (['(input_size[0], input_size[1], 3)'], {}), '((input_size[0], input_size[1], 3))\n', (359, 394), True, 'import numpy as np\n'), ((436, 455), 'numpy.ones', 'np.ones', (['input_size'], {}), '(input_size)\n', (443, 455), True, 'import numpy as np\n'), ((2636, 2669), 'megengine.functional.concat', 'F.concat', (['(output[i], detections)'], {}), '((output[i], detections))\n', (2644, 2669), True, 'import megengine.functional as F\n')]
|
import argparse
import megengine.core.tensor.megbrain_graph as G
import megengine.utils.comp_graph_tools as cgtools
from megengine.core._imperative_rt import make_h2d
def change_batch_and_dump(inp_file, oup_file):
cg, _, outputs = G.load_graph(inp_file)
inputs = cgtools.get_dep_vars(outputs[0], "Host2DeviceCopy")
replace_dict = {}
for var in inputs:
n_shape = list(var.shape)
n_shape[0] = 1
new_input = make_h2d(cg, "xpux", var.dtype, n_shape, var.name)
replace_dict[var] = new_input
new_outputs = cgtools.replace_vars(outputs, replace_dict)
dump_content, _ = G.dump_graph(map(G.VarNode, new_outputs), keep_var_name=2)
with open(oup_file, "wb") as file:
file.write(dump_content)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-i", "--input", required=True, type=str, help="Input megengine dump model file"
)
parser.add_argument(
"-o", "--output", required=True, type=str, help="Output batch1 model file"
)
args = parser.parse_args()
change_batch_and_dump(args.input, args.output)
if __name__ == "__main__":
main()
|
[
"megengine.core._imperative_rt.make_h2d",
"megengine.utils.comp_graph_tools.replace_vars",
"megengine.utils.comp_graph_tools.get_dep_vars",
"megengine.core.tensor.megbrain_graph.load_graph"
] |
[((238, 260), 'megengine.core.tensor.megbrain_graph.load_graph', 'G.load_graph', (['inp_file'], {}), '(inp_file)\n', (250, 260), True, 'import megengine.core.tensor.megbrain_graph as G\n'), ((274, 325), 'megengine.utils.comp_graph_tools.get_dep_vars', 'cgtools.get_dep_vars', (['outputs[0]', '"""Host2DeviceCopy"""'], {}), "(outputs[0], 'Host2DeviceCopy')\n", (294, 325), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((556, 599), 'megengine.utils.comp_graph_tools.replace_vars', 'cgtools.replace_vars', (['outputs', 'replace_dict'], {}), '(outputs, replace_dict)\n', (576, 599), True, 'import megengine.utils.comp_graph_tools as cgtools\n'), ((780, 805), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (803, 805), False, 'import argparse\n'), ((448, 498), 'megengine.core._imperative_rt.make_h2d', 'make_h2d', (['cg', '"""xpux"""', 'var.dtype', 'n_shape', 'var.name'], {}), "(cg, 'xpux', var.dtype, n_shape, var.name)\n", (456, 498), False, 'from megengine.core._imperative_rt import make_h2d\n')]
|
import os
import math
import numpy as np
import six
import megengine._internal as mgb
from enum import Enum
from py_proto import mace_pb2
from transform import base_converter
from transform.base_converter import PoolingType
from transform.base_converter import ActivationType
from transform.base_converter import EltwiseType
from transform.base_converter import FrameworkType
from transform.base_converter import ReduceType
from transform.base_converter import DataFormat
from transform.base_converter import MaceOp
from transform.base_converter import MaceKeyword
from transform.base_converter import ConverterUtil
from transform.base_converter import RoundMode
from utils.util import mace_check
mge_kernel_h_str = "window_h"
mge_kernel_w_str = "window_w"
mge_stride_h_str = "stride_h"
mge_stride_w_str = "stride_w"
mge_pad_h_str = "pad_h"
mge_pad_w_str = "pad_w"
mge_dilate_h_str = "dilate_h"
mge_dilate_w_str = "dilate_w"
MGESupportedOps = [
"AxisAddRemove",
"BatchNormForward",
"Concat",
"ConvolutionForward",
"ConvolutionBackwardData",
"Dimshuffle",
"Elemwise",
"GetVarShape",
"Host2DeviceCopy",
"Identity",
"MarkNoBroadcastElemwise",
"MatrixMul",
"PoolingForward",
"Reduce",
"Reshape",
"SharedDeviceTensor",
"Subtensor",
]
MGEOpType = Enum("MGEOpType", [(op, op) for op in MGESupportedOps], type=str)
def get_symvar_value(mge_symvar):
if mge_symvar.inferred_value is not None:
val = mge_symvar.inferred_value
else:
cg = mge_symvar.owner_graph
func = cg.compile_outonly(mge_symvar)
val = func()
return val
def is_consumer_group_conv(mge_symvar, var2oprs, map_oprs):
consumer_ids = var2oprs[mge_symvar.id]
n_consumers = len(consumer_ids)
for consumer_id in consumer_ids:
consumer_op = map_oprs[consumer_id[0]]
if (mgb.cgtools.get_opr_type(consumer_op)
in ("ConvolutionForward", "ConvolutionBackwardData")
and consumer_op.params["sparse"] == "GROUP"):
mace_check(n_consumers == 1,
"This tensor should only feed depthwise conv/deconv")
return True
return False
class MegengineConverter(base_converter.ConverterInterface):
"""A class for convert megengine dumped model to mace model."""
compute_format_type = {
"NCHW": DataFormat.NCHW,
"NHWC": DataFormat.NHWC,
"DEFAULT": DataFormat.NCHW,
}
reduce_math_type = {
"SUM": ReduceType.SUM,
"PROD": ReduceType.PROD,
"MIN": ReduceType.MIN,
"MAX": ReduceType.MAX,
}
# SQE_DIFF, CLIP, SIGN maybe needed
eltwise_type = {
"ADD": EltwiseType.SUM,
"SUB": EltwiseType.SUB,
"MUL": EltwiseType.PROD,
"TRUE_DIV": EltwiseType.DIV,
"MIN": EltwiseType.MIN,
"MAX": EltwiseType.MAX,
"NEGATE": EltwiseType.NEG,
"ABS": EltwiseType.ABS,
"POW": EltwiseType.POW,
"EQ": EltwiseType.EQUAL,
"FLOOR_DIV": EltwiseType.FLOOR_DIV,
"EXP": EltwiseType.POW,
}
activation_type = {
"RELU": ActivationType.RELU,
"TANH": ActivationType.TANH,
"SIGMOID": ActivationType.SIGMOID,
}
def __init__(self, option, src_model_file):
self._op_converters = {
MGEOpType.AxisAddRemove.name: self.convert_axisaddrm,
MGEOpType.BatchNormForward.name: self.convert_batchnorm,
MGEOpType.Concat.name: self.convert_concat,
MGEOpType.ConvolutionForward.name: self.convert_conv2d,
MGEOpType.ConvolutionBackwardData.name: self.convert_deconv2d,
MGEOpType.Dimshuffle.name: self.convert_dimshuffle,
MGEOpType.Elemwise.name: self.convert_elemwise,
MGEOpType.GetVarShape.name: self.convert_shape,
MGEOpType.Host2DeviceCopy.name: self.convert_nop,
MGEOpType.Identity.name: self.convert_identity,
MGEOpType.MarkNoBroadcastElemwise.name: self.convert_identity,
MGEOpType.MatrixMul.name: self.convert_matmul,
MGEOpType.PoolingForward.name: self.convert_pooling,
MGEOpType.Reduce.name: self.convert_reduce,
MGEOpType.Reshape.name: self.convert_reshape,
MGEOpType.SharedDeviceTensor.name: self.convert_nop,
MGEOpType.Subtensor.name: self.convert_subtensor,
}
self._option = option
self._mace_net_def = mace_pb2.NetDef()
ConverterUtil.set_filter_format(self._mace_net_def, DataFormat.OIHW)
ConverterUtil.add_data_format_arg(self._mace_net_def, DataFormat.NCHW)
cg, _, outputs = mgb.load_comp_graph_from_file(src_model_file)
map_oprs, _, var2oprs, *_ = mgb.cgtools.graph_traversal(outputs)
# prune second input of reshape
# because it introduces several ops, may increase the overhead
operators = mgb.cgtools.get_oprs_seq(outputs, prune_reshape=True)
self._mge_cg = cg
self._mge_operators = operators
self._mge_map_oprs = map_oprs
self._mge_var2oprs = var2oprs
self._skip_tensors = set()
self._bn_statistis_tensors = {}
def run(self):
self.convert_ops()
self.replace_input_output_tensor_name()
return self._mace_net_def
# only change the input/output tensor name for whole model
def replace_input_output_tensor_name(self):
for op in self._mace_net_def.op:
for i in six.moves.range(len(op.input)):
if "," in op.input[i]:
op_name = op.input[i]
op_name = op_name.replace(",", "#")
if (op_name in self._option.input_nodes or
op_name in self._option.output_nodes):
op.input[i] = op_name
for i in six.moves.range(len(op.output)):
if "," in op.output[i]:
op_name = op.output[i]
op_name = op_name.replace(",", "#")
if op_name in self._option.output_nodes:
op.output[i] = op_name
# this method will be called by convert_conv2d/deconv2d and convert_pooling
@staticmethod
def add_stride_pad_kernel_arg(params, op_def):
stride = [params[mge_stride_h_str], params[mge_stride_w_str]]
pad = [params[mge_pad_h_str] * 2, params[mge_pad_w_str] * 2]
strides_arg = op_def.arg.add()
strides_arg.name = MaceKeyword.mace_strides_str
strides_arg.ints.extend(stride)
padding_arg = op_def.arg.add()
padding_arg.name = MaceKeyword.mace_padding_values_str
padding_arg.ints.extend(pad)
if op_def.type == MaceOp.Pooling.name:
kernel = [params[mge_kernel_h_str], params[mge_kernel_w_str]]
kernels_arg = op_def.arg.add()
kernels_arg.name = MaceKeyword.mace_kernel_str
kernels_arg.ints.extend(kernel)
if op_def.type in (MaceOp.Conv2D.name, MaceOp.DepthwiseConv2d.name,
MaceOp.Deconv2D.name,
MaceOp.DepthwiseDeconv2d.name):
dilation = [params[mge_dilate_h_str], params[mge_dilate_w_str]]
dilation_arg = op_def.arg.add()
dilation_arg.name = MaceKeyword.mace_dilations_str
dilation_arg.ints.extend(dilation)
def convert_ops(self):
for mge_op in self._mge_operators:
opr_type = mgb.cgtools.get_opr_type(mge_op)
# some reshape operators provide data for batchnorm
if opr_type == "Reshape":
output = mge_op.outputs[0]
next_ops = self._mge_var2oprs[output.id]
if len(next_ops) == 1:
(next_op_id, _) = next_ops[0]
next_op = self._mge_map_oprs[next_op_id]
if mgb.cgtools.get_opr_type(next_op) == "BatchNormForward":
self._skip_tensors.update(
[inp.name for inp in mge_op.inputs])
# using output name to address input symbol var
self._bn_statistis_tensors[mge_op.outputs[0].name] = \
mge_op.inputs[0]
# skip this reshape op
continue
self._op_converters[opr_type](mge_op)
self.convert_tensors()
def add_tensor(self, name, shape, data_type, value):
tensor = self._mace_net_def.tensors.add()
tensor.name = name
tensor.dims.extend(list(shape))
tensor.data_type = data_type
if data_type == mace_pb2.DT_INT32:
tensor.int32_data.extend(value)
else:
tensor.float_data.extend(value)
# convert all pre-calculated and constant tensors
def convert_tensors(self):
for mge_op in self._mge_operators:
type_opr = mgb.cgtools.get_opr_type(mge_op)
# all tensors generated by SharedDeviceTensor op
if type_opr == "SharedDeviceTensor":
output = mge_op.outputs[0]
if output.name not in self._skip_tensors:
nshape = output.imm_shape
# tensor used for depthwise conv/deconv should be reshaped
for_group_conv = is_consumer_group_conv(
output, self._mge_var2oprs, self._mge_map_oprs
)
if for_group_conv:
nshape = (
1,
output.imm_shape[0],
output.imm_shape[3],
output.imm_shape[4],
)
self.add_tensor(
output.name,
nshape,
mace_pb2.DT_FLOAT,
get_symvar_value(output).flatten())
else:
# handle all constant values
for const_tensor in mge_op.inputs:
if (const_tensor.inferred_value is not None
and const_tensor.name not in self._skip_tensors):
self.add_tensor(
const_tensor.name,
const_tensor.imm_shape,
mace_pb2.DT_INT32,
const_tensor.inferred_value.flatten())
def convert_nop(self, mge_op):
pass
def convert_general_op(self, mge_op):
op = self._mace_net_def.op.add()
op.name = mge_op.name
op.type = mgb.cgtools.get_opr_type(mge_op)
op.input.extend([mge_input.name for mge_input in mge_op.inputs])
op.output.extend([mge_output.name for mge_output in mge_op.outputs])
for mge_output in mge_op.outputs:
output_shape = op.output_shape.add()
output_shape.dims.extend(mge_output.imm_shape)
data_type_arg = op.arg.add()
data_type_arg.name = "T"
data_type_arg.i = self._option.data_type
framework_type_arg = op.arg.add()
framework_type_arg.name = MaceKeyword.mace_framework_type_str
framework_type_arg.i = FrameworkType.MEGENGINE.value
# check compute format of megengine
compute_format = DataFormat.NCHW
try:
if "format" in mge_op.params.keys():
compute_format = self.compute_format_type[
mge_op.params["format"]
]
except AttributeError:
compute_format = DataFormat.NCHW
ConverterUtil.add_data_format_arg(op, compute_format)
return op
def convert_identity(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Identity.name
def convert_conv2d(self, mge_op):
op = self.convert_general_op(mge_op)
if mge_op.params["sparse"] == "GROUP":
# weight shape in group conv2d:
# (groups, out_channel//groups, in_channels//groups, *kernel_size)
groups_divisible = mge_op.inputs[1].imm_shape[2]
mace_check(
groups_divisible == 1,
"Mace does not support group convolution yet",
)
op.type = MaceOp.DepthwiseConv2d.name
elif mge_op.params["sparse"] == "DENSE":
op.type = MaceOp.Conv2D.name
else:
raise Exception("Unknown sparse mode")
mace_check(
mge_op.params["mode"] != "CONVOLUTION",
"Mace does not support CONVOLUTION computation mode yet",
)
self.add_stride_pad_kernel_arg(mge_op.params, op)
del op.output[1:]
del op.output_shape[1:]
def convert_deconv2d(self, mge_op):
op = self.convert_general_op(mge_op)
if mge_op.params["sparse"] == "GROUP":
# weight shape in group conv2d:
# (groups, out_channel//groups, in_channels//groups, *kernel_size)
groups_divisible = mge_op.inputs[0].imm_shape[2]
mace_check(
groups_divisible == 1,
"Mace does not support group deconvolution yet",
)
op.type = MaceOp.DepthwiseConv2d.name
elif mge_op.params["sparse"] == "DENSE":
op.type = MaceOp.Deconv2D.name
else:
mace_check(False, "Unknown sparse mode")
mace_check(
mge_op.params["mode"] != "CONVOLUTION",
"Mace does not support CONVOLUTION computation mode yet",
)
self.add_stride_pad_kernel_arg(mge_op.params, op)
# inputs order is strange in megengine, fix it
swaped_list = [op.input[1], op.input[0]]
del op.input[:]
op.input.extend(swaped_list)
del op.output[1:]
del op.output_shape[1:]
def convert_dimshuffle(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Transpose.name
dims_arg = op.arg.add()
dims_arg.name = MaceKeyword.mace_dims_str
dims_arg.ints.extend(mge_op.params["pattern"])
def convert_math_elemwise(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Eltwise.name
type_arg = op.arg.add()
type_arg.name = MaceKeyword.mace_element_type_str
type_arg.i = self.eltwise_type[mge_op.params["mode"]].value
# EXP in megengine always use the np.e as base
if mge_op.params["mode"] == "EXP":
exp_tensor_name = mge_op.name + "_exp_base"
exp_shape = mge_op.outputs[0].imm_shape
exp_value = (np.e * np.ones(exp_shape)).flatten()
self.add_tensor(
exp_tensor_name, exp_shape, mace_pb2.DT_FLOAT, exp_value
)
del op.input[0]
op.input.extend([exp_tensor_name, mge_op.inputs[0].name])
def convert_activation(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Activation.name
type_arg = op.arg.add()
type_arg.name = MaceKeyword.mace_activation_type_str
type_arg.s = six.b(self.activation_type[mge_op.params["mode"]].name)
def convert_elemwise(self, mge_op):
mode = mge_op.params["mode"]
if mode in self.eltwise_type:
self.convert_math_elemwise(mge_op)
else:
self.convert_activation(mge_op)
def convert_pooling(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Pooling.name
pool_type_arg = op.arg.add()
pool_type_arg.name = MaceKeyword.mace_pooling_type_str
round_mode_arg = op.arg.add()
round_mode_arg.name = MaceKeyword.mace_round_mode_str
round_mode_arg.i = RoundMode.FLOOR.value
# check the case of counting include padding
mode = mge_op.params["mode"]
if mode == "AVERAGE_COUNT_EXCLUDE_PADDING" or \
(mode == "AVERAGE" and mge_op.params["pad_w"] == 0 and
mge_op.params["pad_h"] == 0):
pool_type_arg.i = PoolingType.AVG.value
elif mode == "MAX":
pool_type_arg.i = PoolingType.MAX.value
else:
mace_check(False,
"AVERAGE pooling should not count padding values")
self.add_stride_pad_kernel_arg(mge_op.params, op)
# delete workspace output, it's useless
del op.output[1:]
del op.output_shape[1:]
def convert_matmul(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.MatMul.name
transpose_a = mge_op.params["transposeA"]
transpose_a_arg = op.arg.add()
transpose_a_arg.name = MaceKeyword.mace_transpose_a_str
transpose_a_arg.i = int(transpose_a)
transpose_b = mge_op.params["transposeB"]
transpose_b_arg = op.arg.add()
transpose_b_arg.name = MaceKeyword.mace_transpose_b_str
transpose_b_arg.i = int(transpose_b)
del op.output[1:]
del op.output_shape[1:]
def convert_reshape(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Reshape.name
# just use the output shape
del op.input[1]
t_shape = list(mge_op.outputs[0].imm_shape)
shape_tensor_name = mge_op.name + "_dest_shape"
self.add_tensor(
shape_tensor_name, [len(t_shape)], mace_pb2.DT_INT32, t_shape
)
op.input.extend([shape_tensor_name])
# usually after reduce operator, remove dimension with value 1
# it's hard to just follow this operator
# sometimes axis-add and axis-remove may exist at the same time
# for complicated use-case, using reshape is easier
def convert_axisaddrm(self, mge_op):
op = self.convert_general_op(mge_op)
if mge_op.params["nr_desc"] == 1:
if mge_op.params["desc"][0]["method"] == 0:
op.type = MaceOp.ExpandDims.name
else:
op.type = MaceOp.Squeeze.name
axis_arg = op.arg.add()
axis_arg.name = MaceKeyword.mace_axis_str
axis_arg.i = mge_op.params["desc"][0]["axisnum"]
else:
op.type = MaceOp.Reshape.name
dest_shape_tensor_name = op.name + "_dest_shape"
dest_shape = mge_op.outputs[0].imm_shape
self.add_tensor(
dest_shape_tensor_name,
(len(dest_shape),),
mace_pb2.DT_INT32,
dest_shape,
)
op.input.extend([dest_shape_tensor_name])
def convert_reduce(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Reduce.name
reduce_type_arg = op.arg.add()
reduce_type_arg.name = MaceKeyword.mace_reduce_type_str
reduce_type_arg.i = self.reduce_math_type[mge_op.params["mode"]].value
# in megengine axis won't be list, just int
axis_arg = op.arg.add()
axis_arg.name = MaceKeyword.mace_axis_str
axis_arg.ints.append(mge_op.params["axis"])
# megengine will always keep dims in Reduce operator
# dim removal will be done by operator AxisAddRemove
keep_dims_arg = op.arg.add()
keep_dims_arg.name = MaceKeyword.mace_keepdims_str
keep_dims_arg.i = 1
del op.output[1:]
del op.output_shape[1:]
def convert_concat(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Concat.name
axis_arg = op.arg.add()
axis_arg.name = MaceKeyword.mace_axis_str
axis_arg.i = mge_op.params["axis"]
def convert_batchnorm(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.BatchNorm.name
gamma_value = get_symvar_value(
self._bn_statistis_tensors[mge_op.inputs[1].name]
).flatten()
beta_value = get_symvar_value(
self._bn_statistis_tensors[mge_op.inputs[2].name]
).flatten()
mean_value = get_symvar_value(mge_op.inputs[3]).flatten()
var_value = get_symvar_value(mge_op.inputs[4]).flatten()
epsilon_value = 1e-5
scale_name = mge_op.name + "_scale"
offset_name = mge_op.name + "_offset"
scale_value = (1.0 / np.vectorize(math.sqrt)(
var_value + epsilon_value)) * gamma_value
offset_value = (-mean_value * scale_value) + beta_value
self.add_tensor(
scale_name, scale_value.shape, mace_pb2.DT_FLOAT, scale_value
)
self.add_tensor(
offset_name, offset_value.shape, mace_pb2.DT_FLOAT, offset_value
)
self._skip_tensors.update([inp.name for inp in mge_op.inputs][1:])
del op.input[1:]
op.input.extend([scale_name, offset_name])
# outputs[4] is the correct output
del op.output[-1:]
del op.output_shape[-1:]
del op.output[:4]
del op.output_shape[:4]
def convert_shape(self, mge_op):
op = self.convert_general_op(mge_op)
op.type = MaceOp.Shape.name
op.output_type.extend([mace_pb2.DT_INT32])
# axis of subtensor should be constant
# subtensor in megengine: numpy-like indexing
def convert_subtensor(self, mge_op):
op1 = self.convert_general_op(mge_op)
op1.type = MaceOp.StridedSlice.name
axis = mge_op.inputs[1].inferred_value
t_shape = list(mge_op.inputs[0].imm_shape)
begin_tensor_name = mge_op.name + "_begin"
end_tensor_name = mge_op.name + "_end"
stride_tensor_name = mge_op.name + "_stride"
begin_tensor_shape = (len(t_shape),)
end_tensor_shape = (len(t_shape),)
stride_tensor_shape = (len(t_shape),)
begin_vals = [0] * len(t_shape)
end_vals = [shapei for shapei in t_shape]
stride_vals = [1] * len(t_shape)
def check_val(sym_var):
try:
val = sym_var.inferred_value[0]
except TypeError:
mace_check(
False, "you should feed const values for subtensor axis"
)
return val
squeeze_dims = []
idx = len(mge_op.inputs) - 1
while idx:
val = check_val(mge_op.inputs[idx])
for ai in mge_op.params[::-1]:
ai_idx = ai["axis"]
if ai["step"] > 0:
stride_vals[ai_idx] = val
idx -= 1
if idx == 0:
break
val = check_val(mge_op.inputs[idx])
if ai["end"] > 0:
if val < 0:
val = t_shape[ai_idx] + val
end_vals[ai_idx] = val
idx -= 1
if idx == 0:
break
val = check_val(mge_op.inputs[idx])
if ai["begin"] > 0:
if val < 0:
val = t_shape[ai_idx] + val
begin_vals[ai_idx] = val
idx -= 1
if idx == 0:
break
val = check_val(mge_op.inputs[idx])
if ai["idx"] > 0:
if val < 0:
val = t_shape[ai_idx] + val
squeeze_dims.append(ai_idx)
begin_vals[ai_idx] = val
end_vals[ai_idx] = val + 1
idx -= 1
if idx == 0:
break
val = check_val(mge_op.inputs[idx])
for ai_idx in range(len(t_shape)):
t_shape[ai_idx] = math.ceil(
(end_vals[ai_idx] - begin_vals[ai_idx]) / stride_vals[ai_idx]
)
self.add_tensor(
begin_tensor_name,
begin_tensor_shape,
mace_pb2.DT_INT32,
begin_vals,
)
self.add_tensor(
end_tensor_name, end_tensor_shape, mace_pb2.DT_INT32, end_vals
)
self.add_tensor(
stride_tensor_name,
stride_tensor_shape,
mace_pb2.DT_INT32,
stride_vals,
)
del op1.input[1:]
op1.input.extend(
[begin_tensor_name, end_tensor_name, stride_tensor_name]
)
if len(squeeze_dims) > 0:
# create squeeze op to remove shape=1 dims
mid_output_name = mge_op.name + "_mid_reshape"
del op1.output[0]
op1.output.extend([mid_output_name])
output_shape = op1.output_shape[0]
del output_shape.dims[:]
output_shape.dims.extend(t_shape)
op2 = self._mace_net_def.op.add()
op2.type = MaceOp.Squeeze.name
op2.name = mge_op.name + "_squeeze"
data_type_arg = op2.arg.add()
data_type_arg.name = "T"
data_type_arg.i = self._option.data_type
framework_type_arg = op2.arg.add()
framework_type_arg.name = MaceKeyword.mace_framework_type_str
framework_type_arg.i = FrameworkType.MEGENGINE.value
ConverterUtil.add_data_format_arg(op2, DataFormat.NCHW)
op2.input.extend([mid_output_name])
op2.output.extend([mge_op.outputs[0].name])
output_shape = op2.output_shape.add()
output_shape.dims.extend(mge_op.outputs[0].imm_shape)
axis_arg = op2.arg.add()
axis_arg.name = MaceKeyword.mace_axis_str
axis_arg.ints.extend(squeeze_dims)
|
[
"megengine._internal.cgtools.graph_traversal",
"megengine._internal.cgtools.get_opr_type",
"megengine._internal.cgtools.get_oprs_seq",
"megengine._internal.load_comp_graph_from_file"
] |
[((1313, 1378), 'enum.Enum', 'Enum', (['"""MGEOpType"""', '[(op, op) for op in MGESupportedOps]'], {'type': 'str'}), "('MGEOpType', [(op, op) for op in MGESupportedOps], type=str)\n", (1317, 1378), False, 'from enum import Enum\n'), ((4473, 4490), 'py_proto.mace_pb2.NetDef', 'mace_pb2.NetDef', ([], {}), '()\n', (4488, 4490), False, 'from py_proto import mace_pb2\n'), ((4499, 4567), 'transform.base_converter.ConverterUtil.set_filter_format', 'ConverterUtil.set_filter_format', (['self._mace_net_def', 'DataFormat.OIHW'], {}), '(self._mace_net_def, DataFormat.OIHW)\n', (4530, 4567), False, 'from transform.base_converter import ConverterUtil\n'), ((4576, 4646), 'transform.base_converter.ConverterUtil.add_data_format_arg', 'ConverterUtil.add_data_format_arg', (['self._mace_net_def', 'DataFormat.NCHW'], {}), '(self._mace_net_def, DataFormat.NCHW)\n', (4609, 4646), False, 'from transform.base_converter import ConverterUtil\n'), ((4673, 4718), 'megengine._internal.load_comp_graph_from_file', 'mgb.load_comp_graph_from_file', (['src_model_file'], {}), '(src_model_file)\n', (4702, 4718), True, 'import megengine._internal as mgb\n'), ((4755, 4791), 'megengine._internal.cgtools.graph_traversal', 'mgb.cgtools.graph_traversal', (['outputs'], {}), '(outputs)\n', (4782, 4791), True, 'import megengine._internal as mgb\n'), ((4923, 4976), 'megengine._internal.cgtools.get_oprs_seq', 'mgb.cgtools.get_oprs_seq', (['outputs'], {'prune_reshape': '(True)'}), '(outputs, prune_reshape=True)\n', (4947, 4976), True, 'import megengine._internal as mgb\n'), ((10640, 10672), 'megengine._internal.cgtools.get_opr_type', 'mgb.cgtools.get_opr_type', (['mge_op'], {}), '(mge_op)\n', (10664, 10672), True, 'import megengine._internal as mgb\n'), ((11620, 11673), 'transform.base_converter.ConverterUtil.add_data_format_arg', 'ConverterUtil.add_data_format_arg', (['op', 'compute_format'], {}), '(op, compute_format)\n', (11653, 11673), False, 'from transform.base_converter import ConverterUtil\n'), ((12488, 12600), 'utils.util.mace_check', 'mace_check', (["(mge_op.params['mode'] != 'CONVOLUTION')", '"""Mace does not support CONVOLUTION computation mode yet"""'], {}), "(mge_op.params['mode'] != 'CONVOLUTION',\n 'Mace does not support CONVOLUTION computation mode yet')\n", (12498, 12600), False, 'from utils.util import mace_check\n'), ((13428, 13540), 'utils.util.mace_check', 'mace_check', (["(mge_op.params['mode'] != 'CONVOLUTION')", '"""Mace does not support CONVOLUTION computation mode yet"""'], {}), "(mge_op.params['mode'] != 'CONVOLUTION',\n 'Mace does not support CONVOLUTION computation mode yet')\n", (13438, 13540), False, 'from utils.util import mace_check\n'), ((15136, 15191), 'six.b', 'six.b', (["self.activation_type[mge_op.params['mode']].name"], {}), "(self.activation_type[mge_op.params['mode']].name)\n", (15141, 15191), False, 'import six\n'), ((2048, 2134), 'utils.util.mace_check', 'mace_check', (['(n_consumers == 1)', '"""This tensor should only feed depthwise conv/deconv"""'], {}), "(n_consumers == 1,\n 'This tensor should only feed depthwise conv/deconv')\n", (2058, 2134), False, 'from utils.util import mace_check\n'), ((7486, 7518), 'megengine._internal.cgtools.get_opr_type', 'mgb.cgtools.get_opr_type', (['mge_op'], {}), '(mge_op)\n', (7510, 7518), True, 'import megengine._internal as mgb\n'), ((8937, 8969), 'megengine._internal.cgtools.get_opr_type', 'mgb.cgtools.get_opr_type', (['mge_op'], {}), '(mge_op)\n', (8961, 8969), True, 'import megengine._internal as mgb\n'), ((12146, 12231), 'utils.util.mace_check', 'mace_check', (['(groups_divisible == 1)', '"""Mace does not support group convolution yet"""'], {}), "(groups_divisible == 1, 'Mace does not support group convolution yet'\n )\n", (12156, 12231), False, 'from utils.util import mace_check\n'), ((13080, 13166), 'utils.util.mace_check', 'mace_check', (['(groups_divisible == 1)', '"""Mace does not support group deconvolution yet"""'], {}), "(groups_divisible == 1,\n 'Mace does not support group deconvolution yet')\n", (13090, 13166), False, 'from utils.util import mace_check\n'), ((23684, 23756), 'math.ceil', 'math.ceil', (['((end_vals[ai_idx] - begin_vals[ai_idx]) / stride_vals[ai_idx])'], {}), '((end_vals[ai_idx] - begin_vals[ai_idx]) / stride_vals[ai_idx])\n', (23693, 23756), False, 'import math\n'), ((25169, 25224), 'transform.base_converter.ConverterUtil.add_data_format_arg', 'ConverterUtil.add_data_format_arg', (['op2', 'DataFormat.NCHW'], {}), '(op2, DataFormat.NCHW)\n', (25202, 25224), False, 'from transform.base_converter import ConverterUtil\n'), ((1867, 1904), 'megengine._internal.cgtools.get_opr_type', 'mgb.cgtools.get_opr_type', (['consumer_op'], {}), '(consumer_op)\n', (1891, 1904), True, 'import megengine._internal as mgb\n'), ((13378, 13418), 'utils.util.mace_check', 'mace_check', (['(False)', '"""Unknown sparse mode"""'], {}), "(False, 'Unknown sparse mode')\n", (13388, 13418), False, 'from utils.util import mace_check\n'), ((16210, 16278), 'utils.util.mace_check', 'mace_check', (['(False)', '"""AVERAGE pooling should not count padding values"""'], {}), "(False, 'AVERAGE pooling should not count padding values')\n", (16220, 16278), False, 'from utils.util import mace_check\n'), ((20280, 20303), 'numpy.vectorize', 'np.vectorize', (['math.sqrt'], {}), '(math.sqrt)\n', (20292, 20303), True, 'import numpy as np\n'), ((22013, 22081), 'utils.util.mace_check', 'mace_check', (['(False)', '"""you should feed const values for subtensor axis"""'], {}), "(False, 'you should feed const values for subtensor axis')\n", (22023, 22081), False, 'from utils.util import mace_check\n'), ((7896, 7929), 'megengine._internal.cgtools.get_opr_type', 'mgb.cgtools.get_opr_type', (['next_op'], {}), '(next_op)\n', (7920, 7929), True, 'import megengine._internal as mgb\n'), ((14648, 14666), 'numpy.ones', 'np.ones', (['exp_shape'], {}), '(exp_shape)\n', (14655, 14666), True, 'import numpy as np\n')]
|
# Copyright (c) Megvii, Inc. and its affiliates.
import megengine as mge
import megengine.functional as F
import megengine.module as M
from .resnet import BasicBlock
class STN(M.Module):
"""spatial transformer networks from
`"Spatial Transformer Networks" <https://arxiv.org/pdf/1506.02025.pdf>`_
some detailed implements are highly simplified while good performance maintained
"""
def __init__(self, input_size=112):
assert input_size == 112, f"expected input_size == 112, got {input_size}"
super().__init__()
self.input_size = input_size
self.stem = M.Sequential(
M.Conv2d(3, 8, kernel_size=3, stride=2, padding=1, bias=False),
M.BatchNorm2d(8),
M.ReLU(),
M.MaxPool2d(kernel_size=2, stride=2),
BasicBlock(8, 16),
BasicBlock(16, 32, stride=2),
BasicBlock(32, 64, stride=2),
)
self.fc = M.Linear(64, 9)
def _get_transformed_image(self, image, mat3x3):
"""apply perspective transform to the image
note: there is NO need to guarantee the bottom right element equals 1
Args:
image (Tensor): input images (shape: n * 3 * 112 * 112)
mat3x3 (Tensor): perspective matrix (shape: n * 3 * 3)
Returns:
transformed_image (Tensor): perspectively transformed image
"""
s = self.input_size
transformed_image = F.warp_perspective(image, mat3x3, [s, s])
return transformed_image
def _get_mat3x3(self, image):
"""get perspective matrix used in the transformation
note: there are only 8 degrees of freedom in a perspective matrix, while the output matrix has 9 variables.
Args:
image (Tensor): input images (shape: n * 3 * 112 * 112)
Returns:
mat3x3 (Tensor): perspective matrix (shape: n * 3 * 3)
"""
x = self.stem(image)
x = F.avg_pool2d(x, 7)
x = F.flatten(x, 1)
x = self.fc(x)
s = self.input_size
# 0.01 here is a magic number. it aims to maintain identity transform at early stage of training
residual = x.reshape(-1, 3, 3) * 0.01
base = mge.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1]]).astype("float32")
base = F.broadcast_to(base, residual.shape)
left_scale = mge.tensor([[s, 0, 0], [0, s, 0], [0, 0, 1]]).astype("float32")
left_scale = F.broadcast_to(left_scale, residual.shape)
right_scale = mge.tensor([[1 / s, 0, 0], [0, 1 / s, 0], [0, 0, 1]]).astype("float32")
right_scale = F.broadcast_to(right_scale, residual.shape)
mat3x3 = F.matmul(left_scale, F.matmul(base + residual, right_scale))
return mat3x3
def forward(self, image):
mat3x3 = self._get_mat3x3(image)
transformed_image = self._get_transformed_image(image, mat3x3)
return transformed_image
|
[
"megengine.functional.broadcast_to",
"megengine.functional.flatten",
"megengine.module.ReLU",
"megengine.tensor",
"megengine.module.MaxPool2d",
"megengine.functional.matmul",
"megengine.module.Conv2d",
"megengine.functional.warp_perspective",
"megengine.module.Linear",
"megengine.module.BatchNorm2d",
"megengine.functional.avg_pool2d"
] |
[((944, 959), 'megengine.module.Linear', 'M.Linear', (['(64)', '(9)'], {}), '(64, 9)\n', (952, 959), True, 'import megengine.module as M\n'), ((1452, 1493), 'megengine.functional.warp_perspective', 'F.warp_perspective', (['image', 'mat3x3', '[s, s]'], {}), '(image, mat3x3, [s, s])\n', (1470, 1493), True, 'import megengine.functional as F\n'), ((1960, 1978), 'megengine.functional.avg_pool2d', 'F.avg_pool2d', (['x', '(7)'], {}), '(x, 7)\n', (1972, 1978), True, 'import megengine.functional as F\n'), ((1991, 2006), 'megengine.functional.flatten', 'F.flatten', (['x', '(1)'], {}), '(x, 1)\n', (2000, 2006), True, 'import megengine.functional as F\n'), ((2304, 2340), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['base', 'residual.shape'], {}), '(base, residual.shape)\n', (2318, 2340), True, 'import megengine.functional as F\n'), ((2447, 2489), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['left_scale', 'residual.shape'], {}), '(left_scale, residual.shape)\n', (2461, 2489), True, 'import megengine.functional as F\n'), ((2606, 2649), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['right_scale', 'residual.shape'], {}), '(right_scale, residual.shape)\n', (2620, 2649), True, 'import megengine.functional as F\n'), ((635, 697), 'megengine.module.Conv2d', 'M.Conv2d', (['(3)', '(8)'], {'kernel_size': '(3)', 'stride': '(2)', 'padding': '(1)', 'bias': '(False)'}), '(3, 8, kernel_size=3, stride=2, padding=1, bias=False)\n', (643, 697), True, 'import megengine.module as M\n'), ((711, 727), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(8)'], {}), '(8)\n', (724, 727), True, 'import megengine.module as M\n'), ((741, 749), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (747, 749), True, 'import megengine.module as M\n'), ((763, 799), 'megengine.module.MaxPool2d', 'M.MaxPool2d', ([], {'kernel_size': '(2)', 'stride': '(2)'}), '(kernel_size=2, stride=2)\n', (774, 799), True, 'import megengine.module as M\n'), ((2688, 2726), 'megengine.functional.matmul', 'F.matmul', (['(base + residual)', 'right_scale'], {}), '(base + residual, right_scale)\n', (2696, 2726), True, 'import megengine.functional as F\n'), ((2225, 2270), 'megengine.tensor', 'mge.tensor', (['[[1, 0, 0], [0, 1, 0], [0, 0, 1]]'], {}), '([[1, 0, 0], [0, 1, 0], [0, 0, 1]])\n', (2235, 2270), True, 'import megengine as mge\n'), ((2362, 2407), 'megengine.tensor', 'mge.tensor', (['[[s, 0, 0], [0, s, 0], [0, 0, 1]]'], {}), '([[s, 0, 0], [0, s, 0], [0, 0, 1]])\n', (2372, 2407), True, 'import megengine as mge\n'), ((2512, 2565), 'megengine.tensor', 'mge.tensor', (['[[1 / s, 0, 0], [0, 1 / s, 0], [0, 0, 1]]'], {}), '([[1 / s, 0, 0], [0, 1 / s, 0], [0, 0, 1]])\n', (2522, 2565), True, 'import megengine as mge\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
from megengine.core import tensor
def test_mge_81():
np.random.seed(0)
N, D = 3, 4
x = mge.Parameter(value=np.random.normal(size=(N, D)).astype(np.float32))
y = mge.Parameter(value=np.random.normal(size=(N, D)).astype(np.float32))
z = mge.Parameter(value=np.random.normal(size=(N, D)).astype(np.float32))
a = x * y
b = a + z
c = F.sum(b)
grad_x = F.grad(c, x, use_virtual_grad=False)
grad_y = F.grad(c, y, use_virtual_grad=False)
grad_z = F.grad(c, z, use_virtual_grad=False)
print(grad_x.numpy())
print(grad_y.numpy())
print(grad_z.numpy())
m = M.BatchNorm2d(4)
input = tensor(np.zeros((64, 4, 32, 32), dtype=np.float32))
_ = m(input)
m = M.BatchNorm2d(4, affine=False)
_ = m(input)
|
[
"megengine.functional.sum",
"megengine.functional.grad",
"megengine.module.BatchNorm2d"
] |
[((542, 559), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (556, 559), True, 'import numpy as np\n'), ((846, 854), 'megengine.functional.sum', 'F.sum', (['b'], {}), '(b)\n', (851, 854), True, 'import megengine.functional as F\n'), ((868, 904), 'megengine.functional.grad', 'F.grad', (['c', 'x'], {'use_virtual_grad': '(False)'}), '(c, x, use_virtual_grad=False)\n', (874, 904), True, 'import megengine.functional as F\n'), ((918, 954), 'megengine.functional.grad', 'F.grad', (['c', 'y'], {'use_virtual_grad': '(False)'}), '(c, y, use_virtual_grad=False)\n', (924, 954), True, 'import megengine.functional as F\n'), ((968, 1004), 'megengine.functional.grad', 'F.grad', (['c', 'z'], {'use_virtual_grad': '(False)'}), '(c, z, use_virtual_grad=False)\n', (974, 1004), True, 'import megengine.functional as F\n'), ((1091, 1107), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(4)'], {}), '(4)\n', (1104, 1107), True, 'import megengine.module as M\n'), ((1197, 1227), 'megengine.module.BatchNorm2d', 'M.BatchNorm2d', (['(4)'], {'affine': '(False)'}), '(4, affine=False)\n', (1210, 1227), True, 'import megengine.module as M\n'), ((1127, 1170), 'numpy.zeros', 'np.zeros', (['(64, 4, 32, 32)'], {'dtype': 'np.float32'}), '((64, 4, 32, 32), dtype=np.float32)\n', (1135, 1170), True, 'import numpy as np\n'), ((604, 633), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(N, D)'}), '(size=(N, D))\n', (620, 633), True, 'import numpy as np\n'), ((682, 711), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(N, D)'}), '(size=(N, D))\n', (698, 711), True, 'import numpy as np\n'), ((760, 789), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(N, D)'}), '(size=(N, D))\n', (776, 789), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MIT License
#
# Copyright (c) 2020 <NAME>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# This repo is licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import math
import collections
import megengine.module as nn
import megengine.functional as F
from model.nn_upsample import NeuralUpsampler, FlowMaskEstimator
from common.utils import flow_warp, upsample2d_flow_as
def conv(inp, out, k=3, s=1, d=1, isReLU=True):
if isReLU:
ret = nn.Sequential(nn.Conv2d(inp, out, k, s, padding=((k - 1) * d) // 2, dilation=d, bias=True), nn.LeakyReLU(0.1))
else:
ret = nn.Sequential(nn.Conv2d(inp, out, k, s, padding=((k - 1) * d) // 2, dilation=d, bias=True))
return ret
class ContextNetwork(nn.Module):
def __init__(self, ch_in):
super(ContextNetwork, self).__init__()
self.convs = nn.Sequential(conv(ch_in, 128, 3, 1, 1), conv(128, 128, 3, 1, 2), conv(128, 128, 3, 1, 4), conv(128, 96, 3, 1, 8),
conv(96, 64, 3, 1, 16), conv(64, 32, 3, 1, 1), conv(32, 2, isReLU=False))
def forward(self, x):
return self.convs(x)
class FlowEstimator(nn.Module):
def __init__(self, ch_in):
super(FlowEstimator, self).__init__()
self.conv1 = conv(ch_in, 128)
self.conv2 = conv(128, 128)
self.conv3 = conv(128 + 128, 96)
self.conv4 = conv(96 + 128, 64)
self.conv5 = conv(96 + 64, 32)
# channels of the second last layer
self.feat_dim = 32
self.predict_flow = conv(64 + 32, 2, isReLU=False)
def forward(self, x):
x1 = self.conv1(x)
x2 = self.conv2(x1)
x3 = self.conv3(F.concat([x1, x2], axis=1))
x4 = self.conv4(F.concat([x2, x3], axis=1))
x5 = self.conv5(F.concat([x3, x4], axis=1))
flow = self.predict_flow(F.concat([x4, x5], axis=1))
return x5, flow
class CostVolume(nn.Module):
def __init__(self, d=4, *args, **kwargs):
super(CostVolume, self).__init__()
self.d = d
self.out_dim = 2 * self.d + 1
self.pad_size = self.d
def forward(self, x1, x2):
_, _, H, W = x1.shape
x2 = F.nn.pad(x2, ((0, 0), (0, 0), (self.pad_size, self.pad_size), (self.pad_size, self.pad_size)))
cv = []
for i in range(self.out_dim):
for j in range(self.out_dim):
cost = x1 * x2[:, :, i:(i + H), j:(j + W)]
cost = F.mean(cost, 1, keepdims=True)
cv.append(cost)
return F.concat(cv, 1)
class FeaturePyramidExtractor(nn.Module):
def __init__(self, pyr_chans):
super(FeaturePyramidExtractor, self).__init__()
self.pyr_chans = pyr_chans
self.convs = []
for _, (ch_in, ch_out) in enumerate(zip(pyr_chans[:-1], pyr_chans[1:])):
layer = nn.Sequential(conv(ch_in, ch_out, s=2), conv(ch_out, ch_out))
self.convs.append(layer)
def forward(self, x):
feature_pyramid = []
for conv in self.convs:
x = conv(x)
feature_pyramid.append(x)
return feature_pyramid[::-1]
class GyroFlow(nn.Module):
def __init__(self, params):
super(GyroFlow, self).__init__()
self.leakyRELU = nn.LeakyReLU(0.1)
self.upsample = params.upsample
self.with_bk = True
self.pyr_chans = [3, 16, 32, 64, 96, 128, 192]
self.feature_pyramid_extractor = FeaturePyramidExtractor(self.pyr_chans)
# correlation range
self.d = 4
self.output_level = 4
# cost volume
self.cost_volume = CostVolume(d=self.d)
self.cv_dim = (self.d * 2 + 1)**2
self.upsampler = NeuralUpsampler()
self.ch_inp = 32 + self.cv_dim + 2
self.flow_estimator = FlowEstimator(self.ch_inp)
self.context_net = ContextNetwork(self.flow_estimator.feat_dim + 2)
self.conv_1x1 = list([
conv(192, 32, k=1, s=1, d=1),
conv(128, 32, k=1, s=1, d=1),
conv(96, 32, k=1, s=1, d=1),
conv(64, 32, k=1, s=1, d=1),
conv(32, 32, k=1, s=1, d=1)
])
self.with_gyro_field = True
self.flow_predictor = FlowMaskEstimator(4, (8, 16, 32, 16, 8), 2)
self.mask_predictor = FlowMaskEstimator(64, (32, 32, 32, 16, 8), 1)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.msra_normal_(m.weight, a=math.sqrt(5))
if m.bias is not None:
fan_in, _ = nn.init.calculate_fan_in_and_fan_out(m.weight)
bound = 1 / math.sqrt(fan_in)
nn.init.uniform_(m.bias, -bound, bound)
def generate_fused_flow(self, x1, x2):
input_feature = F.concat((x1, x2), axis=1)
flow = self.flow_predictor(input_feature)[1]
assert flow.shape[1] == 2
return flow
def generate_map(self, x1, x2):
input_feature = F.concat((x1, x2), axis=1)
out = self.mask_predictor(input_feature)[1]
mask = F.sigmoid(out)
assert mask.shape[1] == 1
return mask
def self_guided_fusion_module(self, flow, gyro_field_rsz, x1, x2_warp, layer):
fuse_flow = self.generate_fused_flow(flow, gyro_field_rsz)
mask = self.generate_map(self.conv_1x1[layer](x1), self.conv_1x1[layer](x2_warp))
flow = fuse_flow * mask + gyro_field_rsz * (1 - mask)
return flow
def normalize_features(self, feature_list, normalize, center, moments_across_channels=True, moments_across_images=True):
# Compute feature statistics.
statistics = collections.defaultdict(list)
axes = [1, 2, 3] if moments_across_channels else [2, 3] # [b, c, h, w]
for feature_image in feature_list:
mean = F.mean(feature_image, axis=axes, keepdims=True) # [b,1,1,1] or [b,c,1,1]
variance = F.var(feature_image, axis=axes, keepdims=True) # [b,1,1,1] or [b,c,1,1]
statistics['mean'].append(mean)
statistics['var'].append(variance)
if moments_across_images:
statistics['mean'] = ([F.mean(F.stack(statistics['mean'], axis=0), axis=(0, ))] * len(feature_list))
statistics['var'] = ([F.var(F.stack(statistics['var'], axis=0), axis=(0, ))] * len(feature_list))
statistics['std'] = [F.sqrt(v + 1e-16) for v in statistics['var']]
# Center and normalize features.
if center:
feature_list = [f - mean for f, mean in zip(feature_list, statistics['mean'])]
if normalize:
feature_list = [f / std for f, std in zip(feature_list, statistics['std'])]
return feature_list
def predict_flow(self, x1_pyrs, x2_pyrs, gyro_field=None):
flow_pyrs = []
batch_size, _, h_x1, w_x1 = x1_pyrs[0].shape
dtype = x1_pyrs[0].dtype
flow = F.zeros((batch_size, 2, h_x1, w_x1), dtype=dtype)
for layer, (x1, x2) in enumerate(zip(x1_pyrs, x2_pyrs)):
if layer == 0:
x2_warp = x2
else:
flow = self.upsampler(flow, self.conv_1x1[layer](x1), self.conv_1x1[layer](x2))
gyro_field_rsz = upsample2d_flow_as(gyro_field, flow, if_rate=True)
x2_warp = flow_warp(x2, gyro_field_rsz)
flow = self.self_guided_fusion_module(flow, gyro_field_rsz, x1, x2_warp, layer)
x2_warp = flow_warp(x2, flow)
# cost volume normalized
x1_normalized, x2_warp_normalized = self.normalize_features([x1, x2_warp],
normalize=True,
center=True,
moments_across_channels=False,
moments_across_images=False)
_cv = self.cost_volume(x1_normalized, x2_warp_normalized)
_cv_relu = self.leakyRELU(_cv)
x1 = self.conv_1x1[layer](x1)
_x_feat, flow_pred = self.flow_estimator(F.concat([_cv_relu, x1, flow], axis=1))
flow += flow_pred
flow_refine = self.context_net(F.concat([_x_feat, flow], axis=1))
flow += flow_refine
flow_pyrs.append(flow)
if layer == self.output_level:
break
if self.upsample:
flows = [F.vision.interpolate(flow * 4, scale_factor=4, mode='bilinear', align_corners=True) for flow in flow_pyrs]
return flows[::-1]
def forward(self, data_batch, with_bk=True):
x = data_batch['imgs']
imgs = [x[:, 3 * i:3 * i + 3] for i in range(2)]
x = [self.feature_pyramid_extractor(img) + [img] for img in imgs]
gyro_field = data_batch["gyro_field"]
res = {}
res['flow_fw'] = self.predict_flow(x[0], x[1], gyro_field)
if with_bk:
res['flow_bw'] = self.predict_flow(x[1], x[0], -1 * gyro_field)
return res
class GyroFlowTestFlops(GyroFlow):
def forward(self, data_batch, with_bk=True):
x = data_batch
imgs = [x[:, 3 * i:3 * i + 3] for i in range(2)]
x = [self.feature_pyramid_extractor(img) + [img] for img in imgs]
gyro_field = F.ones_like(data_batch)[:, :2, ...]
res_fw = self.predict_flow(x[0], x[1], gyro_field)
if with_bk:
res_bw = self.predict_flow(x[1], x[0], -1 * gyro_field)
return res_fw, res_bw
def fetch_net(params):
if params.net_type == "gyroflow":
net = GyroFlow(params)
else:
raise NotImplementedError
return net
|
[
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.functional.vision.interpolate",
"megengine.functional.sigmoid",
"megengine.module.Conv2d",
"megengine.functional.nn.pad",
"megengine.functional.var",
"megengine.functional.stack",
"megengine.functional.ones_like",
"megengine.functional.concat",
"megengine.functional.mean",
"megengine.module.init.uniform_",
"megengine.functional.zeros",
"megengine.functional.sqrt",
"megengine.module.LeakyReLU"
] |
[((3076, 3175), 'megengine.functional.nn.pad', 'F.nn.pad', (['x2', '((0, 0), (0, 0), (self.pad_size, self.pad_size), (self.pad_size, self.pad_size)\n )'], {}), '(x2, ((0, 0), (0, 0), (self.pad_size, self.pad_size), (self.\n pad_size, self.pad_size)))\n', (3084, 3175), True, 'import megengine.functional as F\n'), ((3427, 3442), 'megengine.functional.concat', 'F.concat', (['cv', '(1)'], {}), '(cv, 1)\n', (3435, 3442), True, 'import megengine.functional as F\n'), ((4151, 4168), 'megengine.module.LeakyReLU', 'nn.LeakyReLU', (['(0.1)'], {}), '(0.1)\n', (4163, 4168), True, 'import megengine.module as nn\n'), ((4589, 4606), 'model.nn_upsample.NeuralUpsampler', 'NeuralUpsampler', ([], {}), '()\n', (4604, 4606), False, 'from model.nn_upsample import NeuralUpsampler, FlowMaskEstimator\n'), ((5100, 5143), 'model.nn_upsample.FlowMaskEstimator', 'FlowMaskEstimator', (['(4)', '(8, 16, 32, 16, 8)', '(2)'], {}), '(4, (8, 16, 32, 16, 8), 2)\n', (5117, 5143), False, 'from model.nn_upsample import NeuralUpsampler, FlowMaskEstimator\n'), ((5174, 5219), 'model.nn_upsample.FlowMaskEstimator', 'FlowMaskEstimator', (['(64)', '(32, 32, 32, 16, 8)', '(1)'], {}), '(64, (32, 32, 32, 16, 8), 1)\n', (5191, 5219), False, 'from model.nn_upsample import NeuralUpsampler, FlowMaskEstimator\n'), ((5654, 5680), 'megengine.functional.concat', 'F.concat', (['(x1, x2)'], {'axis': '(1)'}), '((x1, x2), axis=1)\n', (5662, 5680), True, 'import megengine.functional as F\n'), ((5849, 5875), 'megengine.functional.concat', 'F.concat', (['(x1, x2)'], {'axis': '(1)'}), '((x1, x2), axis=1)\n', (5857, 5875), True, 'import megengine.functional as F\n'), ((5943, 5957), 'megengine.functional.sigmoid', 'F.sigmoid', (['out'], {}), '(out)\n', (5952, 5957), True, 'import megengine.functional as F\n'), ((6520, 6549), 'collections.defaultdict', 'collections.defaultdict', (['list'], {}), '(list)\n', (6543, 6549), False, 'import collections\n'), ((7767, 7816), 'megengine.functional.zeros', 'F.zeros', (['(batch_size, 2, h_x1, w_x1)'], {'dtype': 'dtype'}), '((batch_size, 2, h_x1, w_x1), dtype=dtype)\n', (7774, 7816), True, 'import megengine.functional as F\n'), ((1392, 1466), 'megengine.module.Conv2d', 'nn.Conv2d', (['inp', 'out', 'k', 's'], {'padding': '((k - 1) * d // 2)', 'dilation': 'd', 'bias': '(True)'}), '(inp, out, k, s, padding=(k - 1) * d // 2, dilation=d, bias=True)\n', (1401, 1466), True, 'import megengine.module as nn\n'), ((1470, 1487), 'megengine.module.LeakyReLU', 'nn.LeakyReLU', (['(0.1)'], {}), '(0.1)\n', (1482, 1487), True, 'import megengine.module as nn\n'), ((1527, 1601), 'megengine.module.Conv2d', 'nn.Conv2d', (['inp', 'out', 'k', 's'], {'padding': '((k - 1) * d // 2)', 'dilation': 'd', 'bias': '(True)'}), '(inp, out, k, s, padding=(k - 1) * d // 2, dilation=d, bias=True)\n', (1536, 1601), True, 'import megengine.module as nn\n'), ((2575, 2601), 'megengine.functional.concat', 'F.concat', (['[x1, x2]'], {'axis': '(1)'}), '([x1, x2], axis=1)\n', (2583, 2601), True, 'import megengine.functional as F\n'), ((2627, 2653), 'megengine.functional.concat', 'F.concat', (['[x2, x3]'], {'axis': '(1)'}), '([x2, x3], axis=1)\n', (2635, 2653), True, 'import megengine.functional as F\n'), ((2679, 2705), 'megengine.functional.concat', 'F.concat', (['[x3, x4]'], {'axis': '(1)'}), '([x3, x4], axis=1)\n', (2687, 2705), True, 'import megengine.functional as F\n'), ((2740, 2766), 'megengine.functional.concat', 'F.concat', (['[x4, x5]'], {'axis': '(1)'}), '([x4, x5], axis=1)\n', (2748, 2766), True, 'import megengine.functional as F\n'), ((6692, 6739), 'megengine.functional.mean', 'F.mean', (['feature_image'], {'axis': 'axes', 'keepdims': '(True)'}), '(feature_image, axis=axes, keepdims=True)\n', (6698, 6739), True, 'import megengine.functional as F\n'), ((6789, 6835), 'megengine.functional.var', 'F.var', (['feature_image'], {'axis': 'axes', 'keepdims': '(True)'}), '(feature_image, axis=axes, keepdims=True)\n', (6794, 6835), True, 'import megengine.functional as F\n'), ((7241, 7258), 'megengine.functional.sqrt', 'F.sqrt', (['(v + 1e-16)'], {}), '(v + 1e-16)\n', (7247, 7258), True, 'import megengine.functional as F\n'), ((10234, 10257), 'megengine.functional.ones_like', 'F.ones_like', (['data_batch'], {}), '(data_batch)\n', (10245, 10257), True, 'import megengine.functional as F\n'), ((3349, 3379), 'megengine.functional.mean', 'F.mean', (['cost', '(1)'], {'keepdims': '(True)'}), '(cost, 1, keepdims=True)\n', (3355, 3379), True, 'import megengine.functional as F\n'), ((8087, 8137), 'common.utils.upsample2d_flow_as', 'upsample2d_flow_as', (['gyro_field', 'flow'], {'if_rate': '(True)'}), '(gyro_field, flow, if_rate=True)\n', (8105, 8137), False, 'from common.utils import flow_warp, upsample2d_flow_as\n'), ((8164, 8193), 'common.utils.flow_warp', 'flow_warp', (['x2', 'gyro_field_rsz'], {}), '(x2, gyro_field_rsz)\n', (8173, 8193), False, 'from common.utils import flow_warp, upsample2d_flow_as\n'), ((8318, 8337), 'common.utils.flow_warp', 'flow_warp', (['x2', 'flow'], {}), '(x2, flow)\n', (8327, 8337), False, 'from common.utils import flow_warp, upsample2d_flow_as\n'), ((9050, 9088), 'megengine.functional.concat', 'F.concat', (['[_cv_relu, x1, flow]'], {'axis': '(1)'}), '([_cv_relu, x1, flow], axis=1)\n', (9058, 9088), True, 'import megengine.functional as F\n'), ((9164, 9197), 'megengine.functional.concat', 'F.concat', (['[_x_feat, flow]'], {'axis': '(1)'}), '([_x_feat, flow], axis=1)\n', (9172, 9197), True, 'import megengine.functional as F\n'), ((9379, 9466), 'megengine.functional.vision.interpolate', 'F.vision.interpolate', (['(flow * 4)'], {'scale_factor': '(4)', 'mode': '"""bilinear"""', 'align_corners': '(True)'}), "(flow * 4, scale_factor=4, mode='bilinear',\n align_corners=True)\n", (9399, 9466), True, 'import megengine.functional as F\n'), ((5429, 5475), 'megengine.module.init.calculate_fan_in_and_fan_out', 'nn.init.calculate_fan_in_and_fan_out', (['m.weight'], {}), '(m.weight)\n', (5465, 5475), True, 'import megengine.module as nn\n'), ((5546, 5585), 'megengine.module.init.uniform_', 'nn.init.uniform_', (['m.bias', '(-bound)', 'bound'], {}), '(m.bias, -bound, bound)\n', (5562, 5585), True, 'import megengine.module as nn\n'), ((5344, 5356), 'math.sqrt', 'math.sqrt', (['(5)'], {}), '(5)\n', (5353, 5356), False, 'import math\n'), ((5508, 5525), 'math.sqrt', 'math.sqrt', (['fan_in'], {}), '(fan_in)\n', (5517, 5525), False, 'import math\n'), ((7030, 7065), 'megengine.functional.stack', 'F.stack', (["statistics['mean']"], {'axis': '(0)'}), "(statistics['mean'], axis=0)\n", (7037, 7065), True, 'import megengine.functional as F\n'), ((7141, 7175), 'megengine.functional.stack', 'F.stack', (["statistics['var']"], {'axis': '(0)'}), "(statistics['var'], axis=0)\n", (7148, 7175), True, 'import megengine.functional as F\n')]
|
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import argparse
import importlib
import os
import sys
import megengine as mge
import megengine.distributed as dist
from basecore.config import ConfigDict
from loguru import logger
from basecls.models import build_model, load_model, sync_model
from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger
def default_parser() -> argparse.ArgumentParser:
"""Build args parser for training script.
Returns:
The args parser.
"""
parser = argparse.ArgumentParser()
parser.add_argument("-f", "--file", type=str, help="training process description file")
parser.add_argument(
"--resume", action="store_true", help="resume training from saved checkpoint or not"
)
parser.add_argument(
"opts",
default=None,
help="Modify config options using the command-line",
nargs=argparse.REMAINDER,
)
return parser
@logger.catch
def worker(args: argparse.Namespace):
"""Worker function for training script.
Args:
args: args for training script.
"""
logger.info(f"Init process group for gpu{dist.get_rank()} done")
sys.path.append(os.path.dirname(args.file))
module_name = os.path.splitext(os.path.basename(args.file))[0]
current_network = importlib.import_module(module_name)
cfg = current_network.Cfg()
cfg.merge(args.opts)
cfg.resume = args.resume
if cfg.output_dir is None:
cfg.output_dir = f"./logs_{module_name}"
cfg.output_dir = os.path.abspath(cfg.output_dir)
cfg.set_mode("freeze")
if dist.get_rank() == 0 and not os.path.exists(cfg.output_dir):
os.makedirs(cfg.output_dir)
dist.group_barrier()
# FIXME: will hang in fork mode, however spawn mode meets other issues
# try:
# from clearml import Task
# if dist.get_rank() == 0:
# Task.current_task().connect_configuration(cfg)
# except Exception as e:
# logger.warning(e)
setup_logger(cfg.output_dir, "train_log.txt", to_loguru=True)
logger.info(f"args: {args}")
if cfg.fastrun:
logger.info("Using fastrun mode...")
mge.functional.debug_param.set_execution_strategy("PROFILE")
if cfg.dtr:
logger.info("Enabling DTR...")
mge.dtr.enable()
trainer = build(cfg)
trainer.train()
def build(cfg: ConfigDict):
"""Build function for training script.
Args:
cfg: config for training.
Returns:
A trainer.
"""
model = build_model(cfg)
if getattr(cfg, "weights", None) is not None:
load_model(model, cfg.weights, strict=False)
sync_model(model)
model.train()
logger.info(f"Using augments named {cfg.augments.name}")
augments = registers.augments.get(cfg.augments.name).build(cfg)
logger.info(f"Using dataloader named {cfg.data.name}")
dataloader = registers.dataloaders.get(cfg.data.name).build(cfg, True, augments)
logger.info(f"Using solver named {cfg.solver.name}")
solver = registers.solvers.get(cfg.solver.name).build(cfg, model)
logger.info(f"Using hooks named {cfg.hooks_name}")
hooks = registers.hooks.get(cfg.hooks_name).build(cfg)
logger.info(f"Using trainer named {cfg.trainer_name}")
TrainerClass = registers.trainers.get(cfg.trainer_name)
return TrainerClass(cfg, model, dataloader, solver, hooks=hooks)
def main():
"""Main function for training script."""
parser = default_parser()
args = parser.parse_args()
set_nccl_env()
set_num_threads()
# FIXME: will hang in fork mode, however spawn mode meets other issues
# try:
# import getpass
# from clearml import Task
# task_name = f"{getpass.getuser()}-{os.path.splitext(os.path.basename(args.file))[0]}"
# task = Task.init(project_name="basecls", task_name=task_name) # noqa: F841
# except Exception as e:
# logger.warning(e)
device_count = mge.device.get_device_count("gpu")
launcher = dist.launcher
if not os.path.exists(args.file):
raise ValueError("Description file does not exist")
if device_count == 0:
raise ValueError("Number of devices should be greater than 0")
elif device_count > 1 or os.environ.get("RLAUNCH_REPLICA_TOTAL", 0) > 1:
mp_worker = launcher(worker)
mp_worker(args)
else:
worker(args)
if __name__ == "__main__":
main()
|
[
"megengine.functional.debug_param.set_execution_strategy",
"megengine.device.get_device_count",
"megengine.distributed.group_barrier",
"megengine.dtr.enable",
"megengine.distributed.get_rank"
] |
[((565, 590), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (588, 590), False, 'import argparse\n'), ((1353, 1389), 'importlib.import_module', 'importlib.import_module', (['module_name'], {}), '(module_name)\n', (1376, 1389), False, 'import importlib\n'), ((1577, 1608), 'os.path.abspath', 'os.path.abspath', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (1592, 1608), False, 'import os\n'), ((1746, 1766), 'megengine.distributed.group_barrier', 'dist.group_barrier', ([], {}), '()\n', (1764, 1766), True, 'import megengine.distributed as dist\n'), ((2048, 2109), 'basecls.utils.setup_logger', 'setup_logger', (['cfg.output_dir', '"""train_log.txt"""'], {'to_loguru': '(True)'}), "(cfg.output_dir, 'train_log.txt', to_loguru=True)\n", (2060, 2109), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((2114, 2142), 'loguru.logger.info', 'logger.info', (['f"""args: {args}"""'], {}), "(f'args: {args}')\n", (2125, 2142), False, 'from loguru import logger\n'), ((2576, 2592), 'basecls.models.build_model', 'build_model', (['cfg'], {}), '(cfg)\n', (2587, 2592), False, 'from basecls.models import build_model, load_model, sync_model\n'), ((2700, 2717), 'basecls.models.sync_model', 'sync_model', (['model'], {}), '(model)\n', (2710, 2717), False, 'from basecls.models import build_model, load_model, sync_model\n'), ((2741, 2797), 'loguru.logger.info', 'logger.info', (['f"""Using augments named {cfg.augments.name}"""'], {}), "(f'Using augments named {cfg.augments.name}')\n", (2752, 2797), False, 'from loguru import logger\n'), ((2870, 2924), 'loguru.logger.info', 'logger.info', (['f"""Using dataloader named {cfg.data.name}"""'], {}), "(f'Using dataloader named {cfg.data.name}')\n", (2881, 2924), False, 'from loguru import logger\n'), ((3014, 3066), 'loguru.logger.info', 'logger.info', (['f"""Using solver named {cfg.solver.name}"""'], {}), "(f'Using solver named {cfg.solver.name}')\n", (3025, 3066), False, 'from loguru import logger\n'), ((3141, 3191), 'loguru.logger.info', 'logger.info', (['f"""Using hooks named {cfg.hooks_name}"""'], {}), "(f'Using hooks named {cfg.hooks_name}')\n", (3152, 3191), False, 'from loguru import logger\n'), ((3256, 3310), 'loguru.logger.info', 'logger.info', (['f"""Using trainer named {cfg.trainer_name}"""'], {}), "(f'Using trainer named {cfg.trainer_name}')\n", (3267, 3310), False, 'from loguru import logger\n'), ((3330, 3370), 'basecls.utils.registers.trainers.get', 'registers.trainers.get', (['cfg.trainer_name'], {}), '(cfg.trainer_name)\n', (3352, 3370), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((3565, 3579), 'basecls.utils.set_nccl_env', 'set_nccl_env', ([], {}), '()\n', (3577, 3579), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((3584, 3601), 'basecls.utils.set_num_threads', 'set_num_threads', ([], {}), '()\n', (3599, 3601), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((4009, 4043), 'megengine.device.get_device_count', 'mge.device.get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (4036, 4043), True, 'import megengine as mge\n'), ((1236, 1262), 'os.path.dirname', 'os.path.dirname', (['args.file'], {}), '(args.file)\n', (1251, 1262), False, 'import os\n'), ((1714, 1741), 'os.makedirs', 'os.makedirs', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (1725, 1741), False, 'import os\n'), ((2172, 2208), 'loguru.logger.info', 'logger.info', (['"""Using fastrun mode..."""'], {}), "('Using fastrun mode...')\n", (2183, 2208), False, 'from loguru import logger\n'), ((2217, 2277), 'megengine.functional.debug_param.set_execution_strategy', 'mge.functional.debug_param.set_execution_strategy', (['"""PROFILE"""'], {}), "('PROFILE')\n", (2266, 2277), True, 'import megengine as mge\n'), ((2303, 2333), 'loguru.logger.info', 'logger.info', (['"""Enabling DTR..."""'], {}), "('Enabling DTR...')\n", (2314, 2333), False, 'from loguru import logger\n'), ((2342, 2358), 'megengine.dtr.enable', 'mge.dtr.enable', ([], {}), '()\n', (2356, 2358), True, 'import megengine as mge\n'), ((2651, 2695), 'basecls.models.load_model', 'load_model', (['model', 'cfg.weights'], {'strict': '(False)'}), '(model, cfg.weights, strict=False)\n', (2661, 2695), False, 'from basecls.models import build_model, load_model, sync_model\n'), ((4085, 4110), 'os.path.exists', 'os.path.exists', (['args.file'], {}), '(args.file)\n', (4099, 4110), False, 'import os\n'), ((1299, 1326), 'os.path.basename', 'os.path.basename', (['args.file'], {}), '(args.file)\n', (1315, 1326), False, 'import os\n'), ((1645, 1660), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1658, 1660), True, 'import megengine.distributed as dist\n'), ((1674, 1704), 'os.path.exists', 'os.path.exists', (['cfg.output_dir'], {}), '(cfg.output_dir)\n', (1688, 1704), False, 'import os\n'), ((2813, 2854), 'basecls.utils.registers.augments.get', 'registers.augments.get', (['cfg.augments.name'], {}), '(cfg.augments.name)\n', (2835, 2854), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((2942, 2982), 'basecls.utils.registers.dataloaders.get', 'registers.dataloaders.get', (['cfg.data.name'], {}), '(cfg.data.name)\n', (2967, 2982), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((3080, 3118), 'basecls.utils.registers.solvers.get', 'registers.solvers.get', (['cfg.solver.name'], {}), '(cfg.solver.name)\n', (3101, 3118), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((3204, 3239), 'basecls.utils.registers.hooks.get', 'registers.hooks.get', (['cfg.hooks_name'], {}), '(cfg.hooks_name)\n', (3223, 3239), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads, setup_logger\n'), ((1191, 1206), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1204, 1206), True, 'import megengine.distributed as dist\n'), ((4299, 4341), 'os.environ.get', 'os.environ.get', (['"""RLAUNCH_REPLICA_TOTAL"""', '(0)'], {}), "('RLAUNCH_REPLICA_TOTAL', 0)\n", (4313, 4341), False, 'import os\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import numpy as np
import pytest
import megengine
import megengine.autodiff as ad
import megengine.optimizer as optimizer
from megengine import Parameter, tensor
from megengine.module import BatchNorm2d
def test_frozen_bn():
nchannel = 3
m = BatchNorm2d(nchannel, freeze=True)
saved_var = m.running_var.numpy()
saved_mean = m.running_mean.numpy()
saved_wt = m.weight.numpy()
saved_bias = m.bias.numpy()
gm = ad.GradManager().attach(m.parameters())
optim = optimizer.SGD(m.parameters(), lr=1.0)
optim.clear_grad()
data = np.random.random((6, nchannel, 2, 2)).astype("float32")
with gm:
loss = m(data).mean()
gm.backward(loss)
optim.step()
np.testing.assert_equal(m.running_var.numpy(), saved_var)
np.testing.assert_equal(m.running_mean.numpy(), saved_mean)
np.testing.assert_equal(m.weight.numpy(), saved_wt)
np.testing.assert_equal(m.bias.numpy(), saved_bias)
np.testing.assert_almost_equal(loss.numpy(), data.mean(), 5)
def test_bn_no_track_stat():
nchannel = 3
m = BatchNorm2d(nchannel, track_running_stats=False)
gm = ad.GradManager().attach(m.parameters())
optim = optimizer.SGD(m.parameters(), lr=1.0)
optim.clear_grad()
data = np.random.random((6, nchannel, 2, 2)).astype("float32")
with gm:
loss = m(data).sum()
gm.backward(loss)
optim.step()
def test_bn_no_track_stat2():
nchannel = 3
m = BatchNorm2d(nchannel) # Init with track_running_stat = True
m.track_running_stats = False
# m.running_var and m.running_mean created during init time
saved_var = m.running_var.numpy()
assert saved_var is not None
saved_mean = m.running_mean.numpy()
assert saved_mean is not None
gm = ad.GradManager().attach(m.parameters())
optim = optimizer.SGD(m.parameters(), lr=1.0)
optim.clear_grad()
data = np.random.random((6, nchannel, 2, 2)).astype("float32")
with gm:
loss = m(data).sum()
gm.backward(loss)
optim.step()
np.testing.assert_equal(m.running_var.numpy(), saved_var)
np.testing.assert_equal(m.running_mean.numpy(), saved_mean)
def test_bn_no_track_stat3():
nchannel = 3
m = BatchNorm2d(nchannel, track_running_stats=False)
m.track_running_stats = True
data = np.random.random((6, nchannel, 2, 2)).astype("float32")
with pytest.raises(Exception):
m(data)
|
[
"megengine.module.BatchNorm2d",
"megengine.autodiff.GradManager"
] |
[((630, 664), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['nchannel'], {'freeze': '(True)'}), '(nchannel, freeze=True)\n', (641, 664), False, 'from megengine.module import BatchNorm2d\n'), ((1445, 1493), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['nchannel'], {'track_running_stats': '(False)'}), '(nchannel, track_running_stats=False)\n', (1456, 1493), False, 'from megengine.module import BatchNorm2d\n'), ((1827, 1848), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['nchannel'], {}), '(nchannel)\n', (1838, 1848), False, 'from megengine.module import BatchNorm2d\n'), ((2592, 2640), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['nchannel'], {'track_running_stats': '(False)'}), '(nchannel, track_running_stats=False)\n', (2603, 2640), False, 'from megengine.module import BatchNorm2d\n'), ((2750, 2774), 'pytest.raises', 'pytest.raises', (['Exception'], {}), '(Exception)\n', (2763, 2774), False, 'import pytest\n'), ((818, 834), 'megengine.autodiff.GradManager', 'ad.GradManager', ([], {}), '()\n', (832, 834), True, 'import megengine.autodiff as ad\n'), ((943, 980), 'numpy.random.random', 'np.random.random', (['(6, nchannel, 2, 2)'], {}), '((6, nchannel, 2, 2))\n', (959, 980), True, 'import numpy as np\n'), ((1504, 1520), 'megengine.autodiff.GradManager', 'ad.GradManager', ([], {}), '()\n', (1518, 1520), True, 'import megengine.autodiff as ad\n'), ((1629, 1666), 'numpy.random.random', 'np.random.random', (['(6, nchannel, 2, 2)'], {}), '((6, nchannel, 2, 2))\n', (1645, 1666), True, 'import numpy as np\n'), ((2142, 2158), 'megengine.autodiff.GradManager', 'ad.GradManager', ([], {}), '()\n', (2156, 2158), True, 'import megengine.autodiff as ad\n'), ((2267, 2304), 'numpy.random.random', 'np.random.random', (['(6, nchannel, 2, 2)'], {}), '((6, nchannel, 2, 2))\n', (2283, 2304), True, 'import numpy as np\n'), ((2685, 2722), 'numpy.random.random', 'np.random.random', (['(6, nchannel, 2, 2)'], {}), '((6, nchannel, 2, 2))\n', (2701, 2722), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import os
import argparse
import datetime
import multiprocessing as mp
import time
import megengine as mge
import megengine.amp as amp
import megengine.autodiff as autodiff
import megengine.distributed as dist
import megengine.functional as F
import megengine.jit as jit
import megengine.optimizer as optim
from basecore.utils import log_every_n_seconds
from loguru import logger
from basecls.data.fake_data import FakeDataLoader
from basecls.layers import Preprocess
from basecls.utils import registers, set_nccl_env, set_num_threads
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-m", "--model", default="resnet50", type=str)
parser.add_argument("--mode", default="eval", type=str)
parser.add_argument("-d", "--device", default="gpu", type=str)
parser.add_argument("--amp", default=0, type=int)
parser.add_argument("--fastrun", action="store_true")
parser.add_argument("--trace", action="store_true")
parser.add_argument("--dtr", action="store_true")
parser.add_argument("-b", "--batch-size", default=32, type=int)
parser.add_argument("--channel", default=3, type=int)
parser.add_argument("--height", default=224, type=int)
parser.add_argument("--width", default=224, type=int)
parser.add_argument("-n", "--world-size", default=8, type=int)
parser.add_argument("--warm-iters", default=50, type=int)
parser.add_argument("-t", "--total-iters", default=200, type=int)
parser.add_argument("--log-seconds", default=2, type=int)
args = parser.parse_args()
mp.set_start_method("spawn")
set_nccl_env()
set_num_threads()
if args.world_size == 1:
worker(args)
else:
dist.launcher(worker, n_gpus=args.world_size)(args)
@logger.catch
def worker(args: argparse.Namespace):
if dist.get_rank() != 0:
logger.remove()
logger.info(f"args: {args}")
if args.fastrun:
logger.info("Using fastrun mode...")
mge.functional.debug_param.set_execution_strategy("PROFILE")
if args.dtr:
logger.info("Enabling DTR...")
mge.dtr.enable()
mge.set_default_device(f"{args.device}{dist.get_rank()}")
model = registers.models.get(args.model)(head=dict(w_out=1000))
dataloader = FakeDataLoader(
args.batch_size,
(args.height, args.width),
args.channel,
length=args.warm_iters + args.total_iters,
num_classes=1000,
)
if args.mode == "train":
BenchCls = TrainBench
elif args.mode == "eval":
BenchCls = EvalBench
else:
raise NotImplementedError(f"Benchmark mode '{args.mode}' not supported")
bench = BenchCls(model, dataloader, args.trace, args.amp)
bench.benchmark(args.warm_iters, args.log_seconds)
class ClsBench:
def __init__(self, model, dataloader, trace: bool = False):
self.model = model
self.dataloader = dataloader
self.preprocess = Preprocess(mean=127, std=128)
if trace:
self.model_step = jit.trace(self.model_step, symbolic=True)
def benchmark(self, warm_iters=50, log_seconds=2):
total_iters = len(self.dataloader) - warm_iters
total_time = 0
for i, data in enumerate(self.dataloader, 1):
if i == warm_iters + 1:
total_time = 0
samples, targets = self.preprocess(data)
mge._full_sync()
t = time.perf_counter()
self.model_step(samples, targets)
mge._full_sync()
total_time += time.perf_counter() - t
if log_seconds > 0:
cnt = i - warm_iters if i > warm_iters else i
tot = total_iters if i > warm_iters else warm_iters
cycle = total_time / cnt
eta = (tot - cnt) * cycle
log_every_n_seconds(
"{} process {}/{}, average speed:{:0.3f}ms/iters. ETA:{}".format(
"Benchmark" if i > warm_iters else "Warmup",
cnt,
tot,
cycle * 1000,
datetime.timedelta(seconds=int(eta)),
),
n=log_seconds,
)
avg_speed_ms = total_time / total_iters * 1000
logger.info(
"Benchmark total time:{}, average speed:{:0.3f}ms/iters.".format(
datetime.timedelta(seconds=int(total_time)), avg_speed_ms
)
)
return avg_speed_ms
def model_step(self, samples, targets):
raise NotImplementedError
class TrainBench(ClsBench):
def __init__(self, model, dataloader, trace: bool = False, amp_version: int = 0):
model.train()
super().__init__(model, dataloader, trace)
self.opt = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=0.0001)
self.gm = autodiff.GradManager()
callbacks = (
[dist.make_allreduce_cb("mean", dist.WORLD)] if dist.get_world_size() > 1 else None
)
self.gm.attach(model.parameters(), callbacks=callbacks)
self.amp_version = amp_version
self.scaler = (
amp.GradScaler(init_scale=65536.0, growth_interval=2000)
if amp_version == 2
else amp.GradScaler(init_scale=128.0, growth_interval=0)
)
def model_step(self, samples, targets):
with self.gm:
with amp.autocast(enabled=self.amp_version > 0):
pred = self.model(samples)
loss = F.loss.cross_entropy(pred, targets)
if self.amp_version > 0:
self.scaler.backward(self.gm, loss, update_scale=False)
self.scaler.update()
else:
self.gm.backward(loss)
self.opt.step().clear_grad()
class EvalBench(ClsBench):
def __init__(self, model, dataloader, trace: bool = False, amp_version: int = 0):
model.eval()
super().__init__(model, dataloader, trace)
self.amp_version = amp_version
def model_step(self, samples, targets):
with amp.autocast(enabled=self.amp_version > 0):
self.model(samples)
if __name__ == "__main__":
main()
|
[
"megengine.functional.loss.cross_entropy",
"megengine._full_sync",
"megengine.autodiff.GradManager",
"megengine.functional.debug_param.set_execution_strategy",
"megengine.jit.trace",
"megengine.amp.autocast",
"megengine.distributed.make_allreduce_cb",
"megengine.distributed.launcher",
"megengine.dtr.enable",
"megengine.amp.GradScaler",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size"
] |
[((941, 966), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (964, 966), False, 'import argparse\n'), ((1927, 1955), 'multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (1946, 1955), True, 'import multiprocessing as mp\n'), ((1961, 1975), 'basecls.utils.set_nccl_env', 'set_nccl_env', ([], {}), '()\n', (1973, 1975), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads\n'), ((1980, 1997), 'basecls.utils.set_num_threads', 'set_num_threads', ([], {}), '()\n', (1995, 1997), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads\n'), ((2230, 2258), 'loguru.logger.info', 'logger.info', (['f"""args: {args}"""'], {}), "(f'args: {args}')\n", (2241, 2258), False, 'from loguru import logger\n'), ((2627, 2764), 'basecls.data.fake_data.FakeDataLoader', 'FakeDataLoader', (['args.batch_size', '(args.height, args.width)', 'args.channel'], {'length': '(args.warm_iters + args.total_iters)', 'num_classes': '(1000)'}), '(args.batch_size, (args.height, args.width), args.channel,\n length=args.warm_iters + args.total_iters, num_classes=1000)\n', (2641, 2764), False, 'from basecls.data.fake_data import FakeDataLoader\n'), ((2180, 2195), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2193, 2195), True, 'import megengine.distributed as dist\n'), ((2210, 2225), 'loguru.logger.remove', 'logger.remove', ([], {}), '()\n', (2223, 2225), False, 'from loguru import logger\n'), ((2289, 2325), 'loguru.logger.info', 'logger.info', (['"""Using fastrun mode..."""'], {}), "('Using fastrun mode...')\n", (2300, 2325), False, 'from loguru import logger\n'), ((2334, 2394), 'megengine.functional.debug_param.set_execution_strategy', 'mge.functional.debug_param.set_execution_strategy', (['"""PROFILE"""'], {}), "('PROFILE')\n", (2383, 2394), True, 'import megengine as mge\n'), ((2421, 2451), 'loguru.logger.info', 'logger.info', (['"""Enabling DTR..."""'], {}), "('Enabling DTR...')\n", (2432, 2451), False, 'from loguru import logger\n'), ((2460, 2476), 'megengine.dtr.enable', 'mge.dtr.enable', ([], {}), '()\n', (2474, 2476), True, 'import megengine as mge\n'), ((2553, 2585), 'basecls.utils.registers.models.get', 'registers.models.get', (['args.model'], {}), '(args.model)\n', (2573, 2585), False, 'from basecls.utils import registers, set_nccl_env, set_num_threads\n'), ((3308, 3337), 'basecls.layers.Preprocess', 'Preprocess', ([], {'mean': '(127)', 'std': '(128)'}), '(mean=127, std=128)\n', (3318, 3337), False, 'from basecls.layers import Preprocess\n'), ((5266, 5288), 'megengine.autodiff.GradManager', 'autodiff.GradManager', ([], {}), '()\n', (5286, 5288), True, 'import megengine.autodiff as autodiff\n'), ((2067, 2112), 'megengine.distributed.launcher', 'dist.launcher', (['worker'], {'n_gpus': 'args.world_size'}), '(worker, n_gpus=args.world_size)\n', (2080, 2112), True, 'import megengine.distributed as dist\n'), ((3387, 3428), 'megengine.jit.trace', 'jit.trace', (['self.model_step'], {'symbolic': '(True)'}), '(self.model_step, symbolic=True)\n', (3396, 3428), True, 'import megengine.jit as jit\n'), ((3753, 3769), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (3767, 3769), True, 'import megengine as mge\n'), ((3786, 3805), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (3803, 3805), False, 'import time\n'), ((3866, 3882), 'megengine._full_sync', 'mge._full_sync', ([], {}), '()\n', (3880, 3882), True, 'import megengine as mge\n'), ((5557, 5613), 'megengine.amp.GradScaler', 'amp.GradScaler', ([], {'init_scale': '(65536.0)', 'growth_interval': '(2000)'}), '(init_scale=65536.0, growth_interval=2000)\n', (5571, 5613), True, 'import megengine.amp as amp\n'), ((5663, 5714), 'megengine.amp.GradScaler', 'amp.GradScaler', ([], {'init_scale': '(128.0)', 'growth_interval': '(0)'}), '(init_scale=128.0, growth_interval=0)\n', (5677, 5714), True, 'import megengine.amp as amp\n'), ((6480, 6522), 'megengine.amp.autocast', 'amp.autocast', ([], {'enabled': '(self.amp_version > 0)'}), '(enabled=self.amp_version > 0)\n', (6492, 6522), True, 'import megengine.amp as amp\n'), ((2521, 2536), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (2534, 2536), True, 'import megengine.distributed as dist\n'), ((3909, 3928), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (3926, 3928), False, 'import time\n'), ((5371, 5392), 'megengine.distributed.get_world_size', 'dist.get_world_size', ([], {}), '()\n', (5390, 5392), True, 'import megengine.distributed as dist\n'), ((5324, 5366), 'megengine.distributed.make_allreduce_cb', 'dist.make_allreduce_cb', (['"""mean"""', 'dist.WORLD'], {}), "('mean', dist.WORLD)\n", (5346, 5366), True, 'import megengine.distributed as dist\n'), ((5809, 5851), 'megengine.amp.autocast', 'amp.autocast', ([], {'enabled': '(self.amp_version > 0)'}), '(enabled=self.amp_version > 0)\n', (5821, 5851), True, 'import megengine.amp as amp\n'), ((5919, 5954), 'megengine.functional.loss.cross_entropy', 'F.loss.cross_entropy', (['pred', 'targets'], {}), '(pred, targets)\n', (5939, 5954), True, 'import megengine.functional as F\n')]
|
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
from typing import List, Tuple
import numpy as np
import megengine._internal as mgb
import megengine.functional as F
from megengine import Graph, jit
from megengine.module import Linear, Module
from megengine.test import assertTensorClose
from .env import modified_environ
class MLP(Module):
def __init__(self):
super().__init__()
self.dense0 = Linear(28, 50)
self.dense1 = Linear(50, 20)
def forward(self, x):
x = self.dense0(x)
x = F.relu(x)
x = self.dense1(x)
return x
def has_gpu(num=1):
try:
mgb.comp_node("gpu{}".format(num - 1))
except mgb.MegBrainError:
return False
return True
def randomNp(*args):
for arg in args:
assert isinstance(arg, int)
return np.random.random(args)
def randomTorch(*args):
import torch # pylint: disable=import-outside-toplevel
for arg in args:
assert isinstance(arg, int)
return torch.tensor(randomNp(*args), dtype=torch.float32)
def graph_mode(*modes):
if not set(modes).issubset({"eager", "static"}):
raise ValueError("graph mode must be in (eager, static)")
def decorator(func):
def wrapper(*args, **kwargs):
if "eager" in set(modes):
func(*args, **kwargs)
if "static" in set(modes):
with Graph() as cg:
cg.set_option("eager_evaluation", False)
func(*args, **kwargs)
return wrapper
return decorator
def _default_compare_fn(x, y):
assertTensorClose(x.numpy(), y)
def opr_test(
cases,
func,
mode=("eager", "static", "dynamic_shape"),
compare_fn=_default_compare_fn,
ref_fn=None,
**kwargs
):
"""
mode: the list of test mode which are eager, static and dynamic_shape
will test all the cases if None.
func: the function to run opr.
compare_fn: the function to compare the result and expected, use assertTensorClose if None.
ref_fn: the function to generate expected data, should assign output if None.
cases: the list which have dict element, the list length should be 2 for dynamic shape test.
and the dict should have input,
and should have output if ref_fn is None.
should use list for multiple inputs and outputs for each case.
kwargs: The additional kwargs for opr func.
simple examples:
dtype = np.float32
cases = [{"input": [10, 20]}, {"input": [20, 30]}]
opr_test(cases,
F.eye,
ref_fn=lambda n, m: np.eye(n, m).astype(dtype),
dtype=dtype)
"""
def check_results(results, expected):
if not isinstance(results, Tuple):
results = (results,)
for r, e in zip(results, expected):
compare_fn(r, e)
def get_trace_fn(func, enabled, symbolic):
jit.trace.enabled = enabled
return jit.trace(func, symbolic=symbolic)
def get_param(cases, idx):
case = cases[idx]
inp = case.get("input", None)
outp = case.get("output", None)
if inp is None:
raise ValueError("the test case should have input")
if not isinstance(inp, List):
inp = (inp,)
else:
inp = tuple(inp)
if ref_fn is not None and callable(ref_fn):
outp = ref_fn(*inp)
if outp is None:
raise ValueError("the test case should have output or reference function")
if not isinstance(outp, List):
outp = (outp,)
else:
outp = tuple(outp)
return inp, outp
if not set(mode).issubset({"eager", "static", "dynamic_shape"}):
raise ValueError("opr test mode must be in (eager, static, dynamic_shape)")
if len(cases) == 0:
raise ValueError("should give one case at least")
if "dynamic_shape" in set(mode):
if len(cases) != 2:
raise ValueError("should give 2 cases for dynamic shape test")
if not callable(func):
raise ValueError("the input func should be callable")
inp, outp = get_param(cases, 0)
def run(*args, **kwargs):
return func(*args, **kwargs)
if "eager" in set(mode):
f = get_trace_fn(run, False, False)
results = f(*inp, **kwargs)
check_results(results, outp)
if "static" in set(mode) or "dynamic_shape" in set(mode):
f = get_trace_fn(run, True, True)
results = f(*inp, **kwargs)
check_results(results, outp)
if "dynamic_shape" in set(mode):
inp, outp = get_param(cases, 1)
results = f(*inp, **kwargs)
check_results(results, outp)
|
[
"megengine.Graph",
"megengine.functional.relu",
"megengine.jit.trace",
"megengine.module.Linear"
] |
[((1156, 1178), 'numpy.random.random', 'np.random.random', (['args'], {}), '(args)\n', (1172, 1178), True, 'import numpy as np\n'), ((747, 761), 'megengine.module.Linear', 'Linear', (['(28)', '(50)'], {}), '(28, 50)\n', (753, 761), False, 'from megengine.module import Linear, Module\n'), ((784, 798), 'megengine.module.Linear', 'Linear', (['(50)', '(20)'], {}), '(50, 20)\n', (790, 798), False, 'from megengine.module import Linear, Module\n'), ((865, 874), 'megengine.functional.relu', 'F.relu', (['x'], {}), '(x)\n', (871, 874), True, 'import megengine.functional as F\n'), ((3321, 3355), 'megengine.jit.trace', 'jit.trace', (['func'], {'symbolic': 'symbolic'}), '(func, symbolic=symbolic)\n', (3330, 3355), False, 'from megengine import Graph, jit\n'), ((1730, 1737), 'megengine.Graph', 'Graph', ([], {}), '()\n', (1735, 1737), False, 'from megengine import Graph, jit\n')]
|
# -*- coding: utf-8 -*-
# Copyright 2018-2019 Open-MMLab.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ---------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
# This file has been modified by Megvii ("Megvii Modifications").
# All Megvii Modifications are Copyright (C) 2014-2019 Megvii Inc. All rights reserved.
# ---------------------------------------------------------------------
from abc import ABCMeta, abstractmethod
import megengine.functional as F
import numpy as np
from megengine.core import tensor, Tensor
class BaseAnchorGenerator(metaclass=ABCMeta):
"""base class for anchor generator.
"""
def __init__(self):
pass
@abstractmethod
def get_anchors_by_feature(self) -> Tensor:
pass
class DefaultAnchorGenerator(BaseAnchorGenerator):
"""default retinanet anchor generator.
This class generate anchors by feature map in level.
Args:
base_size (int): anchor base size.
anchor_scales (np.ndarray): anchor scales based on stride.
The practical anchor scale is anchor_scale * stride
anchor_ratios(np.ndarray): anchor aspect ratios.
offset (float): center point offset.default is 0.
"""
def __init__(
self,
base_size=8,
anchor_scales: np.ndarray = np.array([2, 3, 4]),
anchor_ratios: np.ndarray = np.array([0.5, 1, 2]),
offset: float = 0,
):
super().__init__()
self.base_size = base_size
self.anchor_scales = anchor_scales
self.anchor_ratios = anchor_ratios
self.offset = offset
def _whctrs(self, anchor):
"""convert anchor box into (w, h, ctr_x, ctr_y)
"""
w = anchor[:, 2] - anchor[:, 0] + 1
h = anchor[:, 3] - anchor[:, 1] + 1
x_ctr = anchor[:, 0] + 0.5 * (w - 1)
y_ctr = anchor[:, 1] + 0.5 * (h - 1)
return w, h, x_ctr, y_ctr
def get_plane_anchors(self, anchor_scales: np.ndarray):
"""get anchors per location on feature map.
The anchor number is anchor_scales x anchor_ratios
"""
base_anchor = tensor([0, 0, self.base_size - 1, self.base_size - 1])
base_anchor = F.add_axis(base_anchor, 0)
w, h, x_ctr, y_ctr = self._whctrs(base_anchor)
# ratio enumerate
size = w * h
size_ratios = size / self.anchor_ratios
ws = size_ratios.sqrt().round()
hs = (ws * self.anchor_ratios).round()
# scale enumerate
anchor_scales = anchor_scales[None, ...]
ws = F.add_axis(ws, 1)
hs = F.add_axis(hs, 1)
ws = (ws * anchor_scales).reshape(-1, 1)
hs = (hs * anchor_scales).reshape(-1, 1)
anchors = F.concat(
[
x_ctr - 0.5 * (ws - 1),
y_ctr - 0.5 * (hs - 1),
x_ctr + 0.5 * (ws - 1),
y_ctr + 0.5 * (hs - 1),
],
axis=1,
)
return anchors.astype(np.float32)
def get_center_offsets(self, featmap, stride):
f_shp = featmap.shape
fm_height, fm_width = f_shp[-2], f_shp[-1]
shift_x = F.linspace(0, fm_width - 1, fm_width) * stride
shift_y = F.linspace(0, fm_height - 1, fm_height) * stride
# make the mesh grid of shift_x and shift_y
mesh_shape = (fm_height, fm_width)
broad_shift_x = shift_x.reshape(-1, shift_x.shape[0]).broadcast(*mesh_shape)
broad_shift_y = shift_y.reshape(shift_y.shape[0], -1).broadcast(*mesh_shape)
flatten_shift_x = F.add_axis(broad_shift_x.reshape(-1), 1)
flatten_shift_y = F.add_axis(broad_shift_y.reshape(-1), 1)
centers = F.concat(
[flatten_shift_x, flatten_shift_y, flatten_shift_x, flatten_shift_y,],
axis=1,
)
if self.offset > 0:
centers = centers + self.offset * stride
return centers
def get_anchors_by_feature(self, featmap, stride):
# shifts shape: [A, 4]
shifts = self.get_center_offsets(featmap, stride)
# plane_anchors shape: [B, 4], e.g. B=9
plane_anchors = self.get_plane_anchors(self.anchor_scales * stride)
all_anchors = F.add_axis(plane_anchors, 0) + F.add_axis(shifts, 1)
all_anchors = all_anchors.reshape(-1, 4)
return all_anchors
def __call__(self, featmap, stride):
return self.get_anchors_by_feature(featmap, stride)
|
[
"megengine.functional.linspace",
"megengine.core.tensor",
"megengine.functional.add_axis",
"megengine.functional.concat"
] |
[((2161, 2180), 'numpy.array', 'np.array', (['[2, 3, 4]'], {}), '([2, 3, 4])\n', (2169, 2180), True, 'import numpy as np\n'), ((2218, 2239), 'numpy.array', 'np.array', (['[0.5, 1, 2]'], {}), '([0.5, 1, 2])\n', (2226, 2239), True, 'import numpy as np\n'), ((2971, 3025), 'megengine.core.tensor', 'tensor', (['[0, 0, self.base_size - 1, self.base_size - 1]'], {}), '([0, 0, self.base_size - 1, self.base_size - 1])\n', (2977, 3025), False, 'from megengine.core import tensor, Tensor\n'), ((3048, 3074), 'megengine.functional.add_axis', 'F.add_axis', (['base_anchor', '(0)'], {}), '(base_anchor, 0)\n', (3058, 3074), True, 'import megengine.functional as F\n'), ((3402, 3419), 'megengine.functional.add_axis', 'F.add_axis', (['ws', '(1)'], {}), '(ws, 1)\n', (3412, 3419), True, 'import megengine.functional as F\n'), ((3433, 3450), 'megengine.functional.add_axis', 'F.add_axis', (['hs', '(1)'], {}), '(hs, 1)\n', (3443, 3450), True, 'import megengine.functional as F\n'), ((3568, 3686), 'megengine.functional.concat', 'F.concat', (['[x_ctr - 0.5 * (ws - 1), y_ctr - 0.5 * (hs - 1), x_ctr + 0.5 * (ws - 1), \n y_ctr + 0.5 * (hs - 1)]'], {'axis': '(1)'}), '([x_ctr - 0.5 * (ws - 1), y_ctr - 0.5 * (hs - 1), x_ctr + 0.5 * (ws -\n 1), y_ctr + 0.5 * (hs - 1)], axis=1)\n', (3576, 3686), True, 'import megengine.functional as F\n'), ((4526, 4616), 'megengine.functional.concat', 'F.concat', (['[flatten_shift_x, flatten_shift_y, flatten_shift_x, flatten_shift_y]'], {'axis': '(1)'}), '([flatten_shift_x, flatten_shift_y, flatten_shift_x,\n flatten_shift_y], axis=1)\n', (4534, 4616), True, 'import megengine.functional as F\n'), ((3992, 4029), 'megengine.functional.linspace', 'F.linspace', (['(0)', '(fm_width - 1)', 'fm_width'], {}), '(0, fm_width - 1, fm_width)\n', (4002, 4029), True, 'import megengine.functional as F\n'), ((4057, 4096), 'megengine.functional.linspace', 'F.linspace', (['(0)', '(fm_height - 1)', 'fm_height'], {}), '(0, fm_height - 1, fm_height)\n', (4067, 4096), True, 'import megengine.functional as F\n'), ((5045, 5073), 'megengine.functional.add_axis', 'F.add_axis', (['plane_anchors', '(0)'], {}), '(plane_anchors, 0)\n', (5055, 5073), True, 'import megengine.functional as F\n'), ((5076, 5097), 'megengine.functional.add_axis', 'F.add_axis', (['shifts', '(1)'], {}), '(shifts, 1)\n', (5086, 5097), True, 'import megengine.functional as F\n')]
|
import os
import sys
import pytest
from megengine.core._imperative_rt.imperative import sync
sys.path.append(os.path.join(os.path.dirname(__file__), "helpers"))
def pytest_runtest_teardown():
sync()
|
[
"megengine.core._imperative_rt.imperative.sync"
] |
[((201, 207), 'megengine.core._imperative_rt.imperative.sync', 'sync', ([], {}), '()\n', (205, 207), False, 'from megengine.core._imperative_rt.imperative import sync\n'), ((125, 150), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (140, 150), False, 'import os\n')]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.