* \brief Describing the tensor shape with its actual layout in memory and dtype * * x(i, j, ...) is stored at offset * stride[0]*i + stride[1]*j +

wrap an identifier to associate document note: if the doc starts with a linebreak, it would not be reforamtted.

r"""A tensor object represents a multidimensional, homogeneous array of fixed-size items. Tensor is the primary MegEngine data structure. Dat

* \brief Describing the tensor shape. * * Uninitialized shape: ndim == 0; total_nr_elems() is also defined to be 0 * * Empty shape: ndim > 0 && sh

r"""A kind of Tensor that is to be considered a module parameter. Note: Operations happened on Parameter usually return a Tensor instead

Temporary half-precision expression. This class represents a half-precision expression which just stores a single-precision value internally.

r"""GradManager computes gradients or more generally, vector-Jacobian product, by reverse mode automatic differentiation (a.k.a. back propagation)

! * \brief configuration for operator nodes */

Temporary bfloat16 expression. This class represents a bfloat16 expression which just stores a single-precision value internally.

the network to load a model and forward Examples: .. code-block:: from megenginelite import * config = Lit

! * \brief Wrap a VarNode* for operator overloading */

Description of a block of data with neccessary information. Args: layout: layout of Tensor device_type: device type of Tenso

r"""Data loader. Combines a dataset and a sampler, and provides a convenient way to iterate on a given dataset. The process is as follows: ..

Description of layout using in Lite. A Lite layout will be totally defined by shape and data type. Args: shape: the shape of

* \brief Aligned workspace bundle. * * Each individual workspace is aligned to align_in_bytes. */

r""":class:`RNG` exposes a number of methods for generating random numbers. Args: seed: random seed used to initialize the pseudo-random

* class for string option */

Wraps a callable and provide: * tracing via :meth:`.trace` and :meth:`.dump` * accelerated evalutaion via :meth:`.__call__` Args:

* \brief A simple encapsulation class for n-dimensional tensor. */

! * \brief Information about a data type that can be accessed at runtime */

! * \brief abstraction of a streaming computing resource on localhost (a * thread on CPU, a cuda stream, etc.) * * Note that most of the oper

! * \brief a scalar value with associated dtype */

r"""Sample elements randomly without replacement. Args: dataset: dataset to sample from. batch_size: batch size for batch method.

Configuration when load and compile a network Attributes: has_compression: flag whether the model is compressed, the compress

Tag type for binary_t() construction.

* class for boolean option */

A helper class that counts the total number of constructor and destructor calls.

Tag type for binary_t() construction.

r"""Applies Batch Normalization over a 4D tensor. .. math:: y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma +

r"""Applies a 2D convolution over an input tensor. For instance, given an input of the size :math:`(N, C_{\text{in}}, H, W)`, this layer gene

* \brief create a tensor value from host value or device value * */

! * \brief slice along some axis; index as in Python, with negative indices * supported. Scalar index can also be represented as a Slice, where

r"""ArrayDataset is a dataset for numpy array data. One or more numpy arrays are needed to initiate the dataset. And the dimensions represent

r"""Applies a linear transformation to the input. For instance, if input is x, then output y is: .. math:: y = xW^T + b whe

* \brief A struct representing workspace. * * It differs from TensorND in that workspace does not have a "layout" concept. */

r"""A :class:`~.Module` to do :mod:`~.functional.elemwise` operator. Could be replaced with :class:`~.QATModule` version :class:`~.qat.Elemwise` u

config the network input and output item, the input and output tensor information will describe there Attributes: name: the tens

r"""Store metadata for quantize dtype. Could be used to create custom quant dtype for QAT when the network don't need to be converted for inferenc

define a const data field

r"""Loads a serialized computing graph as a GraphInference object which can be used to execute the computing graph. Args: file: could

the inference options which can optimize the network forwarding performance Attributes: weight_preprocess: is the option which o

* \brief like TensorShape, but allow real scalar shape. * */

r"""A helper :class:`~.Module` simply returning input. Could be replaced with :class:`~.QATModule` version :class:`~.qat.DequantStub` using :func:

r"""A helper :class:`~.Module` simply returning input. Could be replaced with :class:`~.QATModule` version :class:`~.qat.QuantStub` using :func:`~

r"""Sampler for stream dataset. Warning: In the case of multiple machines, sampler should ensure that each worker gets different

A tensor utils is used to collect many single batch tensor to a multi batch size tensor, when the multi batch size tensor collect finish, the

datatype conversion error

the input and output information when load the network for user the NetworkIO will remain in the network until the network is destroyed.

r"""A config class indicating how to do quantize toward :class:`~.QATModule` 's ``activation`` and ``weight``. See :meth:`~.QATModule.set_qconfig`

r"""Applies Synchronized Batch Normalization for distributed training. Args: num_features: usually :math:`C` from an input of shape

r""" Creates a Exponential distribution parameterized by :attr:`rate`. This is a EXPERIMENTAL module that may be subject to change and/or del

r"""``TensorNode`` represents the Tensor objects.

r"""Applies Batch Normalization over a 2D or 3D input. .. math:: y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamm

r"""``CallMethod`` represents a call to the ``__call__`` method of ``Module`` or a method of ``Tensor``. Args: node: the Node to be calle

The tensor data type enum Note: half for float16, int for int32

sample from multinomial distribution

r"""Implements stochastic gradient descent. This optimizer performs stochastic gradient descent with optional momentum and weight decay. Nes