shrinath-suresh/blogs-docs-splitted huggingface dataset:
ratio of the input size, this option can be given. This has to
        be a number or tuple in the range (0, 1)
  * **return_indices** -- if "True", will return the indices along
    with the outputs. Useful to pass to "max_unpool2d()".

Examples::
      >>> input = torch.randn(20, 16, 50, 32)
      >>> # pool of square window of size=3, and target output size 13x12
      >>> F.fractional_max_pool2d(input, 3, output_size=(13, 12))
      >>> # pool of square window and target output size being half of input image size
      >>> F.fractional_max_pool2d(input, 3, output_ratio=(0.5, 0.5))
torch.nn.functional.batch_norm
torch.nn.functional.batch_norm(input, running_mean, running_var, weight=None, bias=None, training=False, momentum=0.1, eps=1e-05)
Applies Batch Normalization for each channel across a batch of
   data.
See "BatchNorm1d", "BatchNorm2d", "BatchNorm3d" for details.
Return type:
      Tensor
torch.jit.set_fusion_strategy
torch.jit.set_fusion_strategy(strategy)
Sets the type and number of specializations that can occur during
   fusion.
Usage: provide a list of pairs (type, depth) where type is one of
   "STATIC" or "DYNAMIC" and depth is an integer.
Behavior - static vs dynamic:
      In STATIC fusion, fused ops are compiled to have fixed input
      shapes. The shape is determined based on some initial profiling
      runs. In DYNAMIC fusion, fused ops are compiled to have variable
      input shapes, so that multiple shapes are possible.
In both cases, we also recompile on new striding behavior, device,
   or dtype.
Behavior - fallback functions & depth:
      When an input doesn't match the format required by the
      specialized compiled op, it will run a fallback function.
      Fallback functions are recursively be compiled and specialized
      based on the observed tensor shapes. Since compilation can be
slow, the "depth" parameter is provided to limit the number of
      specializations that can be compiled, before giving up on
      recompiling and falling back to a completely un-fused, un-
      specialized implementation.
The list of (type, depth) pairs controls the type of
   specializations and the number of specializations. For example:
   [("STATIC", 2), ("DYNAMIC", 2)] indicates that the first two
   specializations will use static fusions, the following two
   specializations will use dynamic fusion, and any inputs that
   satisfy none of the 4 options will run an unfused implementation.
NB: in the future, if more as more fusion backends are added there
   may be more granular apis for specific fusers.
AdaptiveMaxPool2d
class torch.nn.AdaptiveMaxPool2d(output_size, return_indices=False)
Applies a 2D adaptive max pooling over an input signal composed of
   several input planes.
The output is of size H_{out} \times W_{out}, for any input size.
   The number of output features is equal to the number of input
   planes.
Parameters:
      * output_size (Union[int, None,
        Tuple[Optional[int],
        Optional[int]]]) -- the target output size of the
        image of the form H_{out} \times W_{out}. Can be a tuple
        (H_{out}, W_{out}) or a single H_{out} for a square image
        H_{out} \times H_{out}. H_{out} and W_{out} can be either a
        "int", or "None" which means the size will be the same as that
        of the input.
  * **return_indices** (*bool*) -- if "True", will return the
    indices along with the outputs. Useful to pass to
    nn.MaxUnpool2d. Default: "False"

Shape:
Shape:
      * Input: (N, C, H_{in}, W_{in}) or (C, H_{in}, W_{in}).
  * Output: (N, C, H_{out}, W_{out}) or (C, H_{out}, W_{out}),
    where (H_{out}, W_{out})=\text{output\_size}.

-[ Examples ]-



target output size of 5x7
m = nn.AdaptiveMaxPool2d((5, 7))
input = torch.randn(1, 64, 8, 9)
output = m(input)
target output size of 7x7 (square)
m = nn.AdaptiveMaxPool2d(7)
input = torch.randn(1, 64, 10, 9)
output = m(input)
target output size of 10x7
m = nn.AdaptiveMaxPool2d((None, 7))
input = torch.randn(1, 64, 10, 9)
output = m(input)
UpsamplingBilinear2d
class torch.nn.UpsamplingBilinear2d(size=None, scale_factor=None)
Applies a 2D bilinear upsampling to an input signal composed of
   several input channels.
