Joshua Alexander Heriyanto, Sarah Hasna Azzahra

1 MindSpore

1.1 Tentang MindSpore

MindSpore adalah AI computing framework yang dikembangkan Huawei untuk kolaborasi on-demand pada semua skenario cloud. MindSpore menyediakan unified API untuk semua skenario AI model development, running, dan deployment.

MindSpore menggunakan arsitektur terdistribusi kolaborasi on-demand device-edge-cloud, sebuah paradigma baru dari micro-sparing native programming, dan mode AI native execution baru untuk mencapai efisiensi sumber daya, keamanan, dan kepercayaan yang lebih baik, menurunkan AI development thresholds, memanfaatkan kemampuan komputasi dari chip Huawei Ascend AI, dan membantu Pratt & Whitney AI.

Fitur

Saat ini, ada dua execution modes pada mainstream deep learning framework: static graph dan dynamic graph. Static graph memiliki performa training tinggi tetapi susah untuk didebug. Dynamic graph mudah didebug tetapi lebih susah dikonfigurasi dan dijalankan secara efisien.

MindSpore menyediakan unified encoding mode untuk dynamic dan static graphs, dapat meningkatkan kompatibilitas antara static dan dynamic graph. Pengguna tidak perlu mengembangkan beberapa code. Pengguna hanya mengubah 1 line code saja untuk berpindah antara dynamic dan static graph mode.

Detail dapat dilihat pada link berikut:

MindSpore official website


2. MindSpore Basic Practices

Membuat ModelArts Notebook

Mari kita buat notebook development environment di ModelArts. ModelArts notebook menyediakan development environment Python di halaman web. Anda dapat dengan mudah menyusun dan menjalankan kode serta melihat hasilnya.

Langkah 1: Pilih daerah “Beijing 4”, buat OBS bucket “mindspore-test1” dari halaman utama OBS service, dan buat direktori “mindspore”.

Link referensi:

https://support.huaweicloud.com/intl/en-us/usermanual-obs/en-us_topic_0045853662.html

Langkah 2: Pilih daerah “Beijing 4” dan klik Development Environment, lalu klik Create pada halaman utama ModelArts.

Langkah 3: Atur parameter yang diperlukan untuk notebook.

Suggest Input
Namemindspore-test
Work EnvironmentAscend-Powered-Engine 1.0 (Python3)
Resource PoolPublic resource pools
TypeAscend
Instance FlavorAscend: 1*Ascend-910(32GB) | ARM: 24 vCPUs 96 GB
StorageOBS
Storage Path/mindspore-test1/mindspore/

Langkah 4: Setelah mengkonfigurasi parameter notebook, klik Next untuk melihat informasi notebook. Klik Create Now.

Langkah 5: Setelah pembuatan selesai, kembali ke halaman utama Modelarts.

Membuat Development Environment di ModelArts

Selanjutnya, kita akan membuat development environment untuk langkah eksperimental berikutnya.

Langkah 1: Klik tombol “Open” yang ditampilkan pada gambar berikut untuk mengakses Notebook yang baru dibuat.

Langkah 2: Buat Notebook untuk Python3. Klik \”New” di sudut kanan atas dan pilih development environment “Mindspore-python3.7-aarch64”.

Langkah 3: Klik pada nama file “Untitled\” di sebelah kiri atas dan masukkan nama yang sesuai.

Tulis dan eksekusi kode dalam Notebook

Dalam Notebook, masukkan pernyataan print sederhana dan klik tombol Run untuk melihat hasil eksekusi.

Sekarang development environment sudah siap, anda dapat mulai menulis kode.

Mindspore Tensor dan Tipe-Tipe Data

Tensor adalah struktur data dasar dari operasi jaringan MindSpore. Untuk tipe data dalam tensor, lihat dtype.
Tensor dengan dimensi yang berbeda masing-masing mewakili data yang berbeda. tensor 0-dimensi mewakili sebuah skalar, tensor 1-dimensi merupakan sebuah vektor, tensor 2-dimensi mewakili sebuah matriks, tensor 3-dimensi seperti tiga saluran RGB dari gambar berwarna dan seterusnya.

MindSpore tensor mendukung tipe data yang beragam, termasuk int8, int16, int32, int64, uint16, uint32, uint32, uint64, float16, float32, float64, dan bool_. Tipe datanya sesuai dengan NumPy.
Dalam proses kalkulasi MindSpore, int dalam Python diubah ke tipe int64 dan float dibuah ke tipe float64.

Langkah 1 Tentukan tipe data MindSpore.

