Train сеть с использованием циклических Скоростей обучения для создания снимков файловой системы

Открыть Live Script

В этом примере показано, как обучить сеть классифицировать изображения объектов с помощью циклического расписания скорости обучения и создания моментальных снимков для лучшей точности тестирования. В примере вы узнаете, как использовать функцию косинуса для расписания скорости обучения, сделать снимки сети во время обучения, чтобы создать ансамбль модели и добавить L2-norm регуляризацию (распад веса) к потере обучения.

Этот пример обучает остаточную сеть [1] на CIFAR-10 наборе данных [2] с пользовательской циклической скоростью обучения: для каждой итерации решатель использует скорость обучения, заданную сдвинутой функцией косинуса [3] alpha(t) = (alpha0/2)*cos(pi*mod(t-1,T/M)/(T/M)+1), где t - число итерации, T - общее количество итераций обучения, alpha0 - начальная скорость обучения, и M количество циклов/моментальных снимков. Это расписание скорости обучения эффективно разделяет процесс обучения на M циклы. Каждый цикл начинается с большой скорости обучения, которая разрушается монотонно, заставляя сеть исследовать различные локальные минимумы. В конце каждого цикла обучения вы делаете моментальный снимок сети (то есть сохраняете модель в этой итерации) и позже усредняете предсказания всех моделей моментального снимка, также известных как создание моментального снимка [4], чтобы улучшить точность окончательного тестирования.

Подготовка данных

Загрузите CIFAR-10 набор данных [2]. Набор данных содержит 60 000 изображений. Каждое изображение имеет размер 32 на 32 и имеет три цветовых канала (RGB). Размер набора данных составляет 175 МБ. В зависимости от вашего подключения к Интернету процесс загрузки может занять время.

datadir = tempdir; 
downloadCIFARData(datadir);

Загрузите CIFAR-10 обучающие и тестовые изображения как 4-D массивы. Набор обучающих данных содержит 50 000 изображений, а тестовый - 10 000 изображений.

[XTrain,YTrain,XTest,YTest] = loadCIFARData(datadir);
classes = categories(YTrain);
numClasses = numel(classes);

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

figure;
idx = randperm(size(XTrain,4),20);
im = imtile(XTrain(:,:,:,idx),'ThumbnailSize',[96,96]);
imshow(im)

Создайте augmentedImageDatastore объект, используемый для сетевого обучения. Во время обучения datastore случайным образом переворачивает обучающие изображения вдоль вертикальной оси и случайным образом перемещает их до четырех пикселей горизонтально и вертикально. Увеличение количества данных помогает предотвратить сверхподбор кривой сети и запоминание точных деталей обучающих изображений.

imageSize = [32 32 3];
pixelRange = [-4 4];
imageAugmenter = imageDataAugmenter( ...
    'RandXReflection',true, ...
    'RandXTranslation',pixelRange, ...
    'RandYTranslation',pixelRange);
augimdsTrain = augmentedImageDatastore(imageSize,XTrain,YTrain, ...
    'DataAugmentation',imageAugmenter);

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

Создайте остаточную сеть [1] с шестью стандартными сверточными модулями (по два модулей на каскад) и шириной 16. Общая глубина сети составляет 2 * 6 + 2 = 14. В сложение задайте среднее изображение используя 'Mean' опция на входном слое изображения.

netWidth = 16;
layers = [
    imageInputLayer(imageSize,'Name','input','Mean', mean(XTrain,4))
    convolution2dLayer(3,netWidth,'Padding','same','Name','convInp')
    batchNormalizationLayer('Name','BNInp')
    reluLayer('Name','reluInp')
    
    convolutionalUnit(netWidth,1,'S1U1')
    additionLayer(2,'Name','add11')
    reluLayer('Name','relu11')
    convolutionalUnit(netWidth,1,'S1U2')
    additionLayer(2,'Name','add12')
    reluLayer('Name','relu12')
    
    convolutionalUnit(2*netWidth,2,'S2U1')
    additionLayer(2,'Name','add21')
    reluLayer('Name','relu21')
    convolutionalUnit(2*netWidth,1,'S2U2')
    additionLayer(2,'Name','add22')
    reluLayer('Name','relu22')
    
    convolutionalUnit(4*netWidth,2,'S3U1')
    additionLayer(2,'Name','add31')
    reluLayer('Name','relu31')
    convolutionalUnit(4*netWidth,1,'S3U2')
    additionLayer(2,'Name','add32')
    reluLayer('Name','relu32')
    
    averagePooling2dLayer(8,'Name','globalPool')
    fullyConnectedLayer(10,'Name','fcFinal')
    ];

