РазумСпор! Мне нравится эта новая инфраструктура глубокого обучения с открытым исходным кодом!

Я до сих пор помню, как в этом году на конференции разработчиков Huawei HDC 2020 MindSpore, привлекавшая внимание среда глубокого обучения, наконец-то была открыта.

Я следил за MindSpore раньше и с нетерпением жду этого. MindSpore — это унифицированная платформа для обучения и выводов, которая поддерживает независимость/координацию конечной, граничной и облачной среды. Сравнивая с популярными платформами глубокого обучения, такими как TensorFlow и PyTorch, MindSpore стремится значительно снизить порог разработки приложений ИИ и сделать искусственный интеллект повсеместным.

Самая большая особенность MindSpore заключается в том, что порог разработки значительно снижен, что повышает эффективность разработки, что может значительно сократить время разработки модели.

Таким образом, преимущества использования MindSpore можно свести к следующим четырем пунктам:

● Простой опыт разработки

● Гибкий режим отладки

● Полностью задействуйте потенциал оборудования

● Быстрое развертывание всей сцены

Теперь, когда это открытый исходный код, давайте начнем и попробуем MindSpore с открытым исходным кодом! В этой статье я представлю руководство по установке и началу работы с MindSpore, а также проведу весь процесс обучения и тестирования ИИ с помощью простого случая распознавания изображений.

Существует множество способов установки фреймворка с открытым исходным кодом MindSpore, который можно установить в Windows, Ubuntu или на Huawei Ascend 910. Подробные способы установки смотрите по ссылкам ниже:

https://www.mindspore.cn/install

Вот два самых простых способа установки!

1. Установка докера

Установка Docker является самой простой, см.:

https://gitee.com/mindspore/mindspore#docker-image

В качестве примера возьмем версию 0.3.0-альфа:

• CPU:

  docker pull mindspore/mindspore-cpu:0.3.0-alpha

• GPU:

  docker pull mindspore/mindspore-gpu:0.3.0-alpha

После установки вы можете увидеть установленный образ и создать свой контейнер с помощью следующей команды:

docker run -it mindspore/mindspore-cpu:0.3.0-alpha /bin/bash

2. Win10+Anaconda+MindSpore

Его также очень легко установить с помощью Win10 + Anaconda + MindSpore, В этой статье будет использоваться этот метод для установки MindSpore.

На домашней странице установки MindSpore выберите соответствующую конфигурацию для установки:

• Версия: 0.3.0-альфа

• Аппаратная платформа: ЦП

• ОС: Windows-64

• Язык программирования: Python 3.7.5.

Сначала установите Anaconda на Win 10. Anaconda — это дистрибутив Python с открытым исходным кодом, включающий более 180 научных пакетов, таких как conda, Python и их зависимости.

Затем создайте виртуальную среду.

1) Откройте терминал Anaconda Prompt в компоненте Anaconda:

2) Используйте следующую команду, чтобы создать виртуальную среду mindspore (имя можно настроить) и войдите в виртуальную среду:

conda create -n mindspore python=3.7.5 
conda activate mindspore

3) Установите библиотеку зависимостей в соответствии с библиотекой зависимостей, указанной в https://gitee.com/mindspore/mindspore/blob/r0.3/requirements.txt, для установки используйте команду conda. Например:

conda install numpy

4) В соответствии с выбранной ранее соответствующей конфигурацией выберите нужную версию MindSpore на веб-сайте: https://www.mindspore.cn/versions:

mindspore-0.3.0-cp37-cp37m-win_amd64.whl

Вы можете скачать файл .whl локально и установить его с помощью pip (использование команды conda для онлайн-установки может быть медленным, поэтому вы можете загрузить файл .whl локально и установить его с помощью команды pip):

pip install mindspore-0.3.0-cp37-cp37m-win_amd64.whl

Наконец, проверьте, прошла ли установка успешно. Войдите в оболочку Python и выполните следующие команды. Если нет сообщения об ошибке загрузки, такого как «Нет модуля с именем «mindspore», установка прошла успешно.

На этом установка завершена!

1. Установите ноутбук Jupyter.

Сначала установите Jupyter Notebook в виртуальную среду mindspore. Метод следующий: Откройте компонент Anaconda Anaconda Navigator.

В Anaconda Navigator Application выберите только что созданную виртуальную среду mindspore и нажмите «Установить» под компонентом Jupyter Notebook для установки. После завершения установки картина выглядит следующим образом:

Нажмите «Запуск» в разделе «Блокнот», чтобы открыть блокнот Jupyter.

2. Загрузите набор данных

Набор данных рукописного ввода MNIST должен быть всем знаком, он содержит цифры от 0 до 9 и состоит из 60 000 обучающих изображений и 10 000 тестовых изображений.

Страница загрузки набора данных MNIST:

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

Используя MindSpore, мы можем автоматически загружать набор данных MNIST, напрямую определяя функцию download_dataset:

def download_dataset():
    """Download the dataset from http://yann.lecun.com/exdb/mnist/."""
    print("******Downloading the MNIST dataset******")
    train_path = "./MNIST_Data/train/"
    test_path = "./MNIST_Data/test/"
    train_path_check = os.path.exists(train_path)
    test_path_check = os.path.exists(test_path)
    if train_path_check == False and test_path_check ==False:
        os.makedirs(train_path)
        os.makedirs(test_path)
    train_url = {"http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz", "http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz"}
    test_url = {"http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz", "http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz"}
    for url in train_url:
        url_parse = urlparse(url)
        # split the file name from url
        file_name = os.path.join(train_path,url_parse.path.split('/')[-1])
        if not os.path.exists(file_name.replace('.gz','')):
            file = urllib.request.urlretrieve(url, file_name)
            unzipfile(file_name)
            os.remove(file_name)
    for url in test_url:
        url_parse = urlparse(url)
        # split the file name from url
        file_name = os.path.join(test_path,url_parse.path.split('/')[-1])
        if not os.path.exists(file_name.replace('.gz','')):
            file = urllib.request.urlretrieve(url, file_name)
            unzipfile(file_name)
            os.remove(file_name)

Эта функция реализует, что набор данных автоматически загружается в локальный каталог ./MNIST_Data, обучающий набор помещается в подкаталог /train, а тестовый набор помещается в подкаталог /test.

3. Предварительная обработка данных

После того, как набор данных MNIST готов, следующим шагом является выполнение некоторой предварительной обработки набора данных, включая настройку размера изображения до 32x32 (поскольку мы используем сеть LeNet-5, которая будет представлена ​​позже), нормализация пикселей и установка размера пакета. до 32 (регулируемый) и т.д.

MindSpore предоставляет mindspore.dataset.MnistDataset для непосредственного определения набора данных Minist, что очень удобно. Используйте функцию карты mindspore.dataset.MnistDataset.map, чтобы применить обработку данных к набору данных.

Мы определяем функцию create_dataset() для создания набора данных:

def create_dataset(data_path, batch_size=32, repeat_size=1,
                   num_parallel_workers=1):
    """ create dataset for train or test
    Args:
        data_path: Data path
        batch_size: The number of data records in each group
        repeat_size: The number of replicated data records
        num_parallel_workers: The number of parallel workers
    """
    # define dataset
    mnist_ds = ds.MnistDataset(data_path)


    # define operation parameters
    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


    # define map operations
    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)  # Resize images to (32, 32)
    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml) # normalize images
    rescale_op = CV.Rescale(rescale, shift) # rescale images
    hwc2chw_op = CV.HWC2CHW() # change shape from (height, width, channel) to (channel, height, width) to fit network.
    type_cast_op = C.TypeCast(mstype.int32) # change data type of label to int32 to fit network


    # apply map operations on images
    mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
    mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
    mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
    mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
    mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)


    # apply DatasetOps
    buffer_size = 10000
    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)  # 10000 as in LeNet train script
    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
    mnist_ds = mnist_ds.repeat(repeat_size)


    return mnist_ds

С помощью вышеуказанной функции завершается предварительная обработка только что загруженного набора данных MNIST.

4. Определите сеть

LeNet-5 — очень эффективная сверточная нейронная сеть для распознавания рукописных символов. LeNet-5 имеет в общей сложности 7 слоев, которые не содержат входных данных, и каждый слой содержит обучаемые параметры; каждый слой имеет несколько карт функций, и каждая карта функций извлекает функцию входных данных через сверточный фильтр.

1) Инициализация модели

Используйте метод mindspore.common.initializer.TruncatedNormal для инициализации параметров и определите conv и fc_with_initialize для инициализации сверточного слоя и полносвязного слоя соответственно.

