Импортируйте 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

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

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 к параметру, не поддающемуся интерполяции. The 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]