Импортируйте сеть ONNX как функцию. Сеть содержит операторы ONNX, которые не поддерживаются слоями Deep Learning Toolbox. Можно использовать импортированную функцию модели для задач глубокого обучения, таких как предсказание и передача обучения.

Загрузите и установите Конвертер Deep Learning Toolbox для пакета поддержки Формата Модели ONNX. Можно ввести importONNXFunction в командной строке, чтобы проверять, установлен ли пакет поддержки. Если это не установлено, то функция обеспечивает ссылку на необходимый пакет поддержки в Add-On Explorer. Чтобы установить пакет поддержки, щелкните по ссылке, и затем нажмите Install.

Задайте файл, чтобы импортировать как shufflenet с оператором устанавливает 9 из Зоопарка Модели ONNX. shufflenet сверточная нейронная сеть, которая обучена на изображениях от базы данных ImageNet.

modelfile = 'shufflenet-9.onnx';

Методические рекомендации должны попытаться импортировать сеть при помощи importONNXNetwork. Если importONNXNetwork не может импортировать сеть, потому что некоторые слоя сети не поддерживаются, можно импортировать сеть как слои при помощи importONNXLayers, или как функция при помощи importONNXFunction.

Импортируйте shufflenet сеть как слои. Программное обеспечение генерирует слои заполнителя вместо неподдерживаемых слоев.

lgraph = importONNXLayers(modelfile,'OutputLayerType','classification');

Warning: Unable to import some ONNX operators, because they are not supported. They have been replaced by placeholder layers. To find these layers, call the function findPlaceholderLayers on the returned object.

4 operators(s)	:	Average pooling layer in ONNX file does not include padding in the average. This may cause small numeric differences between the ONNX and MATLAB network outputs.
32 operators(s)	:	The Reshape operator is supported only when it performs a flattening operation.
16 operators(s)	:	The operator 'Transpose' is not supported.

To import the ONNX network as a function, which can support most ONNX operators, call importONNXFunction.

Найдите слои заполнителя и отобразите количество слоев заполнителя.

indPlaceholderLayers = findPlaceholderLayers(lgraph);
numel(indPlaceholderLayers)

ans = 48

Необходимо заменить 48 слоев заполнителя, чтобы использовать lgraph для задач глубокого обучения, таких как предсказание.

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

params = importONNXFunction(modelfile,'shufflenetFcn')

OpsetVersion = 9
A function 'shufflenetFcn' containing the imported ONNX network has been saved to the current directory.
To learn how to use this function, type: help shufflenetFcn

params = 
  ONNXParameters with properties:

             Learnables: [1×1 struct]
          Nonlearnables: [1×1 struct]
                  State: [1×1 struct]
          NumDimensions: [1×1 struct]
    NetworkFunctionName: 'shufflenetFcn'

importONNXFunction возвращает ONNXParameters объект params, который содержит сетевые параметры и функциональный shufflnetFcn модели, который содержит сетевую архитектуру. importONNXFunction сохраняет shufflenetFcn в текущей папке. Можно открыть функцию модели, чтобы просмотреть или отредактировать сетевую архитектуру при помощи open shufflenetFcn.

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

Задайте файл, чтобы импортировать как shufflenet с оператором устанавливает 9 из Зоопарка Модели ONNX. shufflenet сверточная нейронная сеть, которая обучена больше чем на миллионе изображений от базы данных ImageNet. В результате сеть изучила богатые представления функции для широкого спектра изображений. Сеть может классифицировать изображения в 1 000 категорий объектов, таких как клавиатура, мышь, карандаш и многие животные.

modelfile = 'shufflenet-9.onnx';

Импортируйте предварительно обученную сеть ONNX как функцию при помощи importONNXFunction, который возвращает ONNXParamaters объект, который содержит сетевые параметры. Функция также создает новую функцию модели в текущей папке, которая содержит сетевую архитектуру. Задайте имя функции модели как shufflenetFcn.

params = importONNXFunction(modelfile,'shufflenetFcn');

OpsetVersion = 9
A function 'shufflenetFcn' containing the imported ONNX network has been saved to the current directory.
To learn how to use this function, type: help shufflenetFcn

Считайте изображение, вы хотите классифицировать и отобразить размер изображения. Изображение является 792 1056 пикселями и имеет три цветовых канала (RGB).

I = imread('peacock.jpg');
size(I)

ans = 1×3

         792        1056           3

Измените размер изображения к входному размеру сети. Покажите изображение.

I = imresize(I,[224 224]);
imshow(I)