import mindspore.nn as nnfrom mindspore.common.initializer import TruncatedNormal
def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):    """Conv layer weight initial."""    weight = weight_variable()    return nn.Conv2d(in_channels, out_channels,                     kernel_size=kernel_size, stride=stride, padding=padding,                     weight_init=weight, has_bias=False, pad_mode="valid")
def fc_with_initialize(input_channels, out_channels):    """Fc layer weight initial."""    weight = weight_variable()    bias = weight_variable()    return nn.Dense(input_channels, out_channels, weight, bias)
def weight_variable():    """Weight initial."""    return TruncatedNormal(0.02)

Используя метод mindspore.common.initializer.TruncatedNormal, операцию инициализации весовых коэффициентов сети можно реализовать очень удобно без пользовательских функций инициализации.

2) Определить сеть LeNet-5

Для MindSpore также очень просто определить сеть LeNet-5.В соответствии со структурой сети можно определить соответствующий сверточный уровень и полносвязный уровень. Определите каждый слой нейронной сети в функции инициализации __init__, а затем завершите прямое построение нейронной сети, определив метод построения.

class LeNet5(nn.Cell):    """Lenet network structure."""    # define the operator required    def __init__(self):        super(LeNet5, self).__init__()        self.conv1 = conv(1, 6, 5)        self.conv2 = conv(6, 16, 5)        self.fc1 = fc_with_initialize(16 * 5 * 5, 120)        self.fc2 = fc_with_initialize(120, 84)        self.fc3 = fc_with_initialize(84, 10)        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.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

LeNet-5 является очень типичной и простой сверточной нейронной сетью Структуру каждого слоя LeNet-5 можно подробно увидеть из метода построения.

3) Определите функцию потерь

Функции потерь, поддерживаемые MindSpore, включают SoftmaxCrossEntropyWithLogits, L1Loss, MSELoss и т. д. Здесь используется функция потери кросс-энтропии SoftmaxCrossEntropyWithLogits.

from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
# define the loss functionnet_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')

4) Определить алгоритм сетевого градиентного спуска.

Алгоритмы градиентного спуска, поддерживаемые MindSpore, включают Adam, AdamWeightDecay, Momentum и т. д. Здесь используется популярный алгоритм Momentum. Среди них скорость обучения установлена ​​​​на 0,01, а параметр импульса установлен на 0,9.

# learning rate setting
lr = 0.01
momentum = 0.9
# define the optimizer
net_opt = nn.Momentum(network.trainable_params(), lr, momentum)

5. Обучите сеть

1) Сохранение модели

Метод mindspore.train.callback.ModelCheckpoint может сохранить модель и параметры сети.

config_ck = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)
# save the network model and parameters for subsequence fine-tuning
ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet", config=config_ck)

2) Обучить сеть

Обучение сети выполняется с использованием метода model.train. Здесь для epoch_size установлено значение 1, а набор данных обучается для 1 итерации. Изменение значения потерь будет напечатано во время тренировки.

from mindspore.nn.metrics import Accuracyfrom mindspore.train.callback import LossMonitorfrom mindspore.train import Model
def train_net(args, model, epoch_size, mnist_path, repeat_size, ckpoint_cb, sink_mode):    """define the training method"""    print("============== Starting Training ==============")    #load training dataset    ds_train = create_dataset(os.path.join(mnist_path, "train"), 32, repeat_size)    model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor()], dataset_sink_mode=sink_mode)

epoch_size = 1
mnist_path = "./MNIST_Data
# group layers into an object with training and evaluation features
model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
train_net(args, model, epoch_size, mnist_path, repeat_size, ckpoint_cb)

где mnist_path — путь к набору данных MNIST.

3) Информация об оборудовании

В основной функции не забудьте настроить информацию об оборудовании для запуска MindSpore. Поскольку мы находимся в среде ЦП, для параметра «--device_target» установлено значение «ЦП».

parser = argparse.ArgumentParser(description='MindSpore LeNet Example')
parser.add_argument('--device_target', type=str, default="CPU", choices=['Ascend', 'GPU', 'CPU'],
                        help='device where the code will be implemented (default: CPU)')
args = parser.parse_args(args=[])
context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target)

'--device_target' здесь по умолчанию является "CPU", и "Ascend" или "GPU" также могут быть выбраны в зависимости от аппаратного обеспечения. Используется режим графика "context.GRAPH_MODE".

4) Модельное обучение

Выполните программу, и начнется обучение модели. Значение потери печатается во время обучения:

...
epoch: 1 step: 262, loss is 1.9212162
epoch: 1 step: 263, loss is 1.8498616
epoch: 1 step: 264, loss is 1.7990671
epoch: 1 step: 265, loss is 1.9492403
epoch: 1 step: 266, loss is 2.0305142
epoch: 1 step: 267, loss is 2.0657792
epoch: 1 step: 268, loss is 1.9582214
epoch: 1 step: 269, loss is 0.9459006
epoch: 1 step: 270, loss is 0.8167224
epoch: 1 step: 271, loss is 0.7432692
...

Видно, что потери в целом будут постепенно уменьшаться, точность будет постепенно увеличиваться, и итоговые потери составят 0,067.

После завершения обучения получите сохраненный файл модели:

checkpoint_lenet-1_1875.ckpt

6. Тестирование модели

После получения файла модели используйте интерфейс model.eval() для чтения набора тестовых данных и запустите набор тестовых данных через модель, чтобы получить результаты. Определите тестовую функцию test_net():

def test_net(args, network, model, mnist_path):
    """Define the evaluation method."""
    print("============== Starting Testing ==============")
    # load the saved model for evaluation
    param_dict = load_checkpoint("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(args, network, model, mnist_path)

============== Starting Testing ==============
============== Accuracy:{'Accuracy': 0.9663461538461539} ==============

В итоге можно увидеть, что точность модели сети LeNet-5, только что обученной на тестовом наборе, составляет 96,63%, что очень хорошо.

На данный момент мы закончили обучение модели LeNet-5 с помощью фреймворка MindSpore. Реализована классификация наборов рукописных данных MNIST на основе собственного Jupyter. В целом MindSpore предоставляет множество модульных методов построения и обучения моделей, что очень удобно для нас, чтобы быстро построить модель нейросети. Вы можете создать свою собственную нейронную сеть и попробовать ее в соответствии с вашими реальными потребностями.

Полный код этого раздела:

https://gitee.com/mindspore/docs/blob/master/tutorials/tutorial_code/lenet.py

Помимо локального использования платформы MindSpore, мы также можем использовать MindSpore на серверах HUAWEI CLOUD. Еще одно преимущество использования MindSpore в HUAWEI CLOUD заключается в том, что мы можем подать заявку на использование пула ресурсов процессора Ascend AI в качестве оборудования.

ModelArts — это универсальная платформа для разработки ИИ для разработчиков, предоставляемая HUAWEI CLOUD и интегрирующая MindSpore. Ниже мы будем использовать сеть ResNet-50 для распознавания изображений CIFAR-10 в ModelArts.

1. Подготовьте ModelArts

1) Перейдите на официальный сайт HUAWEI CLOUD и зарегистрируйте аккаунт.

Конкретные операции:

https://support.huaweicloud.com/prepare-modelarts/modelarts_08_0001.html

2) Получите ключ доступа и завершите настройку ModelArts.

Конкретные операции:

https://support.huaweicloud.com/prepare-modelarts/modelarts_08_0002.html

3) Создать корзину OBS

Конкретные операции:

https://support.huaweicloud.com/prepare-modelarts/modelarts_08_0003.html

2. Подать заявку на процессорные ресурсы сервера Ascend AI

Чтобы использовать процессор искусственного интеллекта HUAWEI CLOUD Ascend в ModelArts, нам необходимо подать заявку на квалификацию опыта.Метод подачи заявки также очень прост.Вы можете подать заявку на следующем веб-сайте:

https://console.huaweicloud.com/modelarts/?region=cn-north-4#/dashboard/applyModelArtsAscend910Beta

Содержимое заявки можно заполнить внимательно, в общем случае она будет одобрена в течение двух рабочих дней.

3. Подготовка данных

1) Загрузите набор данных CIFAR-10.

CIFAR-10 Этот набор данных имеет в общей сложности 60000 цветных изображений, эти изображения имеют размер 32*32, разделены на 10 классов, каждый класс имеет 6000 изображений.

Адрес загрузки набора данных CIFAR-10:

http://www.cs.toronto.edu/~kriz/cifar.html

Примечание для загрузки двоичной версии CIFAR-10.

2) Создайте новую корзину OBS (например, mine-ms-dataset)

ModelArts использует для хранения данных службу Object Storage Service (OBS), поэтому перед началом обучающей задачи вам необходимо загрузить данные в OBS.

Сначала войдите в консоль управления OBS:

https://storage.huaweicloud.com/obs/?region=cn-north-4#/obs/manager/buckets