lgraph = layerGraph(layers);
lgraph = connectLayers(lgraph,'reluInp','add11/in2');
lgraph = connectLayers(lgraph,'relu11','add12/in2');
skip1 = [
    convolution2dLayer(1,2*netWidth,'Stride',2,'Name','skipConv1')
    batchNormalizationLayer('Name','skipBN1')];
lgraph = addLayers(lgraph,skip1);
lgraph = connectLayers(lgraph,'relu12','skipConv1');
lgraph = connectLayers(lgraph,'skipBN1','add21/in2');
lgraph = connectLayers(lgraph,'relu21','add22/in2');
skip2 = [
    convolution2dLayer(1,4*netWidth,'Stride',2,'Name','skipConv2')
    batchNormalizationLayer('Name','skipBN2')];
lgraph = addLayers(lgraph,skip2);
lgraph = connectLayers(lgraph,'relu22','skipConv2');
lgraph = connectLayers(lgraph,'skipBN2','add31/in2');
lgraph = connectLayers(lgraph,'relu31','add32/in2');

Постройте график архитектуры ResNet.

figure;
plot(lgraph)

Создайте dlnetwork объект из графика слоев.

dlnet = dlnetwork(lgraph);

Задайте функцию градиентов модели

Создайте вспомогательную функцию modelGradients, перечисленный в конце примера. Функция принимает dlnetwork dlnet объекта and мини-пакет входных данных dlX с соответствующими метками Y, и возвращает градиенты потерь относительно настраиваемых параметров в dlnet. Эта функция также возвращает потерю и состояние неведомых параметров сети при заданной итерации.

Настройка опций обучения

Задайте опции обучения. Train на 200 эпох с мини-пакетом размером 64.

numEpochs = 200;
miniBatchSize = 64;

numObservations = numel(YTrain);

velocity = [];
momentum = 0.9;
weightDecay = 1e-4;

Задайте опции обучения, характерные для циклической скорости обучения. Alpha0 - начальная скорость обучения и numSnapshots - количество циклов или моментальных снимков, сделанных во время обучения.

alpha0 = 0.1;
numSnapshots = 5;
epochsPerSnapshot = numEpochs./numSnapshots; 
iterationsPerSnapshot = ceil(numObservations./miniBatchSize)*numEpochs./numSnapshots;
modelPrefix = "SnapshotEpoch";

Визуализируйте процесс обучения на графике.

plots = "training-progress";

Инициализируйте обучающий рисунок.

if plots == "training-progress"
    [lossLine,learnRateLine] = plotLossAndLearnRate();
end

Обучите модель

Использование minibatchqueue обрабатывать и управлять мини-пакетами изображений во время обучения. Для каждого мини-пакета:

Используйте пользовательскую функцию мини-пакетной предварительной обработки preprocessMiniBatch (определено в конце этого примера), чтобы закодировать метки классов с одним «горячим» кодом.
Форматируйте данные изображения с помощью меток размерностей 'SSCB' (пространственный, пространственный, канальный, пакетный). По умолчанию в minibatchqueue объект преобразует данные в dlarray объекты с базовым типом single. Не добавляйте формат к меткам классов.
Обучите на графическом процессоре, если он доступен. По умолчанию в minibatchqueue объект преобразует каждый выход в gpuArray при наличии графический процессор. Для использования графический процессор требуется Parallel Computing Toolbox™ и поддерживаемый графический процессор. Для получения информации о поддерживаемых устройствах смотрите Поддержку GPU by Release (Parallel Computing Toolbox).

augimdsTrain.MiniBatchSize = miniBatchSize;

mbqTrain = minibatchqueue(augimdsTrain,...
    'MiniBatchSize',miniBatchSize,...
    'MiniBatchFcn', @preprocessMiniBatch,...
    'MiniBatchFormat',{'SSCB',''});

Обучите модель с помощью пользовательского цикла обучения. Для каждой эпохи перетащите datastore, закольцовывайте мини-пакеты данных и сохраните модель (снимок), если текущая эпоха является произведением epochsPerSnapshot. В конце каждой эпохи отобразите процесс обучения. Для каждого мини-пакета:

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

В данном примере обучение заняло приблизительно 14 часов на NVIDIA™ TITAN RTX.

iteration = 0;
start = tic;

% Loop over epochs.
for epoch = 1:numEpochs
  
    % Shuffle data.
    shuffle(mbqTrain);
    
    % Save snapshot model.
    if ~mod(epoch,epochsPerSnapshot)
        save(modelPrefix + epoch + ".mat",'dlnet');
    end
    
    % Loop over mini-batches.
    while hasdata(mbqTrain)
        iteration = iteration + 1;
        
        % Read mini-batch of data.
        [dlX,dlY] = next(mbqTrain);
        
        % Evaluate the model gradients and loss using dlfeval and the
        % modelGradients function.
        [gradients, loss, state] = dlfeval(@modelGradients,dlnet,dlX,dlY,weightDecay);
        
        % Update the state of nonlearnable parameters.
        dlnet.State = state;
        
        % Determine learning rate for cyclical learning rate schedule.
        learnRate = 0.5*alpha0*(cos((pi*mod(iteration-1,iterationsPerSnapshot)./iterationsPerSnapshot))+1);
        
        % Update the network parameters using the SGDM optimizer.
        [dlnet.Learnables, velocity] = sgdmupdate(dlnet.Learnables, gradients, velocity, learnRate, momentum);
        
        % Display the training progress.
        if plots == "training-progress"
                D = duration(0,0,toc(start),'Format','hh:mm:ss');
                addpoints(lossLine,iteration,double(gather(extractdata(loss))))
                addpoints(learnRateLine, iteration, learnRate);            
                sgtitle("Epoch: " + epoch + ", Elapsed: " + string(D))
                drawnow
        end
        
    end
    
end

Создайте ансамбль снимков и экспериментальную модель

Объедините снимки сети M, сделанные во время обучения, чтобы сформировать итоговый ансамбль и проверить классификационную точность модели. Ансамбль предсказаний соответствовать среднему значению выходных данных полносвязного слоя от всех М отдельных моделей.

Протестируйте модель на тестовых данных, предоставленных с CIFAR-10 набором данных. Управление набором тестовых данных с помощью minibatchqueue объект с той же настройкой, что и обучающие данные.

augimdsTest = augmentedImageDatastore(imageSize,XTest,YTest);
augimdsTest.MiniBatchSize = miniBatchSize;

mbqTest = minibatchqueue(augimdsTest,...
    'MiniBatchSize',miniBatchSize,...
    'MiniBatchFcn', @preprocessMiniBatch,...
    'MiniBatchFormat',{'SSCB',''});

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

modelName = cell(numSnapshots+1,1);
fcOutput = zeros(numClasses,numel(YTest),numSnapshots+1);
classPredictions = cell(1,numSnapshots+1);
modelAccuracy = zeros(numSnapshots+1,1);

for m = 1:numSnapshots
    modelName{m} = modelPrefix + m*epochsPerSnapshot;
    load(modelName{m} + ".mat");
    
    reset(mbqTest);
    [fcOutputTest,classPredTest,classCorrTest] = modelPredictions(dlnet,mbqTest,classes);
    
    fcOutput(:,:,m) = fcOutputTest;    
    classPredictions{m} = classPredTest;
    modelAccuracy(m) = 100*mean(classCorrTest);
    
    disp(modelName{m} + " accuracy: " + modelAccuracy(m) + "%")
end

SnapshotEpoch40 accuracy: 88.35%
SnapshotEpoch80 accuracy: 89.93%
SnapshotEpoch120 accuracy: 90.51%
SnapshotEpoch160 accuracy: 90.33%
SnapshotEpoch200 accuracy: 90.63%

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

fcOutput(:,:,end) = mean(fcOutput(:,:,1:end-1),3);
classPredictions{end} = onehotdecode(softmax(fcOutput(:,:,end)),classes,1,'categorical');

classCorrEnsemble = classPredictions{end} == YTest';
modelAccuracy(end) = 100*mean(classCorrEnsemble);

modelName{end} = "Ensemble model";
disp("Ensemble accuracy: " + modelAccuracy(end) + "%")

Ensemble accuracy: 91.59%

Точность графика

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

figure;bar(modelAccuracy);
ylabel('Accuracy (%)');
xticklabels(modelName)
xtickangle(45)
title('Model accuracy')

Вспомогательные функции

Функция градиентов модели

The modelGradients функция принимает dlnetwork dlnet объектамини-пакет входных данных dlX, метки Y, и параметр для распада веса. Функция возвращает градиенты, потери и состояние непереходимых параметров. Чтобы вычислить градиенты автоматически, используйте dlgradient функция.

