mindspore 2.3.0__cp310-cp310-win_amd64.whl

mindspore/train/train_thor/model_thor.py

@@ -0,0 +1,257 @@
+# Copyright 2021 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.
+# ============================================================================
+"""
+High-Level API for Second Order Training or Testing.
+Second-order optimizer THOR reduces the computation workload and improves the computation speed by reducing the
+frequency of updating the second-order matrix. In order to optimize the overall performance, the ModelThor class
+is redefined to inherit the Model class provided by MindSpore. The parameter of THOR for controlling the frequency
+of updating the second-order matrix can be obtained by the ModelThor class.
+"""
+from __future__ import absolute_import
+
+import math
+
+from mindspore.train.callback import RunContext
+from mindspore import context
+from mindspore import nn
+from mindspore.train.model import Model
+from mindspore.train.dataset_helper import connect_network_with_dataset
+from mindspore.parallel._utils import _need_to_full, _to_full_tensor
+from mindspore.common.dtype import pytype_to_dtype
+from mindspore._c_expression import init_exec_dataset
+from mindspore.train.train_thor.dataset_helper import DatasetHelper
+
+
+def _convert_to_ms_type(types):
+    """
+    Convert from numpy type to mindspore tensor type.
+
+    Args:
+        types (list): Numpy type list of element in dataset.
+
+    Returns:
+        list, list of element in dataset.
+    """
+    ms_types = []
+    for numpy_type in types:
+        ms_type = pytype_to_dtype(numpy_type)
+        ms_types.append(ms_type)
+    return ms_types
+
+
+def _get_types_and_shapes(dataset):
+    """Get dataset types and shapes."""
+    dataset_types = _convert_to_ms_type(dataset.output_types())
+    dataset_shapes = dataset.output_shapes()
+    return dataset_types, dataset_shapes
+
+
+def _exec_datagraph(exec_dataset, dataset_size, phase='dataset'):
+    """Initialize and execute the dataset graph."""
+    batch_size = exec_dataset.get_batch_size()
+    input_indexs = exec_dataset.input_indexs
+
+    # transform data format
+    dataset_types, dataset_shapes = _get_types_and_shapes(exec_dataset)
+    init_exec_dataset(exec_dataset.__transfer_dataset__.queue_name,
+                      dataset_size,
+                      batch_size,
+                      dataset_types,
+                      dataset_shapes,
+                      input_indexs,
+                      phase=phase,
+                      need_run=False)
+
+
+class ModelThor(Model):
+    """
+    High-Level API for Training or Testing.
+
+    `Model` groups layers into an object with training and inference features.
+
+    Args:
+        network (Cell): A training or testing network.
+        loss_fn (Cell): Objective function, if loss_fn is None, the
+                             network should contain the logic of loss and grads calculation, and the logic
+                             of parallel if needed. Default: ``None``.
+        optimizer (Cell): Optimizer for updating the weights. Default: ``None``.
+        metrics (Union[dict, set]): A Dictionary or a set of metrics to be evaluated by the model during
+                        training and testing. eg: {'accuracy', 'recall'}. Default: ``None``.
+        eval_network (Cell): Network for evaluation. If not defined, `network` and `loss_fn` would be wrapped as
+                             `eval_network`. Default: ``None``.
+        eval_indexes (list): When defining the `eval_network`, if `eval_indexes` is None, all outputs of the
+                             `eval_network` would be passed to metrics, otherwise `eval_indexes` must contain three
+                             elements, including the positions of loss value, predicted value and label. The loss
+                             value would be passed to the `Loss` metric, the predicted value and label would be passed
+                             to other metric. Default: ``None``.
+        amp_level (str): Option for argument `level` in `mindspore.amp.build_train_network`, level for mixed
+            precision training. Supports [O0, O2, O3]. Default: "O0".
+
+            - O0: Do not change.
+            - O2: Cast network to float16, keep batchnorm run in float32, using dynamic loss scale.
+            - O3: Cast network to float16, with additional property 'keep_batchnorm_fp32=False'.
+
+            O2 is recommended on GPU, O3 is recommended on Ascend.
+
+        loss_scale_manager (Union[None, LossScaleManager]): If it is None, the loss would not be scaled. Otherwise,
+            scale the loss by LossScaleManager. It is a key argument.
+            e.g. Use `loss_scale_manager=None` to set the value.
+        keep_batchnorm_fp32 (bool): Keep Batchnorm running in `float32`. If it is set to true, the level setting before
+            will be overwritten. Default: ``True``.
+    """
+
+    def __init__(self, network, loss_fn=None, optimizer=None, metrics=None, eval_network=None,
+                 eval_indexes=None, amp_level="O0", **kwargs):
+        super(ModelThor, self).__init__(network, loss_fn, optimizer, metrics, eval_network,
+                                        eval_indexes, amp_level, **kwargs)
+        if isinstance(network, nn.TrainOneStepCell):
+            self._frequency = network.optimizer.get_frequency()
+        else:
+            self._frequency = optimizer.get_frequency()
+        # used to stop training for early stop, such as stopAtTIme or stopATStep
+        self.switch_branch_one = True
+        self.index_first_order = 0
+        self.train_network_init_flag = True
+        self.has_do_dataset_init = False
+        self._train_network = self._build_train_network()
+
+    def _exec_preprocess(self, network, is_train, phase, dataset, dataset_sink_mode, sink_size=-1,
+                         epoch_num=1, iter_first_order=1):
+        """Initializes dataset."""
+        if dataset_sink_mode and not is_train:
+            dataset.__loop_size__ = 1
+        dataset_helper = DatasetHelper(dataset, dataset_sink_mode, sink_size, epoch_num, iter_first_order)
+
+        if dataset_sink_mode and context.get_context("device_target") != "GPU":
+            network = connect_network_with_dataset(network, dataset_helper)
+        network.set_train(is_train)
+        network.phase = phase
+
+        return dataset_helper, network
+
+    def _train_gpu_sink_step(self, cb_params, inputs, list_callback, iter_first_order, run_context):
+        """train gpu sink step"""
+        if self.switch_branch_one:
+            cb_params.cur_step_num += 1
+            if self.train_network_init_flag:
+                self._train_network.add_flags_recursive(thor=True)
+            self._train_network.phase = 'train0'
+            self.switch_branch_one = not self.switch_branch_one
+            outputs = self._train_network(*inputs)
+            cb_params.net_outputs = outputs
+            list_callback.on_train_step_end(run_context)
+        else:
+            cb_params.cur_step_num += 1
+            if self.train_network_init_flag:
+                self._train_network.add_flags_recursive(thor=False)
+                self.train_network_init_flag = False
+            self._train_network.phase = 'train1'
+            outputs = self._train_network(*inputs)
+            cb_params.net_outputs = outputs
+            self.index_first_order += 1
+            if self.index_first_order == iter_first_order:
+                self.index_first_order = 0
+                self.switch_branch_one = not self.switch_branch_one
+                list_callback.on_train_step_end(run_context)
+
+    def _train_ascend_sink_step(self, cb_params, train_dataset, iter_first_order, inputs, list_callback, run_context):
+        """train ascend sink step"""
+        if self.switch_branch_one:
+            cb_params.cur_step_num += 1
+            if self.train_network_init_flag:
+                self._train_network.add_flags_recursive(thor=True)
+            self._train_network.phase = 'train0'
+        else:
+            cb_params.cur_step_num += iter_first_order
+            if self.train_network_init_flag:
+                self._train_network.add_flags_recursive(thor=False)
+                self.train_network_init_flag = False
+            self._train_network.phase = 'train1'
+            if not self.has_do_dataset_init:
+                _exec_datagraph(train_dataset, iter_first_order, phase='train1_dataset')
+                self.has_do_dataset_init = True
+        self.switch_branch_one = not self.switch_branch_one
+        outputs = self._train_network(*inputs)
+        cb_params.net_outputs = outputs
+        list_callback.on_train_step_end(run_context)
+
+    def _train_dataset_sink_process(self, epoch, train_dataset, list_callback=None, cb_params=None,
+                                    sink_size=-1, initial_epoch=0, valid_infos=None):
+        """
+        Training process. The data would be passed to network through dataset channel.
+
+        Args:
+            epoch (int): Total number of iterations on the data.
+            train_dataset (Dataset): A training dataset iterator. If there is no
+                                     loss_fn, a tuple with multiple data (data1, data2, data3, ...) should be
+                                     returned and passed to the network. Otherwise, a tuple (data, label) should
+                                     be returned. The data and label would be passed to the network and loss
+                                     function respectively.
+            list_callback (Callback): Executor of callback list. Default: ``None``.
+            cb_params (_InternalCallbackParam): Callback parameters. Default: ``None``.
+            sink_size (int): Control the amount of data in each sink. Default: -1.
+            initial_epoch (int): Epoch at which to start train, it useful for resuming a previous training run.
+                                 Default: 0.
+        """
+        valid_dataset, _, _ = valid_infos
+        if valid_dataset:
+            raise ValueError("Evaluation in training is currently not supported in the second-order scenario of thor.")
+        if sink_size == -1:
+            epoch_num = epoch - initial_epoch
+        else:
+            epoch_num = math.ceil(epoch * sink_size / train_dataset.get_dataset_size()) - initial_epoch
+
+        iter_first_order = self._frequency - 1
+        iter_second_order = 1
+        train_dataset.__loop_size__ = iter_second_order
+        dataset_helper, train_network = self._exec_preprocess(self._train_network,
+                                                              is_train=True,
+                                                              phase='train',
+                                                              dataset=train_dataset,
+                                                              dataset_sink_mode=True,
+                                                              sink_size=sink_size,
+                                                              epoch_num=epoch_num,
+                                                              iter_first_order=iter_first_order)
+
+        self._train_network = train_network
+        cb_params.train_network = self._train_network
+        cb_params.cur_step_num = 0
+
+        run_context = RunContext(cb_params)
+        list_callback.on_train_begin(run_context)
+
+        for i in range(initial_epoch, epoch):
+            cb_params.cur_epoch_num = i + 1
+            list_callback.on_train_epoch_begin(run_context)
+            # for data sink dataset_helper only iter once, other wise iter epoch_size times.
+            for inputs in dataset_helper:
+                if _need_to_full() and context.get_context("device_target") == "GPU":
+                    inputs = _to_full_tensor(inputs, self._device_number, self._global_rank)
+                list_callback.on_train_step_begin(run_context)
+                if context.get_context("device_target") == "GPU":
+                    self._train_gpu_sink_step(cb_params, inputs, list_callback, iter_first_order, run_context)
+                else:
+                    self._train_ascend_sink_step(cb_params, train_dataset, iter_first_order, inputs, list_callback,
+                                                 run_context)
+            list_callback.on_train_epoch_end(run_context)
+            should_stop = False or run_context.get_stop_requested()
+            if should_stop:
+                break
+        dataset_helper.stop_send()
+
+        list_callback.on_train_end(run_context)
+
+
+__all__ = ["ModelThor"]

