-
-Automatic differentiation is commonly used when implementing machine learning algorithms such as backpropagation for training neural networks. By using automatic differentiation, multi-layer composite functions could be divided into several simple computational steps, thereby helping users avoid implementing complex derivation codes. As a result, automatic differentiation enables ease of use of MindSpore.
-
-The first-order derivative method of MindSpore is `mindspore.ops.GradOperation (get_all=False, get_by_list=False, sens_param=False)`. When `get_all` is set to `False`, the first input derivative is computed. When `get_all` is set to `True`, all input derivatives are computed. When `get_by_list` is set to `False`, weight derivatives are not computed. When `get_by_list` is set to `True`, the weight derivative is computed. `sens_param` scales the output value of the network to change the final gradient. The following uses the MatMul operator derivative for in-depth analysis.
-
-Import the required modules and APIs:
-
-```python
-import numpy as np
-import mindspore.nn as nn
-import mindspore.ops as ops
-from mindspore import Tensor
-from mindspore import ParameterTuple, Parameter
-from mindspore import dtype as mstype
-```
-
-## First-order Derivative of the Input
-
-To compute the input derivative, you need to define a network requiring a derivative. The following uses a network $f(x,y)=z *x* y$ formed by the MatMul operator as an example.
-
-The network structure is as follows:
-
-```python
-class Net(nn.Cell):
- def __init__(self):
- super(Net, self).__init__()
- self.matmul = ops.MatMul()
- self.z = Parameter(Tensor(np.array([1.0], np.float32)), name='z')
-
- def construct(self, x, y):
- x = x * self.z
- out = self.matmul(x, y)
- return out
-```
-
-Define the network requiring the derivative. In the `__init__` function, define the `self.net` and `ops.GradOperation` networks. In the `construct` function, compute the derivative of `self.net`.
-
-The network structure is as follows:
-
-```python
-class GradNetWrtX(nn.Cell):
- def __init__(self, net):
- super(GradNetWrtX, self).__init__()
- self.net = net
- self.grad_op = ops.GradOperation()
-
- def construct(self, x, y):
- gradient_function = self.grad_op(self.net)
- return gradient_function(x, y)
-```
-
-Define the input and display the output:
-
-```python
-x = Tensor([[0.8, 0.6, 0.2], [1.8, 1.3, 1.1]], dtype=mstype.float32)
-y = Tensor([[0.11, 3.3, 1.1], [1.1, 0.2, 1.4], [1.1, 2.2, 0.3]], dtype=mstype.float32)
-output = GradNetWrtX(Net())(x, y)
-print(output)
-```
-
-```text
- [[4.5099998 2.7 3.6000001]
- [4.5099998 2.7 3.6000001]]
-```
-
-If the derivatives of the `x` and `y` inputs are considered, you only need to set `self.grad_op = GradOperation(get_all=True)` in `GradNetWrtX`.
-
-## First-order Derivative of the Weight
-
-To compute weight derivatives, you need to set `get_by_list` in `ops.GradOperation` to `True`.
-
-The `GradNetWrtX` structure is as follows:
-
-```python
-class GradNetWrtX(nn.Cell):
- def __init__(self, net):
- super(GradNetWrtX, self).__init__()
- self.net = net
- self.params = ParameterTuple(net.trainable_params())
- self.grad_op = ops.GradOperation(get_by_list=True)
-
- def construct(self, x, y):
- gradient_function = self.grad_op(self.net, self.params)
- return gradient_function(x, y)
-```
-
-Run and display the output:
-
-```python
-output = GradNetWrtX(Net())(x, y)
-print(output)
-```
-
-```text
-(Tensor(shape=[1], dtype=Float32, value= [ 2.15359993e+01]),)
-```
-
-If computation of certain weight derivatives is not required, set `requirements_grad` to `False` when defining the network requiring derivatives.
-
-```Python
-self.z = Parameter(Tensor(np.array([1.0], np.float32)), name='z', requires_grad=False)
-```
-
-## Gradient Value Scaling
-
-You can use the `sens_param` parameter to scale the output value of the network to change the final gradient. Set `sens_param` in `ops.GradOperation` to `True` and determine the scaling index. The dimension must be the same as the output dimension.
-
-The scaling index `self.grad_wrt_output` may be in the following format:
-
-```python
-self.grad_wrt_output = Tensor([[s1, s2, s3], [s4, s5, s6]])
-```
-
-The `GradNetWrtX` structure is as follows:
-
-```python
-class GradNetWrtX(nn.Cell):
- def __init__(self, net):
- super(GradNetWrtX, self).__init__()
- self.net = net
- self.grad_op = ops.GradOperation(sens_param=True)
- self.grad_wrt_output = Tensor([[0.1, 0.6, 0.2], [0.8, 1.3, 1.1]], dtype=mstype.float32)
-
- def construct(self, x, y):
- gradient_function = self.grad_op(self.net)
- return gradient_function(x, y, self.grad_wrt_output)
-
-output = GradNetWrtX(Net())(x, y)
-print(output)
-```
-
-```text
-[[2.211 0.51 1.49 ]
- [5.588 2.68 4.07 ]]
-```
-
-## Stop Gradient
-
-We can use `stop_gradient` to disable calculation of gradient for certain operators. For example:
-
-```python
-import numpy as np
-import mindspore.nn as nn
-import mindspore.ops as ops
-from mindspore import Tensor
-from mindspore import ParameterTuple, Parameter
-from mindspore import dtype as mstype
-from mindspore.ops import stop_gradient
-
-class Net(nn.Cell):
- def __init__(self):
- super(Net, self).__init__()
- self.matmul = ops.MatMul()
-
- def construct(self, x, y):
- out1 = self.matmul(x, y)
- out2 = self.matmul(x, y)
- out2 = stop_gradient(out2)
- out = out1 + out2
- return out
-
-class GradNetWrtX(nn.Cell):
- def __init__(self, net):
- super(GradNetWrtX, self).__init__()
- self.net = net
- self.grad_op = ops.GradOperation()
-
- def construct(self, x, y):
- gradient_function = self.grad_op(self.net)
- return gradient_function(x, y)
-
-x = Tensor([[0.8, 0.6, 0.2], [1.8, 1.3, 1.1]], dtype=mstype.float32)
-y = Tensor([[0.11, 3.3, 1.1], [1.1, 0.2, 1.4], [1.1, 2.2, 0.3]], dtype=mstype.float32)
-output = GradNetWrtX(Net())(x, y)
-print(output)
-```
-
-```text
- [[4.5, 2.7, 3.6],
- [4.5, 2.7, 3.6]]
-```
-
-Here, we set `stop_gradient` to `out2`, so this operator does not have any contribution to gradient. If we delete `out2 = stop_gradient(out2)`, the result is:
-
-```text
- [[9.0, 5.4, 7.2],
- [9.0, 5.4, 7.2]]
-```
-
-After we do not set `stop_gradient` to `out2`, it will make the same contribution to gradient as `out1`. So we can see that each result has doubled.
\ No newline at end of file
diff --git a/tutorials/source_en/beginner/autograd.md b/tutorials/source_en/beginner/autograd.md
new file mode 100644
index 0000000000000000000000000000000000000000..6fead1c1c05ce181726eb7a3791320bcc8879d0c
--- /dev/null
+++ b/tutorials/source_en/beginner/autograd.md
@@ -0,0 +1,220 @@
+# Automatic Differentiation
+
+
+
+Automatic differentiation is able to calculate the derivative value of a derivative function at a certain point, which is a generalization of backpropagation algorithms. The main problem solved by automatic differentiation is to decompose a complex mathematical operation into a series of simple basic operations, which shields the user from a large number of details and processes of differentiation, which greatly reduces the threshold for the use of the framework.
+
+MindSpore uses `ops.GradOperation` to calculate a first-order derivative, and the attributes of the first-order derivative are as the following:
+
+- `get_all`：Whether to derive the input parameters, the default value is False.
+- `get_by_list`：Whether to derive the weight parameters, the default value is False.
+- `sens_param`：Whether to scale the output value of the network to change the final gradient, the default value is False.
+
+This chapter uses `ops.GradOperation` in MindSpore to find first-order derivatives of the function $f(x)=wx+b$.
+
+## First-order Derivative of the Input
+
+The formula needs to be defined before the input can be derived:
+$$
+f(x)=wx+b \tag {1}
+$$
+The example code below is an expression of Equation (1), and since MindSpore is functionally programmed, all expressions of computational formulas are represented as functions.
+
+```python
+import numpy as np
+import mindspore.nn as nn
+from mindspore import Parameter, Tensor
+
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.w = Parameter(np.array([6.0]), name='w')
+ self.b = Parameter(np.array([1.0]), name='b')
+
+ def construct(self, x):
+ f = self.w * x + self.b
+ return f
+```
+
+Define the derivative class `GradNet`. In the `__init__` function, define the `self.net` and `ops.GradOperation` networks. In the `construct` function, compute the derivative of `self.net`. Its corresponding MindSpore internally produces the following formula (2):
+$$
+f^{'}(x)=w\tag {2}
+$$
+
+```python
+from mindspore import dtype as mstype
+import mindspore.ops as ops
+
+class GradNet(nn.Cell):
+ def __init__(self, net):
+ super(GradNet, self).__init__()
+ self.net = net
+ self.grad_op = ops.GradOperation()
+
+ def construct(self, x):
+ gradient_function = self.grad_op(self.net)
+ return gradient_function(x)
+```
+
+At last, define the weight parameter as w and a first-order derivative is found for the input parameter x in the input formula (1). From the running result, the input in formula (1) is 6, that is:
+$$
+f(x)=wx+b=6*x+1 \tag {3}
+$$
+ To derive the above equation, there is:
+$$
+f^{'}(x)=w=6 \tag {4}
+$$
+
+```python
+x = Tensor([100], dtype=mstype.float32)
+output = GradNet(Net())(x)
+
+print(output)
+```
+
+```text
+[6.]
+```
+
+MindSpore calculates the first derivative method `ops.GradOperation (get_all=False, get_by_lsit=False, sens_param=False)`, where when `get_all` is `False`, only the first input is evaluated, and when `True` is set, all inputs are evaluated.
+
+## First-order Derivative of the Weight
+
+To compute weight derivatives, you need to set `get_by_list` in `ops.GradOperation` to `True`.
+
+```python
+from mindspore import ParameterTuple
+
+class GradNet(nn.Cell):
+ def __init__(self, net):
+ super(GradNet, self).__init__()
+ self.net = net
+ self.params = ParameterTuple(net.trainable_params())
+ self.grad_op = ops.GradOperation(get_by_list=True) # Set the first-order derivative of the weight parameters
+
+ def construct(self, x):
+ gradient_function = self.grad_op(self.net, self.params)
+ return gradient_function(x)
+```
+
+Next, derive the function:
+
+```python
+# Perform a derivative calculation on the function
+x = Tensor([100], dtype=mstype.float32)
+fx = GradNet(Net())(x)
+
+# Print the results
+print(fx)
+print(f"wgrad: {fx[0]}\nbgrad: {fx[1]}")
+```
+
+```text
+(Tensor(shape=[1], dtype=Float32, value= [ 6.00000000e+00]), Tensor(shape=[1], dtype=Float32, value= [ 1.00000000e+00]))
+wgrad: [6.]
+bgrad: [1.]
+```
+
+If computation of certain weight derivatives is not required, set `requirements_grad` to `False` when defining the network requiring derivatives.
+
+```Python
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.w = Parameter(Tensor(np.array([6], np.float32)), name='w')
+ self.b = Parameter(Tensor(np.array([1.0], np.float32)), name='b', requires_grad=False)
+
+ def construct(self, x):
+ out = x * self.w + self.b
+ return out
+
+class GradNet(nn.Cell):
+ def __init__(self, net):
+ super(GradNet, self).__init__()
+ self.net = net
+ self.params = ParameterTuple(net.trainable_params())
+ self.grad_op = ops.GradOperation(get_by_list=True)
+
+ def construct(self, x):
+ gradient_function = self.grad_op(self.net, self.params)
+ return gradient_function(x)
+
+# Construct a derivative network
+x = Tensor([5], dtype=mstype.float32)
+fw = GradNet(Net())(x)
+
+print(fw)
+```
+
+```text
+(Tensor(shape=[1], dtype=Float32, value= [ 5.00000000e+00]),)
+```
+
+## Gradient Value Scaling
+
+You can use the `sens_param` parameter to scale the output value of the network to change the final gradient. Set `sens_param` in `ops.GradOperation` to `True` and determine the scaling index. The dimension must be the same as the output dimension.
+
+```python
+class GradNet(nn.Cell):
+ def __init__(self, net):
+ super(GradNet, self).__init__()
+ self.net = net
+ # Derivative operation
+ self.grad_op = ops.GradOperation(sens_param=True)
+ # Scale index
+ self.grad_wrt_output = Tensor([0.1], dtype=mstype.float32)
+
+ def construct(self, x):
+ gradient_function = self.grad_op(self.net)
+ return gradient_function(x, self.grad_wrt_output)
+
+x = Tensor([6], dtype=mstype.float32)
+output = GradNet(Net())(x)
+
+print(output)
+```
+
+```text
+[0.6]
+```
+
+## Stopping Gradient
+
+We can use `stop_gradient` to disable calculation of gradient for certain operators. For example:
+
+```python
+from mindspore.ops import stop_gradient
+
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.w = Parameter(Tensor(np.array([6], np.float32)), name='w')
+ self.b = Parameter(Tensor(np.array([1.0], np.float32)), name='b')
+
+ def construct(self, x):
+ out = x * self.w + self.b
+ # Stops updating the gradient, and out does not contribute to gradient calculations
+ out = stop_gradient(out)
+ return out
+
+class GradNet(nn.Cell):
+ def __init__(self, net):
+ super(GradNet, self).__init__()
+ self.net = net
+ self.params = ParameterTuple(net.trainable_params())
+ self.grad_op = ops.GradOperation(get_by_list=True)
+
+ def construct(self, x):
+ gradient_function = self.grad_op(self.net, self.params)
+ return gradient_function(x)
+
+x = Tensor([100], dtype=mstype.float32)
+output = GradNet(Net())(x)
+
+print(f"wgrad: {output[0]}\nbgrad: {output[1]}")
+```
+
+```text
+wgrad: [0.]
+bgrad: [0.]
+```
diff --git a/tutorials/source_en/beginner/dataset.md b/tutorials/source_en/beginner/dataset.md
new file mode 100644
index 0000000000000000000000000000000000000000..14ddbba23a352a27c7f229e8845f1b66715ce4d6
--- /dev/null
+++ b/tutorials/source_en/beginner/dataset.md
@@ -0,0 +1,174 @@
+# Data Processing
+
+
+
+Data is the foundation of deep learning, and inputting the high-quality data plays an active role in the entire deep neural network.
+
+[mindspore.dataset](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.dataset.html) provides a loading interface for some commonly used datasets and standard format datasets, enabling users to quickly perform data processing operations. For the image datasets, users can use `mindvision.dataset` to load and process datasets. This chapter first describes how to load and process a CIFAR-10 dataset by using the `mindvision.dataset.Cifar10` interface, and then describes how to use `mindspore.dataset.GeneratorDataset` to implement custom dataset loading.
+
+> `mindvision.dataset`is a dataset interface developed on the basis of `mindspore.dataset`. In addition to providing dataset loading capabilities, `mindvision.dataset` further provides dataset download capabilities, data processing, and data enhancement capabilities.
+
+## Data Process
+
+In the network training and inference process, the raw data is generally stored in a disk or database. The raw data needs to be read into the memory space through the data loading step, converted into a framework-common tensor format, and then mapped to a more easy-to-learn space through the data processing and augmentation steps. While the number of samples and generalization is increased, the data finally enters the network for calculation.
+
+The overall process is shown in the following figure:
+
+
+
+### Dataset
+
+A dataset is a collection of samples, and a row of a dataset is a sample that contains one or more features, and may further contain a label. The dataset needs to meet certain specification requirements to make it easier to evaluate the effectiveness of the model.
+
+Dataset supports multiple format datasets, including MindRecord, a MindSpore self-developed data format, commonly used public image datasets and text datasets, user-defined datasets, etc.
+
+### Dataset Loading
+
+Dataset loading allows the model to be continuously acquired for training during training. Dataset provides corresponding classes for a variety of commonly used datasets to load datasets. For data files in different storage formats, Dataset also has corresponding classes for data loading.
+
+Dataset provides multiple uses of the sampler (Sampler), and the sampler is responsible for generating the read index sequence. The Dataset is responsible for reading the corresponding data according to the index, helping users to sample the dataset in different forms to meet the training needs, and solving problems such as the data set is too large or the sample class distribution is uneven.
+
+> It should be noted that the sampler is responsible for performing filter and reorder operations on the sample, not performing the Batch operation.
+
+### Data processing
+
+After the Dataset loads the data into the memory, the data is organized in a Tensor form. Tensor is also a basic data structure in data augmentation operations.
+
+## Loading the Dataset
+
+In the following example, the CIFAR-10 dataset is loaded through the `mindvision.dataset.Cifar10` interface. The CIFAR-10 dataset has a total of 60,000 32*32 color images, which are divided into 10 categories, each with 6,000 maps, and a total of 50,000 training pictures and 10,000 test pictures in the dataset. `Cifar10` interface provides CIFAR-10 dataset download and load capabilities.
+
+
+
+- `path`: The location of the dataset root directory.
+- `split`: Training, testing or inferencing of the dataset, optionally `train`，`test` or `infer`, `train` by default.
+- `download`: Whether to download the dataset. When `ture` is set, if the dataset does not exist, you can download and extract the dataset, `False` by default.
+
+```python
+from mindvision.dataset import Cifar10
+
+# Dataset root directory
+data_dir = "./datasets"
+
+# Download, extract and load the CIFAR-10 training dataset
+dataset = Cifar10(path=data_dir, split='train', batch_size=6, resize=32, download=True)
+dataset = dataset.run()
+```
+
+The directory structures of the CIFAR-10 dataset files are as follows:
+
+```text
+datasets/
+├── cifar-10-batches-py
+│ ├── batches.meta
+│ ├── data_batch_1
+│ ├── data_batch_2
+│ ├── data_batch_3
+│ ├── data_batch_4
+│ ├── data_batch_5
+│ ├── readme.html
+│ └── test_batch
+└── cifar-10-python.tar.gz
+```
+
+## Iterating Dataset
+
+You can use `create_dict_iterator` interface to create a data iterator to iteratively access data. The data type of the access is `Tensor` by default, and if `output_numpy=True` is set, the data type of the access is `Numpy`.
+
+The following shows the corresponding access data type, and the image shapes and labels.
+
+```python
+data = next(dataset.create_dict_iterator())
+print(f"Data type:{type(data['image'])}\nImage shape: {data['image'].shape}, Label: {data['label']}")
+
+data = next(dataset.create_dict_iterator(output_numpy=True))
+print(f"Data type:{type(data['image'])}\nImage shape: {data['image'].shape}, Label: {data['label']}")
+```
+
+```text
+Data type:
-
+A neural network model consists of multiple data operation layers. `mindspore.nn` provides various basic network modules. The following uses LeNet-5 as an example to first describe how to build a neural network model by using `mindspore.nn` , and then describes how to build a LeNet-5 network model by using `mindvision.classification.models`.
-A neural network model consists of multiple data operation layers. `mindspore.nn` provides various basic network modules.
+> `mindvision.classification.models` is a network model interface developed based on `mindspore.nn`, providing some classic and commonly used network models for the convenience of users.
-The following uses LeNet as an example to describe how MindSpore builds a neural network model.
+## LeNet-5 model
-Import the required modules and APIs:
+[LeNet-5](https://ieeexplore.ieee.org/document/726791) is a typical convolutional neural network proposed by Professor Yann LeCun in 1998, which achieves 99.4% accuracy on the MNIST dataset and is the first classic in the field of CNN. The model structure is shown in the following figure:
-```python
-import numpy as np
-import mindspore
-import mindspore.nn as nn
-from mindspore import Tensor
-```
+
+
+According to the network structure of LeNet, there are 7 layers of LeNet removal input layer, including 3 convolutional layers, 2 sub-sampling layers, and 3 fully-connected layers.
## Defining a Model Class
+In the above figure, C is used to represent the convolutional layer, S to represent the sampling layer, and F to represent the fully-connected layer.
+
+The input size of the picture is fixed at 32∗32. In order to get a good convolution effect, the number is required in the center of the picture, so the size at 32∗32 is actually the result of the picture at 28∗28 after filled. In addition, unlike the input picture of the three channels of the CNN network, the input of the LeNet picture is only a normalized binary image. The output of the network is a prediction probability of ten digits 0\~9, which can be understood as the probability that the input image belongs to 0\~9 digits.
+
The `Cell` class of MindSpore is the base class for building all networks and the basic unit of a network. When a neural network is required, you need to inherit the `Cell` class and overwrite the `__init__` and `construct` methods.
```python
+import mindspore.nn as nn
+
class LeNet5(nn.Cell):
"""
Lenet network structure
"""
def __init__(self, num_class=10, num_channel=1):
super(LeNet5, self).__init__()
- # Define the required operation.
+ # Convolutional layer, the number of input channels is num_channel, the number of output channels is 6, and the convolutional kernel size is 5*5
self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
+ # Convolutional layer, the number of input channels is 6, the number of output channels is 16, and the convolutional kernel size is 5 * 5
self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
+ # Fully connected layer, the number of inputs is 16*5*5, and the number of outputs is 120
self.fc1 = nn.Dense(16 * 5 * 5, 120)
+ # Fully-connected layer, the number of inputs is 120, and the number of outputs is 84
self.fc2 = nn.Dense(120, 84)
+ # Fully connected layer, the number of inputs is 84, and the number of classifications is num_class
self.fc3 = nn.Dense(84, num_class)
+ # ReLU Activation function
self.relu = nn.ReLU()
+ # Pooling layer
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
+ # Multidimensional arrays are flattened into one-dimensional arrays
self.flatten = nn.Flatten()
def construct(self, x):
@@ -55,23 +65,50 @@ class LeNet5(nn.Cell):
return x
```
+Next, build the neural network model defined above and look at the structure of the network model.
+
+```python
+model = LeNet5()
+
+print(model)
+```
+
+```text
+LeNet5<
+ (conv1): Conv2d
+
The following describes the basic functions of MindSpore to implement common tasks in deep learning. For details, see links in each section.
diff --git a/tutorials/source_en/save_load_model.md b/tutorials/source_en/beginner/save_load.md
similarity index 30%
rename from tutorials/source_en/save_load_model.md
rename to tutorials/source_en/beginner/save_load.md
index bf72874642a3d70dc718c6f5a65633d695814a52..e4d3df1663173496b3d91bd07cf0c8c242e4d182 100644
--- a/tutorials/source_en/save_load_model.md
+++ b/tutorials/source_en/beginner/save_load.md
@@ -1,14 +1,68 @@
# Saving and Loading the Model
-`Ascend` `GPU` `CPU` `Beginner` `Model Export` `Model Loading`
+
-
+The content of the previous chapter mainly introduced how to adjust hyperparameters and train network models. During the process of training the network model, we actually want to save the intermediate and final results for fine-tune and subsequent model deployment and inference, and now start learning how to set hyperparameters and optimize model parameters.
-In the previous tutorial, you learn how to train the network. In this tutorial, you will learn how to save and load a model, and how to export a saved model in a specified format to different platforms for inference.
+## Model Training
+
+The following are the basic steps and code for network model training, with sample code as follows:
+
+```python
+import mindspore.nn as nn
+from mindspore.train import Model
+
+from mindvision.classification.dataset import Mnist
+from mindvision.classification.models import lenet
+from mindvision.engine.callback import LossMonitor
+
+epochs = 10 # Training batch
+
+# 1. Build a dataset
+download_train = Mnist(path="./mnist", split="train", batch_size=batch_size, repeat_num=1, shuffle=True, resize=32, download=True)
+dataset_train = download_train.run()
+
+# 2. Define a neural network
+network = lenet(num_classes=10, pretrained=False)
+# 3.1 Define a loss function
+net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
+# 3.2 Defines an optimizer function
+net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)
+# 3.3 Initialize model parameters
+model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'accuracy'})
+
+# 4. Perform training on the neural network
+model.train(epochs, dataset_train, callbacks=[LossMonitor(0.01, 1875)])
+```
+
+```text
+Epoch:[ 0/ 10], step:[ 1875/ 1875], loss:[0.148/1.210], time:2.021 ms, lr:0.01000
+Epoch time: 4251.808 ms, per step time: 2.268 ms, avg loss: 1.210
+Epoch:[ 1/ 10], step:[ 1875/ 1875], loss:[0.049/0.081], time:2.048 ms, lr:0.01000
+Epoch time: 4301.405 ms, per step time: 2.294 ms, avg loss: 0.081
+Epoch:[ 2/ 10], step:[ 1875/ 1875], loss:[0.014/0.050], time:1.992 ms, lr:0.01000
+Epoch time: 4278.799 ms, per step time: 2.282 ms, avg loss: 0.050
+Epoch:[ 3/ 10], step:[ 1875/ 1875], loss:[0.035/0.038], time:2.254 ms, lr:0.01000
+Epoch time: 4380.553 ms, per step time: 2.336 ms, avg loss: 0.038
+Epoch:[ 4/ 10], step:[ 1875/ 1875], loss:[0.130/0.031], time:1.932 ms, lr:0.01000
+Epoch time: 4287.547 ms, per step time: 2.287 ms, avg loss: 0.031
+Epoch:[ 5/ 10], step:[ 1875/ 1875], loss:[0.003/0.027], time:1.981 ms, lr:0.01000
+Epoch time: 4377.000 ms, per step time: 2.334 ms, avg loss: 0.027
+Epoch:[ 6/ 10], step:[ 1875/ 1875], loss:[0.004/0.023], time:2.167 ms, lr:0.01000
+Epoch time: 4687.250 ms, per step time: 2.500 ms, avg loss: 0.023
+Epoch:[ 7/ 10], step:[ 1875/ 1875], loss:[0.004/0.020], time:2.226 ms, lr:0.01000
+Epoch time: 4685.529 ms, per step time: 2.499 ms, avg loss: 0.020
+Epoch:[ 8/ 10], step:[ 1875/ 1875], loss:[0.000/0.016], time:2.275 ms, lr:0.01000
+Epoch time: 4651.129 ms, per step time: 2.481 ms, avg loss: 0.016
+Epoch:[ 9/ 10], step:[ 1875/ 1875], loss:[0.022/0.015], time:2.177 ms, lr:0.01000
+Epoch time: 4623.760 ms, per step time: 2.466 ms, avg loss: 0.015
+```
+
+As you can see from the printed results above, the loss values tend to converge as the number of training rounds increases.
## Saving the Model
-There are two main ways to save the interface of the model:
+After training the network, the following will describe how to save and load the model. There are two main ways to save the interface of the model:
1. One is to simply save the network model, which can be saved before and after training. The advantage is that the interface is simple and easy to use, but only the state of the network model when the command is executed is retained;
@@ -16,7 +70,7 @@ There are two main ways to save the interface of the model:
### Saving the Model Directly
-Use the save_checkpoint provided by MindSpore to save the model, pass it to the network and save the path:
+Use the save_checkpoint provided by MindSpore to save the model, and pass it to the network and save the path:
```python
import mindspore as ms
@@ -25,29 +79,26 @@ import mindspore as ms
ms.save_checkpoint(net, "./MyNet.ckpt")
```
-Here, `net` is the training network, and the definition method can be referred to [Building a Neural Network](https://www.mindspore.cn/tutorials/en/master/model.html).
+Here, `network` is the training network, and `"./MyNet.ckpt"` is the saving path of the network model.
### Saving the Model During Training
-In the process of model training, use the `callbacks` parameter in `model.train` to pass in the object `ModelCheckpoint` that saves the model, which can save the model parameters and generate CheckPoint (abbreviated as ckpt) files.
-
-```python
-from mindspore.train.callback import ModelCheckpoint
-
-ckpt_cb = ModelCheckpoint()
-model.train(epoch_num, dataset, callbacks=ckpt_cb)
-```
-
-Here, `epoch_num` is the number of times that the dataset is traversed during training. The definition method can be referred to [Training the Model](https://www.mindspore.cn/tutorials/en/master/optimization.html). `dataset` is the dataset to be loaded. The definition method can be referred to [Loading and Processing Data](https://www.mindspore.cn/tutorials/en/master/dataset.html).
+In the process of model training, use the `callbacks` parameter in `model.train` to pass in the object [ModelCheckpoint](https://mindspore.cn/docs/api/en/master/api_python/mindspore.train.html#mindspore.train.callback.ModelCheckpoint) that saves the model (Generally used with [CheckpointConfig](https://mindspore.cn/docs/api/en/master/api_python/mindspore.train.html#mindspore.train.callback.CheckpointConfig)), which can save the model parameters and generate CheckPoint (abbreviated as ckpt) files.
You can configure the checkpoint policies as required. The following describes the usage:
```python
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig
-config_ck = CheckpointConfig(save_checkpoint_steps=32, keep_checkpoint_max=10)
-ckpt_cb = ModelCheckpoint(prefix='resnet50', directory=None, config=config_ck)
-model.train(epoch_num, dataset, callbacks=ckpt_cb)
+# Set the number of epoch_num
+epoch_num = 5
+
+# Set the model saving parameters
+config_ck = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)
+
+# Apply the model saving parameters
+ckpoint = ModelCheckpoint(prefix="lenet", directory="./lenet", config=config_ck)
+model.train(epoch_num, dataset_train, callbacks=ckpoint)
```
In the preceding code, you need to initialize a `CheckpointConfig` class object to set the saving policy.
@@ -62,16 +113,16 @@ Create a `ModelCheckpoint` object and pass it to the `model.train` method. Then
The generated checkpoint file is as follows:
```text
-resnet50-graph.meta # Computational graph after build.
-resnet50-1_32.ckpt # The extension of the checkpoint file is .ckpt.
-resnet50-2_32.ckpt # The file name format contains the epoch and step correspond to the saved parameters.
-resnet50-3_32.ckpt # The file name indicates that the model parameters generated during the 32nd step of the third epoch are saved.
+lenet-graph.meta # Computational graph after compiled.
+lenet-1_1875.ckpt # The extension of the checkpoint file is .ckpt.
+lenet-2_1875.ckpt # The file name format contains the epoch and step correspond to the saved parameters. Here are the model parameters for the 1875th step of the 2nd epoch.
+lenet-3_1875.ckpt # indicates the model parameters saved for the 1875th step of the 3rd epoch.
...
```
-If you use the same prefix and run the training script for multiple times, checkpoint files with the same name may be generated. To help users distinguish files generated each time, MindSpore adds underscores (_) and digits to the end of the user-defined prefix. If you want to delete the `.ckpt` file, delete the `.meta` file at the same time.
+If you use the same prefix and run the training script for multiple times, checkpoint files with the same name may be generated. To help users distinguish files generated each time, MindSpore adds underscores "_" and digits to the end of the user-defined prefix. If you want to delete the `.ckpt` file, delete the `.meta` file at the same time.
-For example, `resnet50_3-2_32.ckpt` indicates the checkpoint file generated during the 32nd step of the second epoch after the script is executed for the third time.
+For example, `lenet_3-2_1875.ckpt` indicates the CheckPoint file of the 1875th step of the 2nd epoch generated by running the 3rd script.
## Loading the Model
@@ -82,12 +133,18 @@ The sample code is as follows:
```python
from mindspore import load_checkpoint, load_param_into_net
-resnet = ResNet50()
-# Store model parameters in the parameter dictionary.
-param_dict = load_checkpoint("resnet50-2_32.ckpt")
-# Load parameters to the network.
-load_param_into_net(resnet, param_dict)
-model = Model(resnet, loss, metrics={"accuracy"})
+from mindvision.classification.dataset import Mnist
+from mindvision.classification.models import lenet
+
+# Store the model parameters in the parameter dictionary, where the model parameters saved during the training process above are loaded
+param_dict = load_checkpoint("./lenet/lenet-1_1875.ckpt")
+
+# Redefine a LeNet neural network
+net = lenet(num_classes=10, pretrained=False)
+
+# Load parameters to the network
+load_param_into_net(network, param_dict)
+model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={"accuracy"})
```
- The `load_checkpoint` method loads the network parameters in the parameter file to the `param_dict` dictionary.
@@ -95,80 +152,45 @@ model = Model(resnet, loss, metrics={"accuracy"})
### Validating the Model
-In the inference-only scenario, parameters are directly loaded to the network for subsequent inference and validation. The sample code is as follows:
+After the above module loads the parameters into the network, for the inference scenario, you can call the `eval` function for inference verification. The sample code is as follows:
```python
-# Define a validation dataset.
-dataset_eval = create_dataset(os.path.join(mnist_path, "test"), 32, 1)
-
# Call eval() for inference.
+download_eval = Mnist(path="./mnist", split="test", batch_size=32, resize=32, download=True)
+dataset_eval = download_eval.run()
acc = model.eval(dataset_eval)
+
+print("{}".format(acc))
+```
+
+```text
+{'accuracy': 0.9857772435897436}
```
### For Transfer Learning
-You can load network parameters and optimizer parameters to the model in the case of task interruption, retraining, and fine-tuning. The sample code is as follows:
+For task interruption retraining and fine-tuning scenarios, you can call the `train` function for transfer learning. The sample code is as follows:
```python
-# Set the number of training epochs.
-epoch = 1
# Define a training dataset.
-dataset = create_dataset(os.path.join(mnist_path, "train"), 32, 1)
-# Call train() for training.
-model.train(epoch, dataset)
-```
-
-## Exporting the Model
-
-During model training, you can add checkpoints to save model parameters for inference and retraining. If you want to perform inference on different hardware platforms, you can generate MindIR, AIR, or ONNX files based on the network and checkpoint files.
-
-The following describes how to save a checkpoint file and export a MindIR, AIR, or ONNX file.
+download_train = Mnist(path="./mnist", split="train", batch_size=32, repeat_num=1, shuffle=True, resize=32, download=True)
+dataset_train = download_train.run()
-> MindSpore is an all-scenario AI framework that uses MindSpore IR to unify intermediate representation of network models. Therefore, you are advised to export files in MindIR format.
-
-### Exporting a MindIR File
-
-If you want to perform inference across platforms or hardware (such as the Ascend AI Processors, MindSpore devices, or GPUs) after obtaining a checkpoint file, you can define the network and checkpoint to generate a model file in MINDIR format. Currently, the inference network export based on static graphs is supported and does not contain control flow semantics. An example of the code for exporting the file is as follows:
-
-```python
-from mindspore import export, load_checkpoint, load_param_into_net
-from mindspore import Tensor
-import numpy as np
-
-resnet = ResNet50()
-# Store model parameters in the parameter dictionary.
-param_dict = load_checkpoint("resnet50-2_32.ckpt")
-
-# Load parameters to the network.
-load_param_into_net(resnet, param_dict)
-input = np.random.uniform(0.0, 1.0, size=[32, 3, 224, 224]).astype(np.float32)
-export(resnet, Tensor(input), file_name='resnet50-2_32', file_format='MINDIR')
+# Network model calls train() for training.
+model.train(epoch_num, dataset_train, callbacks=[LossMonitor(0.01, 1875)])
```
-> - `input` specifies the input shape and data type of the exported model. If the network has multiple inputs, you need to pass them to the `export` method. Example: `export(network, Tensor(input1), Tensor(input2), file_name='network', file_format='MINDIR')`
-> - If `file_name` does not contain the ".mindir" suffix, the system will automatically add the ".mindir" suffix to it.
-
-### Exporting in Other Formats
-
-#### Exporting an AIR File
-
-If you want to perform inference on the Ascend AI Processor after obtaining a checkpoint file, use the network and checkpoint to generate a model file in AIR format. An example of the code for exporting the file is as follows:
-
-```python
-export(resnet, Tensor(input), file_name='resnet50-2_32', file_format='AIR')
+```text
+Epoch:[ 0/ 5], step:[ 1875/ 1875], loss:[0.000/0.010], time:2.193 ms, lr:0.01000
+Epoch time: 4106.620 ms, per step time: 2.190 ms, avg loss: 0.010
+Epoch:[ 1/ 5], step:[ 1875/ 1875], loss:[0.000/0.009], time:2.036 ms, lr:0.01000
+Epoch time: 4233.697 ms, per step time: 2.258 ms, avg loss: 0.009
+Epoch:[ 2/ 5], step:[ 1875/ 1875], loss:[0.000/0.010], time:2.045 ms, lr:0.01000
+Epoch time: 4246.248 ms, per step time: 2.265 ms, avg loss: 0.010
+Epoch:[ 3/ 5], step:[ 1875/ 1875], loss:[0.000/0.008], time:2.001 ms, lr:0.01000
+Epoch time: 4235.036 ms, per step time: 2.259 ms, avg loss: 0.008
+Epoch:[ 4/ 5], step:[ 1875/ 1875], loss:[0.002/0.008], time:2.039 ms, lr:0.01000
+Epoch time: 4354.482 ms, per step time: 2.322 ms, avg loss: 0.008
```
-> - `input` specifies the input shape and data type of the exported model. If the network has multiple inputs, you need to pass them to the `export` method. Example: `export(network, Tensor(input1), Tensor(input2), file_name='network', file_format='AIR')`
-> - If `file_name` does not contain the ".air" suffix, the system will automatically add the ".air" suffix to it.
-
-#### Exporting an ONNX File
-
-If you want to perform inference on other third-party hardware after obtaining a checkpoint file, use the network and checkpoint to generate a model file in ONNX format. An example of the code for exporting the file is as follows:
-
-```python
-export(resnet, Tensor(input), file_name='resnet50-2_32', file_format='ONNX')
-```
-> - `input` specifies the input shape and data type of the exported model. If the network has multiple inputs, you need to pass them to the `export` method. Example: `export(network, Tensor(input1), Tensor(input2), file_name='network', file_format='ONNX')`
-> - If `file_name` does not contain the ".onnx" suffix, the system will automatically add the ".onnx" suffix to it.
-> - Currently, only the ONNX format export of ResNet50 and BERT[CLS] networks are supported.
diff --git a/tutorials/source_en/beginner/tensor.ipynb b/tutorials/source_en/beginner/tensor.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..db27ae693903f9a1f7ac9dbfcf46e3a67db318f2
--- /dev/null
+++ b/tutorials/source_en/beginner/tensor.ipynb
@@ -0,0 +1,695 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Tensor\n",
+ "\n",
+ "[](https://gitee.com/mindspore/docs/blob/master/tutorials/source_en/beginner/tensor.ipynb)\n",
+ "\n",
+ "Tensor is a multilinear function that can be used to represent linear relationships between vectors , scalars , and other tensors. The basic examples of these linear relations are the inner product , the outer product , the linear map , and the Cartesian product. In the $n$ dimensional space, its coordinates have $n^{r}$ components, where each component is a function of coordinates, and these components are also linearly transformed according to certain rules when the coordinates are transformed. $r$ is called the rank or order of this tensor (neither has anything to do with the rank and order of the matrix).\n",
+ "\n",
+ "Tensor is a special data structure that is very similar to arrays and matrices. [Tensor](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore/mindspore.Tensor.html) is the basic data structure in MindSpore network operations, and this chapter mainly introduces the attributes and usage of the tensor and the sparse tensor."
+ ],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Building the Tensor\n",
+ "\n",
+ "There are multiple methods for initializing the tensor. When building the tensor, you can pass the Tensor with `float`, `int`, `bool`, `tuple`, `list`, and `NumPy.array` types.\n",
+ "\n",
+ "- **Generating a tensor based on data.**\n",
+ "\n",
+ "You can create a tensor based on data. The data type can be set or automatically inferred."
+ ],
+ "metadata": {}
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "source": [
+ "from mindspore import Tensor\n",
+ "\n",
+ "x = Tensor(0.1)"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "- **Generating a tensor from the NumPy array.**\n",
+ "\n",
+ "You can create a tensor from the NumPy array."
+ ],
+ "metadata": {}
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "arr = np.array([1, 0, 1, 0])\n",
+ "tensor_arr = Tensor(arr)\n",
+ "\n",
+ "print(type(arr))\n",
+ "print(type(tensor_arr))"
+ ],
+ "outputs": [],
+ "metadata": {}
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "
+
+After learning how to create a model and build a dataset in the preceding tutorials, you can start to learn how to set hyperparameters and optimize model parameters.
+
+## Hyperparameters
+
+Hyperparameters can be adjusted to control the model training and optimization process. Different hyperparameter values may affect the model training and convergence speed. At present, deep learning models are mostly optimized by a batch stochastic gradient descent algorithm, and the principle of the stochastic gradient descent algorithm is as follows:
+$$
+w_{t+1}=w_{t}-\eta \frac{1}{n} \sum_{x \in \mathcal{B}} \nabla l\left(x, w_{t}\right)
+$$
+where $n$ is the batch size, and $η$ is a learning rate. In addition, $w_{t}$ is the weight parameter in the training batch t, and $\nabla l$ is the derivative of the loss function. It can be known that in addition to the gradient itself, these two factors directly determine the weight update of the model, and from the optimization itself, they are the most important parameters that affect the performance convergence of the model. Generally, the following hyperparameters are defined for training:
+
+- Epoch: specifies number of times that the dataset is traversed during training.
+- Batch size: The dataset is trained for batch reading, setting the size of each batch of data. The batch size is too small, takes a lot of time, and the gradient oscillation is serious, which is not conducive to convergence. The batch size is too large, and the gradient direction of different batches does not change at all, which is easy to fall into local minimum values. In this way, an appropriate batch size needs to be chosen, to effectively improve the accuracy of the model and global convergence.
+- Learning rate: If the learning rate is low, the convergence speed slows down. If the learning rate is high, unpredictable results such as no training convergence may occur. Gradient descent is a parameter optimization algorithm that is widely used to minimize model errors. Gradient descent estimates the parameters of the model by iterating and minimizing the loss function at each step. The learning rate is that during the iteration process, the learning progress of the model will be controlled.
+
+
+
+```python
+epochs = 10
+batch_size = 32
+momentum = 0.9
+learning_rate = 1e-2
+```
+
+## Loss Functions
+
+The **loss function** is used to evaluate the difference between **predicted value** and **target value** of a model. Here, the absolute error loss function `L1Loss` is used:
+$$
+\text { L1 Loss Function }=\sum_{i=1}^{n}\left|y_{true}-y_{predicted}\right|
+$$
+ `mindspore.nn.loss` provides many common loss functions, such as `SoftmaxCrossEntropyWithLogits`, `MSELoss`, and `SmoothL1Loss`.
+
+Given the predicted value and the target value, we calculate the error (loss value) between the predicted value and the target value by means of a loss function, which is used as follows:
+
+```python
+import numpy as np
+import mindspore.nn as nn
+from mindspore import Tensor
+
+loss = nn.L1Loss()
+output_data = Tensor(np.array([[1, 2, 3], [2, 3, 4]]).astype(np.float32))
+target_data = Tensor(np.array([[0, 2, 5], [3, 1, 1]]).astype(np.float32))
+print(loss(output_data, target_data))
+```
+
+```text
+ 1.5
+```
+
+## Optimizer Functions
+
+An optimizer is used to compute and update the gradient. The selection of the model optimization algorithm directly affects the performance of the final model. A poor effect may be caused by the optimization algorithm instead of the feature or model design.
+
+All optimization logic of MindSpore is encapsulated in the `Optimizer` object. Here, the Momentum optimizer is used. `mindspore.nn` provides many common optimizers, such as `Adam`, `SGD` and `RMSProp`.
+
+You need to build an `Optimizer` object. This object can retain the current parameter status and update parameters based on the computed gradient. To build an `Optimizer`, we need to provide an iterator that contains parameters (must be variable objects) to be optimized. For example, set parameters to `net.trainable_params()` for all `parameter` that can be trained on the network.
+
+Then, you can set the `Optimizer` parameter options, such as the learning rate and weight attenuation.
+
+A code example is as follows:
+
+```python
+from mindspore import nn
+from mindvision.classification.models import lenet
+
+net = lenet(num_classes=10, pretrained=False)
+optim = nn.Momentum(net.trainable_params(), learning_rate, momentum)
+```
+
+## Model Training
+
+A model training process is generally divided into four steps.
+
+1. Define a neural network.
+2. Build a dataset.
+3. Define hyperparameters, a loss function, and an optimizer.
+4. Enter the epoch and dataset for training.
+
+The model training sample code is as follows:
+
+```python
+import mindspore.nn as nn
+from mindspore.train import Model
+
+from mindvision.classification.dataset import Mnist
+from mindvision.classification.models import lenet
+from mindvision.engine.callback import LossMonitor
+
+# 1. Build a dataset
+download_train = Mnist(path="./mnist", split="train", batch_size=batch_size, repeat_num=1, shuffle=True, resize=32, download=True)
+dataset_train = download_train.run()
+
+# 2. Define a neural network
+network = lenet(num_classes=10, pretrained=False)
+# 3.1 Define a loss function
+net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
+# 3.2 Defines an optimizer function
+net_opt = nn.Momentum(network.trainable_params(), learning_rate=learning_rate, momentum=momentum)
+# 3.3 Initialize model parameters
+model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'acc'})
+
+# 4. Perform training on the neural network
+model.train(epochs, dataset_train, callbacks=[LossMonitor(learning_rate, 1875)])
+```
+
+```text
+Epoch:[ 0/ 10], step:[ 1875/ 1875], loss:[0.189/1.176], time:2.254 ms, lr:0.01000
+Epoch time: 4286.163 ms, per step time: 2.286 ms, avg loss: 1.176
+Epoch:[ 1/ 10], step:[ 1875/ 1875], loss:[0.085/0.080], time:1.895 ms, lr:0.01000
+Epoch time: 4064.532 ms, per step time: 2.168 ms, avg loss: 0.080
+Epoch:[ 2/ 10], step:[ 1875/ 1875], loss:[0.021/0.054], time:1.901 ms, lr:0.01000
+Epoch time: 4194.333 ms, per step time: 2.237 ms, avg loss: 0.054
+Epoch:[ 3/ 10], step:[ 1875/ 1875], loss:[0.284/0.041], time:2.130 ms, lr:0.01000
+Epoch time: 4252.222 ms, per step time: 2.268 ms, avg loss: 0.041
+Epoch:[ 4/ 10], step:[ 1875/ 1875], loss:[0.003/0.032], time:2.176 ms, lr:0.01000
+Epoch time: 4216.039 ms, per step time: 2.249 ms, avg loss: 0.032
+Epoch:[ 5/ 10], step:[ 1875/ 1875], loss:[0.003/0.027], time:2.205 ms, lr:0.01000
+Epoch time: 4400.771 ms, per step time: 2.347 ms, avg loss: 0.027
+Epoch:[ 6/ 10], step:[ 1875/ 1875], loss:[0.000/0.024], time:1.973 ms, lr:0.01000
+Epoch time: 4554.252 ms, per step time: 2.429 ms, avg loss: 0.024
+Epoch:[ 7/ 10], step:[ 1875/ 1875], loss:[0.008/0.022], time:2.048 ms, lr:0.01000
+Epoch time: 4361.135 ms, per step time: 2.326 ms, avg loss: 0.022
+Epoch:[ 8/ 10], step:[ 1875/ 1875], loss:[0.000/0.018], time:2.130 ms, lr:0.01000
+Epoch time: 4547.597 ms, per step time: 2.425 ms, avg loss: 0.018
+Epoch:[ 9/ 10], step:[ 1875/ 1875], loss:[0.008/0.017], time:2.135 ms, lr:0.01000
+Epoch time: 4601.861 ms, per step time: 2.454 ms, avg loss: 0.017
+```
+
+The loss value is printed during training. The loss value fluctuates, but in general the loss value decreases gradually and the accuracy gradually increases. The loss values run by different persons have a certain randomness and are not necessarily exactly the same.
\ No newline at end of file
diff --git a/tutorials/source_en/dataset.md b/tutorials/source_en/dataset.md
deleted file mode 100644
index 7e83aeb86652cd5556bc386efbdca6f3003527cc..0000000000000000000000000000000000000000
--- a/tutorials/source_en/dataset.md
+++ /dev/null
@@ -1,252 +0,0 @@
-# Loading and Processing Data
-
-`Ascend` `GPU` `CPU` `Beginner` `Data Preparation`
-
-
-
-MindSpore provides APIs for loading common datasets and datasets in standard formats. You can directly use the corresponding dataset loading class in mindspore.dataset to load data. The dataset class provides common data processing APIs for users to quickly process data.
-
-## Data Preparation
-
-Execute the following command to download and decompress the CIFAR-10 and MNIST dataset to the specified location.
-
-```python
-import os
-import requests
-import tarfile
-import zipfile
-
-def download_dataset(url, target_path):
- """download and decompress dataset"""
- if not os.path.exists(target_path):
- os.makedirs(target_path)
- download_file = url.split("/")[-1]
- if not os.path.exists(download_file):
- res = requests.get(url, stream=True, verify=False)
- if download_file.split(".")[-1] not in ["tgz","zip","tar","gz"]:
- download_file = os.path.join(target_path, download_file)
- with open(download_file, "wb") as f:
- for chunk in res.iter_content(chunk_size=512):
- if chunk:
- f.write(chunk)
- if download_file.endswith("zip"):
- z = zipfile.ZipFile(download_file, "r")
- z.extractall(path=target_path)
- z.close()
- if download_file.endswith(".tar.gz") or download_file.endswith(".tar") or download_file.endswith(".tgz"):
- t = tarfile.open(download_file)
- names = t.getnames()
- for name in names:
- t.extract(name, target_path)
- t.close()
-
-download_dataset("https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz", "./datasets")
-download_dataset("https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip", "./datasets")
-```
-
-The directory structure of the CIFAR-10 dataset file is as follows:
-
-```text
-./datasets/cifar-10-batches-bin
-├── batches.meta.txt
-├── data_batch_1.bin
-├── data_batch_2.bin
-├── data_batch_3.bin
-├── data_batch_4.bin
-├── data_batch_5.bin
-├── readme.html
-└── test_batch.bin
-```
-
-Refer to [Quick Start](https://www.mindspore.cn/tutorials/en/master/quick_start.html#downloading-the-dataset) for the directory structure of MINIST dataset files.
-
-## Loading the Dataset
-
-In the following example, the CIFAR-10 dataset is loaded through the `Cifar10Dataset` API, and the first five samples are obtained using the sequential sampler.
-
-```python
-import mindspore.dataset as ds
-
-DATA_DIR = "./datasets/cifar-10-batches-bin"
-sampler = ds.SequentialSampler(num_samples=5)
-dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-```
-
-## Iterating Dataset
-
-You can use `create_dict_iterator` to create a data iterator to iteratively access data. The following shows the image shapes and labels.
-
-```python
-for data in dataset.create_dict_iterator():
- print("Image shape: {}".format(data['image'].shape), ", Label: {}".format(data['label']))
-```
-
-```text
- Image shape: (32, 32, 3) , Label: 6
- Image shape: (32, 32, 3) , Label: 9
- Image shape: (32, 32, 3) , Label: 9
- Image shape: (32, 32, 3) , Label: 4
- Image shape: (32, 32, 3) , Label: 1
-```
-
-## Customizing Datasets
-
-For datasets that cannot be directly loaded by MindSpore, you can build a custom dataset class and use the `GeneratorDataset` API to customize data loading.
-
-```python
-import numpy as np
-
-np.random.seed(58)
-
-class DatasetGenerator:
- def __init__(self):
- self.data = np.random.sample((5, 2))
- self.label = np.random.sample((5, 1))
-
- def __getitem__(self, index):
- return self.data[index], self.label[index]
-
- def __len__(self):
- return len(self.data)
-```
-
-You need to customize the following class functions:
-
-- **\_\_init\_\_**
-
- When a dataset object is instantiated, the `__init__` function is called. You can perform operations such as data initialization.
-
- ```python
- def __init__(self):
- self.data = np.random.sample((5, 2))
- self.label = np.random.sample((5, 1))
- ```
-
-- **\_\_getitem\_\_**
-
- Define the `__getitem__` function of the dataset class to support random access and obtain and return data in the dataset based on the specified `index` value.
-
- The return value of the `__getitem__` function needs to be a tuple of numpy arrays. When returning a single numpy array, it can be written as `return (np_array_1,)`.
-
- ```python
- def __getitem__(self, index):
- return self.data[index], self.label[index]
- ```
-
-- **\_\_len\_\_**
-
- Define the `__len__` function of the dataset class and return the number of samples in the dataset.
-
- ```python
- def __len__(self):
- return len(self.data)
- ```
-
-After the dataset class is defined, the `GeneratorDataset` API can be used to load and access dataset samples in the user-defined mode.
-
-```python
-dataset_generator = DatasetGenerator()
-dataset = ds.GeneratorDataset(dataset_generator, ["data", "label"], shuffle=False)
-
-for data in dataset.create_dict_iterator():
- print('{}'.format(data["data"]), '{}'.format(data["label"]))
-```
-
-```text
- [0.36510558 0.45120592] [0.78888122]
- [0.49606035 0.07562207] [0.38068183]
- [0.57176158 0.28963401] [0.16271622]
- [0.30880446 0.37487617] [0.54738768]
- [0.81585667 0.96883469] [0.77994068]
-```
-
-## Data Processing and Augmentation
-
-### Processing Data
-
-The dataset APIs provided by MindSpore support common data processing methods. You only need to call the corresponding function APIs to quickly process data.
-
-In the following example, the datasets are shuffled, and then two samples form a batch.
-
-```python
-ds.config.set_seed(58)
-
-# Shuffle the data sequence.
-dataset = dataset.shuffle(buffer_size=10)
-# Perform batch operations on datasets.
-dataset = dataset.batch(batch_size=2)
-
-for data in dataset.create_dict_iterator():
- print("data: {}".format(data["data"]))
- print("label: {}".format(data["label"]))
-```
-
-```text
- data: [[0.36510558 0.45120592]
- [0.57176158 0.28963401]]
- label: [[0.78888122]
- [0.16271622]]
- data: [[0.30880446 0.37487617]
- [0.49606035 0.07562207]]
- label: [[0.54738768]
- [0.38068183]]
- data: [[0.81585667 0.96883469]]
- label: [[0.77994068]]
-```
-
-Where,
-
-`buffer_size`: size of the buffer for shuffle operations in the dataset.
-
-`batch_size`: number of data records in each group. Currently, each group contains 2 data records.
-
-### Data Augmentation
-
-If the data volume is too small or the sample scenario is simple, the model training effect is affected. You can perform the data augmentation operation to expand the sample diversity and improve the generalization capability of the model.
-
-The following example uses the operators in the `mindspore.dataset.vision.c_transforms` module to perform data argumentation on the MNIST dataset.
-
-Import the `c_transforms` module and load the MNIST dataset.
-
-```python
-import matplotlib.pyplot as plt
-
-from mindspore.dataset.vision import Inter
-import mindspore.dataset.vision.c_transforms as c_vision
-
-DATA_DIR = './datasets/MNIST_Data/train'
-
-mnist_dataset = ds.MnistDataset(DATA_DIR, num_samples=6, shuffle=False)
-
-# View the original image data.
-mnist_it = mnist_dataset.create_dict_iterator()
-data = next(mnist_it)
-plt.imshow(data['image'].asnumpy().squeeze(), cmap=plt.cm.gray)
-plt.title(data['label'].asnumpy(), fontsize=20)
-plt.show()
-```
-
-
-
-Define the data augmentation operator, perform the `Resize` and `RandomCrop` operations on the dataset, and insert the dataset into the data processing pipeline through `map` mapping.
-
-```python
-resize_op = c_vision.Resize(size=(200,200), interpolation=Inter.LINEAR)
-crop_op = c_vision.RandomCrop(150)
-transforms_list = [resize_op, crop_op]
-mnist_dataset = mnist_dataset.map(operations=transforms_list, input_columns=["image"])
-```
-
-View the data augmentation effect.
-
-```python
-mnist_dataset = mnist_dataset.create_dict_iterator()
-data = next(mnist_dataset)
-plt.imshow(data['image'].asnumpy().squeeze(), cmap=plt.cm.gray)
-plt.title(data['label'].asnumpy(), fontsize=20)
-plt.show()
-```
-
-
-
-For more information, see [Data augmentation](https://www.mindspore.cn/docs/programming_guide/en/master/augmentation.html).
diff --git a/tutorials/source_en/images/introduction2.png b/tutorials/source_en/images/introduction2.png
deleted file mode 100644
index 61ff0d91e4ee5a54f1a2a05e4e3f000b1af30c58..0000000000000000000000000000000000000000
Binary files a/tutorials/source_en/images/introduction2.png and /dev/null differ
diff --git a/tutorials/source_en/images/introduction3.png b/tutorials/source_en/images/introduction3.png
deleted file mode 100644
index a66da13137d7ed238c6ead4ffae8228dc72f2543..0000000000000000000000000000000000000000
Binary files a/tutorials/source_en/images/introduction3.png and /dev/null differ
diff --git a/tutorials/source_en/images/output_13_0.PNG b/tutorials/source_en/images/output_13_0.PNG
deleted file mode 100644
index c8cdc908c7dadb762ebce708145994b5b753060b..0000000000000000000000000000000000000000
Binary files a/tutorials/source_en/images/output_13_0.PNG and /dev/null differ
diff --git a/tutorials/source_en/images/output_17_0.PNG b/tutorials/source_en/images/output_17_0.PNG
deleted file mode 100644
index 48bcec38475b66b7d7e869b1a1386f3b5955714b..0000000000000000000000000000000000000000
Binary files a/tutorials/source_en/images/output_17_0.PNG and /dev/null differ
diff --git a/tutorials/source_en/index.rst b/tutorials/source_en/index.rst
index cb68315cbe8f149a8d99b1cdfa6bb47d06218309..4d6a8e712ede0597ef1613e2811755362e9e6d8a 100644
--- a/tutorials/source_en/index.rst
+++ b/tutorials/source_en/index.rst
@@ -10,218 +10,13 @@ MindSpore Tutorial
:glob:
:maxdepth: 1
:caption: Quick Start
- :hidden:
- introduction
- quick_start
- tensor
- dataset
- model
- autograd
- optimization
- save_load_model
- inference
- linear_regression
-
-.. raw:: html
-
-
-
-This is the last tutorial. To better adapt to different inference devices, inference is classified into Ascend AI Processor inference and mobile device inference.
-
-## Ascend AI Processor Inference
-
-An Ascend AI Processor is an energy-efficient and highly integrated AI processor oriented to edge scenarios. It can implement multiple data analysis and inference computing, such as image and video analysis, and can be widely used in scenarios such as intelligent surveillance, robots, drones, and video servers. The following describes how to use MindSpore to perform inference on the Ascend AI Processors.
-
-### Inference Code
-
-Create a directory to store the inference code project, for example, `/home/HwHiAiUser/mindspore_sample/ascend910_resnet50_preprocess_sample`. You can download the [sample code](https://gitee.com/mindspore/docs/tree/master/docs/sample_code/ascend910_resnet50_preprocess_sample) from the official website. The `model` directory is used to store the exported [MindIR model file](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/sample_resources/ascend310_resnet50_preprocess_sample/resnet50_imagenet.mindir), and the `test_data` directory is used to store the images to be classified, the images can be selected in [ImageNet2012](http://image-net.org/download-images) validation dataset. The directory structure of the inference code project is as follows:
-
-```text
-└─ascend910_resnet50_preprocess_sample
- ├── CMakeLists.txt // Build script
- ├── README.md // Usage description
- ├── main.cc // Main function
- ├── model
- │ └── resnet50_imagenet.mindir // MindIR model file
- └── test_data
- ├── ILSVRC2012_val_00002138.JPEG // Input sample image 1
- ├── ILSVRC2012_val_00003014.JPEG // Input sample image 2
- ├── ... // Input sample image n.
-```
-
-Namespaces that reference `mindspore` and `mindspore::dataset`.
-
-```c++
-namespace ms = mindspore;
-namespace ds = mindspore::dataset;
-```
-
-Initialize the environment, specify the hardware platform used for inference, and set DeviceID.
-
-Set the hardware to Ascend 910 and set DeviceID to 0. The code example is as follows:
-
-```c++
-auto context = std::make_shared
-
-The following describes the Huawei AI full-stack solution and introduces the position of MindSpore in the solution. Developers who are interested in MindSpore can visit the [MindSpore community](https://gitee.com/mindspore/mindspore) and click [Watch, Star, and Fork](https://gitee.com/mindspore/mindspore).
-
-## Introduction to Huawei Ascend AI Full-Stack Solution
-
-Ascend computing is a full-stack AI computing infrastructure and application based on the Ascend series processors. It includes the Ascend series chips, Atlas series hardware, CANN chip enablement, MindSpore AI framework, ModelArts, and MindX application enablement.
-
-Huawei Atlas AI computing solution is based on Ascend series AI processors and uses various product forms such as modules, cards, edge stations, servers, and clusters to build an all-scenario AI infrastructure solution oriented to device, edge, and cloud. It covers data center and intelligent edge solutions, as well as the entire inference and training processes in the deep learning field.
-
-- **Atlas series**: provides AI training, inference cards, and training servers ([learn more](https://e.huawei.com/en/products/cloud-computing-dc/atlas/)).
-- **CANN at heterogeneous computing architecture**: a driver layer that enables chips ([learn more](https://www.hiascend.com/en/software/cann)).
-- **MindSpore**: all-scenario AI framework ([learn more](https://www.mindspore.cn/en)).
-- **MindX SDK**: Ascend SDK that provides application solutions ([learn more](https://www.hiascend.com/en/software/mindx-sdk)).
-- **ModelArts**: HUAWEI CLOUD AI development platform ([learn more](https://www.huaweicloud.com/product/modelarts.html)).
-- **MindStudio**: E2E development toolchain that provides one-stop IDE for AI development ([learn more](https://www.hiascend.com/en/software/mindstudio)).
-
-For details, click [Huawei Ascend official website](https://e.huawei.com/en/products/servers/ascend).
-
-## MindSpore Introduction
-
-MindSpore is a deep learning framework in all scenarios, aiming to achieve easy development, efficient execution, and all-scenario coverage. Easy development features friendly APIs and easy debugging. Efficient execution is reflected in computing, data preprocessing, and distributed training. All-scenario coverage means that the framework supports cloud, edge, and device scenarios.
-
-The following figure shows the overall MindSpore architecture:
-
-- **ModelZoo**: ModelZoo provides available deep learning algorithm networks, and more developers are welcome to contribute new networks.
-- **MindSpore Extend**: The expansion package of MindSpore expands the support of new fields, such as GNN/deep probabilistic programming/reinforcement learning, etc. We look forward to more developers to contribute and build together.
-- **MindScience**：MindScience is a scientific computing kits for various industries based on the converged MindSpore framefork. It contains the industry-leading datasets, basic network structures, high-precision pre-trained models, and pre-and post-processing tools that accelerate application development of the scientific computing.
-- **MindExpression**: Python-based frontend expression and programming interfaces. In the future, more frontends based on C/C++ will be provided. Cangjie, Huawei's self-developed programming language frontend, is now in the pre-research phase. In addition, Huawei is working on interconnection with third-party frontends to introduce more third-party ecosystems.
-- **MindData**: Provides functions and programming interfaces such as efficient data processing, loading of commonly used datasets, and supports users' flexible definition processing registration and pipeline parallel optimization
-- **MindCompiler**: The core compiler of the layer, which implements three major functions based on the unified device-cloud MindIR, including hardware-independent optimization (type derivation, automatic differentiation, and expression simplification), hardware-related optimization (automatic parallelism, memory optimization, graph kernel fusion, and pipeline execution) and optimization related to deployment and inference (quantification and pruning).
-- **MindRT**: MindSpore runtime system, which covers the cloud-side host-side runtime system, the device-side and the lightweight runtime system of the smaller IoT.
-- **MindInsight**: Provides MindSpore's visual debugging and tuning tools, and supports users to debug and tune the training network.
-- **MindArmour**: For enterprise-level applications, security and privacy protection related enhancements, such as anti-robustness, model security testing, differential privacy training, privacy leakage risk assessment, data drift detection, etc. technology.
-
-
-
-### API Level Structure
-
-To support network building, entire graph execution, subgraph execution, and single-operator execution, MindSpore provides users with three levels of APIs. In ascending order, these are Low-Level Python API, Medium-Level Python API, and High-Level Python API.
-
-
-
-- High-Level Python API
-
- High-level APIs are at the first layer. Based on the medium-level API, these advanced APIs include training and inference management, mixed precision training, and debugging and optimization, enabling users to control the execution process of the entire network and implement training, inference, and optimization of the neural network. For example, by utilizing the Model API, users can specify the neural network model to be trained as well as related training settings, train the neural network model, and debug the neural network performance through the Profiler API.
-
-- Medium-Level Python API
-
- Medium-level APIs are at the second layer, which encapsulates low-cost APIs and provides such modules as the network layer, optimizer, and loss function. Users can flexibly build neural networks and control execution processes through the medium-level API to quickly implement model algorithm logic. For example, users can call the Cell API to build neural network models and computing logic, add the loss function and optimization methods to the neural network model by using the loss module and Optimizer API, and use the dataset module to process data for model training and derivation.
-
-- Low-Level Python API
-
- Low-level APIs are at the third layer, including tensor definition, basic operators, and automatic differential modules, enabling users to easily define tensors and perform derivative computation. For example, users can customize tensors by using the Tensor API, and use the GradOperation operator in the ops.composite module to calculate the derivative of the function at a specified position.
-
-## Joining the Community
-
-Welcome every developer to the MindSpore community and contribute to this all-scenario AI framework.
-
-- **MindSpore official website**: provides comprehensive MindSpore information, including installation, tutorials, documents, community, resources, and news ([learn more](https://www.mindspore.cn/en)).
-- **MindSpore code**:
-
- - [MindSpore Gitee](https://gitee.com/mindspore/mindspore): Top 1 Gitee open-source project in 2020, where you can track the latest progress of MindSpore by clicking Watch, Star, and Fork, discuss issues, and commit code.
-
- - [MindSpore Github](https://github.com/mindspore-ai/mindspore): MindSpore code image of Gitee. Developers who are accustomed to using GitHub can learn MindSpore and view the latest code implementation here.
-
-- **MindSpore forum**: We are dedicated to serving every developer. You can find your voice in MindSpore, regardless of whether you are an entry-level developer or a master. Let's learn and grow together. ([Learn more](https://bbs.huaweicloud.com/forum/forum-1076-1.html))
diff --git a/tutorials/source_en/linear_regression.ipynb b/tutorials/source_en/linear_regression.ipynb
deleted file mode 100644
index 62e7d31f89b03944970ac179b6b2bf81538e76bc..0000000000000000000000000000000000000000
--- a/tutorials/source_en/linear_regression.ipynb
+++ /dev/null
@@ -1,528 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "source": [
- "# Simple Linear Function Fitting\n",
- "\n",
- "Author: [Yi Yang](https://github.com/helloyesterday) Editor: [Mingfu Lv](https://gitee.com/lvmingfu)\n",
- "\n",
- "[](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/tutorials/en/mindspore_linear_regression.ipynb) [](https://gitee.com/mindspore/docs/blob/master/tutorials/source_en/linear_regression.ipynb)"
- ],
- "metadata": {}
- },
- {
- "cell_type": "markdown",
- "source": [
- "## Overview\n",
- "\n",
- "Regression algorithms usually use a series of properties to predict a value, and the predicted values are consecutive. For example, the price of a house is predicted based on some given feature data of the house, such as area and the number of bedrooms; or future temperature conditions are predicted by using the temperature change data and satellite cloud images in the last week. If the actual price of the house is CNY5 million, and the value predicted through regression analysis is CNY4.99 million, the regression analysis is considered accurate. For machine learning problems, common regression analysis includes linear regression, polynomial regression, and logistic regression. This example describes the linear regression algorithms and how to use MindSpore to perform linear regression AI training.\n",
- "\n",
- "The whole process is as follows:\n",
- "\n",
- "1. Generate datasets.\n",
- "2. Define a training network.\n",
- "3. Define and associate the forward and backward propagation networks.\n",
- "4. Prepare for fitting process visualization.\n",
- "5. Perform training.\n",
- "\n",
- "> This document is applicable to CPU, GPU and Ascend environments. The source code address of this example:
-
-After learning how to create a model and build a dataset in the preceding tutorials, you can start to learn how to set hyperparameters and optimize model parameters.
-
-## Hyperparameters
-
-Hyperparameters can be adjusted to control the model training and optimization process. Different hyperparameter values may affect the model training and convergence speed.
-
-Generally, the following hyperparameters are defined for training:
-
-- Epoch: specifies number of times that the dataset is traversed during training.
-- Batch size: specifies the size of each batch of data to be read.
-- Learning rate: If the learning rate is low, the convergence speed slows down. If the learning rate is high, unpredictable results such as no training convergence may occur.
-
-```python
-epochs = 5
-batch_size = 64
-learning_rate = 1e-3
-```
-
-## Loss Functions
-
-The **loss function** is used to evaluate the difference between **predicted value** and **actual value** of a model. Here, the absolute error loss function `L1Loss` is used. `mindspore.nn.loss` provides many common loss functions, such as `SoftmaxCrossEntropyWithLogits`, `MSELoss`, and `SmoothL1Loss`.
-
-The output value and target value are provided to compute the loss value. The method is as follows:
-
-```python
-import numpy as np
-import mindspore.nn as nn
-from mindspore import Tensor
-
-loss = nn.L1Loss()
-output_data = Tensor(np.array([[1, 2, 3], [2, 3, 4]]).astype(np.float32))
-target_data = Tensor(np.array([[0, 2, 5], [3, 1, 1]]).astype(np.float32))
-print(loss(output_data, target_data))
-```
-
-```text
- 1.5
-```
-
-## Optimizer
-
-An optimizer is used to compute and update the gradient. The selection of the model optimization algorithm directly affects the performance of the final model. A poor effect may be caused by the optimization algorithm instead of the feature or model design. All optimization logic of MindSpore is encapsulated in the `Optimizer` object. Here, the Momentum optimizer is used. `mindspore.nn` provides many common optimizers, such as `Adam` and `Momentum`.
-
-You need to build an `Optimizer` object. This object can retain the current parameter status and update parameters based on the computed gradient.
-
-To build an `Optimizer`, we need to provide an iterator that contains parameters (must be variable objects) to be optimized. For example, set `params` to `net.trainable_params()` for all `parameter` that can be trained on the network. Then, you can set the `Optimizer` parameter options, such as the learning rate and weight attenuation.
-
-A code example is as follows:
-
-```python
-from mindspore import nn
-
-optim = nn.Momentum(net.trainable_params(), 0.1, 0.9)
-```
-
-## Training
-
-A model training process is generally divided into four steps.
-
-1. Define a neural network.
-2. Build a dataset.
-3. Define hyperparameters, a loss function, and an optimizer.
-4. Enter the epoch and dataset for training.
-
-Execute the following command to download and decompress the dataset to the specified location.
-
-```python
-import os
-import requests
-import tarfile
-import zipfile
-
-def download_dataset(url, target_path):
- """download dataset"""
- if not os.path.exists(target_path):
- os.makedirs(target_path)
- download_file = url.split("/")[-1]
- if not os.path.exists(download_file):
- res = requests.get(url, stream=True, verify=False)
- if download_file.split(".")[-1] not in ["tgz","zip","tar","gz"]:
- download_file = os.path.join(target_path, download_file)
- with open(download_file, "wb") as f:
- for chunk in res.iter_content(chunk_size=512):
- if chunk:
- f.write(chunk)
- if download_file.endswith("zip"):
- z = zipfile.ZipFile(download_file, "r")
- z.extractall(path=target_path)
- z.close()
- if download_file.endswith(".tar.gz") or download_file.endswith(".tar") or download_file.endswith(".tgz"):
- t = tarfile.open(download_file)
- names = t.getnames()
- for name in names:
- t.extract(name, target_path)
- t.close()
-
-download_dataset("https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz", "./datasets")
-```
-
-The code example for model training is as follows:
-
-```python
-import mindspore.dataset as ds
-import mindspore.dataset.transforms.c_transforms as C
-import mindspore.dataset.vision.c_transforms as CV
-from mindspore import nn, Tensor, Model
-from mindspore import dtype as mstype
-from mindspore.train.callback import LossMonitor
-
-DATA_DIR = "./datasets/cifar-10-batches-bin"
-
-# Define a neural network.
-class Net(nn.Cell):
- def __init__(self, num_class=10, num_channel=3):
- super(Net, self).__init__()
- self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
- self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
- self.fc1 = nn.Dense(16 * 5 * 5, 120)
- self.fc2 = nn.Dense(120, 84)
- self.fc3 = nn.Dense(84, num_class)
- self.relu = nn.ReLU()
- self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
- self.flatten = nn.Flatten()
-
- def construct(self, x):
- x = self.conv1(x)
- x = self.relu(x)
- x = self.max_pool2d(x)
- x = self.conv2(x)
- x = self.relu(x)
- x = self.max_pool2d(x)
- x = self.flatten(x)
- x = self.fc1(x)
- x = self.relu(x)
- x = self.fc2(x)
- x = self.relu(x)
- x = self.fc3(x)
- return x
-
-net = Net()
-epochs = 5
-batch_size = 64
-learning_rate = 1e-3
-
-# Build a dataset.
-sampler = ds.SequentialSampler(num_samples=128)
-dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-
-# Convert the data type.
-type_cast_op_image = C.TypeCast(mstype.float32)
-type_cast_op_label = C.TypeCast(mstype.int32)
-HWC2CHW = CV.HWC2CHW()
-dataset = dataset.map(operations=[type_cast_op_image, HWC2CHW], input_columns="image")
-dataset = dataset.map(operations=type_cast_op_label, input_columns="label")
-dataset = dataset.batch(batch_size)
-
-# Define hyperparameters, a loss function, and an optimizer.
-optim = nn.Momentum(net.trainable_params(), learning_rate, 0.9)
-loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
-cb = LossMonitor()
-
-# Enter the epoch and dataset for training.
-model = Model(net, loss_fn=loss, optimizer=optim)
-model.train(epoch=epochs, train_dataset=dataset, callbacks=cb)
-```
-
-The output is as follows:
-
-```text
-epoch: 1 step: 1, loss is 2.3025818
-epoch: 1 step: 2, loss is 2.3025775
-epoch: 2 step: 1, loss is 2.3025408
-epoch: 2 step: 2, loss is 2.3025331
-epoch: 3 step: 1, loss is 2.3024616
-epoch: 3 step: 2, loss is 2.302457
-epoch: 4 step: 1, loss is 2.3023522
-epoch: 4 step: 2, loss is 2.3023558
-epoch: 5 step: 1, loss is 2.3022182
-epoch: 5 step: 2, loss is 2.3022337
-```
diff --git a/tutorials/source_en/tensor.md b/tutorials/source_en/tensor.md
deleted file mode 100644
index 8fbcdca76e4b7594d02411cd0b866ee25501c341..0000000000000000000000000000000000000000
--- a/tutorials/source_en/tensor.md
+++ /dev/null
@@ -1,230 +0,0 @@
-# Tensor
-
-`Ascend` `GPU` `CPU` `Beginner`
-
-
-
-Tensor is a basic data structure in the MindSpore network computing.
-
-Import the required modules and APIs:
-
-```python
-import numpy as np
-from mindspore import Tensor, context
-from mindspore import dtype as mstype
-context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
-```
-
-## Initializing a Tensor
-
-There are multiple methods for initializing tensors. When building a tensor, you can pass the [Tensor](https://www.mindspore.cn/docs/api/en/master/api_python/mindspore/mindspore.Tensor.html), `float`, `int`, `bool`, `tuple`, `list`, and `NumPy.array` types.
-
-- **Generate a tensor based on data.**
-
-You can create a tensor based on data. The data type can be set or automatically inferred.
-
-```python
-x = Tensor(0.1)
-```
-
-- **Generate a tensor from the NumPy array.**
-
-You can create a tensor from the NumPy array.
-
-```python
-arr = np.array([1, 0, 1, 0])
-x_np = Tensor(arr)
-```
-
-If the initial value is `NumPy.array`, the generated `Tensor` data type corresponds to `NumPy.array`.
-
-- **Generate a tensor from the init**
-
-You can create a tensor with the `init`, `shape` and `dtype`.
-
-- `init`: Supported subclasses of incoming Subclass of [initializer](https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.common.initializer.html).
-- `shape`: Supported subclasses of incoming `list`, `tuple`, `int`.
-- `dtype`: Supported subclasses of incoming [mindspore.dtype](https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype).
-
-```python
-from mindspore import Tensor
-from mindspore import set_seed
-from mindspore import dtype as mstype
-from mindspore.common.initializer import One, Normal
-
-set_seed(1)
-
-tensor1 = Tensor(shape=(2, 2), dtype=mstype.float32, init=One())
-tensor2 = Tensor(shape=(2, 2), dtype=mstype.float32, init=Normal())
-print(tensor1)
-print(tensor2)
-```
-
-```text
- [[1. 1.]
- [1. 1.]]
- [[-0.00128023 -0.01392901]
- [ 0.0130886 -0.00107818]]
-```
-
-The `init` is used for delayed initialization in parallel mode. Usually, it is not recommended to use `init` interface to initialize parameters in other conditions.
-
-- **Inherit attributes of another tensor to form a new tensor.**
-
-```python
-from mindspore import ops
-oneslike = ops.OnesLike()
-x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
-output = oneslike(x)
-print(output)
-```
-
-```text
- [[1 1]
- [1 1]]
-```
-
-- **Output a constant tensor of a specified size.**
-
-`shape` is the size tuple of a tensor, which determines the dimension of the output tensor.
-
-```python
-import mindspore.ops as ops
-
-shape = (2, 2)
-ones = ops.Ones()
-output = ones(shape, mstype.float32)
-print(output)
-
-zeros = ops.Zeros()
-output = zeros(shape, mstype.float32)
-print(output)
-```
-
-```text
- [[1. 1.]
- [1. 1.]]
- [[0. 0.]
- [0. 0.]]
-```
-
-During `Tensor` initialization, dtype can be specified to, for example, `mstype.int32`, `mstype.float32` or `mstype.bool_`.
-
-## Tensor Attributes
-
-Tensor attributes include shape and data type (dtype).
-
-- shape: a tuple
-- dtype: a data type of MindSpore
-
-```python
-t1 = Tensor(np.zeros([1,2,3]), mstype.float32)
-print("Datatype of tensor: {}".format(t1.dtype))
-print("Shape of tensor: {}".format(t1.shape))
-```
-
-```text
- Datatype of tensor: Float32
- Shape of tensor: (1, 2, 3)
-```
-
-## Tensor Operation
-
-There are many operations between tensors, including arithmetic, linear algebra, matrix processing (transposing, indexing, and slicing), and sampling. The following describes several operations. The usage of tensor computation is similar to that of NumPy.
-
-Indexing and slicing operations similar to NumPy:
-
-```python
-tensor = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
-print("First row: {}".format(tensor[0]))
-print("First column: {}".format(tensor[:, 0]))
-print("Last column: {}".format(tensor[..., -1]))
-```
-
-```text
- First row: [0. 1.]
- First column: [0. 2.]
- Last column: [1. 3.]
-```
-
-`Concat` connects a series of tensors in a given dimension.
-
-```python
-data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
-data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
-op = ops.Concat()
-output = op((data1, data2))
-print(output)
-```
-
-```text
- [[0. 1.]
- [2. 3.]
- [4. 5.]
- [6. 7.]]
-```
-
-`Stack` combines two tensors from another dimension.
-
-```python
-data1 = Tensor(np.array([[0, 1], [2, 3]]).astype(np.float32))
-data2 = Tensor(np.array([[4, 5], [6, 7]]).astype(np.float32))
-op = ops.Stack()
-output = op([data1, data2])
-print(output)
-```
-
-```text
- [[[0. 1.]
- [2. 3.]]
-
- [[4. 5.]
- [6. 7.]]]
-```
-
-Common computation:
-
-```python
-input_x = Tensor(np.array([1.0, 2.0, 3.0]), mstype.float32)
-input_y = Tensor(np.array([4.0, 5.0, 6.0]), mstype.float32)
-mul = ops.Mul()
-output = mul(input_x, input_y)
-print(output)
-```
-
-```text
- [ 4. 10. 18.]
-```
-
-## Conversion Between Tensor and NumPy
-
-Tensor and NumPy can be converted to each other.
-
-### Tensor to NumPy
-
-```python
-zeros = ops.Zeros()
-output = zeros((2,2), mstype.float32)
-print("output: {}".format(type(output)))
-n_output = output.asnumpy()
-print("n_output: {}".format(type(n_output)))
-```
-
-```text
- output: