mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/nn/generator.py

@@ -0,0 +1,297 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Generator"""
+import os
+
+import numpy as np
+
+from mindspore import context
+from mindspore.common.parameter import Parameter
+from mindspore.nn.cell import Cell
+from mindspore.ops.operations import Assign, AssignAdd, Depend
+
+
+class Generator(Cell):
+    """
+    A generator that manages the state of random numbers and provides seed and offset for random functions.
+    When the seed and offset are fixed, the random function generates the same random sequence.
+
+    Inputs:
+        - **step** (int) - Set the step size for offset update.
+
+    Outputs:
+        Tuple consisting of the seed and offset of generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore.nn import Generator
+        >>> import numpy as np
+        >>> np.random.seed(10)
+        >>> ms.set_context(mode=1)
+        >>> generator = Generator()
+        >>> print(generator.get_state())
+        (Tensor(shape=[], dtype=Int32, value= 0), Tensor(shape=[], dtype=Int32, value= 0))
+        >>> print(generator(12))
+        (0, 0)
+        >>> print(generator.get_state())
+        (Tensor(shape=[], dtype=Int32, value= 0), Tensor(shape=[], dtype=Int32, value= 12))
+        >>> generator.manual_seed(20)
+        >>> print(generator.get_state())
+        (Tensor(shape=[], dtype=Int32, value= 20), Tensor(shape=[], dtype=Int32, value= 0))
+        >>> print(generator.seed())
+        1165313289
+        >>> print(generator.initial_seed())
+        1165313289
+    """
+
+    def __init__(self):
+        super(Generator, self).__init__()
+        self._assign = Assign().set_device("CPU")
+        self._assign_add = AssignAdd().set_device("CPU")
+        self._depend = Depend()
+        self._seed = Parameter(0, name="seed", requires_grad=False)
+        self._offset = Parameter(0, name="offset", requires_grad=False)
+        self._seed_val = 0
+        self._offset_val = 0
+
+    def set_state(self, seed, offset=None):  # pylint: disable=redefined-outer-name
+        """
+        Sets the generator state.
+
+        Args:
+            seed (int): Seed of the generator.
+            offset (int, optional): Offset of the generator, default: ``None`` , means ``0``.
+        """
+        self._seed_val = int(seed)
+        self._assign(self._seed, self._seed_val)
+        if offset is None:
+            offset = 0
+        self._offset_val = int(offset)
+        self._assign(self._offset, self._offset_val)
+
+    def get_state(self):
+        """
+        Get the generator state.
+
+        Returns:
+            Tuple consisting of the seed and offset of generator.
+        """
+        return self._seed.value(), self._offset.value()
+
+    def seed(self):  # pylint: disable=redefined-outer-name
+        """
+        Generate random seeds that can be used as seeds for generator.
+
+        Returns:
+            Tensor, randomly generated seeds.
+        """
+        seed_ = np.random.randint(np.iinfo(np.int32).min, np.iinfo(np.int32).max)
+        self.set_state(seed_)
+        return self._seed.value()
+
+    def manual_seed(self, seed):  # pylint: disable=redefined-outer-name
+        """
+        Sets the generator seed.
+
+        Args:
+            seed (int): Sets the generator seed.
+
+        Returns:
+            The generator self.
+        """
+        self.set_state(seed)
+        return self
+
+    def initial_seed(self):
+        """
+        Return the initial seed of generator.
+
+        Returns:
+            The initial seed of generator.
+        """
+        return self._seed.value()
+
+    def construct(self, step):
+        """
+        Update the value of offset, and return the seed and the previous offset.
+
+        Args:
+            step (int): Update offset by step.
+
+        Returns:
+            Seed and offset before update.
+        """
+        offset = self._offset.value()
+        step = self._depend(step, offset)
+        self._assign_add(self._offset, step)
+        return self._seed.value(), offset
+
+    def __call__(self, step):
+        if os.getenv("MS_JIT") != '0' and context.get_context("mode") == context.GRAPH_MODE:
+            return super().__call__(step)
+
+        offset_val = self._offset_val
+        self._offset_val += step
+        self._offset.set_data(self._offset_val)
+        return self._seed_val, offset_val
+
+
+default_generator_ = None
+
+
+def _init_default_generator():
+    global default_generator_
+    default_generator_ = Generator()
+    default_generator_.seed()
+
+
+def default_generator():
+    """
+    Return the default generator object.
+
+    When the user does not specify generator, the random operator invokes default generator to generate random numbers.
+
+    Returns:
+        The default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import default_generator
+        >>> default_gen = default_generator()
+        >>> print(type(default_gen))
+        <class 'mindspore.nn.generator.Generator'>
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_
+
+
+def seed():  # pylint: disable=redefined-outer-name
+    """
+    Generate random seeds that can be used as seeds for default generator.
+
+    Returns:
+        Randomly generated seeds.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore.nn import seed
+        >>> np.random.seed(20)
+        >>> print(seed())
+        1663920602
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_.seed()
+
+
+def manual_seed(seed):  # pylint: disable=redefined-outer-name
+    """
+    Sets the default generator seed.
+
+    Args:
+        seed (int): Sets the default generator seed.
+
+    Returns:
+        The default generator self.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import manual_seed, initial_seed
+        >>> manual_seed(13)
+        >>> print(initial_seed())
+        13
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    default_generator_.manual_seed(seed)
+
+
+def initial_seed():
+    """
+    Return the initial seed of default generator.
+
+    Returns:
+        The initial seed of default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import manual_seed, initial_seed
+        >>> manual_seed(14)
+        >>> print(initial_seed())
+        14
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_.initial_seed()
+
+
+def get_rng_state():
+    """
+    Get the default generator state.
+
+    Returns:
+        Tuple consisting of the seed and offset of default generator.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore.nn import get_rng_state
+        >>> np.random.seed(20)
+        >>> print(get_rng_state())
+        (Tensor(shape=[], dtype=Int32, value= 378518883), Tensor(shape=[], dtype=Int32, value= 0))
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    return default_generator_.get_state()
+
+
+def set_rng_state(seed, offset=None):  # pylint: disable=redefined-outer-name
+    """
+    Sets the default generator state.
+
+    Args:
+        seed (int): Seed of the default generator.
+        offset (int, optional): Offset of the default generator, default: ``None`` , means ``0``.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore.nn import set_rng_state, get_rng_state
+        >>> set_rng_state(10)
+        >>> print(get_rng_state())
+        (Tensor(shape=[], dtype=Int32, value= 10), Tensor(shape=[], dtype=Int32, value= 0))
+    """
+    if default_generator_ is None:
+        _init_default_generator()
+    default_generator_.set_state(seed, offset)
+
+
+__all__ = ["Generator", "default_generator", "seed", "manual_seed", "initial_seed", "set_rng_state", "get_rng_state"]

