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

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

Укажите файл для импорта следующим shufflenet с набором операторов 9 из зоопарка ONNX Model. 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 Model. 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 Model Zoo). Переформулируйте изображение заново. Нормализуйте изображение путем вычитания среднего обучающего изображения и деления на стандартное отклонение обучающих изображений.

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 свертка нейронной сети как функции и подстройте предварительно обученную сеть с передачей обучения, чтобы выполнить классификацию на новом наборе изображений.

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

Разархивируйте и загружайте новые изображения как image datastore. imageDatastore автоматически помечает изображения на основе имен папок и сохраняет данные как ImageDatastore объект. image 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

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 позволяет вам вводить данные последовательности в сеть и делать предсказания на основе отдельных временных шагов данных последовательности.

Этот пример использует функцию helper preparePermutationVector. Чтобы просмотреть код для этой функции, смотрите Helper Function.

lstmNet имеет такую же архитектуру, как и сеть LSTM, созданная в Sequence Classification Using Deep Learning. 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