Входные параметры к shufflenet потребуйте дальнейшей предварительной обработки (для получения дополнительной информации, смотрите ShuffleNet в Зоопарке Модели ONNX). Перемасштабируйте изображение. Нормируйте изображение путем вычитания учебного среднего значения изображений, и деление на обучение отображает стандартное отклонение.

I = rescale(I,0,1);

meanIm = [0.485 0.456 0.406];
stdIm = [0.229 0.224 0.225];
I = (I - reshape(meanIm,[1 1 3]))./reshape(stdIm,[1 1 3]);

imshow(I)

Импортируйте имена классов из squeezenet, который также обучен с изображениями от базы данных ImageNet.

net = squeezenet;
ClassNames = net.Layers(end).ClassNames;

Вычислите вероятности класса путем определения изображения, чтобы классифицировать I и ONNXParameters объект params как входные параметры к функциональному shufflenetFcn модели.

scores = shufflenetFcn(I,params);

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

indMax = find(scores==max(scores));
ClassNames(indMax)

ans = 1×1 cell array
    {'peacock'}

scoreMax = scores(indMax)

scoreMax = 0.7517

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

Этот пример использует несколько функций помощника. Чтобы просмотреть код для этих функций, смотрите Функции Помощника.

Разархивируйте и загрузите новые изображения как datastore изображений. imageDatastore автоматически помечает изображения на основе имен папок и хранит данные как ImageDatastore объект. Datastore изображений позволяет вам сохранить большие данные изображения, включая данные, которые не умещаются в памяти, и эффективно считать пакеты изображений во время обучения сверточной нейронной сети. Задайте мини-пакетный размер.

unzip('MerchData.zip');
miniBatchSize = 8;
imds = imageDatastore('MerchData', ...
    'IncludeSubfolders',true, ...
    'LabelSource','foldernames',...
    'ReadSize', miniBatchSize);

Этот набор данных является небольшим, содержа 75 учебных изображений. Отобразите некоторые демонстрационные изображения.

numImages = numel(imds.Labels);
idx = randperm(numImages,16);
figure
for i = 1:16
    subplot(4,4,i)
    I = readimage(imds,idx(i));
    imshow(I)
end

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

XTrain = readall(imds);
XTrain = single(cat(4,XTrain{:}));
YTrain_categ = categorical(imds.Labels);
YTrain = onehotencode(YTrain_categ,2)';

Определите количество классов в данных.

classes = categories(YTrain_categ);
numClasses = numel(classes)

numClasses = 5

AlexNet является сверточной нейронной сетью, которая обучена больше чем на миллионе изображений от базы данных ImageNet. В результате сеть изучила богатые представления функции для широкого спектра изображений. Сеть может классифицировать изображения в 1 000 категорий объектов, таких как клавиатура, мышь, карандаш и многие животные.

Импортируйте предварительно обученный alexnet сеть как функция.

alexnetONNX()
params = importONNXFunction('alexnet.onnx','alexnetFcn')

A function containing the imported ONNX network has been saved to the file alexnetFcn.m.
To learn how to use this function, type: help alexnetFcn.

params = 
  ONNXParameters with properties:

             Learnables: [1×1 struct]
          Nonlearnables: [1×1 struct]
                  State: [1×1 struct]
          NumDimensions: [1×1 struct]
    NetworkFunctionName: 'alexnetFcn'

params ONNXParameters объект, который содержит сетевые параметры. alexnetFcn функция модели, которая содержит сетевую архитектуру. importONNXFunction сохраняет alexnetFcn в текущей папке.

Вычислите точность классификации предварительно обученной сети на новом наборе обучающих данных.

accuracyBeforeTraining = getNetworkAccuracy(XTrain,YTrain,params);
fprintf('%.2f accuracy before transfer learning\n',accuracyBeforeTraining);

0.01 accuracy before transfer learning

Точность является очень низкой.

Отобразите настраиваемые параметры сети. Эти параметры, например, веса (W) и смещение (B) из свертки и полносвязных слоев, обновляются сетью во время обучения. Параметры Nonlearnable остаются постоянными во время обучения.

params.Learnables