Создайте ведро OBS mine-ms-dataset (имя можно изменить, как показано ниже).

Затем во вновь созданном сегменте OBS создайте папку для хранения данных: щелкните сегмент, с которым нужно работать, в списке сегментов, нажмите «Объект» на левой панели навигации и создайте новую папку mine-cifar-10.

Наконец, загрузите загруженный набор данных CIFAR-10 в каталог данных mine-cifar-10 в соответствии со следующей структурой каталогов:

└─对象存储/mine-ms-dataset/mine-cifar-10
    ├─train
    │      data_batch_1.bin
    │      data_batch_2.bin
    │      data_batch_3.bin
    │      data_batch_4.bin
    │      data_batch_5.bin
    │
    └─eval
        test_batch.bin

4. Процедура подготовки

Создайте новую корзину OBS (например, mine-resnet50-train) и создайте в ней каталог кода (например, mine-resnet50_cifar10_train). В то же время создайте выходной каталог и каталог журналов в корзине для хранения моделей и журналов.

Поместите URL:

https://gitee.com/mindspore/docs/tree/master/tutorials/tutorial_code/sample_for_cloud/

Два файла .py в dataset.py и resnet50_train.py загружаются и загружаются в каталог кода mine-resnet50_cifar10_train.

Структура каталога кода mine-resnet50_cifar10_train выглядит следующим образом:

└─对象存储/mine-resnet50-train
    ├─mine-resnet50_cifar10_train
    │      dataset.py
    │      resnet50_train.py
    │
    ├─output
    └─log

5. Создайте тренировочное задание

После подготовки данных и выполнения скрипта следующим шагом будет создание обучающей задачи на облачном сервере.

1) Зайдите в консоль ModelArts

Откройте домашнюю страницу HUAWEI CLOUD ModelArts.

https://www.huaweicloud.com/product/modelarts.html

Нажмите «Войти в консоль».

2) Используйте MindSpore в качестве общей платформы для создания учебных заданий.

На левой панели навигации выберите «Управление обучением» > «Задания обучения», чтобы открыть список заданий обучения по умолчанию.

В списке заданий по обучению нажмите «Создать» в верхнем левом углу, чтобы перейти на страницу «Создать задание по обучению».

На странице «Создать задание по обучению» настройте имя задания по обучению, например mine-resnet50-trainjob. Заполните соответствующие параметры задания обучения Конкретные параметры конфигурации:

Стоит отметить, что Ascend-Powered-Engine выбран в качестве общего фреймворка для источников алгоритмов, потому что используемое нами оборудование — процессор Huawei Cloud Ascend AI. Для версии MindSpore выберите MindSpore-0.1-python3.7-aarch64.

После настройки нажмите «Далее» -> «Отправить» -> «Вернуться к списку заданий обучения», вы увидите, что задание обучения mine-resnet50-trainjob запущено:

Весь рабочий процесс занимает около 8 с половиной минут и показывает, что операция выполнена успешно, что указывает на завершение обучения и тестирования модели.

Наконец, щелкните задание обучения mine-resnet50-trainjob, и вы увидите в журнале, что точность модели на тестовом наборе составляет 92,49%, что указывает на то, что модель работает хорошо.

Мы также можем загрузить файлы журналов из OBS и просмотреть их.

Выше приведено простое руководство по использованию MindSpore в облаке.

4. Резюме:

В этой статье фреймворк MindSpore с открытым исходным кодом в основном представлен в двух случаях практического применения. Один из них — распознавание рукописных данных MNIST на основе локального Jupyter Notebook, другой — классификация изображений CIFAR-10 на основе облачного сервера Huawei. Оба случая вращаются вокруг и используют MindSpore.

По моему личному опыту, MindSpore очень прост в использовании, а функции инкапсулированы более лаконично, что более удобно в использовании. С помощью практического руководства вы сможете сделать это самостоятельно и ощутить прелесть фреймворка с открытым исходным кодом MindSpore.

Вы также можете использовать MindSpore для создания моделей нейронных сетей для решения практических задач в соответствии с вашими конкретными сценариями приложений и практическими случаями. Будь то компьютерное зрение или обработка естественного языка, я считаю, что MindSpore может обеспечить вам плавный опыт.

Использованная литература:

https://www.mindspore.cn/

https://www.mindspore.cn/tutorial/zh-CN/master/index.html

https://support.huaweicloud.com/modelarts/index.html