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

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

Разархивируйте и загрузите новые изображения как 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

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

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

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

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);

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

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

Импортируйте сеть, сохраненную в формате ONNX как функция, и переместите mislabeled параметры при помощи freeze или unfreeze.

Импортируйте предварительно обученный simplenet.onnx сеть как функция. simplenet простая сверточная нейронная сеть, обученная на данных изображения цифры. Для получения дополнительной информации о том, как создать simplenet, смотрите Создают Простую Сеть Классификации Изображений.

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

params = importONNXFunction('simplenet.onnx','simplenetFcn');

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

importONNXFunction помечает параметры импортированной сети как Learnables (параметры, которые обновляются во время обучения), или Nonlearnables (параметры, которые остаются неизменными во время обучения). Маркировка не всегда точна. Методические рекомендации должны проверять, присвоены ли параметры правильной структуре params.Learnables или params.Nonlearnables. Отобразите learnable и nonlearnable параметры импортированной сети.

params.Learnables

ans = struct with fields:
    imageinput_Mean: [1×1 dlarray]
             conv_W: [5×5×1×20 dlarray]
             conv_B: [20×1 dlarray]
    batchnorm_scale: [20×1 dlarray]
        batchnorm_B: [20×1 dlarray]
               fc_W: [24×24×20×10 dlarray]
               fc_B: [10×1 dlarray]

params.Nonlearnables

ans = struct with fields:
            ConvStride1004: [2×1 dlarray]
    ConvDilationFactor1005: [2×1 dlarray]
           ConvPadding1006: [4×1 dlarray]
            ConvStride1007: [2×1 dlarray]
    ConvDilationFactor1008: [2×1 dlarray]
           ConvPadding1009: [4×1 dlarray]

Обратите внимание на то, что params.Learnables содержит параметр imageinput_Mean, который должен остаться неизменным во время обучения (см. Mean свойство imageInputLayer). Преобразуйте imageinput_Mean к nonlearnable параметру. freezeParameters функция удаляет параметр imageinput_Mean от param.Learnables и добавляет его в params.Nonlearnables последовательно.

params = freezeParameters(params,'imageinput_Mean');

Отобразите обновленные learnable и nonlearnable параметры.

params.Learnables

ans = struct with fields:
             conv_W: [5×5×1×20 dlarray]
             conv_B: [20×1 dlarray]
    batchnorm_scale: [20×1 dlarray]
        batchnorm_B: [20×1 dlarray]
               fc_W: [24×24×20×10 dlarray]
               fc_B: [10×1 dlarray]

params.Nonlearnables

ans = struct with fields:
            ConvStride1004: [2×1 dlarray]
    ConvDilationFactor1005: [2×1 dlarray]
           ConvPadding1006: [4×1 dlarray]
            ConvStride1007: [2×1 dlarray]
    ConvDilationFactor1008: [2×1 dlarray]
           ConvPadding1009: [4×1 dlarray]
           imageinput_Mean: [1×1 dlarray]