To specify the scale, it takes either the "size" or the
   "scale_factor" as it's constructor argument.
When "size" is given, it is the output size of the image (h, w).
Parameters:
      * size (int or Tuple[int, int],
        optional) -- output spatial sizes
  * **scale_factor** (*float** or **Tuple**[**float**,
    **float**]**, **optional*) -- multiplier for spatial size.

Warning:
 This class is deprecated in favor of "interpolate()". It is
 equivalent to "nn.functional.interpolate(..., mode='bilinear',
 align_corners=True)".

Shape:
      * Input: (N, C, H_{in}, W_{in})
  * Output: (N, C, H_{out}, W_{out}) where

  H_{out} = \left\lfloor H_{in} \times \text{scale\_factor}
  \right\rfloor
\right\rfloor
  W_{out} = \left\lfloor W_{in} \times \text{scale\_factor}
  \right\rfloor

Examples:
  >>> input = torch.arange(1, 5, dtype=torch.float32).view(1, 1, 2, 2)
  >>> input
  tensor([[[[1., 2.],
            [3., 4.]]]])

  >>> m = nn.UpsamplingBilinear2d(scale_factor=2)
  >>> m(input)
  tensor([[[[1.0000, 1.3333, 1.6667, 2.0000],
            [1.6667, 2.0000, 2.3333, 2.6667],
            [2.3333, 2.6667, 3.0000, 3.3333],
            [3.0000, 3.3333, 3.6667, 4.0000]]]])
AvgPool2d
class torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)
Applies a 2D average pooling over an input signal composed of
   several input planes.
In the simplest case, the output value of the layer with input size
   (N, C, H, W), output (N, C, H_{out}, W_{out}) and "kernel_size"
   (kH, kW) can be precisely described as:
  out(N_i, C_j, h, w)  = \frac{1}{kH * kW} \sum_{m=0}^{kH-1}
  \sum_{n=0}^{kW-1}                        input(N_i, C_j,
  stride[0] \times h + m, stride[1] \times w + n)

If "padding" is non-zero, then the input is implicitly zero-padded
   on both sides for "padding" number of points.
Note:
 When ceil_mode=True, sliding windows are allowed to go off-bounds
 if they start within the left padding or the input. Sliding
 windows that would start in the right padded region are ignored.

The parameters "kernel_size", "stride", "padding" can either be:
a single "int" -- in which case the same value is used for the
        height and width dimension

a "tuple" of two ints -- in which case, the first int is
    used for the height dimension, and the second int for the
    width dimension



Parameters:
      * kernel_size (Union[int, Tuple[int,
        int]]) -- the size of the window
  * **stride** (*Union**[**int**, **Tuple**[**int**, **int**]**]*)
    -- the stride of the window. Default value is "kernel_size"

  * **padding** (*Union**[**int**, **Tuple**[**int**,
    **int**]**]*) -- implicit zero padding to be added on both
    sides

  * **ceil_mode** (*bool*) -- when True, will use *ceil* instead
    of *floor* to compute the output shape

  * **count_include_pad** (*bool*) -- when True, will include the
    zero-padding in the averaging calculation

  * **divisor_override** (*Optional**[**int**]*) -- if specified,
it will be used as divisor, otherwise size of the pooling
        region will be used.
Shape:
      * Input: (N, C, H_{in}, W_{in}) or (C, H_{in}, W_{in}).
  * Output: (N, C, H_{out}, W_{out}) or (C, H_{out}, W_{out}),
    where

       H_{out} = \left\lfloor\frac{H_{in}  + 2 \times
       \text{padding}[0] -
       \text{kernel\_size}[0]}{\text{stride}[0]} + 1\right\rfloor

       W_{out} = \left\lfloor\frac{W_{in}  + 2 \times
       \text{padding}[1] -
       \text{kernel\_size}[1]}{\text{stride}[1]} + 1\right\rfloor

Examples:
  >>> # pool of square window of size=3, stride=2
  >>> m = nn.AvgPool2d(3, stride=2)
  >>> # pool of non-square window
  >>> m = nn.AvgPool2d((3, 2), stride=(2, 1))
  >>> input = torch.randn(20, 16, 50, 32)
  >>> output = m(input)
