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 ARRANTI... | [
"megengine.functional.add_axis",
"megengine.functional.arange",
"megengine.functional.sigmoid",
"megengine.functional.abs",
"megengine.functional.exp"
] | [((1623, 1655), 'megengine.functional.arange', 'F.arange', (['(1)', '(logits.shape[2] + 1)'], {}), '(1, logits.shape[2] + 1)\n', (1631, 1655), True, 'import megengine.functional as F\n'), ((1670, 1696), 'megengine.functional.add_axis', 'F.add_axis', (['labels'], {'axis': '(2)'}), '(labels, axis=2)\n', (1680, 1696), Tru... |
#!/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.models.repvgg import RepVGGBlock
@pytest.mark.parametrize("w_in", [32, 64])
@pytest.mark.parametrize("w_out", [64])
@pytest.mark.paramet... | [
"megengine.random.uniform"
] | [((218, 259), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[32, 64]'], {}), "('w_in', [32, 64])\n", (241, 259), False, 'import pytest\n'), ((261, 299), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[64]'], {}), "('w_out', [64])\n", (284, 299), False, 'import pytest\n'... |
import math
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
# ================================= GRU Implementation ==========================================================
class GRUCell(M.Module):
"""
An implementation of GRUCell.
"""
de... | [
"megengine.functional.zeros",
"megengine.functional.mul",
"megengine.functional.sigmoid",
"megengine.functional.split",
"megengine.functional.stack",
"megengine.module.Linear",
"megengine.functional.dropout",
"megengine.functional.tanh",
"megengine.functional.reshape",
"megengine.module.init.unifo... | [((520, 568), 'megengine.module.Linear', 'M.Linear', (['input_size', '(3 * hidden_size)'], {'bias': 'bias'}), '(input_size, 3 * hidden_size, bias=bias)\n', (528, 568), True, 'import megengine.module as M\n'), ((587, 636), 'megengine.module.Linear', 'M.Linear', (['hidden_size', '(3 * hidden_size)'], {'bias': 'bias'}), '... |
import megengine.module as M
import megengine.functional as F
class FlowHead(M.Module):
def __init__(self, input_dim=128, hidden_dim=256):
super(FlowHead, self).__init__()
self.conv1 = M.Conv2d(input_dim, hidden_dim, 3, padding=1)
self.conv2 = M.Conv2d(hidden_dim, 2, 3, padding=1)
... | [
"megengine.functional.concat",
"megengine.module.ReLU",
"megengine.module.Conv2d"
] | [((207, 252), 'megengine.module.Conv2d', 'M.Conv2d', (['input_dim', 'hidden_dim', '(3)'], {'padding': '(1)'}), '(input_dim, hidden_dim, 3, padding=1)\n', (215, 252), True, 'import megengine.module as M\n'), ((274, 311), 'megengine.module.Conv2d', 'M.Conv2d', (['hidden_dim', '(2)', '(3)'], {'padding': '(1)'}), '(hidden_... |
#!/usr/bin/env python3
from dataset import SIDDValData
from model import UNetD
import megengine.data as data
from utils import batch_PSNR
from tqdm import tqdm
import argparse
import pickle
import megengine
def test(args):
valid_dataset = SIDDValData(args.data)
valid_sampler = data.SequentialSampler(
... | [
"megengine.data.DataLoader",
"megengine.tensor",
"megengine.data.SequentialSampler"
] | [((245, 267), 'dataset.SIDDValData', 'SIDDValData', (['args.data'], {}), '(args.data)\n', (256, 267), False, 'from dataset import SIDDValData\n'), ((288, 356), 'megengine.data.SequentialSampler', 'data.SequentialSampler', (['valid_dataset'], {'batch_size': '(1)', 'drop_last': '(False)'}), '(valid_dataset, batch_size=1,... |
import os
import numpy as np
import collections
import megengine.module as M
import megengine.functional as F
import megengine as mge
from megengine.data.dataset import Dataset
from megengine.data import DataLoader
import hparams as hp
from megengine.data import Collator
class AsrDataset(Dataset):
def __init__(se... | [
"megengine.Tensor"
] | [((7013, 7087), 'numpy.pad', 'np.pad', (['x', '(0, length - x.shape[0])'], {'mode': '"""constant"""', 'constant_values': '_pad'}), "(x, (0, length - x.shape[0]), mode='constant', constant_values=_pad)\n", (7019, 7087), True, 'import numpy as np\n'), ((1250, 1285), 'numpy.array', 'np.array', (['token_ids'], {'dtype': '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 ARRANTI... | [
"megengine.functional.topk_accuracy",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.distributed.init_process_group",
"megengine.utils.dtr.DTR",
"megengine.distributed.get_rank",
"megengine.functional.distributed.all_reduce_sum",
"megengine.data.transform.CenterCrop",
"megengine.distribut... | [((753, 782), 'megengine.logger.get_logger', 'megengine.logger.get_logger', ([], {}), '()\n', (780, 782), False, 'import megengine\n'), ((809, 875), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""MegEngine ImageNet Training"""'}), "(description='MegEngine ImageNet Training')\n", (832, 87... |
# -*- coding: utf-8 -*-
import megengine as mge
import megengine.random as rand
import megengine.functional as F
import numpy as np
from config import config
from det_opr.bbox_opr import box_overlap_opr, bbox_transform_opr, box_overlap_ignore_opr
import pdb
def fpn_roi_target(rpn_rois, im_info, gt_boxes, fg_threshold ... | [
"megengine.functional.gather",
"megengine.functional.minimum",
"megengine.functional.argsort",
"megengine.tensor",
"megengine.functional.cond_take",
"megengine.random.uniform",
"megengine.functional.equal",
"megengine.functional.expand_dims",
"megengine.functional.concat",
"megengine.functional.on... | [((6507, 6535), 'megengine.functional.equal', 'F.equal', (['masks', 'sample_value'], {}), '(masks, sample_value)\n', (6514, 6535), True, 'import megengine.functional as F\n'), ((6593, 6625), 'megengine.functional.minimum', 'F.minimum', (['num_mask', 'num_samples'], {}), '(num_mask, num_samples)\n', (6602, 6625), True, ... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import copy
from typing import Optional, Sequence
import cv2
import megengine.data as data
import megengine.data.transform as T
import numpy as np
from basecore.config import ConfigDict
from loguru import logger
from basecls.utils impor... | [
"megengine.data.transform.Lighting",
"megengine.data.transform.PseudoTransform",
"megengine.data.transform.RandomResizedCrop",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.data.transform.ColorJitter",
"megengine.data.transform.Compose",
"megengine.data.transform.ToMode",
"megengine.data... | [((3450, 3479), 'basecls.utils.registers.augments.register', 'registers.augments.register', ([], {}), '()\n', (3477, 3479), False, 'from basecls.utils import registers\n'), ((3640, 3669), 'basecls.utils.registers.augments.register', 'registers.augments.register', ([], {}), '()\n', (3667, 3669), False, 'from basecls.uti... |
# 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 Megv... | [
"megengine.random.gaussian",
"megengine.functional.zero_grad",
"megengine.functional.sigmoid"
] | [((2259, 2298), 'megengine.random.gaussian', 'R.gaussian', ([], {'shape': '[batch_size, self.nz]'}), '(shape=[batch_size, self.nz])\n', (2269, 2298), True, 'import megengine.random as R\n'), ((3780, 3804), 'megengine.functional.zero_grad', 'F.zero_grad', (['fake_images'], {}), '(fake_images)\n', (3791, 3804), True, 'im... |
import numpy as np
import megengine
import megengine.module as M
import megengine.functional as F
import math
from . import default_init_weights
class ShuffleV2Block(M.Module):
def __init__(self, inp, oup, mid_channels, *, ksize, stride):
super().__init__()
self.stride = stride
assert strid... | [
"megengine.module.ReLU",
"megengine.module.BatchNorm2d",
"megengine.functional.transpose",
"megengine.module.Sequential",
"megengine.module.Conv2d"
] | [((943, 969), 'megengine.module.Sequential', 'M.Sequential', (['*branch_main'], {}), '(*branch_main)\n', (955, 969), True, 'import megengine.module as M\n'), ((2111, 2136), 'megengine.functional.transpose', 'F.transpose', (['x', '(1, 0, 2)'], {}), '(x, (1, 0, 2))\n', (2122, 2136), True, 'import megengine.functional as ... |
# -*- coding: utf-8 -*-
# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
# ---------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License"... | [
"megengine.hub.pretrained",
"megengine.module.Embedding",
"megengine.hub.load",
"megengine.tensor",
"megengine.functional.concat",
"megengine.functional.matmul",
"megengine.functional.sqrt",
"megengine.functional.ones_like",
"megengine.functional.zeros_like",
"megengine.functional.linspace",
"me... | [((24900, 25043), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/models/weights/bert/uncased_L-12_H-768_A-12/bert_4f2157f7_uncased_L-12_H-768_A-12.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/models/weights/bert/uncased_L-12_H-768_A-12/bert_4f2157f7_uncased_L-12_H-768_A-12.pk... |
#!/usr/bin/env mdl
# This file will seal the nms opr within a better way than lib_nms
import ctypes
import os
import struct
import numpy as np
import megengine as mge
import megengine.functional as F
from megengine._internal.craniotome import CraniotomeBase
from megengine.core.tensor import wrap_io_tensor
_current_p... | [
"megengine.tensor"
] | [((380, 421), 'os.path.join', 'os.path.join', (['_current_path', '"""lib_nms.so"""'], {}), "(_current_path, 'lib_nms.so')\n", (392, 421), False, 'import os\n'), ((342, 367), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (357, 367), False, 'import os\n'), ((441, 462), 'ctypes.CDLL', 'ctypes.C... |
# -*- coding: utf-8 -*-
# Copyright 2019 - present, Facebook, Inc
#
# 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 app... | [
"megengine.functional.mean",
"megengine.functional.sqrt",
"megengine.module.init.zeros_",
"megengine.module.init.ones_"
] | [((3029, 3066), 'megengine.functional.mean', 'F.mean', (['output'], {'axis': '(2)', 'keepdims': '(True)'}), '(output, axis=2, keepdims=True)\n', (3035, 3066), True, 'import megengine.functional as F\n'), ((3083, 3125), 'megengine.functional.mean', 'F.mean', (['(output ** 2)'], {'axis': '(2)', 'keepdims': '(True)'}), '(... |
# BSD 3-Clause License
# Copyright (c) <NAME> 2016,
# All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of con... | [
"megengine.module.Elemwise",
"megengine.module.ConvBnRelu2d",
"megengine.module.Dropout",
"megengine.functional.flatten",
"megengine.module.DequantStub",
"megengine.module.Linear",
"megengine.module.ConvBn2d",
"megengine.module.init.msra_normal_",
"megengine.module.init.zeros_",
"megengine.module.... | [((3759, 3780), 'megengine.module.Sequential', 'M.Sequential', (['*layers'], {}), '(*layers)\n', (3771, 3780), True, 'import megengine.module as M\n'), ((3800, 3817), 'megengine.module.Elemwise', 'M.Elemwise', (['"""ADD"""'], {}), "('ADD')\n", (3810, 3817), True, 'import megengine.module as M\n'), ((6265, 6288), 'megen... |
# -*- 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 ARRANTI... | [
"megengine.functional.max",
"megengine.functional.argmax",
"megengine.functional.full_like"
] | [((1208, 1232), 'megengine.functional.argmax', 'F.argmax', (['matrix'], {'axis': '(0)'}), '(matrix, axis=0)\n', (1216, 1232), True, 'import megengine.functional as F\n'), ((1286, 1316), 'megengine.functional.full_like', 'F.full_like', (['match_indices', '(-1)'], {}), '(match_indices, -1)\n', (1297, 1316), True, 'import... |
# -*- 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 ARRANTI... | [
"megengine.functional.conv3d",
"megengine.functional.pixel_shuffle",
"megengine.core.tensor.dtype.convert_to_qint32",
"megengine.config._override",
"megengine.functional.argmax",
"megengine.functional.adaptive_avg_pool2d",
"megengine.functional.argmin",
"megengine.jit.trace",
"megengine.functional.u... | [((6039, 6149), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape_a, shape_b"""', '[((0,), (0,)), ((10, 0), (0, 10)), ((3, 10, 0), (3, 0, 10))]'], {}), "('shape_a, shape_b', [((0,), (0,)), ((10, 0), (0, 10\n )), ((3, 10, 0), (3, 0, 10))])\n", (6062, 6149), False, 'import pytest\n'), ((6154, 6213), 'p... |
# 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 ... | [
"megengine._internal.dtype.is_quantize",
"megengine._internal.dtype.is_bfloat16",
"megengine.zeros",
"megengine.get_logger"
] | [((741, 765), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (755, 765), True, 'import megengine as mge\n'), ((1434, 1462), 'numpy.prod', 'np.prod', (['output[0].shape[2:]'], {}), '(output[0].shape[2:])\n', (1441, 1462), True, 'import numpy as np\n'), ((1722, 1749), 'numpy.prod', 'np.prod... |
# 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 ... | [
"megengine.distributed.helper.get_device_count_by_fork",
"megengine.jit.trace",
"megengine.Tensor",
"megengine.tensor",
"megengine.module.Linear",
"megengine.distributed.get_rank",
"megengine.autodiff.GradManager",
"megengine.Parameter",
"megengine.functional.matmul",
"megengine.distributed.functi... | [((905, 921), 'megengine.tensor', 'mge.tensor', (['(-1.0)'], {}), '(-1.0)\n', (915, 921), True, 'import megengine as mge\n'), ((986, 1000), 'megengine.functional.matmul', 'F.matmul', (['x', 'w'], {}), '(x, w)\n', (994, 1000), True, 'import megengine.functional as F\n'), ((1454, 1474), 'megengine.Parameter', 'mge.Parame... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.module as M
import pytest
from basecls.models.regnet import RegBottleneckBlock
from basecls.models.resnet import (
AnyStage,
ResBasicBlock,
ResBottleneckBlock,
ResDeepStem,
Res... | [
"megengine.random.normal"
] | [((347, 440), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""Block"""', '[RegBottleneckBlock, ResBasicBlock, ResBottleneckBlock]'], {}), "('Block', [RegBottleneckBlock, ResBasicBlock,\n ResBottleneckBlock])\n", (370, 440), False, 'import pytest\n'), ((438, 475), 'pytest.mark.parametrize', 'pytest.mark.p... |
# 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 ... | [
"megengine.functional.round",
"megengine.functional.maximum",
"megengine.tensor",
"megengine.autodiff.GradManager",
"megengine.Parameter",
"megengine.functional.exp"
] | [((4180, 4189), 'megengine.tensor', 'tensor', (['c'], {}), '(c)\n', (4186, 4189), False, 'from megengine import tensor\n'), ((7147, 7180), 'numpy.array', 'np.array', (['[1.0]'], {'dtype': 'np.float32'}), '([1.0], dtype=np.float32)\n', (7155, 7180), True, 'import numpy as np\n'), ((7197, 7230), 'numpy.array', 'np.array'... |
import megengine as mge
import megengine.functional as F
from megengine import tensor
import numpy as np
from megengine.functional.nn import nms
from config import config
from det_opr.bbox_opr import bbox_transform_inv_opr, clip_boxes_opr, \
filter_boxes_opr, box_overlap_opr
# from bbox_opr import box_overlap_opr
i... | [
"megengine.functional.nn.nms",
"megengine.functional.prod",
"megengine.functional.minimum",
"megengine.functional.argsort",
"megengine.tensor",
"megengine.functional.cond_take",
"megengine.functional.concat",
"megengine.functional.ones",
"megengine.functional.softmax"
] | [((2223, 2261), 'megengine.functional.concat', 'F.concat', (['batch_proposals_list'], {'axis': '(0)'}), '(batch_proposals_list, axis=0)\n', (2231, 2261), True, 'import megengine.functional as F\n'), ((2284, 2318), 'megengine.functional.concat', 'F.concat', (['batch_probs_list'], {'axis': '(0)'}), '(batch_probs_list, ax... |
# 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 ... | [
"megengine.tensor"
] | [((2960, 3025), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', "['normal', 'group', 'transpose']"], {}), "('mode', ['normal', 'group', 'transpose'])\n", (2983, 3025), False, 'import pytest\n'), ((4527, 4573), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', '[True, False]'], ... |
import numpy as np
import pytest
import megengine.functional as F
from megengine import tensor
from megengine.test import assertTensorClose
def test_onehot_low_dimension():
inp = tensor(np.arange(1, 4, dtype=np.int32))
out = F.one_hot(inp)
assertTensorClose(
out.numpy(), np.eye(4, dtype=np.int32... | [
"megengine.functional.one_hot",
"megengine.tensor"
] | [((236, 250), 'megengine.functional.one_hot', 'F.one_hot', (['inp'], {}), '(inp)\n', (245, 250), True, 'import megengine.functional as F\n'), ((407, 501), 'numpy.array', 'np.array', (['[[3, 2, 4, 4, 2, 4, 0, 4, 4, 1], [4, 1, 1, 3, 2, 2, 4, 2, 4, 3]]'], {'dtype': 'np.int32'}), '([[3, 2, 4, 4, 2, 4, 0, 4, 4, 1], [4, 1, 1... |
# -*- 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 ARRANTI... | [
"megengine.hub.load"
] | [((1489, 1554), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', "['normal', 'group', 'transpose']"], {}), "('mode', ['normal', 'group', 'transpose'])\n", (1512, 1554), False, 'import pytest\n'), ((2238, 2285), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', "['max', 'avg']"],... |
import megengine as mge
import megengine.functional as F
import numpy as np
def bilinear_sampler(img, coords, mode="bilinear", mask=False):
"""Wrapper for grid_sample, uses pixel coordinates"""
H, W = img.shape[-2:]
img = F.remap(img, coords, border_mode="constant")
if mask:
mask = (
... | [
"megengine.functional.remap",
"megengine.functional.stack",
"megengine.tensor",
"megengine.functional.expand_dims",
"megengine.functional.concat",
"megengine.functional.repeat",
"megengine.functional.logical_not"
] | [((237, 281), 'megengine.functional.remap', 'F.remap', (['img', 'coords'], {'border_mode': '"""constant"""'}), "(img, coords, border_mode='constant')\n", (244, 281), True, 'import megengine.functional as F\n'), ((805, 838), 'megengine.functional.stack', 'F.stack', (['[x_grid, y_grid]'], {'axis': '(0)'}), '([x_grid, y_g... |
# -*- 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 ARRANTI... | [
"megengine.data.sampler.RandomSampler",
"megengine.data.dataset.ArrayDataset",
"megengine.data.dataloader.DataLoader",
"megengine.data.sampler.StreamSampler",
"megengine.data.transform.Normalize",
"megengine.data.transform.ToMode"
] | [((2861, 2908), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""batch"""', '[True, False]'], {}), "('batch', [True, False])\n", (2884, 2908), False, 'import pytest\n'), ((2910, 2956), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""num_workers"""', '[0, 2]'], {}), "('num_workers', [0, 2])\n", (2... |
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.core.tensor import dtype
from megengine.quantization import min_max_fakequant_qconfig
from megengine.quanti... | [
"megengine.functional.round",
"megengine.module.quantized.Linear.from_qat_module",
"megengine.module.qat.Elemwise.from_float_module",
"megengine.module.qat.DequantStub.from_float_module",
"megengine.module.QuantStub",
"megengine.quantization.quantize.propagate_qconfig",
"megengine.module.Elemwise",
"m... | [((3223, 3302), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""kind"""', "['COS', 'RELU', 'ADD', 'MUL', 'FUSE_ADD_RELU']"], {}), "('kind', ['COS', 'RELU', 'ADD', 'MUL', 'FUSE_ADD_RELU'])\n", (3246, 3302), False, 'import pytest\n'), ((6367, 6440), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""... |
# Copyright (c) Megvii, Inc. and its affiliates.
"""do the evaluation work with single gpu
"""
import argparse
import os
import megengine as mge
import megengine.data as data
import megengine.data.transform as T
import megengine.functional as F
import numpy as np
from tqdm.auto import tqdm
from recognition.datasets ... | [
"megengine.functional.normalize",
"megengine.data.DataLoader",
"megengine.load",
"megengine.tensor",
"megengine.data.SequentialSampler",
"megengine.get_logger",
"megengine.set_log_file",
"megengine.data.transform.Normalize",
"megengine.data.transform.ToMode"
] | [((464, 488), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (478, 488), True, 'import megengine as mge\n'), ((967, 996), 'recognition.models.FaceRecognitionModel', 'FaceRecognitionModel', (['configs'], {}), '(configs)\n', (987, 996), False, 'from recognition.models import FaceRecognition... |
# -*- 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 ARRANTI... | [
"megengine.jit.trace",
"megengine.module.external.ExternOprSubgraph"
] | [((666, 774), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""load a .pb model and convert to corresponding load-and-run model"""'}), "(description=\n 'load a .pb model and convert to corresponding load-and-run model')\n", (689, 774), False, 'import argparse\n'), ((1185, 1197), 'yaml.l... |
import os
import sys
import time
import logging
from collections import namedtuple
import megengine as mge
import megengine.distributed as dist
import megengine.functional as F
import megengine.autodiff as autodiff
import megengine.optimizer as optim
import yaml
from tensorboardX import SummaryWriter
from nets impor... | [
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.data.DataLoader",
"megengine.get_device_count",
"megengine.load",
"megengine.functional.abs",
"megengine.tensor",
"megengine.functional.concat",
"megengine.amp.GradScaler",
"megengine.distributed.make_allreduce_cb... | [((2048, 2074), 'megengine.random.seed', 'mge.random.seed', (['args.seed'], {}), '(args.seed)\n', (2063, 2074), True, 'import megengine as mge\n'), ((2141, 2157), 'megengine.dtr.enable', 'mge.dtr.enable', ([], {}), '()\n', (2155, 2157), True, 'import megengine as mge\n'), ((2261, 2297), 'os.path.join', 'os.path.join', ... |
# -*- 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 ARRANTI... | [
"megengine._internal.opr.cond_take",
"megengine._internal.opr.dimshuffle",
"megengine._internal.opr.add_axis",
"megengine._internal.opr.remove_axis",
"megengine._internal.opr.set_advanced_indexing",
"megengine._internal.opr.reshape",
"megengine._internal.opr.broadcast",
"megengine._internal.opr.linspa... | [((1563, 1592), 'megengine._internal.opr.broadcast', 'mgb.opr.broadcast', (['inp', 'shape'], {}), '(inp, shape)\n', (1580, 1592), True, 'import megengine._internal as mgb\n'), ((10424, 10499), 'megengine._internal.opr.cond_take', 'mgb.opr.cond_take', (['x', 'mask'], {'mode': 'mgb.opr_param_defs.CondTake.Mode.EQ', 'val'... |
from collections import OrderedDict
import numpy as np
import megengine.functional as F
import megengine.module as M
from megengine import Tensor
from megengine.core._imperative_rt.core2 import apply
from megengine.core.ops import builtin
from megengine.module import Module
from megengine.traced_module import TracedM... | [
"megengine.traced_module.enable_expr_checker",
"megengine.Tensor",
"megengine.module.Elemwise",
"megengine.core.ops.builtin.Elemwise",
"megengine.traced_module.trace_module"
] | [((1514, 1535), 'megengine.traced_module.enable_expr_checker', 'enable_expr_checker', ([], {}), '()\n', (1533, 1535), False, 'from megengine.traced_module import TracedModule, enable_expr_checker, trace_module\n'), ((1544, 1553), 'megengine.Tensor', 'Tensor', (['(1)'], {}), '(1)\n', (1550, 1553), False, 'from megengine... |
# -*- 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 ARRANTI... | [
"megengine._internal.opr.elem.exp",
"megengine._internal.opr.pooling",
"megengine._internal.opr.add_axis",
"megengine._internal.opr.assert_equal",
"megengine._internal.opr.elemwise",
"megengine._internal.opr.reshape",
"megengine._internal.opr.indexing_one_hot",
"megengine._internal.opr.batch_norm",
... | [((1169, 1217), 'megengine._internal.opr.matrix_mul', 'mgb.opr.matrix_mul', (['inp', 'weight'], {'transposeB': '(True)'}), '(inp, weight, transposeB=True)\n', (1187, 1217), True, 'import megengine._internal as mgb\n'), ((7082, 7204), 'megengine._internal.opr.pooling', 'mgb.opr.pooling', (['inp'], {'mode': 'mode', 'form... |
# 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 ... | [
"megengine.quantization.quantize.quantize_qat",
"megengine.module.Elemwise",
"megengine.traced_module.fake_quant.FakeQuantize",
"megengine.tensor",
"megengine.quantization.utils.create_qparams",
"megengine.core.tensor.dtype.get_scale",
"megengine.module.quant_dequant.QuantStub",
"megengine.core.tensor... | [((1132, 1149), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['net'], {}), '(net)\n', (1144, 1149), False, 'from megengine.quantization.quantize import quantize_qat\n'), ((2064, 2081), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['net'], {}), '(net)\n', (2076, 2081), False, 'fro... |
import numpy as np
import megengine as mge
import megengine.autodiff as ad
import megengine.optimizer as optimizer
from megengine import Parameter, tensor
from megengine.core.tensor.raw_tensor import RawTensor
from megengine.module import Module
class Simple(Module):
def __init__(self):
super().__init__(... | [
"megengine.get_default_device",
"megengine.load",
"megengine.tensor",
"megengine.set_default_device",
"megengine.autodiff.GradManager",
"megengine.Parameter"
] | [((636, 650), 'megengine.tensor', 'tensor', (['[2.34]'], {}), '([2.34])\n', (642, 650), False, 'from megengine import Parameter, tensor\n'), ((1031, 1072), 'megengine.load', 'mge.load', (['model_name'], {'map_location': '"""cpu0"""'}), "(model_name, map_location='cpu0')\n", (1039, 1072), True, 'import megengine as mge\... |
# -*- 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 ARRANTI... | [
"megengine.core._imperative_rt.core2._set_swap_flag",
"megengine.core._imperative_rt.core2.set_option",
"megengine.Tensor",
"megengine.module.Linear",
"megengine.functional.nn.cross_entropy",
"megengine.core._imperative_rt.core2._set_drop_flag",
"megengine.autodiff.GradManager",
"megengine.functional.... | [((2431, 2451), 'megengine.core._imperative_rt.core2._set_swap_flag', '_set_swap_flag', (['(True)'], {}), '(True)\n', (2445, 2451), False, 'from megengine.core._imperative_rt.core2 import _set_drop_flag, _set_swap_flag, get_option, set_option\n'), ((2456, 2476), 'megengine.core._imperative_rt.core2._set_drop_flag', '_s... |
# -*- 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 ARRANTIE... | [
"megengine.functional.zeros",
"megengine.functional.topk",
"megengine.random.uniform",
"megengine.functional.zeros_like"
] | [((1015, 1038), 'megengine.random.uniform', 'uniform', ([], {'size': 'num_class'}), '(size=num_class)\n', (1022, 1038), False, 'from megengine.random import uniform\n'), ((1060, 1106), 'megengine.functional.topk', 'F.topk', (['topk_tensor'], {'k': '(num_samples - num_class)'}), '(topk_tensor, k=num_samples - num_class)... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import os
from typing import Iterable, Union
from megengine import Parameter, tensor
from megengine.functional.inplace import _inplace_add_
from megengine.optimizer import Optimizer
class SGD(Optimizer):
r"""Implements stochastic g... | [
"megengine.tensor",
"megengine.functional.inplace._inplace_add_"
] | [((2154, 2164), 'megengine.tensor', 'tensor', (['lr'], {}), '(lr)\n', (2160, 2164), False, 'from megengine import Parameter, tensor\n'), ((2189, 2209), 'megengine.tensor', 'tensor', (['weight_decay'], {}), '(weight_decay)\n', (2195, 2209), False, 'from megengine import Parameter, tensor\n'), ((2230, 2246), 'megengine.t... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
from collections import namedtuple
from typing import Iterable, Union
import megengine as mge
import megengine.distributed as dist
import megengine.module as M
import megengine.optimizer as optim
from basecore.config import ConfigDict
fr... | [
"megengine.optimizer.SGD",
"megengine.optimizer.Adam",
"megengine.amp.GradScaler",
"megengine.optimizer.AdamW",
"megengine.autodiff.GradManager",
"megengine.distributed.make_allreduce_cb",
"megengine.distributed.get_world_size"
] | [((649, 715), 'collections.namedtuple', 'namedtuple', (['"""Solver"""', "['optimizer', 'grad_manager', 'grad_scaler']"], {}), "('Solver', ['optimizer', 'grad_manager', 'grad_scaler'])\n", (659, 715), False, 'from collections import namedtuple\n'), ((1267, 1295), 'basecls.utils.registers.solvers.register', 'registers.so... |
# -*- 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 ARRANTI... | [
"megengine.jit.trace",
"megengine.functional.add_update",
"megengine.functional.conv2d",
"megengine.tensor",
"megengine.functional.flatten",
"megengine.functional.concat",
"megengine._internal.dtype.convert_to_qint32",
"megengine._internal.dtype.convert_to_qint8",
"megengine._internal.dtype.qint8",
... | [((1047, 1096), 'helpers.opr_test', 'opr_test', (['cases', 'F.flatten'], {'compare_fn': 'compare_fn'}), '(cases, F.flatten, compare_fn=compare_fn)\n', (1055, 1096), False, 'from helpers import opr_test\n'), ((1247, 1310), 'helpers.opr_test', 'opr_test', (['cases', 'F.flatten'], {'compare_fn': 'compare_fn', 'start_axis'... |
# -*- 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 ARRANTI... | [
"megengine.functional.arange",
"megengine.functional.tile",
"megengine.Tensor",
"megengine.functional.stack",
"megengine.functional.vision.remap",
"megengine.functional.mean",
"megengine.functional.transpose",
"megengine.functional.vision.interpolate",
"megengine.functional.sum"
] | [((3019, 3038), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (3036, 3038), False, 'import logging\n'), ((3078, 3171), 'coloredlogs.install', 'coloredlogs.install', ([], {'level': '"""INFO"""', 'logger': 'logger', 'fmt': '"""%(asctime)s %(name)s %(message)s"""'}), "(level='INFO', logger=logger, fmt=\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.ji... | [
"megengine.core.ops.builtin.GetVarShape",
"megengine.core.tensor.utils.subgraph_fn",
"megengine.device.CompNode",
"megengine.jit.trace",
"megengine.device.get_default_device",
"megengine.core.ops.builtin.Reduce",
"megengine.tensor",
"megengine.core.ops.builtin.TypeCvt",
"megengine.autodiff.grad_mana... | [((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'}), '(ma... |
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
import megengine.optimizer as optim
class AdaptiveAvgPool2d(M.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return F.mean(F.mean(x, axis=-2, keepdims=True), axis=-1... | [
"megengine.module.Sigmoid",
"megengine.module.ReLU",
"megengine.functional.mean",
"megengine.functional.max",
"megengine.module.Conv2d"
] | [((933, 944), 'megengine.module.Sigmoid', 'M.Sigmoid', ([], {}), '()\n', (942, 944), True, 'import megengine.module as M\n'), ((1239, 1289), 'megengine.module.Conv2d', 'M.Conv2d', (['(2)', '(1)', 'kernel_size'], {'padding': '(1)', 'bias': '(False)'}), '(2, 1, kernel_size, padding=1, bias=False)\n', (1247, 1289), True, ... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
from typing import Callable, Union
import megengine as mge
import megengine.functional as F
import megengine.module as M
from .activations import activation
__all__ = ["conv2d", "norm2d", "pool2d", "gap2d", "linear", "SE", "DropPath"]
... | [
"megengine.module.AdaptiveAvgPool2d",
"megengine.module.Identity",
"megengine.module.Sigmoid",
"megengine.module.Linear",
"megengine.functional.dropout",
"megengine.functional.ones",
"megengine.module.Conv2d"
] | [((1058, 1133), 'megengine.module.Conv2d', 'M.Conv2d', (['w_in', 'w_out', 'k'], {'stride': 's', 'padding': 'p', 'dilation': 'd', 'groups': 'g', 'bias': 'b'}), '(w_in, w_out, k, stride=s, padding=p, dilation=d, groups=g, bias=b)\n', (1066, 1133), True, 'import megengine.module as M\n'), ((2780, 2806), 'megengine.module.... |
#! /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 ARRANTI... | [
"megengine.utils.module_stats.sizeof_fmt",
"megengine.utils.tensorboard.SummaryWriterExtend"
] | [((6623, 6642), 'os.walk', 'os.walk', (['args.input'], {}), '(args.input)\n', (6630, 6642), False, 'import os\n'), ((7413, 7577), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""convert json dumped by c to logs which can be read by python tensorboard"""'], {'formatter_class': 'argparse.ArgumentDefaultsHelpF... |
# -*- 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 ARRANTI... | [
"megengine.data.transform.RandomResize",
"megengine.jit.trace",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.distributed.init_process_group",
"megengine.load",
"megengine.data.dataset.Cityscapes",
"megengine.get_logger",
"megengine.data.transform.Normalize",
"megengine.data.transform.... | [((872, 896), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (886, 896), True, 'import megengine as mge\n'), ((924, 949), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (947, 949), False, 'import argparse\n'), ((1986, 2022), 'official.vision.segmentation.utils.imp... |
# -*- 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 ARRANTI... | [
"megengine.load",
"megengine.functional.grad",
"megengine.core.TensorDict",
"megengine.core.tensor"
] | [((7391, 7420), 'helpers.graph_mode', 'graph_mode', (['"""eager"""', '"""static"""'], {}), "('eager', 'static')\n", (7401, 7420), False, 'from helpers import MLP, graph_mode\n'), ((829, 837), 'megengine.core.tensor', 'tensor', ([], {}), '()\n', (835, 837), False, 'from megengine.core import TensorDict, tensor\n'), ((85... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine.functional as F
import megengine.module as M
from .darknet import Darknet
from .network_blocks import BaseConv, UpSample
class YOLOFPN(M.Module):
"""
YOLOFPN module. Darknet 53 is the ... | [
"megengine.functional.concat"
] | [((1916, 1940), 'megengine.functional.concat', 'F.concat', (['[x1_in, x1]', '(1)'], {}), '([x1_in, x1], 1)\n', (1924, 1940), True, 'import megengine.functional as F\n'), ((2098, 2122), 'megengine.functional.concat', 'F.concat', (['[x2_in, x2]', '(1)'], {}), '([x2_in, x2], 1)\n', (2106, 2122), True, 'import megengine.fu... |
# -*- 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 ARRANTI... | [
"megengine.jit.trace",
"megengine.distributed.get_rank",
"megengine.quantization.enable_fake_quant",
"megengine.tensor",
"megengine.functional.nn.cross_entropy",
"megengine.quantization.enable_observer",
"megengine.quantization.quantize_qat",
"megengine.jit.SublinearMemoryConfig",
"megengine.optimiz... | [((908, 937), 'megengine.logger.get_logger', 'megengine.logger.get_logger', ([], {}), '()\n', (935, 937), False, 'import megengine\n'), ((1301, 1360), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""shufflenet benchmark"""'}), "(description='shufflenet benchmark')\n", (1324, 1360), False,... |
import os.path as osp
from abc import ABCMeta, abstractmethod
import megengine as mge
import megengine.distributed as dist
from megengine.optimizer.optimizer import Optimizer
from megengine.module import Module
from edit.utils import mkdir_or_exist, build_from_cfg, get_root_logger
from ..hook import Hook, HOOKS, get_pr... | [
"megengine.distributed.is_distributed",
"megengine.distributed.get_rank"
] | [((1254, 1271), 'edit.utils.get_root_logger', 'get_root_logger', ([], {}), '()\n', (1269, 1271), False, 'from edit.utils import mkdir_or_exist, build_from_cfg, get_root_logger\n'), ((3305, 3326), 'megengine.distributed.is_distributed', 'dist.is_distributed', ([], {}), '()\n', (3324, 3326), True, 'import megengine.distr... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
"""VGG Series
VGG: `"Very Deep Convolutional Networks for Large-Scale Image Recognition"
<https://arxiv.org/abs/1409.1556>`_
"""
from typing import Any, Mapping, Sequence
import megengine as mge
import megengine.hub as hub
import megeng... | [
"megengine.module.MaxPool2d",
"megengine.hub.pretrained"
] | [((1300, 1327), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (1325, 1327), False, 'from basecls.utils import recursive_update, registers\n'), ((2727, 2754), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (2752, 2754), False, 'from b... |
# -*- 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 ARRANTI... | [
"megengine.core.tensor.megbrain_graph.InputNode",
"megengine.utils.comp_graph_tools.get_owner_opr_type",
"megengine.utils.comp_graph_tools.get_dep_vars",
"megengine.utils.comp_graph_tools.get_opr_type",
"megengine.core.tensor.megbrain_graph.load_graph",
"megengine.utils.comp_graph_tools.replace_vars",
"... | [((1102, 1123), 'megengine.get_logger', 'mge_get_logger', (['*args'], {}), '(*args)\n', (1116, 1123), True, 'from megengine import get_logger as mge_get_logger\n'), ((2222, 2251), 'megengine.utils.comp_graph_tools.get_dep_vars', 'cgtools.get_dep_vars', (['x', 'type'], {}), '(x, type)\n', (2242, 2251), True, 'import meg... |
# -*- 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 ARRANTI... | [
"megengine.module.BatchNorm2d",
"megengine.module.BatchNorm1d",
"megengine.core.tensor"
] | [((669, 708), 'megengine.module.BatchNorm1d', 'BatchNorm1d', (['nr_chan'], {'momentum': 'momentum'}), '(nr_chan, momentum=momentum)\n', (680, 708), False, 'from megengine.module import BatchNorm1d, BatchNorm2d\n'), ((728, 771), 'numpy.zeros', 'np.zeros', (['(1, nr_chan, 1)'], {'dtype': 'np.float32'}), '((1, nr_chan, 1)... |
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import megengine as mge
import megengine.module as M
from models.yolo_fpn import YOLOFPN
from models.yolo_head import YOLOXHead
from models.yolo_pafpn import YOLOPAFPN
from models.yolox import YOLOX
def build_yolox(name="yolox-s"):
num_classes = 80
# value mean... | [
"megengine.load"
] | [((1412, 1433), 'megengine.load', 'mge.load', (['weight_file'], {}), '(weight_file)\n', (1420, 1433), True, 'import megengine as mge\n'), ((650, 659), 'models.yolo_fpn.YOLOFPN', 'YOLOFPN', ([], {}), '()\n', (657, 659), False, 'from models.yolo_fpn import YOLOFPN\n'), ((675, 746), 'models.yolo_head.YOLOXHead', 'YOLOXHea... |
import numpy as np
import argparse
from datetime import datetime
import time
import model as resnet_model
import megengine as mge
import megengine.autodiff as ad
import megengine.functional as F
import megengine.optimizer as optim
parser = argparse.ArgumentParser(description="MegEngine ResNet Training")
parser.add_a... | [
"megengine.functional.nn.cross_entropy",
"megengine.get_mem_status_bytes",
"megengine.utils.dtr.DTR",
"megengine.autodiff.GradManager"
] | [((243, 307), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""MegEngine ResNet Training"""'}), "(description='MegEngine ResNet Training')\n", (266, 307), False, 'import argparse\n'), ((1079, 1125), 'megengine.utils.dtr.DTR', 'DTR', ([], {'memory_budget': '(args.mem_budget * 1024 ** 3)'}),... |
import numpy as np
import megengine.functional as F
import megengine.module as M
from config import config
from .anchors_generator import AnchorGenerator
from .find_top_rpn_proposals import find_top_rpn_proposals
from .fpn_anchor_target import fpn_anchor_target, fpn_rpn_reshape
from det_opr.loss_opr import softmax_loss... | [
"megengine.module.init.fill_",
"megengine.module.init.normal_",
"megengine.module.Conv2d"
] | [((640, 702), 'megengine.module.Conv2d', 'M.Conv2d', (['(256)', 'rpn_channel'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(256, rpn_channel, kernel_size=3, stride=1, padding=1)\n', (648, 702), True, 'import megengine.module as M\n'), ((732, 807), 'megengine.module.Conv2d', 'M.Conv2d', (['rpn_channel'... |
# -*- 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 ARRANTI... | [
"megengine.test.assertTensorClose",
"megengine.graph.compile",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.module.Linear",
"megengine.module.init.zeros_",
"megengine.functional.cross_entropy_with_softmax",
"megengine.functional.relu"
] | [((3348, 3387), 'megengine.functional.cross_entropy_with_softmax', 'cross_entropy_with_softmax', (['pred', 'label'], {}), '(pred, label)\n', (3374, 3387), False, 'from megengine.functional import cross_entropy_with_softmax, relu\n'), ((3448, 3478), 'megengine.graph.compile', 'mge.graph.compile', (['loss', 'grads'], {})... |
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) Megvii, Inc. and its affiliates.
import argparse
import megengine as mge
import numpy as np
from megengine import jit
from ..build import build_and_load
def make_parser():
parser = argparse.ArgumentParser("YOLOX Demo Dump")
parser.add_argument("... | [
"megengine.jit.trace"
] | [((252, 294), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""YOLOX Demo Dump"""'], {}), "('YOLOX Demo Dump')\n", (275, 294), False, 'import argparse\n'), ((780, 812), 'megengine.jit.trace', 'jit.trace', ([], {'capture_as_const': '(True)'}), '(capture_as_const=True)\n', (789, 812), False, 'from megengine im... |
# -*- 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 ARRANTI... | [
"megengine.jit.trace",
"megengine.core.graph.get_default_graph",
"megengine.distributed.init_process_group",
"megengine.functional.cross_entropy_with_softmax",
"megengine._internal.plugin.CompGraphProfiler",
"megengine.functional.debug_param.set_conv_execution_strategy"
] | [((1128, 1147), 'megengine.core.graph.get_default_graph', 'get_default_graph', ([], {}), '()\n', (1145, 1147), False, 'from megengine.core.graph import get_default_graph\n'), ((1165, 1194), 'megengine._internal.plugin.CompGraphProfiler', 'CompGraphProfiler', (['comp_graph'], {}), '(comp_graph)\n', (1182, 1194), False, ... |
# 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 ... | [
"megengine._internal.dtype.qint32",
"megengine._internal.dtype.get_scale"
] | [((958, 988), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['inp.dtype'], {}), '(inp.dtype)\n', (977, 988), True, 'import megengine._internal as mgb\n'), ((1007, 1045), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['self.weight.dtype'], {}), '(self.weight.dtype)\n', (1026, 1045), Tru... |
import os
import math
import argparse
from multiprocessing import Process, Queue
from tqdm import tqdm
import numpy as np
import megengine as mge
from megengine import jit
from config import config
import network
import dataset
import misc_utils
if_set_nms = True
def eval_all(args):
# model_path
saveDir = c... | [
"megengine.jit.trace",
"megengine.load"
] | [((370, 400), 'misc_utils.ensure_dir', 'misc_utils.ensure_dir', (['evalDir'], {}), '(evalDir)\n', (391, 400), False, 'import misc_utils\n'), ((508, 534), 'os.path.exists', 'os.path.exists', (['model_file'], {}), '(model_file)\n', (522, 534), False, 'import os\n'), ((565, 611), 'misc_utils.load_json_lines', 'misc_utils.... |
import megengine as mge
import megengine.module as M
import pytest
from basecls.models.snet import SNV2Block, SNV2XceptionBlock
@pytest.mark.parametrize("w_in", [32, 48])
@pytest.mark.parametrize("w_out", [64])
@pytest.mark.parametrize("w_mid", [32, 24])
@pytest.mark.parametrize("stride", [1, 2])
@pytest.mark.parame... | [
"megengine.random.normal"
] | [((132, 173), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[32, 48]'], {}), "('w_in', [32, 48])\n", (155, 173), False, 'import pytest\n'), ((175, 213), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[64]'], {}), "('w_out', [64])\n", (198, 213), False, 'import pytest\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
import torch
import torch.nn as nn
from basecls.configs import BaseConfig
from basecls.layers import BinaryCrossEntropy, CrossEntropy, build_loss
@py... | [
"megengine.Tensor"
] | [((318, 407), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""name"""', "[CrossEntropy, 'BinaryCrossEntropy', 'CrossEntropy']"], {}), "('name', [CrossEntropy, 'BinaryCrossEntropy',\n 'CrossEntropy'])\n", (341, 407), False, 'import pytest\n'), ((483, 498), 'basecls.layers.build_loss', 'build_loss', (['cfg... |
import io
import numpy as np
import megengine.core.tensor.megbrain_graph as G
import megengine.utils.comp_graph_tools as cgtools
from megengine import tensor
from megengine.jit import trace
from megengine.utils.network_node import VarNode
def _default_compare_fn(x, y):
if isinstance(x, np.ndarray):
np.t... | [
"megengine.jit.trace",
"megengine.tensor",
"megengine.utils.comp_graph_tools.GraphInference",
"megengine.utils.network_node.VarNode"
] | [((316, 360), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['x', 'y'], {'rtol': '(1e-06)'}), '(x, y, rtol=1e-06)\n', (342, 360), True, 'import numpy as np\n'), ((653, 677), 'megengine.tensor', 'tensor', (['x'], {'device': 'device'}), '(x, device=device)\n', (659, 677), False, 'from megengine import t... |
import numpy as np
import megengine
import megengine.module as M
import megengine.functional as F
from edit.models.common import ShuffleV2Block, CoordAtt
import math
from . import default_init_weights
class MobileNeXt(M.Module):
def __init__(self, in_channels, out_channels, kernel_size=3):
"""
... | [
"megengine.module.ConvRelu2d",
"megengine.module.Sequential",
"megengine.module.Conv2d"
] | [((515, 639), 'megengine.module.ConvRelu2d', 'M.ConvRelu2d', (['in_channels', 'out_channels'], {'kernel_size': 'kernel_size', 'stride': '(1)', 'padding': '(kernel_size // 2)', 'groups': 'in_channels'}), '(in_channels, out_channels, kernel_size=kernel_size, stride=1,\n padding=kernel_size // 2, groups=in_channels)\n'... |
import megengine as mge
import megengine.functional as F
from megengine.core import tensor
from layers.nms import gpu_nms
from config import config
from det_opr.bbox_opr import bbox_transform_inv_opr, clip_boxes_opr, \
filter_boxes_opr
def find_top_rpn_proposals(is_train, rpn_bbox_offsets_list, rpn_cls_prob_list,... | [
"megengine.functional.argsort",
"megengine.functional.concat",
"megengine.functional.softmax",
"megengine.core.tensor"
] | [((2080, 2118), 'megengine.functional.concat', 'F.concat', (['batch_proposals_list'], {'axis': '(0)'}), '(batch_proposals_list, axis=0)\n', (2088, 2118), True, 'import megengine.functional as F\n'), ((2141, 2175), 'megengine.functional.concat', 'F.concat', (['batch_probs_list'], {'axis': '(0)'}), '(batch_probs_list, ax... |
import os, sys
import numpy as np
from config import config
from det_opr.bbox_opr import box_overlap_opr, bbox_transform_opr
import megengine as mge
from megengine import functional as F
import pdb
def _compute_center(boxes):
ptrx = 0.5 * (boxes[:, 0] + boxes[:, 2])
ptry = 0.5 * (boxes[:, 1] + boxes[:, 3])
... | [
"megengine.functional.zeros",
"megengine.functional.gather",
"megengine.functional.minimum",
"megengine.functional.mean",
"megengine.functional.abs",
"megengine.functional.stack",
"megengine.functional.std",
"megengine.functional.maximum",
"megengine.functional.argsort",
"megengine.functional.cond... | [((330, 359), 'megengine.functional.stack', 'F.stack', (['[ptrx, ptry]'], {'axis': '(1)'}), '([ptrx, ptry], axis=1)\n', (337, 359), True, 'from megengine import functional as F\n'), ((687, 716), 'megengine.functional.stack', 'F.stack', (['[l, t, r, b]'], {'axis': '(1)'}), '([l, t, r, b], axis=1)\n', (694, 716), True, '... |
import os
import time
from megengine.distributed.group import is_distributed
import megengine.distributed as dist
from megengine.data.dataloader import DataLoader
from edit.core.hook import Hook
from edit.utils import to_list, is_list_of, get_logger, mkdir_or_exist
class EvalIterHook(Hook):
"""evaluation hook by ... | [
"megengine.distributed.group.is_distributed",
"megengine.distributed.get_rank",
"megengine.distributed.group_barrier",
"megengine.distributed.get_world_size"
] | [((1392, 1422), 'edit.utils.mkdir_or_exist', 'mkdir_or_exist', (['self.save_path'], {}), '(self.save_path)\n', (1406, 1422), False, 'from edit.utils import to_list, is_list_of, get_logger, mkdir_or_exist\n'), ((1445, 1500), 'edit.utils.get_logger', 'get_logger', ([], {'name': '"""EvalIterHook"""', 'log_file': 'self.log... |
# -*- 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 ARRANTI... | [
"megengine.jit.trace",
"megengine.tensor",
"megengine.functional.sort"
] | [((3460, 3519), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""is_symbolic"""', '[None, False, True]'], {}), "('is_symbolic', [None, False, True])\n", (3483, 3519), False, 'import pytest\n'), ((6105, 6157), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""descending"""', '[True, False]'], {}), "... |
# -*- 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 ARRANTI... | [
"megengine.jit.trace",
"megengine.distributed.init_process_group",
"megengine.distributed.is_distributed",
"megengine.functional.cross_entropy_with_softmax",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.data.transform.CenterCrop",
"megengine.get_device_count",
... | [((909, 933), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (923, 933), True, 'import megengine as mge\n'), ((961, 986), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (984, 986), False, 'import argparse\n'), ((3464, 3488), 'megengine.jit.trace', 'jit.trace', ([]... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import argparse
import importlib
import json
import multiprocessing as mp
import os
import pathlib
import sys
import megengine as mge
import megengine.distributed as dist
from basecore.config import ConfigDict
from loguru import logger
... | [
"megengine.distributed.get_rank",
"megengine.device.get_device_count",
"megengine.functional.debug_param.set_execution_strategy",
"megengine.distributed.launcher"
] | [((659, 684), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (682, 684), False, 'import argparse\n'), ((1017, 1042), 'os.path.abspath', 'os.path.abspath', (['args.dir'], {}), '(args.dir)\n', (1032, 1042), False, 'import os\n'), ((1047, 1105), 'basecls.utils.setup_logger', 'setup_logger', (['arg... |
import logging
import os
import pickle
import numpy as np
import h5py
from megengine.data import DataLoader
from megengine.data.dataset import Dataset
from megengine.data.sampler import RandomSampler, SequentialSampler
import megengine.distributed as dist
from dataset.transformations import fetch_transform
from comm... | [
"megengine.data.DataLoader",
"megengine.data.sampler.RandomSampler",
"megengine.data.sampler.SequentialSampler",
"megengine.distributed.get_rank"
] | [((347, 374), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (364, 374), False, 'import logging\n'), ((3269, 3292), 'dataset.transformations.fetch_transform', 'fetch_transform', (['params'], {}), '(params)\n', (3284, 3292), False, 'from dataset.transformations import fetch_transform\n'), ... |
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
from config import config
from backbone.resnet50 import ResNet50
from module.rpn import RPN
from layers.roi_pool import roi_pool
from det_opr.bbox_opr import bbox_transform_inv_opr, restore_bbox
from det_opr.fpn_roi... | [
"megengine.module.ReLU",
"megengine.functional.softmax",
"megengine.functional.flatten",
"megengine.functional.stack",
"megengine.tensor",
"megengine.module.init.msra_normal_",
"megengine.functional.max_pool2d",
"megengine.functional.concat",
"megengine.module.init.normal_",
"megengine.module.init... | [((656, 666), 'backbone.resnet50.ResNet50', 'ResNet50', ([], {}), '()\n', (664, 666), False, 'from backbone.resnet50 import ResNet50\n'), ((1312, 1335), 'module.rpn.RPN', 'RPN', (['config.rpn_channel'], {}), '(config.rpn_channel)\n', (1315, 1335), False, 'from module.rpn import RPN\n'), ((2306, 2342), 'det_opr.utils.ge... |
# -*- 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 ARRANTI... | [
"megengine.module.AvgPool2d",
"megengine.tensor"
] | [((725, 795), 'megengine.module.AvgPool2d', 'AvgPool2d', (['kernel_size'], {'stride': 'stride', 'padding': 'padding', 'mode': '"""average"""'}), "(kernel_size, stride=stride, padding=padding, mode='average')\n", (734, 795), False, 'from megengine.module import AvgPool2d, MaxPool2d\n'), ((1115, 1184), 'numpy.pad', 'np.p... |
# -*- 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 ARRANTI... | [
"megengine.core.tensor",
"megengine.test.assertTensorClose"
] | [((733, 756), 'megengine.test.assertTensorClose', 'assertTensorClose', (['a', 'b'], {}), '(a, b)\n', (750, 756), False, 'from megengine.test import assertTensorClose\n'), ((767, 782), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (780, 782), False, 'from tempfile import TemporaryFile\n'), ((804, 848), 'n... |
# Copyright (c) Megvii, Inc. and its affiliates.
import math
import megengine.functional as F
import megengine.module as M
class LogitsFullyConnected(M.Module):
"""single fully connected layer, mapping embedding to logits with normalized weight
"""
def __init__(self, num_class, feature_dim):
su... | [
"megengine.module.Linear",
"megengine.functional.normalize",
"megengine.functional.topk_accuracy",
"megengine.functional.where",
"megengine.functional.acos",
"megengine.functional.one_hot",
"megengine.functional.loss.cross_entropy"
] | [((350, 394), 'megengine.module.Linear', 'M.Linear', (['feature_dim', 'num_class'], {'bias': '(False)'}), '(feature_dim, num_class, bias=False)\n', (358, 394), True, 'import megengine.module as M\n'), ((532, 564), 'megengine.functional.normalize', 'F.normalize', (['self.weight'], {'axis': '(1)'}), '(self.weight, axis=1... |
# -*- 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 ARRANTI... | [
"megengine.tensor",
"megengine.quantization.utils.tqt_forward",
"megengine.quantization.utils.fake_quant_tensor",
"megengine.core.tensor.utils.make_shape_tuple",
"megengine.core.autodiff.grad.Grad"
] | [((2219, 2254), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(1, 2, 3, 4)'}), '(size=(1, 2, 3, 4))\n', (2235, 2254), True, 'import numpy as np\n'), ((2295, 2339), 'numpy.ones', 'np.ones', ([], {'shape': '(1, 2, 3, 4)', 'dtype': '"""float32"""'}), "(shape=(1, 2, 3, 4), dtype='float32')\n", (2302, 2339), Tru... |
import megengine.module as M
import megengine.functional as F
from megengine import amp
from .update import BasicUpdateBlock
from .extractor import BasicEncoder
from .corr import AGCL
from .attention import PositionEncodingSine, LocalFeatureTransformer
class CREStereo(M.Module):
def __init__(self, max_disp=192,... | [
"megengine.functional.split",
"megengine.functional.sigmoid",
"megengine.functional.nn.interpolate",
"megengine.functional.softmax",
"megengine.functional.transpose",
"megengine.amp.autocast",
"megengine.functional.avg_pool2d",
"megengine.functional.relu",
"megengine.functional.sum",
"megengine.fu... | [((1276, 1346), 'megengine.module.Conv2d', 'M.Conv2d', (['(256)', '(self.search_num * 2)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(256, self.search_num * 2, kernel_size=3, stride=1, padding=1)\n', (1284, 1346), True, 'import megengine.module as M\n'), ((1398, 1468), 'megengine.module.Conv2d', 'M.... |
# 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 ... | [
"megengine.load"
] | [((1858, 1881), 'megengine.load', 'mge.load', (['traced_module'], {}), '(traced_module)\n', (1866, 1881), True, 'import megengine as mge\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 Megv... | [
"megengine.module.ReLU",
"megengine.module.BatchNorm2d",
"megengine.functional.avg_pool2d",
"megengine.functional.relu",
"megengine.module.init.xavier_uniform_",
"megengine.functional.interpolate",
"megengine.module.Conv2d"
] | [((2136, 2201), 'megengine.module.Conv2d', 'M.Conv2d', (['self.in_channels', 'self.hidden_channels', '(3)', '(1)'], {'padding': '(1)'}), '(self.in_channels, self.hidden_channels, 3, 1, padding=1)\n', (2144, 2201), True, 'import megengine.module as M\n'), ((2328, 2394), 'megengine.module.Conv2d', 'M.Conv2d', (['self.hid... |
#!/usr/bin/env python
# -*-coding=utf-8-*-
from megengine.logger import get_logger
logger = get_logger(__name__)
try:
from tensorboardX import SummaryWriter
from tensorboardX.proto.attr_value_pb2 import AttrValue
from tensorboardX.proto.graph_pb2 import GraphDef
from tensorboardX.proto.node_def_pb2 i... | [
"megengine.logger.get_logger"
] | [((94, 114), 'megengine.logger.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (104, 114), False, 'from megengine.logger import get_logger\n'), ((3050, 3090), 'tensorboardX.proto.summary_pb2.SummaryMetadata', 'SummaryMetadata', ([], {'plugin_data': 'plugin_data'}), '(plugin_data=plugin_data)\n', (3065, 3... |
# -*- 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
#... | [
"megengine.distributed.is_distributed",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.distributed.all_reduce_sum",
"megengine.distributed.init_process_group"
] | [((2327, 2352), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2350, 2352), False, 'import argparse\n'), ((3419, 3460), 'devkit.core.init_dist', 'init_dist', ([], {'backend': '"""nccl"""', 'port': 'args.port'}), "(backend='nccl', port=args.port)\n", (3428, 3460), False, 'from devkit.core impor... |
# 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 ... | [
"megengine.load"
] | [((1616, 1639), 'megengine.load', 'mge.load', (['traced_module'], {}), '(traced_module)\n', (1624, 1639), True, 'import megengine as mge\n')] |
import numpy as np
from megengine import tensor
def _default_compare_fn(x, y):
np.testing.assert_allclose(x.numpy(), y, rtol=1e-6)
def opr_test(cases, func, compare_fn=_default_compare_fn, ref_fn=None, **kwargs):
"""
:param cases: the list which have dict element, the list length should be 2 for dynami... | [
"megengine.tensor"
] | [((2055, 2067), 'megengine.tensor', 'tensor', (['inpi'], {}), '(inpi)\n', (2061, 2067), False, 'from megengine import tensor\n')] |
from itertools import product
import numpy as np
from megengine import tensor
from megengine.module import (
Conv2d,
ConvBn2d,
ConvRelu2d,
DequantStub,
Module,
QuantStub,
)
from megengine.quantization.quantize import disable_fake_quant, quantize_qat
def test_qat_convbn2d():
in_channels =... | [
"megengine.quantization.quantize.quantize_qat",
"megengine.module.QuantStub",
"megengine.module.ConvBn2d",
"megengine.quantization.quantize.disable_fake_quant",
"megengine.module.DequantStub",
"megengine.module.ConvRelu2d",
"megengine.module.Conv2d"
] | [((390, 420), 'itertools.product', 'product', (['[1, 4]', '[True, False]'], {}), '([1, 4], [True, False])\n', (397, 420), False, 'from itertools import product\n'), ((2349, 2379), 'itertools.product', 'product', (['[1, 4]', '[True, False]'], {}), '([1, 4], [True, False])\n', (2356, 2379), False, 'from itertools import ... |
#!/usr/bin/env python3
# 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.
"""LARS optimizer
References: https://github.com/rwightman/pytorch-image-models/blob/master/timm/optim/lars.py
"""... | [
"megengine.tensor",
"megengine.functional.inplace._inplace_add_",
"megengine.functional.sum"
] | [((2538, 2548), 'megengine.tensor', 'tensor', (['lr'], {}), '(lr)\n', (2544, 2548), False, 'from megengine import Parameter, tensor\n'), ((2573, 2593), 'megengine.tensor', 'tensor', (['weight_decay'], {}), '(weight_decay)\n', (2579, 2593), False, 'from megengine import Parameter, tensor\n'), ((2614, 2630), 'megengine.t... |
import os
import megengine as mge
import megengine.functional as F
import argparse
import numpy as np
import cv2
from nets import Model
def load_model(model_path):
print("Loading model:", os.path.abspath(model_path))
pretrained_dict = mge.load(model_path)
model = Model(max_disp=256, mixed_precision=Fals... | [
"megengine.functional.nn.interpolate",
"megengine.functional.squeeze",
"megengine.tensor",
"megengine.load"
] | [((247, 267), 'megengine.load', 'mge.load', (['model_path'], {}), '(model_path)\n', (255, 267), True, 'import megengine as mge\n'), ((280, 338), 'nets.Model', 'Model', ([], {'max_disp': '(256)', 'mixed_precision': '(False)', 'test_mode': '(True)'}), '(max_disp=256, mixed_precision=False, test_mode=True)\n', (285, 338),... |
import os
import cv2
import argparse
import warnings
import megengine as mge
import megengine.functional as F
warnings.filterwarnings("ignore")
parser = argparse.ArgumentParser(description='Interpolation for a pair of images')
parser.add_argument('--img', dest='img', nargs=2, required=True)
parser.add_argument('--exp'... | [
"megengine.functional.nn.pad"
] | [((110, 143), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (133, 143), False, 'import warnings\n'), ((154, 227), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Interpolation for a pair of images"""'}), "(description='Interpolation for a pa... |
# -*- 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 ARRANTI... | [
"megengine.module.ReLU",
"megengine.tensor",
"megengine.functional.top_k",
"megengine.module.init.zeros_",
"megengine.module.init.msra_normal_",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.module.ConvTranspose2d",
"megengine.module.Sequential",
"megengine.module.Conv2d",
"mege... | [((7936, 8043), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/models/weights/mspn_4stage_256x192_0_255_75_2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/models/weights/mspn_4stage_256x192_0_255_75_2.pkl'\n )\n", (7950, 8043), True, 'import megengine.hub as hub\n'), ((2520... |
# 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 ... | [
"megengine.distributed.functional.remote_recv",
"megengine.functional.ones",
"megengine.module.Conv2d",
"megengine.distributed.get_rank",
"megengine.functional.batch_norm",
"megengine.distributed.get_world_size",
"megengine.Parameter",
"megengine.jit.trace",
"megengine.functional.matmul",
"megengi... | [((847, 863), 'megengine.tensor', 'mge.tensor', (['(-1.0)'], {}), '(-1.0)\n', (857, 863), True, 'import megengine as mge\n'), ((928, 942), 'megengine.functional.matmul', 'F.matmul', (['x', 'w'], {}), '(x, w)\n', (936, 942), True, 'import megengine.functional as F\n'), ((1396, 1416), 'megengine.Parameter', 'mge.Paramete... |
import numpy as np
import megengine as mge
import megengine.module as M
import megengine.functional as F
from .utils.utils import bilinear_sampler, coords_grid
class AGCL:
"""
Implementation of Adaptive Group Correlation Layer (AGCL).
"""
def __init__(self, fmap1, fmap2, att=None):
self.fmap1... | [
"megengine.functional.split",
"megengine.functional.pad",
"megengine.tensor",
"megengine.functional.expand_dims",
"megengine.functional.transpose",
"megengine.functional.mean",
"megengine.functional.concat",
"megengine.functional.reshape",
"megengine.functional.sliding_window",
"megengine.function... | [((1102, 1202), 'megengine.functional.pad', 'F.pad', (['right_feature'], {'pad_witdth': '((0, 0), (0, 0), (pady, pady), (padx, padx))', 'mode': '"""replicate"""'}), "(right_feature, pad_witdth=((0, 0), (0, 0), (pady, pady), (padx, padx)\n ), mode='replicate')\n", (1107, 1202), True, 'import megengine.functional as F... |
import megengine as mge
import megengine.module as M
from megengine import functional as F
import numpy as np
from .transformer import MultiheadAttention
#from .utility import has_nan_or_inf
# mge.core.set_option('async_level', 0)
class DecoderWrapper(M.Module):
def __init__(self, cfg):
super().__init__()... | [
"megengine.module.Linear"
] | [((590, 643), 'megengine.module.Linear', 'M.Linear', ([], {'in_features': 'channels', 'out_features': 'channels'}), '(in_features=channels, out_features=channels)\n', (598, 643), True, 'import megengine.module as M\n')] |
import io
import pickle
import numpy as np
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(T... | [
"megengine.jit.trace",
"megengine.functional.maximum",
"megengine.functional.zeros",
"megengine.functional.broadcast_to",
"megengine.functional.ones",
"megengine.functional.warp_perspective",
"megengine.core._trace_option.set_symbolic_shape",
"megengine.traced_module.trace_module",
"megengine.utils.... | [((300, 324), 'megengine.core._trace_option.set_symbolic_shape', 'set_symbolic_shape', (['(True)'], {}), '(True)\n', (318, 324), False, 'from megengine.core._trace_option import set_symbolic_shape\n'), ((1612, 1649), 'megengine.functional.ones', 'F.ones', (['(1, 14, 8, 8)'], {'dtype': 'np.uint8'}), '((1, 14, 8, 8), dty... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import os
from typing import List
import megengine.distributed as dist
from basecore.config import ConfigDict
from basecore.engine import BaseHook
from basecore.utils import str_timestamp
from basecls.utils import registers
from .hooks... | [
"megengine.distributed.get_rank"
] | [((490, 516), 'basecls.utils.registers.hooks.register', 'registers.hooks.register', ([], {}), '()\n', (514, 516), False, 'from basecls.utils import registers\n'), ((1367, 1382), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1380, 1382), True, 'import megengine.distributed as dist\n'), ((1611, 16... |
# -*- 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 ARRANTI... | [
"megengine.functional.transpose",
"megengine.functional.sum",
"megengine.module.Conv2d",
"megengine.module.pooling.MaxPool2d",
"megengine.functional.remove_axis",
"megengine.functional.squeeze",
"megengine.functional.floor",
"megengine.module.BatchNorm2d",
"megengine.functional.log",
"megengine.fu... | [((657, 677), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (662, 677), False, 'from megengine.jit import trace\n'), ((1193, 1236), 'megengine.jit.trace', 'trace', ([], {'symbolic': '(True)', 'capture_as_const': '(True)'}), '(symbolic=True, capture_as_const=True)\n', (1198, 1236), F... |
# -*- 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 ARRANTIE... | [
"megengine.functional.maximum",
"megengine.module.init.normal_",
"megengine.functional.full",
"megengine.functional.topk",
"megengine.functional.concat",
"megengine.module.Conv2d",
"megengine.functional.loss.binary_cross_entropy",
"megengine.module.init.fill_",
"megengine.functional.full_like"
] | [((580, 630), 'layers.BoxCoder', 'layers.BoxCoder', (['cfg.rpn_reg_mean', 'cfg.rpn_reg_std'], {}), '(cfg.rpn_reg_mean, cfg.rpn_reg_std)\n', (595, 630), False, 'import layers\n'), ((997, 1148), 'layers.AnchorBoxGenerator', 'layers.AnchorBoxGenerator', ([], {'anchor_scales': 'cfg.anchor_scales', 'anchor_ratios': 'cfg.anc... |
# -*- coding: utf-8 -*-
# MIT License
#
# Copyright (c) 2021 coolbeam
#
# 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, ... | [
"megengine.functional.sigmoid",
"megengine.functional.expand_dims",
"megengine.module.BatchNorm2d",
"megengine.functional.vision.interpolate",
"megengine.module.InstanceNorm",
"megengine.functional.concat",
"megengine.module.Conv2d",
"megengine.module.LeakyReLU"
] | [((5825, 5856), 'common.utils.flow_warp', 'flow_warp', (['feature_2', 'flow_init'], {}), '(feature_2, flow_init)\n', (5834, 5856), False, 'from common.utils import flow_warp, upsample2d_flow_as\n'), ((5881, 5926), 'megengine.functional.concat', 'F.concat', (['(feature_1, feature_2_warp)'], {'axis': '(1)'}), '((feature_... |
# -*- 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 ARRANTI... | [
"megengine.data.transform.Normalize",
"megengine.data.SequentialSampler",
"megengine.jit.trace",
"megengine.tensor",
"megengine.data.dataset.Cityscapes",
"megengine.load"
] | [((813, 838), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (836, 838), False, 'import argparse\n'), ((1203, 1239), 'official.vision.segmentation.utils.import_config_from_file', 'import_config_from_file', (['args.config'], {}), '(args.config)\n', (1226, 1239), False, 'from official.vision.segm... |
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import math
import megengine as mge
import megengine.functional as F
import megengine.module as M
from yolox.utils import bboxes_iou
from .losses import binary_cross_entropy, iou_loss, l1_loss
from .network_bloc... | [
"megengine.functional.equal",
"megengine.functional.pow",
"megengine.functional.transpose",
"megengine.functional.zeros",
"megengine.functional.argmax",
"megengine.functional.log",
"megengine.functional.broadcast_to",
"megengine.functional.stack",
"megengine.functional.flatten",
"megengine.functio... | [((523, 552), 'megengine.functional.broadcast_to', 'F.broadcast_to', (['x', 'mesh_shape'], {}), '(x, mesh_shape)\n', (537, 552), True, 'import megengine.functional as F\n'), ((8005, 8028), 'megengine.functional.concat', 'F.concat', (['grids'], {'axis': '(1)'}), '(grids, axis=1)\n', (8013, 8028), True, 'import megengine... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.