Import MindSpore dan atur sel Jupyter notebook untuk mengeluarkan beberapa baris.

# Import MindSporeimport mindsporefrom mindspore import dtypefrom mindspore import Tensor
# The cell outputs multiple lines at the same timefrom IPython.core.interactiveshell import InteractiveShellInteractiveShell.ast_node_interactivity = "all"
# Specifies the data typea = 1type(a)b = Tensor(a, dtype.float64)b.dtype

Langkah 2 Pembuatan Tensor

Tensor, float, int, bool, tuple, list, dan NumPy.array dapat ditransfer selama pembuatan tensor ini. Tuple dan list hanya dapat menyimpan data float, int, dan bool.

Dalam pembuatan tensor, dtype dapat ditentukan. Jika dtype tidak ditentukan, initial value int, float, dan bool masing-masing akan menghasilkan tensor 0-dimensi dengan tipe data mindspore.int32, mindspore.float32, dan mindspore.bool. Tipe data Tensor 1D yang dihasilkan oleh initial value tuple dan list sesuai dengan tipe data yang disimpan dalam tuple dan list. Jika banyak tipe data yang disertakan, tipe data yang sesuai dengan tipe dengan prioritas tertinggi akan dipilih berdasarkan urutan berikut: bool < int < float. Jika initial value adalah Tensor, tipe data Tensor yang dihasilkan sama dengan initial value-nya. Bila nilai awal NumPy.array maka tipe data Tensor yang dihasilkan sama dengannya.

Membuat Tensor dengan Arrays

import numpy as npfrom mindspore import Tensor # Creating Tensors from Arraysx = Tensor(np.array([[1, 2], [3, 4]]), dtype.int32)x

Membuat Tensor dengan Nilai Numerik

# Creating Tensors with Numeric Valuesy = Tensor(1.0, dtype.int32)z = Tensor(2, dtype.int32)yz

Membuat Tensor dengan Bool

# Creating a Tensor with a Boolm = Tensor(True, dtype.bool_)m

Membuat Tensor dengan Tuple

# Creating tensors with tuplesn = Tensor((1, 2, 3), dtype.int16)n

Membuat Tensor dengan List

# Creating tensors with listp = Tensor([4.0, 5.0, 6.0], dtype.float64)p

Membuat Tensor dengan Konstanta

# Creating Tensors with Constantsq = Tensor(1, dtype.float64)q

Langkah 3 Tensor Properties

Properti tensor mencakup shape dan tipe data.

  • Shape : Tensor shape adalah sebuah tuple.
  • Data type: Tensor dtype merupakan tipe data dari MindSpore.
x = Tensor(np.array([[1, 2], [3, 4]]), dtype.int32)x_shape = x.shape # Shapex_dtype = x.dtype # Data Type x_shapex_dtype
x = Tensor(np.array([[1, 2], [3, 4]]), dtype.int32) x.shape # Shapex.dtype # Data Typex.ndim # Dimensionx.size # Size

Langkah 4 Tensor method

asumpy(): mengubah Tensor menjadi sebuah NumPy array.

y = Tensor(np.array([[True, True], [False, False]]), dtype.bool_) # Converting Tensor Data Types to NumPyy_array = y.asnumpy() yy_array

Handwritten Digit Recognition dengan Algoritma LeNet berbasis Mindspore

# Checking the Version of the Current Environmentimport mindsporeprint(mindspore.__version__)

1. Download dataset

MNIST adalah sebuah handwritten digit dataset. Training set berisi 60.000 handwritten digit, dan test set berisi 10.000 handwritten digit. Ada 10 jenis tulisan tangan (0-9).

Unduh dari OBS public bucket di HUAWEI CLOUD.

import os
import moxing as mox
 
if not os.path.exists("./MNIST_Data.zip"):
mox.file.copy("obs://modelarts-labs-bj4-v2/course/hwc_edu/python_module_framework/datasets/mindspore_data/MNIST_Data.zip", "./MNIST_Data.zip")
 
!unzip -o MNIST_Data.zip -d ./

2. Memproses dataset MNIST

Karena kita akan menggunakan convolutional neural network seperti LeNet untuk melakukan training pada dataset nanti, kita perlu memeriksa data dalam dataset terlebih dahulu. Dengan cara ini, sebuah fungsi konversi data dapat dibangun untuk menyesuaikan dataset menjadi bentuk data yang dibutuhkan untuk training.

Langkah 1 Periksa dataset awal

from mindspore import context
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
import mindspore.dataset as ds
 