torch.nn.functional.feature_alpha_dropout
torch.nn.functional.feature_alpha_dropout(input, p=0.5, training=False, inplace=False)
Randomly masks out entire channels (a channel is a feature map,
   e.g. the j-th channel of the i-th sample in the batch input is a
   tensor \text{input}[i, j]) of the input tensor). Instead of setting
   activations to zero, as in regular Dropout, the activations are set
   to the negative saturation value of the SELU activation function.
Each element will be masked independently on every forward call
   with probability "p" using samples from a Bernoulli distribution.
   The elements to be masked are randomized on every forward call, and
   scaled and shifted to maintain zero mean and unit variance.
See "FeatureAlphaDropout" for details.
Parameters:
      * p (float) -- dropout probability of a channel to be
        zeroed. Default: 0.5
  * **training** (*bool*) -- apply dropout if is "True". Default:
torch.Tensor.to_sparse_csr
Tensor.to_sparse_csr(dense_dim=None) -> Tensor
Convert a tensor to compressed row storage format (CSR).  Except
   for strided tensors, only works with 2D tensors.  If the "self" is
   strided, then the number of dense dimensions could be specified,
   and a hybrid CSR tensor will be created, with dense_dim dense
   dimensions and self.dim() - 2 - dense_dim batch dimension.
Parameters:
      dense_dim (int, optional) -- Number of dense
      dimensions of the resulting CSR tensor.  This argument should be
      used only if "self" is a strided tensor, and must be a value
      between 0 and dimension of "self" tensor minus two.