mindspore/nn/layer/activation.py

@@ -351,17 +351,16 @@ class ELU(Cell):
 
     Args:
         alpha (float): The alpha value of ELU, the data type is float. Default: ``1.0`` .
-            Only alpha equal to ``1.0`` is supported currently.
 
     Inputs:
-        - **input_x** (Tensor) - The input of ELU is a Tensor of any dimension with data type of float16 or float32.
+        - **x** (Tensor) - The input of ELU is a Tensor of any dimension with data type of float16 or float32.
 
     Outputs:
-        Tensor, with the same type and shape as the `input_x`.
+        Tensor, with the same type and shape as the `x`.
 
     Raises:
         TypeError: If `alpha` is not a float.
-        TypeError: If dtype of `input_x` is neither float16 nor float32.
+        TypeError: If dtype of `x` is neither float16 nor float32.
         ValueError: If `alpha` is not equal to 1.0.
 
     Supported Platforms:

mindspore/nn/layer/basic.py

@@ -28,7 +28,6 @@ from mindspore.common.initializer import initializer, HeUniform, Uniform
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 from mindspore.ops.function.nn_func import interpolate_ext
-from mindspore.ops.auto_generate import unfold_ext
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.primitive import constexpr, Primitive, _primexpr
 from mindspore.common.parameter import Parameter
@@ -37,8 +36,8 @@ from mindspore import _checkparam as Validator
 from mindspore.nn.cell import Cell
 from mindspore.nn.layer.activation import get_activation
 from mindspore.common._decorator import deprecated