ans = struct with fields:
    data_Mean: [227×227×3 dlarray]
      conv1_W: [11×11×3×96 dlarray]
      conv1_B: [96×1 dlarray]
      conv2_W: [5×5×48×256 dlarray]
      conv2_B: [256×1 dlarray]
      conv3_W: [3×3×256×384 dlarray]
      conv3_B: [384×1 dlarray]
      conv4_W: [3×3×192×384 dlarray]
      conv4_B: [384×1 dlarray]
      conv5_W: [3×3×192×256 dlarray]
      conv5_B: [256×1 dlarray]
        fc6_W: [6×6×256×4096 dlarray]
        fc6_B: [4096×1 dlarray]
        fc7_W: [1×1×4096×4096 dlarray]
        fc7_B: [4096×1 dlarray]
        fc8_W: [1×1×4096×1000 dlarray]
        fc8_B: [1000×1 dlarray]

Последние два настраиваемых параметра предварительно обученной сети сконфигурированы для 1 000 классов. Параметры fc8_W и fc8_B должен быть подстроен для новой проблемы классификации. Передайте параметры, чтобы классифицировать 5 классов путем инициализации их.

params.Learnables.fc8_B = rand(5,1);
params.Learnables.fc8_W = rand(1,1,4096,5);

Заморозьте все параметры сети, чтобы преобразовать их в nonlearnable параметры. Поскольку вы не должны вычислять градиенты блокированных слоев, замораживание весов многих начальных слоев может значительно ускорить сетевое обучение.

params = freezeParameters(params,'all');

Разморозьте последние два параметра сети, чтобы преобразовать их в настраиваемые параметры.

params = unfreezeParameters(params,'fc8_W');
params = unfreezeParameters(params,'fc8_B');

Теперь сеть готова к обучению. Инициализируйте график процесса обучения.

plots = "training-progress";
if plots == "training-progress"
    figure
    lineLossTrain = animatedline;
    xlabel("Iteration")
    ylabel("Loss")
end

Задайте опции обучения.

velocity = [];
numEpochs = 5;
miniBatchSize = 16;
numObservations = size(YTrain,2);
numIterationsPerEpoch = floor(numObservations./miniBatchSize);
initialLearnRate = 0.01;
momentum = 0.9;
decay = 0.01;

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

iteration = 0;
start = tic;
executionEnvironment = "cpu"; % Change to "gpu" to train on a GPU.

% Loop over epochs.
for epoch = 1:numEpochs
    
    % Shuffle data.
    idx = randperm(numObservations);
    XTrain = XTrain(:,:,:,idx);
    YTrain = YTrain(:,idx);
    
    % Loop over mini-batches.
    for i = 1:numIterationsPerEpoch
        iteration = iteration + 1;
        
        % Read mini-batch of data.
        idx = (i-1)*miniBatchSize+1:i*miniBatchSize;
        X = XTrain(:,:,:,idx);        
        Y = YTrain(:,idx);
        
        % If training on a GPU, then convert data to gpuArray.
        if (executionEnvironment == "auto" && canUseGPU) || executionEnvironment == "gpu"
            X = gpuArray(X);         
        end
        
        % Evaluate the model gradients and loss using dlfeval and the
        % modelGradients function.
        [gradients,loss,state] = dlfeval(@modelGradients,X,Y,params);
        params.State = state;
        
        % Determine learning rate for time-based decay learning rate schedule.
        learnRate = initialLearnRate/(1 + decay*iteration);
        
        % Update the network parameters using the SGDM optimizer.
        [params.Learnables,velocity] = sgdmupdate(params.Learnables,gradients,velocity);
        
        % Display the training progress.
        if plots == "training-progress"
            D = duration(0,0,toc(start),'Format','hh:mm:ss');
            addpoints(lineLossTrain,iteration,double(gather(extractdata(loss))))
            title("Epoch: " + epoch + ", Elapsed: " + string(D))
            drawnow
        end
    end
end

Вычислите точность классификации сети после подстройки.

accuracyAfterTraining = getNetworkAccuracy(XTrain,YTrain,params);
fprintf('%.2f accuracy after transfer learning\n',accuracyAfterTraining);

0.99 accuracy after transfer learning

function accuracy = getNetworkAccuracy(X,Y,onnxParams)

N = size(X,4);
Ypred = alexnetFcn(X,onnxParams,'Training',false);

[~,YIdx] = max(Y,[],1);
[~,YpredIdx] = max(Ypred,[],1);
numIncorrect = sum(abs(YIdx-YpredIdx) > 0);
accuracy = 1 - numIncorrect/N;

end

function [grad, loss, state] = modelGradients(X,Y,onnxParams)

[y,state] = alexnetFcn(X,onnxParams,'Training',true);
loss = crossentropy(y,Y,'DataFormat','CB');
grad = dlgradient(loss,onnxParams.Learnables);

end

function alexnetONNX()
    
exportONNXNetwork(alexnet,'alexnet.onnx');

end