Example:
  >>> dense = torch.randn(5, 5)
  >>> sparse = dense.to_sparse_csr()
  >>> sparse._nnz()
  25

  >>> dense = torch.zeros(3, 3, 1, 1)
  >>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
  >>> dense.to_sparse_csr(dense_dim=2)
  tensor(crow_indices=tensor([0, 1, 2, 3]),
torch.nn.functional.glu
torch.nn.functional.glu(input, dim=- 1) -> Tensor
The gated linear unit. Computes:
  \text{GLU}(a, b) = a \otimes \sigma(b)

where input is split in half along dim to form a and b,
   \sigma is the sigmoid function and \otimes is the element-wise
   product between matrices.
See Language Modeling with Gated Convolutional Networks.
Parameters:
      * input (Tensor) -- input tensor
  * **dim** (*int*) -- dimension on which to split the input.
    Default: -1

Return type:
      Tensor
torch.nn.functional.conv1d
torch.nn.functional.conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor
Applies a 1D convolution over an input signal composed of several
   input planes.
This operator supports TensorFloat32.
See "Conv1d" for details and output shape.
Note:
 In some circumstances when given tensors on a CUDA device and
 using CuDNN, this operator may select a nondeterministic
 algorithm to increase performance. If this is undesirable, you
 can try to make the operation deterministic (potentially at a
 performance cost) by setting "torch.backends.cudnn.deterministic
 = True". See Reproducibility for more information.

Note:
 This operator supports complex data types i.e. "complex32,
 complex64, complex128".

Parameters:
      * input -- input tensor of shape (\text{minibatch} ,
        \text{in_channels} , iW)
  * **weight** -- filters of shape (\text{out\_channels} ,
\frac{\text{in_channels}}{\text{groups}} , kW)
  * **bias** -- optional bias of shape (\text{out\_channels}).
    Default: "None"

  * **stride** -- the stride of the convolving kernel. Can be a
    single number or a one-element tuple *(sW,)*. Default: 1

  * **padding** --

    implicit paddings on both sides of the input. Can be a string
    {'valid', 'same'}, single number or a one-element tuple
    *(padW,)*. Default: 0 "padding='valid'" is the same as no
    padding. "padding='same'" pads the input so the output has the
    same shape as the input. However, this mode doesn't support
    any stride values other than 1.

    Warning:

      For "padding='same'", if the "weight" is even-length and
      "dilation" is odd in any dimension, a full "pad()" operation
      may be needed internally. Lowering performance.

  * **dilation** -- the spacing between kernel elements. Can be a
single number or a one-element tuple (dW,). Default: 1
  * **groups** -- split input into groups, \text{in\_channels}
    should be divisible by the number of groups. Default: 1

Examples:
  >>> inputs = torch.randn(33, 16, 30)
  >>> filters = torch.randn(20, 16, 5)
  >>> F.conv1d(inputs, filters)
torch.gradient
torch.gradient(input, *, spacing=1, dim=None, edge_order=1) -> List of Tensors
Estimates the gradient of a function g : \mathbb{R}^n \rightarrow
   \mathbb{R} in one or more dimensions using the second-order
   accurate central differences method.
The gradient of g is estimated using samples. By default, when
   "spacing" is not specified, the samples are entirely described by
   "input", and the mapping of input coordinates to an output is the
   same as the tensor's mapping of indices to values. For example, for
   a three-dimensional "input" the function described is g :
   \mathbb{R}^3 \rightarrow \mathbb{R}, and g(1, 2, 3)\ == input[1, 2,
   3].
When "spacing" is specified, it modifies the relationship between
   "input" and input coordinates. This is detailed in the "Keyword
   Arguments" section below.
The gradient is estimated by estimating each partial derivative of
   g independently. This estimation is accurate if g is in C^3 (it has
at least 3 continuous derivatives), and the estimation can be
   improved by providing closer samples. Mathematically, the value at
   each interior point of a partial derivative is estimated using
   Taylorâs theorem with remainder. Letting x be an interior point and
   x+h_r be point neighboring it, the partial gradient at f(x+h_r) is
   estimated using:
  \begin{aligned}     f(x+h_r) = f(x) + h_r f'(x) + {h_r}^2
  \frac{f''(x)}{2} + {h_r}^3 \frac{f'''(x_r)}{6} \\ \end{aligned}

where x_r is a number in the interval [x, x+ h_r]  and using the
   fact that f \in C^3 we derive :
  f'(x) \approx \frac{ {h_l}^2 f(x+h_r) - {h_r}^2 f(x-h_l)       +
  ({h_r}^2-{h_l}^2 ) f(x) }{ {h_r} {h_l}^2 + {h_r}^2 {h_l} }

Note:
 We estimate the gradient of functions in complex domain g :
 \mathbb{C}^n \rightarrow \mathbb{C} in the same way.

The value of each partial derivative at the boundary points is
   computed differently. See edge_order below.
Parameters:
Parameters:
      input ("Tensor") -- the tensor that represents the values of
      the function
Keyword Arguments:
      * spacing ("scalar", "list of scalar", "list of Tensor",
        optional) -- "spacing" can be used to modify how the "input"
        tensor's indices relate to sample coordinates. If "spacing" is
        a scalar then the indices are multiplied by the scalar to
        produce the coordinates. For example, if "spacing=2" the
        indices (1, 2, 3) become coordinates (2, 4, 6). If "spacing"
        is a list of scalars then the corresponding indices are
        multiplied. For example, if "spacing=(2, -1, 3)" the indices
        (1, 2, 3) become coordinates (2, -2, 9). Finally, if "spacing"
        is a list of one-dimensional tensors then each tensor
        specifies the coordinates for the corresponding dimension. For
        example, if the indices are (1, 2, 3) and the tensors are (t0,
        t1, t2), then the coordinates are (t0[1], t1[2], t2[3])
dim ("int", "list of int", optional) -- the dimension or
        dimensions to approximate the gradient over.  By default the
        partial  gradient in every dimension is computed. Note that
        when "dim" is  specified the elements of the "spacing"
        argument must correspond with the specified dims."

edge_order ("int", optional) -- 1 or 2, for first-order or
    second-order estimation of the boundary ("edge") values,
    respectively.



Examples:
  >>> # Estimates the gradient of f(x)=x^2 at points [-2, -1, 2, 4]
  >>> coordinates = (torch.tensor([-2., -1., 1., 4.]),)
  >>> values = torch.tensor([4., 1., 1., 16.], )
  >>> torch.gradient(values, spacing = coordinates)
  (tensor([-3., -2., 2., 5.]),)

  >>> # Estimates the gradient of the R^2 -> R function whose samples are
  >>> # described by the tensor t. Implicit coordinates are [0, 1] for the outermost
dimension and [0, 1, 2, 3] for the innermost dimension, and function estimates
  >>> # partial derivative for both dimensions.
  >>> t = torch.tensor([[1, 2, 4, 8], [10, 20, 40, 80]])
  >>> torch.gradient(t)
  (tensor([[ 9., 18., 36., 72.],
           [ 9., 18., 36., 72.]]),
   tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
           [10.0000, 15.0000, 30.0000, 40.0000]]))




  >>> # A scalar value for spacing modifies the relationship between tensor indices
  >>> # and input coordinates by multiplying the indices to find the
  >>> # coordinates. For example, below the indices of the innermost
  >>> # 0, 1, 2, 3 translate to coordinates of [0, 2, 4, 6], and the indices of
  >>> # the outermost dimension 0, 1 translate to coordinates of [0, 2].
  >>> torch.gradient(t, spacing = 2.0) # dim = None (implicitly [0, 1])
  (tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
            [ 4.5000, 9.0000, 18.0000, 36.0000]]),
tensor([[ 0.5000, 0.7500, 1.5000, 2.0000],
                [ 5.0000, 7.5000, 15.0000, 20.0000]]))
      >>> # doubling the spacing between samples halves the estimated partial gradients.
  >>>
  >>> # Estimates only the partial derivative for dimension 1
  >>> torch.gradient(t, dim = 1) # spacing = None (implicitly 1.)
  (tensor([[ 1.0000, 1.5000, 3.0000, 4.0000],
           [10.0000, 15.0000, 30.0000, 40.0000]]),)

  >>> # When spacing is a list of scalars, the relationship between the tensor
  >>> # indices and input coordinates changes based on dimension.
  >>> # For example, below, the indices of the innermost dimension 0, 1, 2, 3 translate
  >>> # to coordinates of [0, 3, 6, 9], and the indices of the outermost dimension
  >>> # 0, 1 translate to coordinates of [0, 2].
  >>> torch.gradient(t, spacing = [3., 2.])
  (tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
           [ 4.5000, 9.0000, 18.0000, 36.0000]]),
tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
               [ 3.3333, 5.0000, 10.0000, 13.3333]]))
  >>> # The following example is a replication of the previous one with explicit
  >>> # coordinates.
  >>> coords = (torch.tensor([0, 2]), torch.tensor([0, 3, 6, 9]))
  >>> torch.gradient(t, spacing = coords)
  (tensor([[ 4.5000, 9.0000, 18.0000, 36.0000],
           [ 4.5000, 9.0000, 18.0000, 36.0000]]),
   tensor([[ 0.3333, 0.5000, 1.0000, 1.3333],
           [ 3.3333, 5.0000, 10.0000, 13.3333]]))
torch.select_scatter
torch.select_scatter(input, src, dim, index) -> Tensor
Embeds the values of the "src" tensor into "input" at the given
   index. This function returns a tensor with fresh storage; it does
   not create a view.
Parameters:
      * input (Tensor) -- the input tensor.
  * **src** (*Tensor*) -- The tensor to embed into "input"

  * **dim** (*int*) -- the dimension to insert the slice into.

  * **index** (*int*) -- the index to select with

Note:
 "src" must be of the proper size in order to be embedded into
 "input". Specifically, it should have the same shape as
 "torch.select(input, dim, index)"

Example:
  >>> a = torch.zeros(2, 2)
  >>> b = torch.ones(2)
  >>> a.select_scatter(b, 0, 0)
  tensor([[1., 1.],
          [0., 0.]])
LSTM
class torch.nn.quantizable.LSTM(input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0.0, bidirectional=False, device=None, dtype=None)
A quantizable long short-term memory (LSTM).
For the description and the argument types, please, refer to "LSTM"
Variables:
      layers -- instances of the _LSTMLayer
Note:
 To access the weights and biases, you need to access them per
 layer. See examples below.

Examples:
  >>> import torch.nn.quantizable as nnqa
  >>> rnn = nnqa.LSTM(10, 20, 2)
  >>> input = torch.randn(5, 3, 10)
  >>> h0 = torch.randn(2, 3, 20)
  >>> c0 = torch.randn(2, 3, 20)
  >>> output, (hn, cn) = rnn(input, (h0, c0))
  >>> # To get the weights:
  >>> print(rnn.layers[0].weight_ih)
  tensor([[...]])
  >>> print(rnn.layers[0].weight_hh)
  AssertionError: There is no reverse path in the non-bidirectional layer
torch.result_type
torch.result_type(tensor1, tensor2) -> dtype
Returns the "torch.dtype" that would result from performing an
   arithmetic operation on the provided input tensors. See type
   promotion documentation for more information on the type promotion
   logic.
Parameters:
      * tensor1 (Tensor or Number) -- an input tensor or
        number
  * **tensor2** (*Tensor** or **Number*) -- an input tensor or
    number

Example:
  >>> torch.result_type(torch.tensor([1, 2], dtype=torch.int), 1.0)
  torch.float32
  >>> torch.result_type(torch.tensor([1, 2], dtype=torch.uint8), torch.tensor(1))
  torch.uint8
torch.resolve_neg
torch.resolve_neg(input) -> Tensor
Returns a new tensor with materialized negation if "input"'s
   negative bit is set to True, else returns "input". The output
   tensor will always have its negative bit set to False. :param
   input: the input tensor. :type input: Tensor
Example:
  >>> x = torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j])
  >>> y = x.conj()
  >>> z = y.imag
  >>> z.is_neg()
  True
  >>> out = y.resolve_neg()
  >>> out
  tensor([-1, -2, -3])
  >>> out.is_neg()
  False
torch.conj_physical
torch.conj_physical(input, *, out=None) -> Tensor
Computes the element-wise conjugate of the given "input" tensor. If
   "input" has a non-complex dtype, this function just returns
   "input".
Note:
 This performs the conjugate operation regardless of the fact
 conjugate bit is set or not.

Warning:
 In the future, "torch.conj_physical()" may return a non-writeable
 view for an "input" of non-complex dtype. It's recommended that
 programs not modify the tensor returned by
 "torch.conj_physical()" when "input" is of non-complex dtype to
 be compatible with this change.

  \text{out}_{i} = conj(\text{input}_{i})

Parameters:
      input (Tensor) -- the input tensor.
Keyword Arguments:
      out (Tensor, optional) -- the output tensor.
Example:
  >>> torch.conj_physical(torch.tensor([-1 + 1j, -2 + 2j, 3 - 3j]))
  tensor([-1 - 1j, -2 - 2j, 3 + 3j])
torch.Tensor.new_zeros
Tensor.new_zeros(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) -> Tensor
Returns a Tensor of size "size" filled with "0". By default, the
   returned Tensor has the same "torch.dtype" and "torch.device" as
   this tensor.
Parameters:
      size (int...) -- a list, tuple, or "torch.Size" of
      integers defining the shape of the output tensor.
Keyword Arguments:
      * dtype ("torch.dtype", optional) -- the desired type of
        returned tensor. Default: if None, same "torch.dtype" as this
        tensor.
  * **device** ("torch.device", optional) -- the desired device of
    returned tensor. Default: if None, same "torch.device" as this
    tensor.

  * **requires_grad** (*bool**, **optional*) -- If autograd should
    record operations on the returned tensor. Default: "False".

  * **layout** ("torch.layout", optional) -- the desired layout of
returned Tensor. Default: "torch.strided".
  * **pin_memory** (*bool**, **optional*) -- If set, returned
    tensor would be allocated in the pinned memory. Works only for
    CPU tensors. Default: "False".

Example:
  >>> tensor = torch.tensor((), dtype=torch.float64)
  >>> tensor.new_zeros((2, 3))
  tensor([[ 0.,  0.,  0.],
          [ 0.,  0.,  0.]], dtype=torch.float64)
propagate_qconfig
class torch.quantization.propagate_qconfig_(module, qconfig_dict=None, prepare_custom_config_dict=None)
Propagate qconfig through the module hierarchy and assign qconfig
   attribute on each leaf module
Parameters:
      * module -- input module
  * **qconfig_dict** -- dictionary that maps from name or type of
    submodule to quantization configuration, qconfig applies to
    all submodules of a given module unless qconfig for the
    submodules are specified (when the submodule already has
    qconfig attribute)

  * **prepare_custom_config_dict** -- dictionary for custom
    handling of modules see docs for "prepare_fx()"

Returns:
      None, module is modified inplace with qconfig attached