Go to file
i-robot d1e4e674ab !26690 Add supoort resolving outer lambda function for ops.Partial.
Merge pull request !26690 from hezhenhao1/add_lambda
2021-11-26 09:21:34 +00:00
.gitee update .gitee/PULL_REQUEST_TEMPLATE.md. 2020-09-18 10:56:48 +08:00
.github update .github/PULL_REQUEST_TEMPLATE.md. 2020-09-15 09:30:17 +08:00
.jenkins cast between fp16 int8 2021-11-19 17:07:46 +08:00
akg@b3f67ab15c update akg, refine document of Custom op 2021-11-16 11:06:40 +08:00
cmake !26667 md5 master 1123 2021-11-24 07:36:05 +00:00
config fix fusion type 2021-07-13 10:44:50 +08:00
docs !26673 modify Dataset_rst and zip_rst master 2021-11-26 07:04:40 +00:00
graphengine@8f7df5fd1f Support Cann callback api for ascend async dump 2021-11-24 10:35:29 -05:00
include !26815 310 ocr model support dynamic hw 2021-11-26 08:00:09 +00:00
mindspore !26690 Add supoort resolving outer lambda function for ops.Partial. 2021-11-26 09:21:34 +00:00
model_zoo Remove model_zoo from mindspore 2021-09-27 10:45:15 +08:00
scripts Replace std::unordered_map/set with robin-hood-hashing 2021-11-24 10:47:40 +08:00
tests !26690 Add supoort resolving outer lambda function for ops.Partial. 2021-11-26 09:21:34 +00:00
third_party Replace std::unordered_map/set with robin-hood-hashing 2021-11-24 10:47:40 +08:00
.clang-format change back clang-format 2020-10-19 20:28:44 +08:00
.gitignore [auto-monad] Optimize order list 2021-02-19 12:54:10 +08:00
.gitmodules add models as submodule in tests 2021-09-16 10:03:19 +08:00
CMakeLists.txt Replace std::unordered_map/set with robin-hood-hashing 2021-11-24 10:47:40 +08:00
CONTRIBUTING.md update contributing wiki 2021-05-18 09:56:11 +08:00
LICENSE initial version 2020-03-27 22:54:54 +08:00
NOTICE initial version 2020-03-27 22:54:54 +08:00
OWNERS upgrade Ascend software package 28 Sep 21 2021-09-28 15:50:24 +08:00
README.md update readme, add 1.4 and 1.5 maintenace info 2021-10-30 11:03:50 +08:00
README_CN.md update readme, add 1.4 and 1.5 maintenace info 2021-10-30 11:03:50 +08:00
RELEASE.md update release note 2021-11-04 17:00:50 +08:00
SECURITY.md add security for mindspore lite to SECURITY.md 2020-12-15 16:50:05 +08:00
Third_Party_Open_Source_Software_Notice upgrade asttokens version to >= 2.0.0 2021-11-04 21:27:59 +08:00
build.bat fix cpack error on windows 2021-11-15 16:53:23 +08:00
build.sh GraphKernel supports CPU 2021-09-29 23:34:16 +08:00
requirements.txt upgrade asttokens version to >= 2.0.0 2021-11-04 21:27:59 +08:00
setup.py update setup.py 2021-11-11 14:11:50 +08:00
version.txt upgrade Ascend software package Nov 5 2021-11-08 15:28:39 +08:00

README.md

MindSpore Logo

PyPI - Python Version PyPI Downloads DockerHub LICENSE Slack PRs Welcome

查看中文

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.

MindSpore Architecture

For more details please check out our Architecture Guide.

Automatic Differentiation

There are currently three automatic differentiation techniques in mainstream deep learning frameworks:

  • Conversion based on static compute graph: Convert the network into a static data flow graph at compile time, then turn the chain rule into a data flow graph to implement automatic differentiation.
  • Conversion based on dynamic compute graph: 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.
  • Conversion based on source code: 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.

TensorFlow adopted static calculation diagrams in the early days, whereas PyTorch used dynamic calculation diagrams. Static maps can utilize static compilation technology to optimize network performance, however, building a network or debugging it is very complicated. The use of dynamic graphics is very convenient, but it is difficult to achieve extreme optimization in performance.

But MindSpore finds another way, automatic differentiation based on source code conversion. 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.

Automatic Differentiation

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.

Automatic Parallel

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, and install the package.

    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.

    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))
    
    [ 4. 10. 18.]
    

Use pip mode method to install MindSpore in different environments. Refer to the following documents.

Source code compilation installation

Use the source code compilation method to install MindSpore in different environments. Refer to the following documents.

Docker Image

MindSpore docker image is hosted on Docker Hub, 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:

    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:

    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:

    $ vim /etc/docker/daemon.json
    {
        "runtimes": {
            "nvidia": {
                "path": "nvidia-container-runtime",
                "runtimeArgs": []
            }
        }
    }
    

    Restart docker again:

    sudo systemctl daemon-reload
    sudo systemctl restart docker
    

    Then you can pull and run the latest stable image using the below command:

    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:

    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))
    
    [[[ 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 repo for the details.

Quickstart

See the Quick Start to implement the image classification.

Docs

More details about installation guide, tutorials and APIs, please see the User Documentation.

Community

Governance

Check out how MindSpore Open Governance works.

Communication

Contributing

Welcome contributions. See our Contributor Wiki 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
r1.5 Maintained 2021-10-15 Unmaintained
2022-10-15 estimated
r1.4 Maintained 2021-08-15 Unmaintained
2022-08-15 estimated
r1.3 Maintained 2021-07-15 Unmaintained
2022-07-15 estimated
r1.2 Unmaintained 2021-04-15 End Of Life
2022-04-15 estimated
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.

License

Apache License 2.0