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

Загрузите и установите пакет поддержки Deep Learning Toolbox Converter для формата модели ONNX. Можно ввести importONNXFunction в командной строке, чтобы проверить, установлен ли пакет поддержки. Если он не установлен, функция предоставляет ссылку на необходимый пакет поддержки в обозревателе надстроек. Чтобы установить пакет поддержки, щелкните ссылку и нажмите кнопку Установить.

Укажите файл для импорта как 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. В результате сеть получила богатые представления элементов для широкого спектра изображений. Сеть может классифицировать изображения на 1000 категорий объектов, таких как клавиатура, мышь, карандаш и многие животные.

modelfile = 'shufflenet-9.onnx';

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

params = importONNXFunction(modelfile,'shufflenetFcn');

A function containing the imported ONNX network has been saved to the file shufflenetFcn.m.
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

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

В этом примере используется несколько вспомогательных функций. Для просмотра кода этих функций см. раздел Вспомогательные функции.

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

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

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

Импорт предварительно подготовленных squeezenet сеть как функция.

squeezenetONNX()
params = importONNXFunction('squeezenet.onnx','squeezenetFcn')

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

params = 
  ONNXParameters with properties:

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

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

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

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

0.01 accuracy before transfer learning

Точность очень низкая.

Отображение обучаемых параметров сети путем ввода params.Learnables. Эти параметры, такие как веса (W) и предвзятость (B) свёртки и полностью соединенных слоев, обновляются сетью во время обучения. Нечеткие параметры остаются постоянными во время обучения.

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

conv10_W: [1×1×512×1000 dlarray]

conv10_B: [1000×1 dlarray]

Параметры conv10_W и conv10_B необходимо выполнить точную настройку для новой проблемы классификации. Передайте параметры для классификации пяти классов путем инициализации параметров.

params.Learnables.conv10_W = rand(1,1,512,5);
params.Learnables.conv10_B = rand(5,1);

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

params = freezeParameters(params,'all');

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

params = unfreezeParameters(params,'conv10_W');
params = unfreezeParameters(params,'conv10_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 the learning rate for the 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);

1.00 accuracy after transfer learning

function accuracy = getNetworkAccuracy(X,Y,onnxParams)

N = size(X,4);
Ypred = squeezenetFcn(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] = squeezenetFcn(X,onnxParams,'Training',true);
loss = crossentropy(y,Y,'DataFormat','CB');
grad = dlgradient(loss,onnxParams.Learnables);

end

function squeezenetONNX()
    
exportONNXNetwork(squeezenet,'squeezenet.onnx');

end

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

В этом примере используется вспомогательная функция preparePermutationVector. Для просмотра кода этой функции см. раздел Вспомогательная функция.

lstmNet имеет сходную архитектуру с сетью LSTM, созданной в классификации последовательностей с использованием глубокого обучения. lstmNet обучается распознаванию говорящего данных временного ряда, представляющих два японских гласных, произносимых последовательно. Данные обучения содержат данные временных рядов для девяти ораторов. Каждая последовательность имеет 12 признаков и варьирует по длине.

Определить lstmNet в качестве файла модели.

modelfile = 'lstmNet.onnx';

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

params = importONNXFunction(modelfile,'lstmnetFcn');

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

Загрузите данные теста японских гласных. XTest - массив ячеек, содержащий 370 последовательностей размерности 12 и изменяющейся длины. YTest - категориальный вектор меток «1», «2»,... «9», которым соответствуют девять говорящих.

[XTest,YTest] = japaneseVowelsTestData;

lstmNet был обучен с использованием мини-партий с последовательностями аналогичной длины. Для организации тестовых данных аналогичным образом сортируйте тестовые данные по длине последовательности.

numObservationsTest = numel(XTest);
for i=1:numObservationsTest
    sequence = XTest{i};
    sequenceLengthsTest(i) = size(sequence,2);
end
[sequenceLengthsTest,idx] = sort(sequenceLengthsTest);
XTest = XTest(idx);
YTest = YTest(idx);

Использовать preparePermutationVector для вычисления вектора перестановки inputPerm, который преобразует порядок размерности входных данных последовательности в порядок размерности импортированного сетевого входа LSTM. Можно ввести help lstmnetFcn для просмотра порядка размеров сетевого входа SEQUENCEINPUT.

inputPerm = preparePermutationVector(["FeaturesLength","SequenceLength","BatchSize"],...
    ["SequenceLength","BatchSize","FeaturesLength"]);

Вычисление вероятностей класса путем указания данных последовательности для классификации XTest и ONNXParameters объект params в качестве входных аргументов для функции модели lstmnetFcn. Настройка порядка входных размеров путем назначения числового вектора inputPerm к аргументу имя-значение 'InputDataPermutation'. Вернуть scores в порядке размеров сетевого вывода путем назначения 'none' к аргументу имя-значение 'OutputDataPermutation'.

for i = 1:length(XTest)
    scores = lstmnetFcn(XTest{i},params,'InputDataPermutation',inputPerm,'OutputDataPermutation','none');
    YPred(i) = find(scores==max(scores));
end
YPred = categorical(YPred');

Вычислите точность классификации прогнозов.

acc = sum(YPred == YTest)./numel(YTest)

acc = 0.9514

function perm = preparePermutationVector(fromDimOrder, toDimOrder)

% Check if both fromDimOrder and toDimOrder are vectors.
if ~isvector(fromDimOrder) || ~isvector(toDimOrder)
    error(message('nnet_cnn_onnx:onnx:FPVtypes'));
end

% Convert fromDimOrder and toDimOrder to the appropriate type.
if isstring(fromDimOrder) && isscalar(fromDimOrder)
    fromDimOrder = char(fromDimOrder);
end
if isstring(toDimOrder) && isscalar(toDimOrder)
    toDimOrder = char(toDimOrder);
end

% Check if fromDimOrder and toDimOrder have unique elements.
[fromSorted, ifrom] = unique(fromDimOrder);
[toSorted, ~, iToInv] = unique(toDimOrder);

if numel(fromSorted) ~= numel(fromDimOrder)
    error(message('nnet_cnn_onnx:onnx:FPVfromunique'));
end
if numel(toSorted) ~= numel(toDimOrder)
    error(message('nnet_cnn_onnx:onnx:FPVtounique'));
end

% Check if fromDimOrder and toDimOrder have the same number of elements.
if ~isequal(fromSorted, toSorted)
    error(message('nnet_cnn_onnx:onnx:FPVsame'));
end

% Compute the permutation vector.
perm = ifrom(iToInv);
perm = perm(:)';

end