mindspore

Tensor

`mindspore.Tensor`	Tensor is used for data storage.
`mindspore.RowTensor`	A sparse representation of a set of tensor slices at given indices.
`mindspore.SparseTensor`	A sparse representation of a set of nonzero elememts from a tensor at given indices.

Parameter

`mindspore.Parameter`	An object holding weights of cells, after initialized Parameter is a subtype of Tensor.
`mindspore.ParameterTuple`	Class for storing tuple of parameters.

DataType

class mindspore.dtype

Create a data type object of MindSpore.

The actual path of dtype is /mindspore/common/dtype.py. Run the following command to import the package:

from mindspore import dtype as mstype

Numeric Type

Currently, MindSpore supports Int type, Uint type, Float type and Complex type. The following table lists the details.

Definition	Description
`mindspore.int8` , `mindspore.byte`	8-bit integer
`mindspore.int16` , `mindspore.short`	16-bit integer
`mindspore.int32` , `mindspore.intc`	32-bit integer
`mindspore.int64` , `mindspore.intp`	64-bit integer
`mindspore.uint8` , `mindspore.ubyte`	unsigned 8-bit integer
`mindspore.uint16` , `mindspore.ushort`	unsigned 16-bit integer
`mindspore.uint32` , `mindspore.uintc`	unsigned 32-bit integer
`mindspore.uint64` , `mindspore.uintp`	unsigned 64-bit integer
`mindspore.float16` , `mindspore.half`	16-bit floating-point number
`mindspore.float32` , `mindspore.single`	32-bit floating-point number
`mindspore.float64` , `mindspore.double`	64-bit floating-point number
`mindspore.complex64`	64-bit complex number
`mindspore.complex128`	128-bit complex number

Other Type

For other defined types, see the following table.

Type	Description
`tensor`	MindSpore’s `tensor` type. Data format uses NCHW. For details, see tensor.
`bool_`	Boolean `True` or `False`.
`int_`	Integer scalar.
`uint`	Unsigned integer scalar.
`float_`	Floating-point scalar.
`complex`	Complex scalar.
`number`	Number, including `int_` , `uint` , `float_` , `complex` and `bool_` .
`list_`	List constructed by `tensor` , such as `List[T0,T1,...,Tn]` , where the element `Ti` can be of different types.
`tuple_`	Tuple constructed by `tensor` , such as `Tuple[T0,T1,...,Tn]` , where the element `Ti` can be of different types.
`function`	Function. Return in two ways, when function is not None, returns Func directly, the other returns Func(args: List[T0,T1,…,Tn], retval: T) when function is None.
`type_type`	Type definition of type.
`type_none`	No matching return type, corresponding to the `type(None)` in Python.
`symbolic_key`	The value of a variable is used as a key of the variable in `env_type` .
`env_type`	Used to store the gradient of the free variable of a function, where the key is the `symbolic_key` of the free variable’s node and the value is the gradient.

Tree Topology

The relationships of the above types are as follows:

└─────── number
    │   ├─── bool_
    │   ├─── int_
    │   │   ├─── int8, byte
    │   │   ├─── int16, short
    │   │   ├─── int32, intc
    │   │   └─── int64, intp
    │   ├─── uint
    │   │   ├─── uint8, ubyte
    │   │   ├─── uint16, ushort
    │   │   ├─── uint32, uintc
    │   │   └─── uint64, uintp
    │   ├─── float_
    │   │   ├─── float16
    │   │   ├─── float32
    │   │   └─── float64
    │   └─── complex
    │       ├─── complex64
    │       └─── complex128
    ├─── tensor
    │   ├─── Array[Float32]
    │   └─── ...
    ├─── list_
    │   ├─── List[Int32,Float32]
    │   └─── ...
    ├─── tuple_
    │   ├─── Tuple[Int32,Float32]
    │   └─── ...
    ├─── function
    │   ├─── Func
    │   ├─── Func[(Int32, Float32), Int32]
    │   └─── ...
    ├─── type_type
    ├─── type_none
    ├─── symbolic_key
    └─── env_type

`mindspore.dtype_to_nptype`	Convert MindSpore dtype to numpy data type.
`mindspore.issubclass_`	Determine whether type_ is a subclass of dtype.
`mindspore.dtype_to_pytype`	Convert MindSpore dtype to python data type.
`mindspore.pytype_to_dtype`	Convert python type to MindSpore type.
`mindspore.get_py_obj_dtype`	Get the MindSpore data type, which corresponds to python type or variable.

Seed

`mindspore.set_seed`	Set global seed.
`mindspore.get_seed`	Get global seed.

Model

mindspore.Model

High-Level API for training or inference.

Dataset Helper

`mindspore.DatasetHelper`	DatasetHelper is a class to process the MindData dataset and provides the information of dataset.
`mindspore.connect_network_with_dataset`	Connect the network with dataset in dataset_helper.

Loss Scale Manager

`mindspore.LossScaleManager`	Loss scale manager abstract class.
`mindspore.FixedLossScaleManager`	Loss scale with a fixed value, inherits from LossScaleManager.
`mindspore.DynamicLossScaleManager`	Loss scale that dynamically adjusts itself, inherits from LossScaleManager.

Serialization

`mindspore.save_checkpoint`	Save checkpoint to a specified file.
`mindspore.load_checkpoint`	Load checkpoint info from a specified file.
`mindspore.load_param_into_net`	Load parameters into network.
`mindspore.export`	Export the mindspore network into an offline model in the specified format.
`mindspore.load`	Load MindIR.
`mindspore.parse_print`	Parse saved data generated by mindspore.ops.Print.
`mindspore.build_searched_strategy`	Build strategy of every parameter in network.
`mindspore.merge_sliced_parameter`	Merge parameter slices into one parameter.
`mindspore.load_distributed_checkpoint`	Load checkpoint into net for distributed predication.
`mindspore.async_ckpt_thread_status`	Get the status of asynchronous save checkpoint thread.

JIT

mindspore.ms_function

Create a callable MindSpore graph from a Python function.

Log

`mindspore.get_level`	Get the logger level.
`mindspore.get_log_config`	Get logger configurations.

Automatic Mixed Precision

mindspore.build_train_network

Build the mixed precision training cell automatically.

Installation Verification

mindspore.run_check

Provide a convenient API to check if the installation is successful or failed.