mindspore/version.py

@@ -0,0 +1 @@
+__version__ = '2.3.0'

mindspore-2.3.0.dist-info/METADATA

@@ -0,0 +1,351 @@
+Metadata-Version: 2.1
+Name: mindspore
+Version: 2.3.0
+Summary: MindSpore is a new open source deep learning training/inference framework that could be used for mobile, edge and cloud scenarios.
+Home-page: https://www.mindspore.cn
+Author: The MindSpore Authors
+Author-email: contact@mindspore.cn
+License: Apache 2.0
+Download-URL: https://github.com/mindspore-ai/mindspore/tags
+Project-URL: Sources, https://github.com/mindspore-ai/mindspore
+Project-URL: Issue Tracker, https://github.com/mindspore-ai/mindspore/issues
+Keywords: mindspore machine learning
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy <2.0.0,>=1.20.0
+Requires-Dist: protobuf >=3.13.0
+Requires-Dist: asttokens >=2.0.4
+Requires-Dist: pillow >=6.2.0
+Requires-Dist: scipy >=1.5.4
+Requires-Dist: packaging >=20.0
+Requires-Dist: psutil >=5.6.1
+Requires-Dist: astunparse >=1.6.3
+
+![MindSpore Logo](https://gitee.com/mindspore/mindspore/raw/master/docs/MindSpore-logo.png "MindSpore logo")
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mindspore.svg)](https://pypi.org/project/mindspore)
+[![PyPI](https://badge.fury.io/py/mindspore.svg)](https://badge.fury.io/py/mindspore)
+[![Downloads](https://static.pepy.tech/badge/mindspore)](https://pepy.tech/project/mindspore)
+[![DockerHub](https://img.shields.io/docker/pulls/mindspore/mindspore-cpu.svg)](https://hub.docker.com/r/mindspore/mindspore-cpu)
+[![LICENSE](https://img.shields.io/github/license/mindspore-ai/mindspore.svg?style=flat-square)](https://github.com/mindspore-ai/mindspore/blob/master/LICENSE)
+[![Slack](https://img.shields.io/badge/slack-chat-green.svg?logo=slack)](https://join.slack.com/t/mindspore/shared_invite/zt-dgk65rli-3ex4xvS4wHX7UDmsQmfu8w)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://gitee.com/mindspore/mindspore/pulls)
+
+[查看中文](./README_CN.md)
+
+<!-- TOC -->
+
+- [What Is MindSpore](#what-is-mindspore)
+    - [Automatic Differentiation](#automatic-differentiation)
+    - [Automatic Parallel](#automatic-parallel)
+- [Installation](#installation)
+    - [Pip mode method installation](#pip-mode-method-installation)
+    - [Source code compilation installation](#source-code-compilation-installation)
+    - [Docker Image](#docker-image)
+- [Quickstart](#quickstart)
+- [Docs](#docs)
+- [Community](#community)
+    - [Governance](#governance)
+    - [Communication](#communication)
+- [Contributing](#contributing)
+- [Maintenance phases](#maintenance-phases)
+- [Maintenance status](#maintenance-status)
+- [Release Notes](#release-notes)
+- [License](#license)
+
+<!-- /TOC -->
+
+## What Is MindSpore
+
+MindSpore is a new open source deep learning training/inference framework that
+could be used for mobile, edge and cloud scenarios. MindSpore is designed to
+provide development experience with friendly design and efficient execution for
+the data scientists and algorithmic engineers, native support for Ascend AI
+processor, and software hardware co-optimization. At the meantime MindSpore as
+a global AI open source community, aims to further advance the development and
+enrichment of the AI software/hardware application ecosystem.
+
+<img src="https://gitee.com/mindspore/mindspore/raw/master/docs/MindSpore-architecture.png" alt="MindSpore Architecture"/>
+
+For more details please check out our [Architecture Guide](https://www.mindspore.cn/tutorials/en/master/beginner/introduction.html).
+
+### Automatic Differentiation
+
+Currently, there are two automatic differentiation techniques in mainstream deep learning frameworks:
+
+- **Operator Overloading (OO)**: Overloading the basic operators of the programming language to encapsulate their gradient rules. Record the operation trajectory of the network during forward execution in an operator overloaded manner, then apply the chain rule to the dynamically generated data flow graph to implement automatic differentiation.
+- **Source Transformation (ST)**: This technology is evolving from the functional programming framework and performs automatic differential transformation on the intermediate expression (the expression form of the program during the compilation process) in the form of just-in-time compilation (JIT), supporting complex control flow scenarios, higher-order functions and closures.
+
+PyTorch used OO. Compared to ST, OO generates gradient graph in runtime, so it does not need to take function call and control flow into consideration, which makes it easier to develop. However, OO can not perform gradient graph optimization in compilation time and the control flow has to be unfolded in runtime, so it is difficult to achieve extreme optimization in performance.
+
+MindSpore implemented automatic differentiation based on ST. On the one hand, it supports automatic differentiation of automatic control flow, so it is quite convenient to build models like PyTorch. On the other hand, MindSpore can perform static compilation optimization on neural networks to achieve great performance.
+
+<img src="https://gitee.com/mindspore/mindspore/raw/master/docs/Automatic-differentiation.png" alt="Automatic Differentiation" width="600"/>
+
+The implementation of MindSpore automatic differentiation can be understood as the symbolic differentiation of the program itself. Because MindSpore IR is a functional intermediate expression, it has an intuitive correspondence with the composite function in basic algebra. The derivation formula of the composite function composed of arbitrary basic functions can be derived. Each primitive operation in MindSpore IR can correspond to the basic functions in basic algebra, which can build more complex flow control.
+
+### Automatic Parallel
+
+The goal of MindSpore automatic parallel is to build a training method that combines data parallelism, model parallelism, and hybrid parallelism. It can automatically select a least cost model splitting strategy to achieve automatic distributed parallel training.
+
+<img src="https://gitee.com/mindspore/mindspore/raw/master/docs/Automatic-parallel.png" alt="Automatic Parallel" width="600"/>
+
+At present, MindSpore uses a fine-grained parallel strategy of splitting operators, that is, each operator in the figure is split into a cluster to complete parallel operations. The splitting strategy during this period may be very complicated, but as a developer advocating Pythonic, you don't need to care about the underlying implementation, as long as the top-level API compute is efficient.
+
+## Installation
+
+### Pip mode method installation
+
+MindSpore offers build options across multiple backends:
+
+| Hardware Platform | Operating System | Status |
+| :---------------- | :--------------- | :----- |
+| Ascend910 | Ubuntu-x86 | ✔️ |
+|  | Ubuntu-aarch64 | ✔️ |
+|  | EulerOS-aarch64 | ✔️ |
+|  | CentOS-x86 | ✔️ |
+|  | CentOS-aarch64 | ✔️ |
+| GPU CUDA 10.1 | Ubuntu-x86 | ✔️ |
+| CPU | Ubuntu-x86 | ✔️ |
+|  | Ubuntu-aarch64 | ✔️ |
+|  | Windows-x86 | ✔️ |
+
+For installation using `pip`, take `CPU` and `Ubuntu-x86` build version as an example:
+
+1. Download whl from [MindSpore download page](https://www.mindspore.cn/versions/en), and install the package.
+
+    ```bash
+    pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.2.0-rc1/MindSpore/cpu/ubuntu_x86/mindspore-1.2.0rc1-cp37-cp37m-linux_x86_64.whl
+    ```
+
+2. Run the following command to verify the install.
+
+    ```python
+    import numpy as np
+    import mindspore.context as context
+    import mindspore.nn as nn
+    from mindspore import Tensor
+    from mindspore.ops import operations as P
+
+    context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
+
+    class Mul(nn.Cell):
+        def __init__(self):
+            super(Mul, self).__init__()
+            self.mul = P.Mul()
+
+        def construct(self, x, y):
+            return self.mul(x, y)
+
+    x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
+    y = Tensor(np.array([4.0, 5.0, 6.0]).astype(np.float32))
+
+    mul = Mul()
+    print(mul(x, y))
+    ```
+
+    ```text
+    [ 4. 10. 18.]
+    ```
+
+Use pip mode method to install MindSpore in different environments. Refer to the following documents.
+
+- [Using pip mode method to install MindSpore in Ascend environment](https://gitee.com/mindspore/docs/blob/master/install/mindspore_ascend_install_pip_en.md)
+- [Using pip mode method to install MindSpore in GPU environment](https://gitee.com/mindspore/docs/blob/master/install/mindspore_gpu_install_pip_en.md)
+- [Using pip mode method to install MindSpore in CPU environment](https://gitee.com/mindspore/docs/blob/master/install/mindspore_cpu_install_pip_en.md)
+
+### Source code compilation installation
+
+Use the source code compilation method to install MindSpore in different environments. Refer to the following documents.
+
+- [Using the source code compilation method to install MindSpore in Ascend environment](https://gitee.com/mindspore/docs/blob/master/install/mindspore_ascend_install_source_en.md)
+- [Using the source code compilation method to install MindSpore in GPU environment](https://gitee.com/mindspore/docs/blob/master/install/mindspore_gpu_install_source_en.md)
+- [Using the source code compilation method to install MindSpore in CPU environment](https://gitee.com/mindspore/docs/blob/master/install/mindspore_cpu_install_source_en.md)
+
+### Docker Image
+
+MindSpore docker image is hosted on [Docker Hub](https://hub.docker.com/r/mindspore),
+currently the containerized build options are supported as follows:
+
+| Hardware Platform | Docker Image Repository | Tag | Description |
+| :---------------- | :---------------------- | :-- | :---------- |
+| CPU | `mindspore/mindspore-cpu` | `x.y.z` | Production environment with pre-installed MindSpore `x.y.z` CPU release. |
+|  |  | `devel` | Development environment provided to build MindSpore (with `CPU` backend) from the source, refer to <https://www.mindspore.cn/install/en> for installation details. |
+|  |  | `runtime` | Runtime environment provided to install MindSpore binary package with `CPU` backend. |
+| GPU | `mindspore/mindspore-gpu` | `x.y.z` | Production environment with pre-installed MindSpore `x.y.z` GPU release. |
+|  |  | `devel` | Development environment provided to build MindSpore (with `GPU CUDA10.1` backend) from the source, refer to <https://www.mindspore.cn/install/en> for installation details. |
+|  |  | `runtime` | Runtime environment provided to install MindSpore binary package with `GPU CUDA10.1` backend. |
+
+> **NOTICE:** For GPU `devel` docker image, it's NOT suggested to directly install the whl package after building from the source, instead we strongly RECOMMEND you transfer and install the whl package inside GPU `runtime` docker image.
+
+- CPU
+
+    For `CPU` backend, you can directly pull and run the latest stable image using the below command:
+
+    ```bash
+    docker pull mindspore/mindspore-cpu:1.1.0
+    docker run -it mindspore/mindspore-cpu:1.1.0 /bin/bash
+    ```
+
+- GPU
+
+    For `GPU` backend, please make sure the `nvidia-container-toolkit` has been installed in advance, here are some install guidelines for `Ubuntu` users:
+
+    ```bash
+    DISTRIBUTION=$(. /etc/os-release; echo $ID$VERSION_ID)
+    curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | apt-key add -
+    curl -s -L https://nvidia.github.io/nvidia-docker/$DISTRIBUTION/nvidia-docker.list | tee /etc/apt/sources.list.d/nvidia-docker.list
+
+    sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit nvidia-docker2
+    sudo systemctl restart docker
+    ```
+
+    Then edit the file daemon.json:
+
+    ```bash
+    $ vim /etc/docker/daemon.json
+    {
+        "runtimes": {
+            "nvidia": {
+                "path": "nvidia-container-runtime",
+                "runtimeArgs": []
+            }
+        }
+    }
+    ```
+
+    Restart docker again:
+
+    ```bash
+    sudo systemctl daemon-reload
+    sudo systemctl restart docker
+    ```
+
+    Then you can pull and run the latest stable image using the below command:
+
+    ```bash
+    docker pull mindspore/mindspore-gpu:1.1.0
+    docker run -it -v /dev/shm:/dev/shm --runtime=nvidia --privileged=true mindspore/mindspore-gpu:1.1.0 /bin/bash
+    ```
+
+    To test if the docker image works, please execute the python code below and check the output:
+
+    ```python
+    import numpy as np
+    import mindspore.context as context
+    from mindspore import Tensor
+    from mindspore.ops import functional as F
+
+    context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")
+
+    x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+    y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+    print(F.tensor_add(x, y))
+    ```
+
+    ```text
+    [[[ 2.  2.  2.  2.],
+    [ 2.  2.  2.  2.],
+    [ 2.  2.  2.  2.]],
+
+    [[ 2.  2.  2.  2.],
+    [ 2.  2.  2.  2.],
+    [ 2.  2.  2.  2.]],
+
+    [[ 2.  2.  2.  2.],
+    [ 2.  2.  2.  2.],
+    [ 2.  2.  2.  2.]]]
+    ```
+
+If you want to learn more about the building process of MindSpore docker images,
+please check out [docker](https://gitee.com/mindspore/mindspore/blob/master/scripts/docker/README.md) repo for the details.
+
+## Quickstart
+
+See the [Quick Start](https://www.mindspore.cn/tutorials/en/master/beginner/quick_start.html)
+to implement the image classification.
+
+## Docs
+
+More details about installation guide, tutorials and APIs, please see the
+[User Documentation](https://gitee.com/mindspore/docs).
+
+## Community
+
+### Governance
+
+Check out how MindSpore Open Governance [works](https://gitee.com/mindspore/community/blob/master/governance.md).
+
+### Communication
+
+- [MindSpore Slack](https://join.slack.com/t/mindspore/shared_invite/zt-dgk65rli-3ex4xvS4wHX7UDmsQmfu8w) - Communication platform for developers.
+- IRC channel at `#mindspore` (only for meeting minutes logging purpose)
+- Video Conferencing: TBD
+- Mailing-list: <https://mailweb.mindspore.cn/postorius/lists>
+
+## Contributing
+
+Welcome contributions. See our [Contributor Wiki](https://gitee.com/mindspore/mindspore/blob/master/CONTRIBUTING.md) for
+more details.
+
+## Maintenance phases
+
+Project stable branches will be in one of the following states:
+
+| **State**       | **Time frame**    | **Summary**                                          |
+|-------------|---------------|--------------------------------------------------|
+| Planning    | 1 - 3 months  | Features are under planning.                     |
+| Development | 3 months      | Features are under development.                  |
+| Maintained  | 6 - 12 months | All bugfixes are appropriate. Releases produced. |
+| Unmaintained| 0 - 3 months  | All bugfixes are appropriate. No Maintainers and No Releases produced.                                                 |
+| End Of Life (EOL) |  N/A |  Branch no longer accepting changes.    |
+
+## Maintenance status
+
+| **Branch** | **Status**   | **Initial Release Date** | **Next Phase**                         | **EOL Date**|
+|------------|--------------|--------------------------|----------------------------------------|-------------|
+| **r2.2**   | Maintained   | 2023-10-18               | Unmaintained <br> 2024-10-18 estimated |             |
+| **r2.1**   | Maintained   | 2023-07-29               | Unmaintained <br> 2024-07-29 estimated |             |
+| **r2.0**   | Maintained   | 2023-06-15               | Unmaintained <br> 2024-06-15 estimated |             |
+| **r1.10**  | End Of Life  | 2023-02-02               |                                        | 2024-02-02  |
+| **r1.9**   | End Of Life  | 2022-10-26               |                                        | 2023-10-26  |
+| **r1.8**   | End Of Life  | 2022-07-29               |                                        | 2023-07-29  |
+| **r1.7**   | End Of Life  | 2022-04-29               |                                        | 2023-04-29  |
+| **r1.6**   | End Of Life  | 2022-01-29               |                                        | 2023-01-29  |
+| **r1.5**   | End Of Life  | 2021-10-15               |                                        | 2022-10-15  |
+| **r1.4**   | End Of Life  | 2021-08-15               |                                        | 2022-08-15  |
+| **r1.3**   | End Of Life  | 2021-07-15               |                                        | 2022-07-15  |
+| **r1.2**   | End Of Life  | 2021-04-15               |                                        | 2022-04-29  |
+| **r1.1**   | End Of Life  | 2020-12-31               |                                        | 2021-09-30  |
+| **r1.0**   | End Of Life  | 2020-09-24               |                                        | 2021-07-30  |
+| **r0.7**   | End Of Life  | 2020-08-31               |                                        | 2021-02-28  |
+| **r0.6**   | End Of Life  | 2020-07-31               |                                        | 2020-12-30  |
+| **r0.5**   | End Of Life  | 2020-06-30               |                                        | 2021-06-30  |
+| **r0.3**   | End Of Life  | 2020-05-31               |                                        | 2020-09-30  |
+| **r0.2**   | End Of Life  | 2020-04-30               |                                        | 2020-08-31  |
+| **r0.1**   | End Of Life  | 2020-03-28               |                                        | 2020-06-30  |
+
+## Release Notes
+
+The release notes, see our [RELEASE](https://gitee.com/mindspore/mindspore/blob/master/RELEASE.md).
+
+## License
+
+[Apache License 2.0](https://gitee.com/mindspore/mindspore/blob/master/LICENSE)
+
+