# device_target: CPU, GPU, and Ascend. When GPU is selected, the CPU specifications need to be switched to the GPU.
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
# device_id = int(os.getenv("DEVICE_ID"))
# context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", device_id=device_id)
train_data_path = "./MNIST_Data/train"
test_data_path = "./MNIST_Data/test"
mnist_ds = ds.MnistDataset(train_data_path)
print('The type of mnist_ds:', type(mnist_ds))
print ("Number of pictures contained in the mnist_ds:", mnist_ds.get_dataset_size())
 
dic_ds = mnist_ds.create_dict_iterator()
item = next(dic_ds)
img = item["image"].asnumpy()
label = item["label"].asnumpy()
 
print("The item of mnist_ds:", item.keys())
print("Tensor of image in item:", img.shape)
print("The label of item:", label)
 
plt.imshow(np.squeeze(img))
plt.title("number:%s"% item["label"].asnumpy())
plt.show()

Langkah 2 Data processing

Dataset sangat penting untuk training. Satu set data yang baik dapat secara efektif meningkatkan presisi dan efisiensi. Sebelum memuat data set, kami biasanya melakukan beberapa pemrosesan pada set data.

Tentukan data set dan operasi data

Setelah definisi selesai, gunakan create datasets untuk meningkatkan data asli, ekstrak data dari suatu batch, dan tampilkan perubahan data setelah peningkatan.

