MegEngine support (#607) (#940)

source/megengine-metadata.json

@@ -0,0 +1,2203 @@
+[
+  {
+    "name": "megengine.distributed.functional.all_gather",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" },
+      { "name": "axis" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.all_reduce_max",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.all_reduce_min",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.all_reduce_sum",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.all_to_all",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" },
+      { "name": "split_axis" },
+      { "name": "concat_axis" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.broadcast",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.collective_comm",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "mode" },
+      { "name": "group" },
+      { "name": "device" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.gather",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" },
+      { "name": "axis" }
+    ],
+    "category": "Transform"
+  },
+  {
+    "name": "megengine.distributed.functional.reduce_scatter_sum",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" },
+      { "name": "axis" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.reduce_sum",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.remote_recv",
+    "attributes": [
+      { "name": "src_rank" },
+      { "name": "device" },
+      { "name": "inp" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.remote_send",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "dest_rank" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.distributed.functional.scatter",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "group" },
+      { "name": "device" },
+      { "name": "axis" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.elemwise.abs",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.add",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.acos",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.asin",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.atan",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.atan2",
+    "attributes": [
+      { "name": "y" },
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.asinh",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.acosh",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.atanh",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.ceil",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.clip",
+    "attributes": [
+      { "name": "x" },
+      { "name": "lower" },
+      { "name": "upper" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.cos",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.cosh",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.div",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.equal",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.exp",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.expm1",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.floor",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.floor_div",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.greater",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.greater_equal",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.left_shift",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.less",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.less_equal",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.log",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.log1p",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.logical_and",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.logical_not",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.logical_or",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.logical_xor",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.logaddexp",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.maximum",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.minimum",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.mod",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.mul",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.neg",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.not_equal",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.pow",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.right_shift",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.round",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.sin",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.sinh",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.sqrt",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.square",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.sub",
+    "attributes": [
+      { "name": "x" },
+      { "name": "y" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.tan",
+    "attributes": [
+      { "name": "x" }
+    ]
+  },
+  {
+    "name": "megengine.functional.elemwise.tanh",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.loss.l1_loss",
+    "attributes": [],
+    "category": "Layer",
+    "varargs": "args"
+  },
+  {
+    "name": "megengine.functional.loss.square_loss",
+    "attributes": [],
+    "category": "Layer",
+    "varargs": "args"
+  },
+  {
+    "name": "megengine.functional.loss.cross_entropy",
+    "attributes": [],
+    "category": "Layer",
+    "varargs": "args"
+  },
+  {
+    "name": "megengine.functional.loss.binary_cross_entropy",
+    "attributes": [],
+    "category": "Layer",
+    "varargs": "args"
+  },
+  {
+    "name": "megengine.functional.loss.hinge_loss",
+    "attributes": [],
+    "category": "Layer",
+    "varargs": "args"
+  },
+  {
+    "name": "megengine.functional.loss.ctc_loss",
+    "attributes": [
+      { "name": "pred" },
+      { "name": "pred_lengths" },
+      { "name": "label" },
+      { "name": "label_lengths" },
+      { "name": "blank" },
+      { "name": "reduction" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.argmax",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.argmin",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.argsort",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "descending" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.dot",
+    "attributes": [
+      { "name": "inp1" },
+      { "name": "inp2" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.isinf",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.isnan",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.matinv",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.matmul",
+    "attributes": [
+      { "name": "inp1" },
+      { "name": "inp2" },
+      { "name": "transpose_a" },
+      { "name": "transpose_b" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.max",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.mean",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.min",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.norm",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "ord" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.normalize",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "ord" },
+      { "name": "axis" },
+      { "name": "eps" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.prod",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.sign",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.sort",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "descending" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.std",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.sum",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.svd",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "full_matrices" },
+      { "name": "compute_uv" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.math.topk",
+    "attributes": [],
+    "category": "Layer",
+    "varargs": "args"
+  },
+  {
+    "name": "megengine.functional.math.var",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.metric.topk_accuracy",
+    "attributes": [
+      { "name": "logits" },
+      { "name": "target" },
+      { "name": "topk" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.adaptive_avg_pool2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "oshp" }
+    ],
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.functional.nn.adaptive_max_pool2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "oshp" }
+    ],
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.functional.nn.avg_pool2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "kernel_size" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "mode" }
+    ],
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.functional.nn.batch_norm",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "running_mean" },
+      { "name": "running_var" },
+      { "name": "weight" },
+      { "name": "bias" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.conv1d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.conv2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.conv3d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "conv_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.conv_transpose2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.conv_transpose3d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.deformable_conv2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "offset" },
+      { "name": "mask" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.deformable_psroi_pooling",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "rois" },
+      { "name": "trans" },
+      { "name": "no_trans" },
+      { "name": "part_size" },
+      { "name": "pooled_h" },
+      { "name": "pooled_w" },
+      { "name": "sample_per_part" },
+      { "name": "spatial_scale" },
+      { "name": "trans_std" }
+    ],
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.functional.nn.dropout",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "drop_prob" },
+      { "name": "training" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.embedding",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "padding_idx" },
+      { "name": "max_norm" },
+      { "name": "norm_type" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.gelu",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.hsigmoid",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.hswish",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.indexing_one_hot",
+    "attributes": [
+      { "name": "src" },
+      { "name": "index" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.layer_norm",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "normalized_shape" },
+      { "name": "affine" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "eps" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.leaky_relu",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "negative_slope" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.linear",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.local_conv2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "conv_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.local_response_norm",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "kernel_size" },
+      { "name": "k" },
+      { "name": "alpha" },
+      { "name": "beta" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.logsigmoid",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.logsumexp",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.logsoftmax",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.max_pool2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "kernel_size" },
+      { "name": "stride" },
+      { "name": "padding" }
+    ],
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.functional.nn.one_hot",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "num_classes" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.prelu",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.pad",
+    "attributes": [
+      { "name": "src" },
+      { "name": "pad_width" },
+      { "name": "mode" },
+      { "name": "constant_value" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.relu",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.relu6",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.vision.remap",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "map_xy" },
+      { "name": "border_mode" },
+      { "name": "scalar" },
+      { "name": "interp_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.sigmoid",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.sliding_window",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "kernel_size" },
+      { "name": "padding" },
+      { "name": "stride" },
+      { "name": "dilation" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.sliding_window_transpose",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "output_size" },
+      { "name": "kernel_size" },
+      { "name": "padding" },
+      { "name": "stride" },
+      { "name": "dilation" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.silu",
+    "attributes": [
+      { "name": "x" }
+    ],
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.functional.nn.softmax",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.softplus",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.sync_batch_norm",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "running_mean" },
+      { "name": "running_var" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "training" },
+      { "name": "momentum" },
+      { "name": "eps" },
+      { "name": "eps_mode" },
+      { "name": "group" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.warp_affine",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "mat" },
+      { "name": "out_shape" },
+      { "name": "border_mode" },
+      { "name": "border_val" },
+      { "name": "format" },
+      { "name": "interp_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.warp_perspective",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "mat" },
+      { "name": "out_shape" },
+      { "name": "mat_idx" },
+      { "name": "border_mode" },
+      { "name": "border_val" },
+      { "name": "format" },
+      { "name": "interp_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.nn.pixel_shuffle",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "upscale_factor" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.debug_param.get_execution_strategy",
+    "attributes": [],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.quantized.conv_bias_activation",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "dtype" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "nonlinear_mode" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.quantized.batch_conv_bias_activation",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "dtype" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "nonlinear_mode" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.quantized.conv_transpose2d",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "weight" },
+      { "name": "bias" },
+      { "name": "dtype" },
+      { "name": "stride" },
+      { "name": "padding" },
+      { "name": "dilation" },
+      { "name": "groups" },
+      { "name": "conv_mode" },
+      { "name": "compute_mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.tensor.arange",
+    "attributes": [
+      { "name": "start" },
+      { "name": "stop" },
+      { "name": "step" },
+      { "name": "dtype" },
+      { "name": "device" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.broadcast_to",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "shape" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.concat",
+    "attributes": [
+      { "name": "inps" },
+      { "name": "axis" },
+      { "name": "device" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.cond_take",
+    "attributes": [
+      { "name": "mask" },
+      { "name": "x" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.cumsum",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.diag",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "k" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.expand_dims",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.eye",
+    "attributes": [
+      { "name": "N" },
+      { "name": "M" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.flatten",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "start_axis" },
+      { "name": "end_axis" }
+    ],
+    "category": "Shape"
+  },
+  {
+    "name": "megengine.functional.tensor.full",
+    "attributes": [
+      { "name": "shape" },
+      { "name": "value" },
+      { "name": "dtype" },
+      { "name": "device" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.full_like",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "value" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.gather",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "index" }
+    ],
+    "category": "Transform"
+  },
+  {
+    "name": "megengine.functional.tensor.linspace",
+    "attributes": [
+      { "name": "start" },
+      { "name": "stop" },
+      { "name": "num" },
+      { "name": "dtype" },
+      { "name": "device" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.ones",
+    "attributes": [
+      { "name": "shape" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.ones_like",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.repeat",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "repeats" },
+      { "name": "axis" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.reshape",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "target_shape" }
+    ],
+    "category": "Shape"
+  },
+  {
+    "name": "megengine.functional.tensor.roll",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "shift" },
+      { "name": "axis" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.split",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "nsplits_or_sections" },
+      { "name": "axis" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.squeeze",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" }
+    ],
+    "category": "Transform"
+  },
+  {
+    "name": "megengine.functional.tensor.stack",
+    "attributes": [
+      { "name": "inps" },
+      { "name": "axis" },
+      { "name": "device" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.scatter",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis" },
+      { "name": "index" },
+      { "name": "source" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.tile",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "reps" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.copy",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "device" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.transpose",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "pattern" }
+    ],
+    "category": "Shape"
+  },
+  {
+    "name": "megengine.functional.tensor.swapaxes",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "axis1" },
+      { "name": "axis2" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.where",
+    "attributes": [
+      { "name": "mask" },
+      { "name": "x" },
+      { "name": "y" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.zeros",
+    "attributes": [
+      { "name": "shape" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.tensor.zeros_like",
+    "attributes": [
+      { "name": "inp" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.functional.vision.correlation",
+    "attributes": [
+      { "name": "data1" },
+      { "name": "data2" },
+      { "name": "kernel_size" },
+      { "name": "max_displacement" },
+      { "name": "stride1" },
+      { "name": "stride2" },
+      { "name": "pad_size" },
+      { "name": "is_multiply" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.cvt_color",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "mode" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.interpolate",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "size" },
+      { "name": "scale_factor" },
+      { "name": "mode" },
+      { "name": "align_corners" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.nms",
+    "attributes": [
+      { "name": "boxes" },
+      { "name": "scores" },
+      { "name": "iou_thresh" },
+      { "name": "max_output" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.nvof",
+    "attributes": [
+      { "name": "src" },
+      { "name": "precision" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.roi_align",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "rois" },
+      { "name": "output_shape" },
+      { "name": "mode" },
+      { "name": "spatial_scale" },
+      { "name": "sample_points" },
+      { "name": "aligned" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.functional.vision.roi_pooling",
+    "attributes": [
+      { "name": "inp" },
+      { "name": "rois" },
+      { "name": "output_shape" },
+      { "name": "mode" },
+      { "name": "scale" }
+    ],
+    "category": "Pool"
+  },
+  {
+    "name": "__lt__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__le__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__gt__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ge__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__eq__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ne__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__neg__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__pos__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__abs__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__invert__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__round__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__floor__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__ceil__",
+    "attributes": [
+      { "name": "self" }
+    ]
+  },
+  {
+    "name": "__add__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__sub__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__mul__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__matmul__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "other" }
+    ]
+  },
+  {
+    "name": "__truediv__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__floordiv__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__mod__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__pow__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__lshift__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rshift__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__and__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__or__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__xor__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__radd__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rsub__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rmul__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rmatmul__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "other" }
+    ]
+  },
+  {
+    "name": "__rtruediv__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rfloordiv__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rmod__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rpow__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rlshift__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rrshift__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rand__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ror__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__rxor__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__iadd__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__isub__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__imul__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__imatmul__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__itruediv__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ifloordiv__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__imod__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ipow__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ilshift__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__irshift__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__iand__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ior__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "__ixor__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "value" }
+    ]
+  },
+  {
+    "name": "transpose",
+    "attributes": [
+      { "name": "self" }
+    ],
+    "category": "Shape",
+    "varargs": "args"
+  },
+  {
+    "name": "astype",
+    "attributes": [
+      { "name": "self" },
+      { "name": "dtype" }
+    ],
+    "category": "Layer"
+  },
+  {
+    "name": "reshape",
+    "attributes": [
+      { "name": "self" }
+    ],
+    "category": "Shape",
+    "varargs": "args"
+  },
+  {
+    "name": "_broadcast",
+    "attributes": [
+      { "name": "self" }
+    ],
+    "category": "Shape",
+    "varargs": "args"
+  },
+  {
+    "name": "flatten",
+    "attributes": [
+      { "name": "self" }
+    ],
+    "category": "Shape"
+  },
+  {
+    "name": "sum",
+    "attributes": [
+      { "name": "self" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ]
+  },
+  {
+    "name": "prod",
+    "attributes": [
+      { "name": "self" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ]
+  },
+  {
+    "name": "min",
+    "attributes": [
+      { "name": "self" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ]
+  },
+  {
+    "name": "max",
+    "attributes": [
+      { "name": "self" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ]
+  },
+  {
+    "name": "mean",
+    "attributes": [
+      { "name": "self" },
+      { "name": "axis" },
+      { "name": "keepdims" }
+    ]
+  },
+  {
+    "name": "__getitem__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "index" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "__setitem__",
+    "attributes": [
+      { "name": "self" },
+      { "name": "index" },
+      { "name": "value" }
+    ],
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.module.adaptive_pooling.AdaptiveAvgPool2d",
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.module.adaptive_pooling.AdaptiveMaxPool2d",
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.module.pooling.AvgPool2d",
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.module.batch_matmul_activation.BatchMatMulActivation",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.batchnorm.BatchNorm1d",
+    "category": "Normalization"
+  },
+  {
+    "name": "megengine.module.batchnorm.BatchNorm2d",
+    "category": "Normalization"
+  },
+  {
+    "name": "megengine.module.concat.Concat",
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.module.conv.Conv1d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.Conv2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.Conv3d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv_bn.ConvBn2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv_bn.ConvBnRelu2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.ConvRelu2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.ConvTranspose2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.ConvTranspose3d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.DeformableConv2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.deformable_psroi_pooling.DeformablePSROIPooling",
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.module.quant_dequant.DequantStub",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.dropout.Dropout",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.elemwise.Elemwise"
+  },
+  {
+    "name": "megengine.module.embedding.Embedding",
+    "category": "Transform"
+  },
+  {
+    "name": "megengine.module.activation.GELU",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.normalization.GroupNorm",
+    "category": "Normalization"
+  },
+  {
+    "name": "megengine.module.identity.Identity",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.normalization.InstanceNorm",
+    "category": "Normalization"
+  },
+  {
+    "name": "megengine.module.rnn.LSTM",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.rnn.LSTMCell",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.normalization.LayerNorm",
+    "category": "Normalization"
+  },
+  {
+    "name": "megengine.module.activation.LeakyReLU",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.linear.Linear",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.conv.LocalConv2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.lrn.LocalResponseNorm",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.pooling.MaxPool2d",
+    "category": "Pool"
+  },
+  {
+    "name": "megengine.module.module.Module",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.activation.PReLU",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.padding.Pad",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.pixel_shuffle.PixelShuffle",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quant_dequant.QuantStub",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.rnn.RNN",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.rnn.RNNCell",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.activation.ReLU",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.activation.SiLU",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.activation.Sigmoid",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.sliding_window.SlidingWindow",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.sliding_window.SlidingWindowTranspose",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.activation.Softmax",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.batchnorm.SyncBatchNorm",
+    "category": "Normalization"
+  },
+  {
+    "name": "megengine.module.qat.batch_matmul_activation.BatchMatMulActivation",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.qat.concat.Concat",
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.module.qat.conv.Conv2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.conv_bn.ConvBn2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.conv_bn.ConvBnRelu2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.conv.ConvRelu2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.conv.ConvTranspose2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.quant_dequant.DequantStub",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.linear.Linear",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.module.QATModule",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.qat.quant_dequant.QuantStub",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.batch_matmul_activation.BatchMatMulActivation",
+    "category": "Activation"
+  },
+  {
+    "name": "megengine.module.quantized.concat.Concat",
+    "category": "Tensor"
+  },
+  {
+    "name": "megengine.module.quantized.conv.Conv2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.conv_bn.ConvBn2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.conv_bn.ConvBnRelu2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.conv.ConvRelu2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.conv.ConvTranspose2d",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.quant_dequant.DequantStub",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.linear.Linear",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.quant_dequant.QuantStub",
+    "category": "Layer"
+  },
+  {
+    "name": "megengine.module.quantized.module.QuantizedModule",
+    "category": "Layer"
+  }
+]

source/megengine.js

@@ -0,0 +1,696 @@
+
+// Experimental
+
+var megengine = megengine || {};
+var base = base || require('./base');
+
+megengine.ModelFactory = class {
+
+    match(context) {
+        const obj = context.open('pkl');
+        if (obj.__class__ && obj.__class__.__module__ === 'megengine.traced_module.traced_module' && obj.__class__.__name__ === 'TracedModule') {
+            return 'megengine.pickle';
+        }
+        return '';
+    }
+
+    open(context) {
+        return context.metadata('megengine-metadata.json').then((metadata) => {
+            const obj = context.open('pkl');
+            return new megengine.Model(metadata, obj);
+        });
+    }
+};
+
+megengine.Model = class {
+
+    constructor(metadata, obj) {
+        this._format = 'MegEngine' + (obj.dump_info && obj.dump_info.version ? ' v' + obj.dump_info.version : '');
+        this._graphs = [ new megengine.Graph(metadata, obj) ];
+    }
+
+    get format() {
+        return this._format;
+    }
+
+    get graphs() {
+        return this._graphs;
+    }
+};
+
+megengine.Graph = class {
+
+    constructor(metadata, obj) {
+        this._nodes = [];
+        this._inputs = [];
+        this._outputs = [];
+        const loadgraph = (tmodule, igraph, context, name_prefix, metadata, isroot) =>{
+            const expressions = igraph._exprs;
+            const isTensor = (obj) => {
+                return obj && obj.__class__ && obj.__class__.__module__ == 'megengine.tensor' && (obj.__class__.__name__ === 'Tensor' || obj.__class__.__name__ === 'Parameter');
+            };
+            const getTensorType = (dtype, shape) => {
+                const dt = dtype !== null ? dtype.__name__ : null;
+                return new megengine.TensorType(dt, new megengine.TensorShape(shape));
+            };
+            const getOpNode = (metadata, item, expr, state) => {
+                const op = new megengine.Node(metadata, item);
+                let inp_idx = 0;
+                for (const i of expr.inputs) {
+                    if (i.__class__.__name__ !== 'ModuleNode') {
+                        const initializer = i.initializer !== undefined ? i.initializer : null;
+                        const inp_name = 'inp' + inp_idx;
+                        op._inputs.push(new megengine.Parameter(inp_name, true, [
+                            new megengine.Argument(i._fullname, getTensorType(i._dtype, i._shape), initializer)
+                        ]));
+                        inp_idx += 1;
+                    }
+                }
+                const out_idx = 0;
+                let qparams = null;
+                for (const o of expr.outputs) {
+                    if (o._qparams !== null) {
+                        qparams = o._qparams[1];
+                    }
+                    op._outputs.push(new megengine.Parameter('out' + out_idx, true, [
+                        new megengine.Argument(o._fullname, getTensorType(o._dtype, o._shape), null)
+                    ]));
+                }
+                if (qparams !== null) {
+                    state = state === null? {} : state;
+                    state['scale'] = qparams.scale;
+                    state['zero_point'] = qparams.zero_point;
+                    state['quant_dtype_meta'] = qparams.dtype_meta;
+                }
+                if (state !== null) {
+                    for (const key in state) {
+                        const isModule = (obj) => {
+                            return obj && (obj.state || obj._forward_pre_hooks);
+                        };
+                        if (!key.startsWith('_') && !isModule(state[key])) {
+                            if (!isTensor(state[key])) {
+                                op._attributes.push(new megengine.Attribute(null, key, state[key] !== null ? state[key] : 'None'));
+                            }
+                            else {
+                                const tensor = state[key];
+                                op._inputs.push(new megengine.Parameter(key, true, [
+                                    new megengine.Argument('', getTensorType(tensor.dtype, tensor.data.shape), new megengine.Tensor(key, tensor))
+                                ]));
+                            }
+                        }
+                    }
+                }
+                return op;
+            };
+            if (isroot) {
+                for (const node of igraph._inputs) {
+                    if (node.__class__.__name__ === 'ModuleNode') {
+                        continue;
+                    }
+                    this._inputs.push(new megengine.Parameter(node._name, true, [new megengine.Argument(node._name, getTensorType(node._dtype, node._shape), null)]));
+                }
+                for (const node of igraph._outputs) {
+                    this._outputs.push(new megengine.Parameter(node._name, true, [new megengine.Argument(node._name, getTensorType(node._dtype, node._shape), null)]));
+                }
+            }
+            const parse_getattr = (tmodule, getattr_expr) => {
+                let attr_name = getattr_expr.name.split('.');
+                while (getattr_expr.inputs[0].expr.__class__.__name__ === 'GetAttr') {
+                    getattr_expr = getattr_expr.inputs[0].expr;
+                    attr_name = getattr_expr.name.split('.').concat(attr_name);
+                }
+                let attr_obj = tmodule;
+                for (const n of attr_name) {
+                    attr_obj = attr_obj[n];
+                }
+                return attr_obj;
+            };
+            const parseargs = (args, kwargs, meta) => {
+                const state = {};
+                const schema = meta !== undefined ? meta.schema : undefined;
+                let arg_idx = 0;
+                let attr_name = '';
+                const process_args = (inp, start_idx) => {
+                    while (typeof inp === 'string' && inp.indexOf('Tensor') !== -1) {
+                        inp = inp.replace('Tensor', 'inp' + start_idx);
+                        start_idx += 1;
+                    }
+                    return [inp, start_idx];
+                };
+                const formatTreeDef = (obj) => {
+                    if (obj.__class__.__name__ !== 'TreeDef' && obj.__class__.__name__ !== 'LeafDef') {
+                        throw new megengine.Error('formatTreeDef gets invalid argument');
+                    }
+                    if (obj.__class__.__name__ === 'TreeDef') {
+                        const type = typeof obj.type !== 'string' ? obj.type.__name__ : obj.type.split('.').slice(-1)[0];
+                        const list = obj.children_defs.map((child) => formatTreeDef(child));
+                        switch (type) {
+                            case 'tuple': {
+                                return '(' + list.join(',') + ')';
+                            }
+                            case 'slice': {
+                                return list.join(':');
+                            }
+                            case 'list': {
+                                return '[' + list.join(',') + ']';
+                            }
+                            case 'dict': {
+                                let content = '';
+                                for (let i = 0; i < this.children_defs.length; i++) {
+                                    content += this.aux_data[i] + ':' + list[i];
+                                }
+                                return '{' + content + '}';
+                            }
+                            default: {
+                                return type + '(' + list.join(',') + ')';
+                            }
+                        }
+                    }
+                    if (obj.const_val !== null) {
+                        return obj.const_val;
+                    }
+                    else if (obj.type[0].__module__ !== undefined) {
+                        return obj.type[0].__name__;
+                    }
+                    return 'None';
+                };
+                let inp_idx = 0;
+                for (const arg of args.children_defs) {
+                    if (schema === undefined || (schema.attributes.length !== args.children_defs.length && schema.varargs === null)) {
+                        attr_name = 'arg' + arg_idx;
+                    }
+                    else if (arg_idx < schema.attributes.length) {
+                        attr_name = schema.attributes[arg_idx];
+                    }
+                    else {
+                        attr_name = schema.varargs + (arg_idx - schema.attributes.length);
+                    }
+                    const rst = process_args(formatTreeDef(arg), inp_idx);
+                    state[attr_name] = rst[0];
+                    inp_idx = rst[1];
+                    arg_idx += 1;
+                }
+                for (let i = 0; i < kwargs.children_defs.length; i++) {
+                    const rst = process_args(formatTreeDef(kwargs.children_defs[i]), inp_idx);
+                    inp_idx = rst[1];
+                    state[kwargs.aux_data[i]] = rst[0];
+                }
+                return state;
+            };
+            const getname = (context, name) => {
+                let rst = name;
+                while (context.get(rst) !== undefined) {
+                    if (rst === context.get(rst)) {
+                        return rst;
+                    }
+                    rst = context.get(rst);
+                }
+                return rst;
+            };
+            const getfullname = (prefix, name) => {
+                return prefix === '' ? name : prefix + '_' + name;
+            };
+            for (const expr of expressions) {
+                const type = expr.__class__.__name__;
+                for (const i of expr.inputs) {
+                    i._fullname = getname(context, getfullname(name_prefix, i._name));
+                }
+                for (const o of expr.outputs) {
+                    o._fullname = getname(context, getfullname(name_prefix, o._name));
+                }
+                switch (type) {
+                    case 'Input': {
+                        break;
+                    }
+                    case 'GetAttr': {
+                        if (expr.outputs[0].__class__.__name__ === 'TensorNode') {
+                            const tensor = parse_getattr(tmodule, expr);
+                            expr.outputs[0].initializer = new megengine.Tensor(expr.name, tensor);
+                        }
+                        break;
+                    }
+                    case 'Constant': {
+                        if (expr.outputs[0].__class__.__name__ === 'TensorNode') {
+                            expr.outputs[0].initializer = new megengine.Tensor('', expr.value);
+                        }
+                        break;
+                    }
+                    case 'CallMethod': {
+                        if (expr.method === '__call__') {
+                            const getattr_expr = expr.inputs[0].expr;
+                            const called_module = parse_getattr(tmodule, getattr_expr);
+                            const getModuleType = (obj) => {
+                                if (obj.module !== undefined) {
+                                    return obj.module[0] + '.' + obj.module[1];
+                                }
+                                return obj.__class__.__module__ + '.' + obj.__class__.__name__;
+                            };
+                            const module_type = called_module.__class__.__name__ !== 'TracedModule' ? getModuleType(called_module) : 'TracedModule';
+                            if (module_type === 'TracedModule') {
+                                const prefix = getfullname(name_prefix, expr.inputs[0]._name);
+                                const internal_graph = called_module.argdef_graph_map[expr.arg_def.toString()];
+                                for (let i = 0; i < expr.inputs.length; i++) {
+                                    const actual_name = getfullname(name_prefix, expr.inputs[i]._name);
+                                    const internal_name = getfullname(prefix, internal_graph._inputs[i]._name);
+                                    context.set(internal_name, actual_name);
+                                }
+                                for (let i = 0; i < expr.outputs.length; i++) {
+                                    const actual_name = getfullname(name_prefix, expr.outputs[i]._name);
+                                    const internal_name = getfullname(prefix, internal_graph._outputs[i]._name);
+                                    context.set(internal_name, actual_name);
+                                }
+                                loadgraph(called_module, internal_graph, context, prefix, metadata, false);
+                                continue;
+                            }
+                            const item = { 'name': '', 'type': module_type };
+                            let state = called_module.__class__.__name__ !== 'TracedModule' ? called_module.state : called_module;
+                            if (state === undefined) {
+                                state = called_module;
+                            }
+                            this._nodes.push(getOpNode(metadata, item, expr, state));
+                        }
+                        else {
+                            const item = { 'name': '', 'type': expr.method };
+                            const args = expr.arg_def.children_defs[0];
+                            const kwargs = expr.arg_def.children_defs[1];
+                            const schema = metadata.type(expr.method);
+                            const state = parseargs(args, kwargs, schema);
+                            this._nodes.push(getOpNode(metadata, item, expr, state));
+                        }
+                        break;
+                    }
+                    case 'CallFunction': {
+                        const getFunctionType = (obj) => {
+                            if (obj.func.__module__ !== undefined) {
+                                return obj.func.__module__ + '.' + obj.func.__name__;
+                            }
+                            return obj.func[0] + '.' + obj.func[1];
+                        };
+                        const func = getFunctionType(expr);
+                        const item = { 'name': '', 'type': func };
+                        const args = expr.arg_def.children_defs[0];
+                        const kwargs = expr.arg_def.children_defs[1];
+                        const schema = metadata._types.get(func);
+                        const state = parseargs(args, kwargs, schema);
+                        this._nodes.push(getOpNode(metadata, item, expr, state));
+                        break;
+                    }
+                    case 'Apply': {
+                        const opdef = expr.opdef_state ? expr.opdef_state.opdef_type : expr.opdef.type;
+                        const item = { 'name': '', 'type': opdef.__module__ + '.' + opdef.__name__ };
+                        this._nodes.push(getOpNode(metadata, item, expr, expr.opdef_state));
+                        break;
+                    }
+                    default: {
+                        break;
+                    }
+                }
+            }
+        };
+        const graph = Object.values(obj.argdef_graph_map)[0];
+        loadgraph(obj, graph, new Map(), '', metadata, true);
+    }
+
+    get inputs() {
+        return this._inputs;
+    }
+
+    get outputs() {
+        return this._outputs;
+    }
+
+    get nodes() {
+        return this._nodes;
+    }
+};
+
+megengine.Parameter = class {
+
+    constructor(name, visible, args) {
+        this._name = name;
+        this._visible = visible;
+        this._arguments = args;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get visible() {
+        return this._visible;
+    }
+
+    get arguments() {
+        return this._arguments;
+    }
+};
+
+megengine.Argument = class {
+
+    constructor(name, type, initializer) {
+        if (typeof name !== 'string') {
+            throw new megengine.Error("Invalid argument identifier '" + JSON.stringify(name) + "'.");
+        }
+        this._name = name;
+        this._type = type;
+        this._initializer = initializer;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get type() {
+        if (this._initializer) {
+            return this._initializer.type;
+        }
+        return this._type;
+    }
+
+    get initializer() {
+        return this._initializer;
+    }
+};
+
+megengine.Node = class {
+
+    constructor(metadata, item) {
+        this._name = item.name || '';
+        this._type = Object.assign({}, metadata.type(item.type));
+        if (this._type.name.length > 4 && this._type.name.startsWith('__') && this._type.name.endsWith('__')) {
+            this._type.name = this._type.name.substring(2, this._type.name.length - 2);
+        }
+        this._inputs = [];
+        this._outputs = [];
+        this._chain = [];
+        this._attributes = [];
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get type() {
+        return this._type;
+    }
+
+    get attributes() {
+        return this._attributes;
+    }
+
+    get inputs() {
+        return this._inputs;
+    }
+
+    get outputs() {
+        return this._outputs;
+    }
+
+    get nodes() {
+        return this._nodes;
+    }
+};
+
+megengine.Attribute = class {
+
+    constructor(metadata, name, value) {
+        this._name = name;
+        this._value = value;
+
+        if (this._name === 'training') {
+            this._visible = false;
+            this._type = 'boolean';
+        }
+    }
+
+    get type() {
+        return this._type;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get value() {
+        return this._value;
+    }
+
+    get visible() {
+        return this._visible == false ? false : true;
+    }
+};
+
+megengine.Tensor = class {
+
+    constructor(name, tensor) {
+        this._name = name || '';
+        this._type = new megengine.TensorType(tensor.dtype.__name__, new megengine.TensorShape(tensor.data.shape));
+        this._data = tensor.data.data;
+    }
+
+    get kind() {
+        return 'Tensor';
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get type() {
+        return this._type;
+    }
+
+    get state() {
+        return this._context().state;
+    }
+
+    get value() {
+        const context = this._context();
+        if (context.state) {
+            return null;
+        }
+        context.limit = Number.MAX_SAFE_INTEGER;
+        return this._decode(context, 0);
+    }
+
+    toString() {
+        const context = this._context();
+        if (context.state) {
+            return '';
+        }
+        context.limit = 10000;
+        const value = this._decode(context, 0);
+        return megengine.Tensor._stringify(value, '', '    ');
+    }
+
+    _context() {
+        const context = {};
+        context.state = null;
+        context.index = 0;
+        context.count = 0;
+
+        if (!this._type.dataType) {
+            context.state = 'Tensor has no data type.';
+            return context;
+        }
+        switch (this._type.dataType) {
+            case 'boolean':
+            case 'uint8':
+            case 'qint8':
+            case 'int8':
+            case 'int16':
+            case 'int32':
+            case 'int64':
+            case 'float16':
+            case 'float32':
+            case 'float64':
+            case 'bfloat16':
+                break;
+            default:
+                context.state = "Tensor data type '" + this._type.dataType + "' is not supported.";
+                return context;
+        }
+        if (!this._type.shape) {
+            context.state = 'Tensor has no dimensions.';
+            return context;
+        }
+        if (!this._data) {
+            context.state = 'Tensor data is empty.';
+            return context;
+        }
+
+        try {
+            context.data = this._data instanceof Uint8Array ? this._data : this._data.peek();
+        }
+        catch (err) {
+            context.state = err.message;
+            return context;
+        }
+
+        context.dataType = this._type.dataType;
+        context.dimensions = this._type.shape.dimensions;
+        context.dataView = new DataView(context.data.buffer, context.data.byteOffset, context.data.byteLength);
+        return context;
+    }
+
+    _decode(context, dimension) {
+        const results = [];
+        const dimensions = (context.dimensions.length == 0) ? [1] : context.dimensions;
+        const size = dimensions[dimension];
+        if (dimension == dimensions.length - 1) {
+            for (let i = 0; i < size; i++) {
+                if (context.count > context.limit) {
+                    results.push('...');
+                    return results;
+                }
+                switch (context.dataType) {
+                    case 'boolean':
+                        results.push(context.dataView.getUint8(context.index) === 0 ? false : true);
+                        context.index++;
+                        context.count++;
+                        break;
+                    case 'uint8':
+                        results.push(context.dataView.getUint8(context.index));
+                        context.index++;
+                        context.count++;
+                        break;
+                    case 'qint8':
+                    case 'int8':
+                        results.push(context.dataView.getInt8(context.index));
+                        context.index++;
+                        context.count++;
+                        break;
+                    case 'int16':
+                        results.push(context.dataView.getInt16(context.index, true));
+                        context.index += 2;
+                        context.count++;
+                        break;
+                    case 'int32':
+                        results.push(context.dataView.getInt32(context.index, true));
+                        context.index += 4;
+                        context.count++;
+                        break;
+                    case 'int64':
+                        results.push(context.dataView.getInt64(context.index, true));
+                        context.index += 8;
+                        context.count++;
+                        break;
+                    case 'float16':
+                        results.push(context.dataView.getFloat16(context.index, true));
+                        context.index += 2;
+                        context.count++;
+                        break;
+                    case 'float32':
+                        results.push(context.dataView.getFloat32(context.index, true));
+                        context.index += 4;
+                        context.count++;
+                        break;
+                    case 'float64':
+                        results.push(context.dataView.getFloat64(context.index, true));
+                        context.index += 8;
+                        context.count++;
+                        break;
+                    case 'bfloat16':
+                        results.push(context.dataView.getBfloat16(context.index, true));
+                        context.index += 2;
+                        context.count++;
+                        break;
+                    default:
+                        throw new megengine.Error("Unsupported tensor data type '" + context.dataType + "'.");
+                }
+            }
+        }
+        else {
+            for (let j = 0; j < size; j++) {
+                if (context.count > context.limit) {
+                    results.push('...');
+                    return results;
+                }
+                results.push(this._decode(context, dimension + 1));
+            }
+        }
+        if (context.dimensions.length == 0) {
+            return results[0];
+        }
+        return results;
+    }
+
+    static _stringify(value, indentation, indent) {
+        if (Array.isArray(value)) {
+            const result = [];
+            result.push(indentation + '[');
+            const items = value.map((item) => megengine.Tensor._stringify(item, indentation + indent, indent));
+            if (items.length > 0) {
+                result.push(items.join(',\n'));
+            }
+            result.push(indentation + ']');
+            return result.join('\n');
+        }
+        if (value && (value instanceof base.Int64 || value instanceof base.Uint64)) {
+            return indentation + value.toString();
+        }
+        if (typeof value == 'string') {
+            return indentation + value;
+        }
+        if (value == Infinity) {
+            return indentation + 'Infinity';
+        }
+        if (value == -Infinity) {
+            return indentation + '-Infinity';
+        }
+        if (isNaN(value)) {
+            return indentation + 'NaN';
+        }
+        return indentation + value.toString();
+    }
+};
+
+megengine.TensorType = class {
+
+    constructor(dataType, shape) {
+        this._dataType = dataType;
+        this._shape = shape;
+    }
+
+    get dataType() {
+        return this._dataType;
+    }
+
+    get shape() {
+        return this._shape;
+    }
+
+    toString() {
+        return this._dataType + this._shape.toString();
+    }
+};
+
+megengine.TensorShape = class {
+
+    constructor(dimensions) {
+        this._dimensions = dimensions || [];
+    }
+
+    get dimensions() {
+        return this._dimensions;
+    }
+
+    toString() {
+        if (this._dimensions && this._dimensions.length > 0) {
+            return '[' + this._dimensions.map((dimension) => dimension.toString()).join(',') + ']';
+        }
+        return '';
+    }
+};
+
+megengine.Error = class extends Error {
+
+    constructor(message) {
+        super(message);
+        this.name = 'Error loading MegEngine model.';
+    }
+};
+
+if (typeof module !== 'undefined' && typeof module.exports === 'object') {
+    module.exports.ModelFactory = megengine.ModelFactory;
+}

source/python.js

@@ -2187,6 +2187,72 @@ python.Execution = class {
                 }
             }
         });
+        this.registerType('megengine.traced_module.traced_module.TracedModule', class { });
+        this.registerType('megengine.module.module.Module', class { });
+        this.registerType('megengine.traced_module.node.ModuleNode', class { });
+        this.registerType('megengine.traced_module.node.NodeMixin', class { });
+        this.registerType('megengine.traced_module.pytree.ArgsIndex', class { });
+        this.registerType('megengine.traced_module.node.TensorNode', class { });
+        this.registerType('megengine.traced_module.traced_module.InternalGraph', class { });
+        this.registerType('megengine.traced_module.expr.GetAttr', class { });
+        this.registerType('megengine.traced_module.expr.Input', class { });
+        this.registerType('megengine.traced_module.expr.CallMethod', class { });
+        this.registerType('megengine.core._imperative_rt.common.CompNode', class { });
+        this.registerType('megengine.traced_module.traced_module.NameSpace', class { });
+        this.registerType('megengine.traced_module.expr.CallFunction', class { });
+        this.registerType('megengine.traced_module.expr.Apply', class { });
+        this.registerType('megengine.traced_module.serialization._ModuleState', class { });
+        this.registerType('megengine.core._imperative_rt.ops.GetVarShape', class { });
+        this.registerType('megengine.tensor.Parameter', class {
+            constructor(data, dtype, device) {
+                this.data = data;
+                this.dtype = dtype;
+                this.device = device;
+            }
+        });
+        this.registerType('megengine.traced_module.pytree.TreeDef', class {
+            toString() {
+                let content = '';
+                for (const child of this.children_defs) {
+                    content += child.toString() + ",";
+                }
+                if (typeof this.type === "string") {
+                    return this.type.split(".").slice(-1) + '(' + content + ')';
+                }
+                return this.type.__name__ + '(' + content + ')';
+            }
+        });
+        this.registerType('megengine.traced_module.pytree.LeafDef', class {
+            toString() {
+                let content = '';
+                if (this.const_val !== null) {
+                    content += this.const_val;
+                }
+                else {content += '[';}
+                for (var t of Object.values(this.type)) {
+                    content += t.__name__;
+                }
+                content += ']';
+                return content;
+            }
+        });
+        this.registerType('megengine.tensor.Tensor', class {
+            constructor(data, dtype, device) {
+                this.data = data;
+                this.dtype = dtype;
+                this.device = device;
+            }
+        });
+        this.registerType('megengine.core.tensor.dtype.QuantDtypeMeta', class {
+            constructor(name, cname, np_dtype, qmin, qmax, is_signed) {
+                this.name = name;
+                this.cname = cname;
+                this.np_dtype = np_dtype;
+                this.qmin = qmin;
+                this.qmax = qmax;
+                this.is_signed = is_signed;
+            }
+        });
         this.registerType('nolearn.lasagne.base.BatchIterator', class {});
         this.registerType('nolearn.lasagne.base.Layers', class {});
         this.registerType('nolearn.lasagne.base.NeuralNet', class {});

source/view.js

@@ -1587,6 +1587,7 @@ view.ModelFactoryService = class {
         this.register('./lightgbm', [ '.txt', '.pkl', '.model' ]);
         this.register('./keras', [ '.h5', '.hd5', '.hdf5', '.keras', '.json', '.cfg', '.model', '.pb', '.pth', '.weights', '.pkl', '.lite', '.tflite', '.ckpt' ], [ '.zip' ]);
         this.register('./sklearn', [ '.pkl', '.pickle', '.joblib', '.model', '.meta', '.pb', '.pt', '.h5', '.pkl.z', '.joblib.z' ]);
+        this.register('./megengine', ['.tm']);
         this.register('./pickle', [ '.pkl', '.pickle', '.joblib', '.model', '.meta', '.pb', '.pt', '.h5', '.pkl.z', '.joblib.z', '.pdstates' ]);
         this.register('./cntk', [ '.model', '.cntk', '.cmf', '.dnn' ]);
         this.register('./paddle', [ '.pdmodel', '.pdiparams', '.pdparams', '.pdopt', '.paddle', '__model__', '.__model__', '.pbtxt', '.txt', '.tar', '.tar.gz', '.nb' ]);

test/models.json

@@ -2540,6 +2540,20 @@
     "format":   "MediaPipe",
     "link":     "https://github.com/google/mediapipe"
   },
+  {
+    "type":     "megengine",
+    "target":   "mobilenetv1.tm",
+    "source":   "https://github.com/lutzroeder/netron/files/9257882/mobilenetv1.tm.zip[mobilenetv1.tm]",
+    "format":   "MegEngine v1.10.0",
+    "link":     "https://github.com/MegEngine/MegEngine"
+  },
+  {
+    "type":     "megengine",
+    "target":   "shufflenet_v2_x1_0.tm",
+    "source":   "https://github.com/lutzroeder/netron/files/9257733/shufflenet_v2_x1_0.tm.zip[shufflenet_v2_x1_0.tm]",
+    "format":   "MegEngine v1.10.0",
+    "link":     "https://github.com/MegEngine/MegEngine"
+  },
   {
     "type":     "mlnet",
     "target":   "BinaryClassification_AutoML_SentimentModel.zip",