mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

mindspore/include/c_api/ms/tensor.h

@@ -1,161 +0,0 @@
-/**
- * Copyright 2022 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.
- */
-
-#ifndef MINDSPORE_CCSRC_C_API_INCLUDE_FUNC_TENSOR_H_
-#define MINDSPORE_CCSRC_C_API_INCLUDE_FUNC_TENSOR_H_
-
-#include <stdbool.h>
-#include <stdlib.h>
-#include "include/c_api/ms/base/macros.h"
-#include "include/c_api/ms/base/status.h"
-#include "include/c_api/ms/base/types.h"
-#include "include/c_api/ms/base/handle_types.h"
-#include "include/c_api/ms/context.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// \brief Create a tensor with input data buffer.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] data The input data to be copied into tensor.
-/// \param[in] type [TypeId] Data type of the tensor.
-/// \param[in] shape The shape arary of the tensor.
-/// \param[in] shape_size The size of shape array, i.e., the rank of the tensor.
-/// \param[in] data_len The length of data in bytes.
-///
-/// \return The pointer of the created tensor instance.
-MIND_C_API TensorHandle MSNewTensor(ResMgrHandle res_mgr, void *data, DataTypeC type, const int64_t shape[],
-                                    size_t shape_size, size_t data_len);
-
-/// \brief Create a tensor with path to a space-sperated txt file.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] type [TypeId] Data type of the tensor.
-/// \param[in] shape The shape arary of the tensor.
-/// \param[in] shape_size The size of shape array, i.e., the rank of the tensor.
-/// \param[in] path path to the file.
-///
-/// \return The pointer of the created tensor instance.
-MIND_C_API TensorHandle MSNewTensorFromFile(ResMgrHandle res_mgr, DataTypeC type, const int64_t shape[],
-                                            size_t shape_size, const char *path);
-
-/// \brief Create a tensor with input data buffer and given source data type.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] shape The shape arary of the tensor.
-/// \param[in] shape_size The size of shape array, i.e., the rank of the tensor.
-/// \param[in] data The input data to be copied into tensor.
-/// \param[in] tensor_type [TypeId] Data type of the tensor.
-/// \param[in] src_type [TypeId] The source data type.
-///
-/// \return The pointer of the created tensor instance.
-MIND_C_API TensorHandle MSNewTensorWithSrcType(ResMgrHandle res_mgr, void *data, const int64_t shape[],
-                                               size_t shape_size, DataTypeC tensor_type, DataTypeC src_type);
-
-/// \brief Create a tensor with float32 scalar value.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] value The input scalar value.
-///
-/// \return The pointer of the created tensor instance.
-MIND_C_API TensorHandle MSNewTensorScalarFloat32(ResMgrHandle res_mgr, float value);
-
-/// \brief Create a tensor with int32 scalar value.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] value The input scalar value.
-///
-/// \return The pointer of the created tensor instance.
-MIND_C_API TensorHandle MSNewTensorScalarInt32(ResMgrHandle res_mgr, int value);
-
-/// \brief Get the raw pointer of tensor data.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-///
-/// \return The pointer to the tensor data
-MIND_C_API void *MSTensorGetData(ResMgrHandle res_mgr, ConstTensorHandle tensor);
-
-/// \brief Set tensor data type.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-/// \param[in] type The data type to be set.
-///
-/// \return Error code that indicate whether the functions executed successfully.
-MIND_C_API STATUS MSTensorSetDataType(ResMgrHandle res_mgr, TensorHandle tensor, DataTypeC type);
-
-/// \brief Get tensor data type.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-///
-/// \return The data type of tensor.
-MIND_C_API DataTypeC MSTensorGetDataType(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
-
-/// \brief Get the byte size of tensor data.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-/// \param[in] error Records error code that indicate whether the functions executed successfully.
-///
-/// \return The byte size of tensor data.
-MIND_C_API size_t MSTensorGetDataSize(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
-
-/// \brief Get the element number of tensor array.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-/// \param[in] error Records error code that indicate whether the functions executed successfully.
-///
-/// \return The element number of tensor array.
-MIND_C_API size_t MSTensorGetElementNum(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
-
-/// \brief Get the dimension of tensor.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-/// \param[in] error Records error code that indicate whether the functions executed successfully.
-///
-/// \return The dimension of tensor.
-MIND_C_API size_t MSTensorGetDimension(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
-
-/// \brief Set the shape of tensor array.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-/// \param[in] shape The shape array.
-/// \param[in] dim The the dimension of tensor, i.e., size of shape array.
-///
-/// \return Error code indicates whether the function executed successfully.
-MIND_C_API STATUS MSTensorSetShape(ResMgrHandle res_mgr, TensorHandle tensor, const int64_t shape[], size_t dim);
-
-/// \brief Get the shape of tensor array.
-///
-/// \param[in] res_mgr Resource manager that saves allocated instance resources.
-/// \param[in] tensor The pointer of the tensor instance.
-/// \param[in] shape The shape array.
-/// \param[in] dim The the dimension of tensor, i.e., size of shape array.
-///
-/// \return Error code indicates whether the function executed successfully.
-MIND_C_API STATUS MSTensorGetShape(ResMgrHandle res_mgr, ConstTensorHandle tensor, int64_t shape[], size_t dim);
-
-#ifdef __cplusplus
-}
-#endif
-#endif  // MINDSPORE_CCSRC_C_API_INCLUDE_FUNC_TENSOR_H_

mindspore/include/c_api/ms/value.h

@@ -1,84 +0,0 @@
-/**
- * Copyright 2022 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.
- */
-
-#ifndef MINDSPORE_CCSRC_C_API_INCLUDE_VALUE_H_
-#define MINDSPORE_CCSRC_C_API_INCLUDE_VALUE_H_
-
-#include <stdbool.h>
-#include <stdlib.h>
-#include "include/c_api/ms/base/macros.h"
-#include "include/c_api/ms/base/handle_types.h"
-#include "include/c_api/ms/base/types.h"
-#include "include/c_api/ms/context.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// \brief Create new Int64 scalar value.
-///
-/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
-/// \param[in] v Given value.
-///
-/// \return Value handle.
-MIND_C_API ValueHandle MSNewValueInt64(ResMgrHandle res_mgr, const int64_t v);
-
-/// \brief Create new flaot32 scalar value.
-///
-/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
-/// \param[in] v Given value.
-///
-/// \return Value handle.
-MIND_C_API ValueHandle MSNewValueFloat32(ResMgrHandle res_mgr, const float v);
-
-/// \brief Create new Bool scalar value.
-///
-/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
-/// \param[in] v Given value.
-///
-/// \return Value handle.
-MIND_C_API ValueHandle MSNewValueBool(ResMgrHandle res_mgr, const bool v);
-
-/// \brief Create new value of DataType.
-///
-/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
-/// \param[in] type Given data type.
-///
-/// \return Value handle.
-MIND_C_API ValueHandle MSNewValueType(ResMgrHandle res_mgr, DataTypeC type);
-
-/// \brief Create new vector of Strings Value.
-///
-/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
-/// \param[in] strs Given value.
-/// \param[in] vec_len Length of the string vector.
-///
-/// \return Value handle.
-MIND_C_API ValueHandle MSNewValueStrings(ResMgrHandle res_mgr, const char *strs[], size_t vec_len);
-
-/// \brief Create new Value with array.
-///
-/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
-/// \param[in] value Given array.
-/// \param[in] vec_size Given array size.
-/// \param[in] data_type Datatype of the array.
-///
-/// \return Value handle
-MIND_C_API ValueHandle MSNewValueArray(ResMgrHandle res_mgr, void *value, size_t vec_size, DataTypeC data_type);
-#ifdef __cplusplus
-}
-#endif
-#endif  // MINDSPORE_CCSRC_C_API_INCLUDE_VALUE_H_

mindspore/nn/extend/basic.py

@@ -1,140 +0,0 @@
-# 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.
-# ============================================================================
-
-"""basic"""
-from __future__ import absolute_import
-
-import math
-
-import mindspore.common.dtype as mstype
-from mindspore import _checkparam as Validator
-from mindspore._extends import cell_attr_register
-from mindspore.common.initializer import initializer, HeUniform, Uniform
-from mindspore.common.parameter import Parameter
-from mindspore.common.tensor import Tensor
-from mindspore.nn.cell import Cell
-from mindspore.ops import operations as P
-
-__all__ = ['Linear']
-
-
-class Linear(Cell):
-    r"""
-    The linear connected layer.
-
-    Applies linear connected layer for the input. This layer implements the operation as:
-
-    .. math::
-        \text{outputs} = X * kernel + bias
-
-    where :math:`X` is the input tensors, :math:`\text{kernel}` is a weight matrix with the same
-    data type as the :math:`X` created by the layer, and :math:`\text{bias}` is a bias vector
-    with the same data type as the :math:`X` created by the layer (only if has_bias is True).
-
-    Args:
-        in_features (int): The number of features in the input space.
-        out_features (int): The number of features in the output space.
-        bias (bool): Specifies whether the layer uses a bias vector :math:`\text{bias}`. Default: ``True``.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable weight_init parameter. The dtype
-            is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
-            weight will be initialized using HeUniform.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
-            same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
-            bias will be initialized using Uniform.
-        dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``None`` .
-
-    Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(*, in\_features)`. The `in_features` in `Args` should be equal
-          to :math:`in\_features` in `Inputs`.
-
-    Outputs:
-        Tensor of shape :math:`(*, out\_features)`.
-
-    Raises:
-        TypeError: If `in_features` or `out_features` is not an int.
-        TypeError: If `bias` is not a bool.
-        ValueError: If length of shape of `weight_init` is not equal to 2 or shape[0] of `weight_init`
-                    is not equal to `out_features` or shape[1] of `weight_init` is not equal to `in_features`.
-        ValueError: If length of shape of `bias_init` is not equal to 1
-                    or shape[0] of `bias_init` is not equal to `out_features`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor
-        >>> from mindspore import nn
-        >>> import numpy as np
-        >>> x = Tensor(np.array([[180, 234, 154], [244, 48, 247]]), mindspore.float32)
-        >>> net = nn.extend.Linear(3, 4)
-        >>> output = net(x)
-        >>> print(output.shape)
-        (2, 4)
-    """
-
-    @cell_attr_register(attrs=['has_bias'])
-    def __init__(self,
-                 in_features,
-                 out_features,
-                 bias=True,
-                 weight_init=None,
-                 bias_init=None,
-                 dtype=None):
-        """Initialize Linear."""
-        super(Linear, self).__init__()
-        self.in_features = Validator.check_positive_int(
-            in_features, "in_features", self.cls_name)
-        self.out_features = Validator.check_positive_int(
-            out_features, "out_features", self.cls_name)
-        self.has_bias = Validator.check_bool(
-            bias, "has_bias", self.cls_name)
-        self.dense = P.Dense()
-        if dtype is None:
-            dtype = mstype.float32
-        if isinstance(weight_init, Tensor):
-            if weight_init.ndim != 2 or weight_init.shape[0] != out_features or \
-                    weight_init.shape[1] != in_features:
-                raise ValueError(f"For '{self.cls_name}', weight init shape error. The ndim of 'weight_init' must "
-                                 f"be equal to 2, and the first dim must be equal to 'out_features', and the "
-                                 f"second dim must be equal to 'in_features'. But got 'weight_init': {weight_init}, "
-                                 f"'out_features': {out_features}, 'in_features': {in_features}.")
-        if weight_init is None:
-            weight_init = HeUniform(math.sqrt(5))
-        self.weight = Parameter(initializer(
-            weight_init, [out_features, in_features], dtype=dtype), name="weight")
-
-        self.bias = None
-        if self.has_bias:
-            if isinstance(bias_init, Tensor):
-                if bias_init.ndim != 1 or bias_init.shape[0] != out_features:
-                    raise ValueError(f"For '{self.cls_name}', bias init shape error. The ndim of 'bias_init' must "
-                                     f"be equal to 1, and the first dim must be equal to 'out_features'. But got "
-                                     f"'bias_init': {bias_init}, 'out_features': {out_features}.")
-            if bias_init is None:
-                bound = 1 / math.sqrt(in_features)
-                bias_init = Uniform(scale=bound)
-            self.bias = Parameter(initializer(
-                bias_init, [out_features], dtype=dtype), name="bias")
-
-    def construct(self, x):
-        x = self.dense(x, self.weight, self.bias)
-        return x
-
-    def extend_repr(self):
-        s = f'input_features={self.in_features}, output_features={self.out_features}'
-        if self.has_bias:
-            s += f', has_bias={self.has_bias}'
-        return s

mindspore/nn/extend/embedding.py

@@ -1,143 +0,0 @@
-# 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.
-# ============================================================================
-"""embedding"""
-from __future__ import absolute_import
-
-import mindspore.common.dtype as mstype
-from mindspore.common.initializer import Normal
-from mindspore import _checkparam as Validator
-from mindspore.nn.cell import Cell
-from mindspore import ops
-from mindspore.common.parameter import Parameter
-from mindspore.common.tensor import Tensor
-
-__all__ = ['Embedding']
-
-
-class Embedding(Cell):
-    r"""
-    Embedding layer.
-    Retrieve the word embeddings in weight stored in the layer using indices specified in `input`.
-
-    .. warning::
-        On Ascend, the behavior is unpredictable when the value of `input` is invalid.
-
-    Args:
-        num_embeddings (int): Size of the dictionary of embeddings.
-        embedding_dim (int): The size of each embedding vector.
-        padding_idx (int, optional): If the value is not None, the corresponding row of embedding vector
-            will not be updated in training. The value of embedding vector at `padding_idx` will default
-            to zeros when the Embedding layer is newly constructed. The value should be in range
-            `[-num_embeddings, num_embeddings)` if it's not ``None``. Default ``None``.
-        max_norm (float, optional): If the value is not None, firstly get the p-norm result of the embedding
-            vector specified by `input` where p is specified by `norm_type`; if the result is larger then `max_norm`,
-            update the embedding vector` with :math:`\frac{max\_norm}{result+1e^{-7}}`. Default ``None``.
-        norm_type (float, optional): Indicated the value of p in p-norm. Default ``2.0``.
-        scale_grad_by_freq (bool, optional): If ``True`` the gradients will be scaled by the inverse of frequency
-            of the index in `input`. Default ``False``.
-        _weight (Tensor, optional): Used to initialize the weight of Embedding. If ``None``, the weight will be
-            initialized from normal distribution :math:`{N}(\text{sigma=1.0}, \text{mean=0.0})`. Default ``None``.
-        dtype (mindspore.dtype, optional) : Dtype of Parameters. It is meaningless when `_weight` is not None.
-            Default: ``mindspore.float32``.
-
-    Inputs:
-        - **input** (Tensor) - The indices used to lookup in the embedding vector. The data type must be
-          mindspore.int32 or mindspore.int64, and the value should be in range `[0, num_embeddings)`.
-
-    Outputs:
-        Tensor, has the same data type as weight, the shape is :math:`(*input.shape, embedding\_dim)`.
-
-    Raises:
-        TypeError: If `num_embeddings` is not an int.
-        TypeError: If `embedding_dim` is not an int.
-        ValueError: If `padding_idx` is out of valid range.
-        TypeError: If `max_norm` is not a float.
-        TypeError: If `norm_type` is not a float.
-        TypeError: If `scale_grad_by_freq` is not a bool.
-        TypeError: If `dtype` is not one of mindspore.dtype.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn
-        >>> input = Tensor([[1, 0, 1, 1], [0, 0, 1, 0]])
-        >>> embedding = nn.extend.Embedding(num_embeddings=10, embedding_dim=3)
-        >>> output = embedding(input)
-        >>> print(output)
-        [[[-0.0024154  -0.01203444  0.00811537]
-          [ 0.00233847 -0.00596091  0.00536799]
-          [-0.0024154  -0.01203444  0.00811537]
-          [-0.0024154  -0.01203444  0.00811537]]
-         [[ 0.00233847 -0.00596091  0.00536799]
-          [ 0.00233847 -0.00596091  0.00536799]
-          [-0.0024154  -0.01203444  0.00811537]
-          [ 0.00233847 -0.00596091  0.00536799]]]
-    """
-
-    def __init__(self, num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0,
-                 scale_grad_by_freq=False, _weight=None, dtype=mstype.float32):
-        """Initialize Embedding."""
-        super().__init__()
-        self.num_embeddings = Validator.check_value_type(
-            'num_embeddings', num_embeddings, [int], self.cls_name)
-        self.embedding_dim = Validator.check_value_type(
-            'embedding_dim', embedding_dim, [int], self.cls_name)
-        Validator.check_subclass(
-            "dtype", dtype, mstype.number_type, self.cls_name)
-        self.dtype = dtype
-        self.padding_idx = padding_idx
-        if _weight is None:
-            init_tensor = Tensor(shape=[num_embeddings, embedding_dim], dtype=dtype, init=Normal(1, 0))
-            init_tensor = self._zero_weight_by_index(init_tensor)
-            self.weight = Parameter(init_tensor, name='weight')
-        else:
-            self.weight = Parameter(_weight)
-
-        self.max_norm = max_norm
-        if max_norm is not None:
-            self.max_norm = Validator.check_value_type('max_norm', max_norm, [float], self.cls_name)
-
-        self.norm_type = norm_type
-        if norm_type is not None:
-            self.norm_type = Validator.check_value_type('norm_type', norm_type,
-                                                        [float], self.cls_name)
-
-        self.scale_grad_by_freq = scale_grad_by_freq
-        if scale_grad_by_freq is not None:
-            self.scale_grad_by_freq = Validator.check_value_type('scale_grad_by_freq',
-                                                                 scale_grad_by_freq,
-                                                                 [bool], self.cls_name)
-
-    def _zero_weight_by_index(self, init_tensor):
-        if self.padding_idx is not None:
-            self.padding_idx = Validator.check_int_range(self.padding_idx, -self.num_embeddings, self.num_embeddings,
-                                                         Validator.INC_LEFT, "padding_idx", self.cls_name)
-            if isinstance(init_tensor, Tensor) and init_tensor.init is not None:
-                init_tensor = init_tensor.init_data()
-            init_tensor[self.padding_idx] = 0
-
-        return init_tensor
-
-    def construct(self, input):
-        return ops.embedding(input, self.weight, self.padding_idx, self.max_norm,
-                             self.norm_type, self.scale_grad_by_freq)
-
-    def extend_repr(self):
-        return f'num_embeddings={self.num_embeddings}, embedding_dim={self.embedding_dim}, '  \
-               f'padding_idx={self.padding_idx}, max_norm={self.max_norm}, norm_type={self.norm_type}, ' \
-               f'scale_grad_by_freq={self.scale_grad_by_freq}, dtype={self.dtype}'

mindspore/nn/extend/layer/normalization.py

@@ -1,109 +0,0 @@
-# Copyright 2020-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.
-# ============================================================================
-"""normalization"""
-from __future__ import absolute_import
-from __future__ import division
-
-from mindspore.ops import functional as F
-from mindspore.common.parameter import Parameter
-from mindspore.common.initializer import initializer
-from mindspore.common import dtype as mstype
-from mindspore.nn.cell import Cell
-
-__all__ = ['LayerNorm']
-
-
-class LayerNorm(Cell):
-    r"""
-    Applies Layer Normalization over a mini-batch of inputs.
-
-    Layer Normalization is widely used in recurrent neural networks. It applies
-    normalization on a mini-batch of inputs for each single training case as described
-    in the paper `Layer Normalization <https://arxiv.org/pdf/1607.06450.pdf>`_. Unlike Batch
-    Normalization, Layer Normalization performs exactly the same computation at training and
-    testing time. It is applied across all channels and pixel but only one batch size.
-    :math:`\gamma` and :math:`\beta` are trainable scale and shift.
-    It can be described using the following formula:
-
-    .. math::
-        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
-
-    Args:
-        normalized_shape (Union(tuple[int], list[int])): The normalized shape of `x` for LayerNorm
-        gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
-            ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
-        beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
-            ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
-        eps (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
-        elementwise_affine (bool): A bool value, When set to True, gamma and beta can be learned. Default: True.
-        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
-
-    Inputs:
-        - **x** (Tensor) - The shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
-
-    Outputs:
-        Tensor, the normalized and scaled offset tensor, has the same shape and data type as the `x`.
-
-    Raises:
-        TypeError: If `epsilon` is not a float.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> x = ms.Tensor(np.ones([20, 5, 10, 10]), ms.float32)
-        >>> shape1 = x.shape[1:]
-        >>> m = ms.nn.extend.LayerNorm(shape1)
-        >>> output = m(x).shape
-        >>> print(output)
-        (20, 5, 10, 10)
-    """
-
-    def __init__(self,
-                 normalized_shape,
-                 gamma_init='ones',
-                 beta_init='zeros',
-                 eps=1e-5,
-                 elementwise_affine=True,
-                 dtype=mstype.float32
-                 ):
-        """Initialize LayerNorm."""
-        super(LayerNorm, self).__init__()
-        if not isinstance(normalized_shape, (tuple, list)):
-            raise TypeError(f"For '{self.cls_name}', the type of 'normalized_shape' must be tuple[int] or list[int], "
-                            f"but got {normalized_shape} and the type is {type(normalized_shape)}.")
-        if not normalized_shape:
-            raise ValueError(
-                f"Expected normalized_shape to be at least 1-dimensional, i.e., containing at "
-                f"least one element, but got normalized_shape = {normalized_shape}"
-            )
-        self.normalized_shape = normalized_shape
-        self.epsilon = eps
-        self.gamma = Parameter(initializer(
-            gamma_init, normalized_shape, dtype=dtype), name="gamma", requires_grad=elementwise_affine)
-        self.beta = Parameter(initializer(
-            beta_init, normalized_shape, dtype=dtype), name="beta", requires_grad=elementwise_affine)
-
-    def construct(self, input_x):
-        y = F.layer_norm(input_x, self.normalized_shape, self.gamma.astype(input_x.dtype),
-                         self.beta.astype(input_x.dtype), self.epsilon)
-        return y
-
-    def extend_repr(self):
-        return 'normalized_shape={}, gamma{}, beta={}'.format(self.normalized_shape, self.gamma, self.beta)