import mindspore.dataset.vision.c_transforms as CV
import mindspore.dataset.transforms.c_transforms as C
from mindspore.dataset.vision import Inter
from mindspore import dtype as mstype
 
 
def create_dataset(data_path, batch_size=32, repeat_size=1,
num_parallel_workers=1):
" " "
    create dataset for train or test
    
    Args:
        data_path (str): Data path
        batch_size (int): The number of data records in each group
        repeat_size (int): The number of replicated data records
        num_parallel_workers (int): The number of parallel workers
    """
    # define dataset
    mnist_ds = ds.MnistDataset(data_path)
 
    # define some parameters needed for data enhancement and rough justification
    resize_height, resize_width = 32, 32
    rescale = 1.0 / 255.0
    shift = 0.0
    rescale_nml = 1 / 0.3081
    shift_nml = -1 * 0.1307 / 0.3081
 
    # according to the parameters, generate the corresponding data enhancement method
    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)
    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)
    rescale_op = CV.Rescale(rescale, shift)
hwc2chw_op = CV.HWC2CHW()
type_cast_op = C.TypeCast(mstype.int32)
 
# using map to apply operations to a dataset
mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns="label", num_parallel_workers=num_parallel_workers)
mnist_ds = mnist_ds.map(operations=resize_op, input_columns="image", num_parallel_workers=num_parallel_workers)
mnist_ds = mnist_ds.map(operations=rescale_op, input_columns="image", num_parallel_workers=num_parallel_workers)
mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns="image", num_parallel_workers=num_parallel_workers)
mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns="image", num_parallel_workers=num_parallel_workers)
 
# process the generated dataset
buffer_size = 10000
mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)
mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
mnist_ds = mnist_ds.repeat(repeat_size)
 
return mnist_ds
 
ms_dataset = create_dataset(train_data_path)
print('Number of groups in the dataset:', ms_dataset.get_dataset_size())

Setelah fungsi data enhancement dipanggil, ukuran dataset berubah dari 60000 menjadi 1875, sesuai dengan operasi mnist_ds.batch (60000/32 batch = 1875).

Langkah 3 Lihat data yang diubah

Ambil sebuah grup data dari 1875 dan lihat volume dan label datanya.

data = next(ms_dataset.create_dict_iterator(output_numpy=True))
images = data["image"]
labels = data["label"]
print('Tensor of image:', images.shape)
print('label:', label)

Data dan nilai tensor sebelumnya divisualisasikan.

count = 1
for i in images:
plt.subplot(4, 8, count)
plt.imshow(np.squeeze(i))
plt.title('num:%s'%labels[count-1])
plt.xticks([])
count += 1
plt.axis("off")
plt.show()

3. Define the model

Langkah 4 Menentukan model

Arsitektur Convolutional Neural Network (CNN) biasanya digunakan dalam pembelajaran dan prediksi dalam handwritten font recognition. Arsitektur paling klasik yaitu LeNet5 dibuat oleh Yann LeCun pada tahun 1998.
Gambar berikut ini menunjukkan struktur LeNet5.

Informasi lebih lanjut tentang LeNet tidak dijelaskan pada artikel ini. Untuk mempelajari lebih lanjut tentang LeNet Anda dapat mencari informasi melalui link berikut:

http://yann.lecun.com/exdb/lenet/

import mindspore.nn as nn
from mindspore.common.initializer import Normal
 
class LeNet5(nn.Cell):
"""Lenet network structure."""
# define the operator required
def __init__(self, num_class=10, num_channel=1):
super(LeNet5, 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, weight_init=Normal(0.02))
self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
self.relu = nn.ReLU()
self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
self.flatten = nn.Flatten()
 
# use the preceding operators to construct networks
def construct(self, x):
x = self.max_pool2d(self.relu(self.conv1(x)))
x = self.max_pool2d(self.relu(self.conv2(x)))
x = self.flatten(x)
x = self.relu(self.fc1(x))
x = self.relu(self.fc2(x))
x = self.fc3(x)
return x
 
network = LeNet5()
print("layer conv1:", network.conv1)
print("*"*40)
print("layer fc1:", network.fc1)

4. Siapkan training network dan lakukan training.

Fungsi untuk melakukan training model adalah Model.train.

Dalam contoh ini akan menggunakan epoch = 1. Training dengan CPU memakan waktu sekitar 15 menit. Untuk melakukan training dengan cepat, anda dapat memilih spesifikasi yang lebih tinggi.

import os
from mindspore import Tensor, Model
from mindspore import load_checkpoint, load_param_into_net
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
from mindspore.nn.metrics import Accuracy
from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
 
lr = 0.01
momentum = 0.9
epoch_size = 1
mnist_path = "./MNIST_Data"
model_path = "./models/ckpt/"
 
# clean up old run files before in Linux
os.system(' rm -f {}*.ckpt {}*.meta {}*.pb' .format(model_path, model_path, model_path))
 
# create the network
network = LeNet5()
 
# define the optimizer
net_opt = nn.Momentum(network.trainable_params(), lr, momentum)
 
# define the loss function
net_loss = SoftmaxCrossEntropyWithLogits (sparse=True, reduction='mean')
 
# define the model
model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
 
# save the network model and parameters for subsequence fine-tuning
config_ck = CheckpointConfig(save_checkpoint_steps=375, keep_checkpoint_max=16)
# group layers into an object with training and evaluation features
ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet", directory=model_path, config=config_ck)
 
 
eval_dataset = create_dataset("./MNIST_Data/test")
 
step_loss = {"step": [], "loss_value": []}
steps_eval = {"step": [], "acc": []}
 
repeat_size = 1
ds_train = create_dataset(os.path.join(mnist_path, "train"), 32, repeat_size)
 
model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(125)], dataset_sink_mode=False)

5. Testdata untuk memverifikasi akurasi model

# testing relate modules
def test_net(network, model, mnist_path):
"""Define the evaluation method."""
print("============== Starting Testing ==============")
# load the saved model for evaluation
param_dict = load_checkpoint("./models/ckpt/checkpoint_lenet-1_1875.ckpt")
# load parameter to the network
load_param_into_net(network, param_dict)
# load testing dataset
ds_eval = create_dataset(os.path.join(mnist_path, "test"))
acc = model.eval(ds_eval, dataset_sink_mode=False)
print("============== Accuracy:{} ==============".format(acc))
 
test_net(network, model, mnist_path)

6. Inference (setelah training)

Kita mencoba menggunakan model yang dihasilkan untuk memprediksi satu atau satu grup data gambar, dan kita dapat melihat bahwa hasil recognition pada dasarnya benar.

ds_test = create_dataset(test_data_path).create_dict_iterator()
data = next(ds_test)
images = data["image"].asnumpy()
labels = data["label"].asnumpy()
 
output = model.predict(Tsor(data['image']))
pred = np.argmax(output.asnumpy(), axis=1)
err_num = []
index = 1
for i in range(len(labels)):
plt.subplot(4, 8, i+1)
color =' blue' if pred[i] == labels[i] else'red'
plt.title("pre:{}".format(pred[i]), color=color)
plt.imshow(np.squeeze(images[i]))
plt.axis("off")
if color =='red':
index = 0
print("Row {}, column {} is incorrectly identified as {}, the correct value should be {}".format(int(i/8)+1, i%8+1, pred[i], labels[i]),'\n')
if index:
print("All the figures in this group are predicted correctly!")
print(pred, "<--Predicted figures")
print(labels, "<--The right number")
plt.show()

3. Referensi

https://gitee.com/mindspore/mindspore

https://github.com/mindspore-ai/mindspore