function [gradients,loss,state] = modelGradients(dlnet,dlX,Y,weightDecay)
    
    [dlYPred,state] = forward(dlnet,dlX);
    dlYPred = softmax(dlYPred);
    
    loss = crossentropy(dlYPred, Y);
    
    % L2-regularization (weight decay)
    allParams = dlnet.Learnables(dlnet.Learnables.Parameter == "Weights" | dlnet.Learnables.Parameter == "Scale",:).Value;
    l2Norm = cellfun(@(x) sum(x.^2,'All'),allParams,'UniformOutput',false);
    l2Norm = sum(cat(1,l2Norm{:}));
    loss = loss + weightDecay*0.5*l2Norm;
    
    gradients = dlgradient(loss,dlnet.Learnables);
end

Функция предсказаний модели

The modelPredictions функция принимает как вход dlnetwork dlnet объекта, а minibatchqueue входных данных mbq, и вычисляет предсказания модели путем итерации по всем данным в minibatchqueue. Функция использует onehotdecode функция для поиска предсказанного класса с самым высоким счетом и затем сравнивает предсказание с истинным классом. Функция возвращает выход сети, предсказания классов и вектор таковых и нулей, который представляет правильные и неправильные предсказания.

function [rawPredictions,classPredictions,classCorr] = modelPredictions(dlnet,mbq,classes)
    rawPredictions = [];
    classPredictions = [];
    classCorr = [];
    
    while hasdata(mbq)
        [dlX,dlY] = next(mbq);
        
        % Make predictions
        dlYPred = predict(dlnet,dlX);
        rawPredictions = [rawPredictions extractdata(gather(dlYPred))];
        
        % Convert network output to probabilities and determine predicted
        % classes
        dlYPred = softmax(dlYPred);
        YPredBatch = onehotdecode(dlYPred,classes,1);
        classPredictions = [classPredictions YPredBatch];
        
        % Compare predicted and true classes
        Y = onehotdecode(dlY,classes,1);
        classCorr = [classCorr YPredBatch == Y];
    end
    
end

Построение графика потерь и функции скорости обучения

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

function [lossLine, learnRateLine] = plotLossAndLearnRate()
    figure
    
    subplot(2,1,1); 
    lossLine = animatedline('Color',[0.85 0.325 0.098]);
    title('Loss');
    xlabel('Iteration')
    ylabel('Loss')
    grid on
    
    subplot(2,1,2); 
    learnRateLine = animatedline('Color',[0 0.447 0.741]);
    title('Learning rate');
    xlabel('Iteration')
    ylabel('Learning rate')
    grid on
end

Функция сверточного модуля

The convolutionalUnit(numF,stride,tag) функция создает массив слоев с двумя сверточными слоями и соответствующими слоями нормализации партии . и ReLU. numF количество сверточных фильтров, stride является шагом первого сверточного слоя и tag - тег, подготовленный ко всем именам слоев.

function layers = convolutionalUnit(numF,stride,tag)
    layers = [
        convolution2dLayer(3,numF,'Padding','same','Stride',stride,'Name',[tag,'conv1'])
        batchNormalizationLayer('Name',[tag,'BN1'])
        reluLayer('Name',[tag,'relu1'])
        convolution2dLayer(3,numF,'Padding','same','Name',[tag,'conv2'])
        batchNormalizationLayer('Name',[tag,'BN2'])];
end

Функция предварительной обработки данных

The preprocessMiniBatch функция предварительно обрабатывает данные с помощью следующих шагов:

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

function [X,Y] = preprocessMiniBatch(XCell,YCell)
    % Extract image data from cell and concatenate
    X = cat(4,XCell{:});
    % Extract label data from cell and concatenate
    Y = cat(2,YCell{:});
    
    % One-hot encode labels
    Y = onehotencode(Y,1);
end

Ссылки

[1] He, Kaiming, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. «Глубокое остаточное обучение для распознавания изображений». В материалах конференции IEEE по компьютерному зрению и распознаванию шаблонов, стр. 770-778. 2016.

[2] Крижевский, Алекс. «Изучение нескольких слоев функций из крошечных изображений». (2009). https://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf

[3] Лощилов, Илья и Фрэнк Хаттер. Sgdr: Стохастический градиентный спуск с теплыми перезапусками. (2016). arXiv препринт arXiv:1608.03983.

[4] Хуан, Гао, Исюань Ли, Джефф Плейсс, Чжуан Лю, Джон Э. Хопкрофт и Килиан К. Вайнбергер. «Snapshot ensembles: Train 1, get m бесплатно». (2017). arXiv препринт arXiv:1704.00109.

См. также

Документация