-from mindspore.ops.auto_generate import dropout_ext_op, fold_ext
-from mindspore.common.generator import default_generator
+from mindspore.ops.auto_generate import dropout_ext_op
+from mindspore.nn.generator import default_generator
 
 __all__ = ['Dropout', 'Flatten', 'Dense', 'ClipByNorm', 'Norm', 'OneHot', 'Pad', 'Unfold', 'Tril', 'Triu',
            'MatrixDiag', 'MatrixDiagPart', 'MatrixSetDiag', 'L1Regularizer', 'Dropout1d',
@@ -222,20 +221,20 @@ class DropoutExt(Cell):
 
     Note:
         - Each channel will be zeroed out independently on every construct call.
-        - Parameter `p` means the probability of the element of the input tensor to be zeroed.
+          Parameter `p` means the probability of the element of the input tensor to be zeroed.
 
     Args:
-        p (float): The dropout rate of input neurons, E.g. `p` =0.9, dropping out 90% of input neurons.
-            Default: ``0.5`` .
+        p (float): The dropout rate, greater than or equal to 0 and less than 1.
+            E.g. rate=0.9, dropping out 90% of input neurons. Default: ``0.5`` .
 
     Inputs:
-        - **x** (Tensor) - The input of Dropout.
+        - **x** (Tensor) - The input of Dropout with data type of float16 or float32.
 
     Outputs:
         Tensor, output tensor with the same shape as the `x`.
 
     Raises:
-        TypeError: If the dtype of `p` is not float.
+        ValueError: If `p` is not in range [0, 1).
         ValueError: If length of shape of `x` is less than 1.
 
     Supported Platforms:
@@ -256,15 +255,16 @@ class DropoutExt(Cell):
     def __init__(self, p=0.5):
         """Initialize DropoutExt."""
         super(DropoutExt, self).__init__()
+        self.generator = default_generator()
+        self.dropout = dropout_ext_op
         self.p = p
-        self.generator_step = Tensor(1, mstype.int64)
 
     def construct(self, x):
         if not self.training or self.p == 0:
             return x
 
-        seed, offset = default_generator._step(self.generator_step)  # pylint: disable=protected-access
-        out, _ = dropout_ext_op(x, self.p, seed, offset)
+        seed, offset = self.generator(1)
+        out, _ = self.dropout(x, self.p, seed, offset)
         return out
 
 
@@ -477,16 +477,16 @@ class Upsample(Cell):
 
 class UpsampleExt(Cell):
     r"""
-    For details, please refer to :func:`mindspore.mint.nn.functional.interpolate`.
+    For details, please refer to :func:`mindspore.mint.interpolate`.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import nn
+        >>> from mindspore import mint
         >>> x = ms.Tensor([[[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]])
-        >>> upsample = nn.UpsampleExt(size=(5, 5))
+        >>> upsample = mint.Upsample(size=(5, 5))
         >>> out = upsample(x)
         >>> print(x.asnumpy())
         [[[[1. 2. 3. 4.]
@@ -535,8 +535,7 @@ class Flatten(Cell):
         TypeError: If `x` is not a Tensor.
         TypeError: If `start_dim` or `end_dim` is not int.
         ValueError: If `start_dim` is greater than `end_dim` after canonicalized.
-        ValueError: If `start_dim` or `end_dim` is not in range of [-x.dim, x.dim-1]. For example, the default values
-                    are used for the args and the input is a 0-dimensional or 1-dimensional Tensor.
+        ValueError: If `start_dim` or `end_dim` is not in range of [-x.dim, x.dim-1].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1131,68 +1130,6 @@ class Unfold(Cell):
         return result
 
 
-class UnfoldExt(Cell):
-    r"""
-    Extracts sliding local blocks from a batched input tensor.
-
-    For details, please refer to :func:`mindspore.mint.nn.functional.unfold`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn
-        >>> input = Tensor(np.random.rand(4, 4, 32, 32), mindspore.float64)
-        >>> unfold = nn.UnfoldExt(kernel_size=3, dilation=1, stride=1)
-        >>> output = unfold(input)
-        >>> print(output.shape)
-        (4, 36, 900)
-    """
-    def __init__(self, kernel_size, dilation=1, padding=0, stride=1):
-        super(UnfoldExt, self).__init__()
-        self.kernel_size = kernel_size
-        self.dilation = dilation
-        self.padding = padding
-        self.stride = stride
-
-    def construct(self, input):
-        return unfold_ext(input, self.kernel_size, self.dilation, self.padding, self.stride)
-
-
-class Fold(Cell):
-    r"""
-    Combines an array of sliding local blocks into a large containing tensor.
-
-    For details, please refer to :func:`mindspore.mint.nn.functional.fold`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn
-        >>> from mindspore import dtype as mstype
-        >>> fold = nn.Fold([8, 8], [2, 2], [2, 2], [2, 2], [2, 2])
-        >>> input = Tensor(input_data=np.random.rand(16, 64, 25), dtype=mstype.float32)
-        >>> output = fold(input)
-        >>> print(output.shape)
-        (16, 16, 8, 8)
-    """
-    def __init__(self, output_size, kernel_size, dilation=1, padding=0, stride=1):
-        super(Fold, self).__init__()
-        self.output_size = output_size
-        self.kernel_size = kernel_size
-        self.dilation = dilation
-        self.padding = padding
-        self.stride = stride
-
-    def construct(self, input):
-        return fold_ext(input, self.output_size, self.kernel_size,
-                        self.dilation, self.padding, self.stride)
-
-
 @_primexpr
 def tril(x_shape, x_dtype, k):
     Validator.check_int(len(x_shape), 1, Validator.GE, "x rank", "tril")

mindspore/nn/layer/conv.py

@@ -16,7 +16,6 @@
 from __future__ import absolute_import
 
 import math
-import numpy as np
 
 from mindspore import context
 from mindspore.ops import operations as P
@@ -542,14 +541,10 @@ class Conv1d(_Conv):
         stride = (1, stride)
         dilation = (1, dilation)
         get_shape = P.Shape()
-        get_dtype = P.DType()
         if isinstance(weight_init, Tensor):
             weight_init_shape = get_shape(weight_init)
             Validator.check_equal_int(len(weight_init_shape), 3, 'weight_init_shape', self.cls_name)
-            weight_init_dtype = get_dtype(weight_init)
-            weight_init_value = weight_init.asnumpy()
-            weight_init_value = np.expand_dims(weight_init_value, 2)
-            weight_init = Tensor(weight_init_value, weight_init_dtype)
+            weight_init = weight_init.expand_dims(2)
 
         super(Conv1d, self).__init__(
             in_channels,
@@ -708,7 +703,7 @@ class Conv3d(_Conv):
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
-          Currently, input data type support float16 and float32 in CPU and GPU, and only float16 in Ascend.
+          Currently input data type only support float16 and float32.
 
     Outputs:
         Tensor of shape is :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`.
@@ -908,11 +903,11 @@ class Conv3dTranspose(_Conv):
         group (int): Splits filter into groups, `in_channels` and `out_channels` must be
             divisible by `group`. Default: ``1`` .
         output_padding (Union(int, tuple[int])): The number of padding on the depth, height and width directions of
-            the output. The data type is an integer or a tuple of three integers. If `output_padding` is an integer,
-            then the depth, height, and width dimension padding are all equal to `output_padding`.
-            If `output_padding` is a tuple of three integers, then the depth, height, and width padding is equal to
-            `output_padding[0]`, `output_padding[1]` and `output_padding[2]` respectively.
-            The value should be greater than or equal to 0.
+            the output. The data type is an integer or a tuple of six integers. If `output_padding` is an integer,
+            then the head, tail, top, bottom, left, and right padding are all equal to `output_padding`.
+            If `output_padding` is a tuple of six integers, then the head, tail, top, bottom, left, and right padding
+            is equal to `output_padding[0]`, `output_padding[1]`, `output_padding[2]`, `output_padding[3]`,
+            `output_padding[4]` and `output_padding[5]` respectively. The value should be greater than or equal to 0.
             Default: ``0`` .
         has_bias (bool): Whether the Conv3dTranspose layer has a bias parameter. Default: ``False`` .
         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
@@ -1437,14 +1432,10 @@ class Conv1dTranspose(_Conv):
         stride = (1, stride)
         dilation = (1, dilation)
         get_shape = P.Shape()
-        get_dtype = P.DType()
         if isinstance(weight_init, Tensor):
             weight_init_shape = get_shape(weight_init)
             Validator.check_equal_int(len(weight_init_shape), 3, 'weight_init_shape', self.cls_name)
-            weight_init_dtype = get_dtype(weight_init)
-            weight_init_value = weight_init.asnumpy()
-            weight_init_value = np.expand_dims(weight_init_value, 2)
-            weight_init = Tensor(weight_init_value, weight_init_dtype)
+            weight_init = weight_init.expand_dims(2)
         # out_channels and in_channels swap.
         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel,
         # then Conv1dTranspose's out_channel refers to Conv2DBackpropInput's in_channel.

mindspore/nn/layer/embedding.py

@@ -124,7 +124,10 @@ class Embedding(Cell):
             if isinstance(self.init_tensor, Tensor) and self.init_tensor.init is not None:
                 self.init_tensor = self.init_tensor.init_data()
             init_tensor_type = self.init_tensor.dtype
-            self.init_tensor = self.init_tensor.asnumpy()
+            if init_tensor_type == mstype.bfloat16:
+                self.init_tensor = self.init_tensor.float().asnumpy()
+            else:
+                self.init_tensor = self.init_tensor.asnumpy()
             self.init_tensor[self.padding_idx] = 0
             self.init_tensor = Tensor(self.init_tensor, init_tensor_type)
         self.embedding_table = Parameter(

mindspore/nn/layer/math.py

@@ -136,7 +136,7 @@ class Range(Cell):
         if delta == 0:
             raise ValueError(f"For '{self.cls_name}', the 'delta' can not be zero.")
         data = np.arange(start, limit, delta)
-        if data.dtype == np.float_:
+        if data.dtype == np.float:
             self.ms_dtype = mstype.float32
         else:
             self.ms_dtype = mstype.int32

mindspore/nn/layer/normalization.py

@@ -1152,7 +1152,7 @@ class GroupNorm(Cell):
 
     def _cal_output(self, x):
         """calculate groupnorm output"""
-        return group_norm(x, self.num_groups, self.gamma.to(x.dtype), self.beta.to(x.dtype), self.eps)
+        return group_norm(x, self.num_groups, self.gamma, self.beta, self.eps)
 
     @staticmethod
     @_primexpr

mindspore/nn/layer/pooling.py

@@ -27,7 +27,6 @@ from mindspore.common import dtype as mstype
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool2D
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool3D, AdaptiveAvgPool3D
 from mindspore.nn.cell import Cell
-from mindspore._c_expression import MSContext
 
 __all__ = ['AvgPool3d', 'MaxPool3d', 'AvgPool2d', 'MaxPool2d', 'AvgPool1d', 'MaxPool1d', 'FractionalMaxPool2d',
            'FractionalMaxPool3d', 'AdaptiveAvgPool1d', 'AdaptiveMaxPool1d', 'AdaptiveMaxPool2d', 'AdaptiveMaxPool3d',
@@ -1015,12 +1014,8 @@ class AvgPool2d(_PoolNd):
                  data_format="NCHW"):
         """Initialize AvgPool2d."""
         super(AvgPool2d, self).__init__(kernel_size, stride, pad_mode, data_format)
-        self.ascend_910bc_target = (MSContext.get_instance().get_ascend_soc_version() in ['ascend910b', 'ascend910c'])
         if pad_mode.upper() == 'PAD' or padding != 0 or ceil_mode or not count_include_pad \
                 or divisor_override is not None:
-            if self.ascend_910bc_target:
-                raise ValueError(f"For '{self.cls_name}, the pad_mod 'PAD' is not support in 910B now, "
-                                 f"it will be supported in the future.")
             if self.format == "NHWC":
                 raise ValueError(f"For '{self.cls_name}, the 'NHWC' format are not support when 'pad_mode' is 'pad' or "
                                  f"'padding' is not 0 or 'ceil_mode' is not False or 'count_include_pad' is not True"

mindspore/nn/layer/rnn_cells.py

@@ -178,7 +178,7 @@ class RNNCell(RNNCellBase):
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
-        has_bias (bool): Whether the cell has bias :math:`b_{ih}` and :math:`b_{hh}`. Default: ``True`` .
+        has_bias (bool): Whether the cell has bias :math:`b_ih` and :math:`b_hh`. Default: ``True`` .
         nonlinearity (str): The non-linearity to use. Can be either ``"tanh"`` or ``"relu"`` .
             Default: ``"tanh"`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
@@ -263,7 +263,7 @@ class LSTMCell(RNNCellBase):
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
-        has_bias (bool): Whether the cell has bias `b_{ih}` and `b_{hh}`. Default: ``True`` .
+        has_bias (bool): Whether the cell has bias `b_ih` and `b_hh`. Default: ``True`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs: