Глубокое обучение Используя байесовую оптимизацию

Этот пример использует:

Скрипт Open Live Script

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

Чтобы обучить глубокую нейронную сеть, необходимо задать архитектуру нейронной сети, а также опции алгоритма настройки. Выбор и настройка этих гиперпараметров могут затруднить и занять время. Байесова оптимизация является алгоритмом, хорошо подходящим для оптимизации гиперпараметров моделей регрессии и классификации. Можно использовать Байесовую оптимизацию, чтобы оптимизировать функции, которые недифференцируемы, прерывисты, и длительны, чтобы оценить. Алгоритм внутренне обеспечивает Гауссову модель процесса целевой функции и использует оценки целевой функции, чтобы обучить эту модель.

В этом примере показано, как к:

  • Загрузите и подготовьте набор данных CIFAR-10 к сетевому обучению. Этот набор данных является одним из наиболее широко используемых наборов данных для тестирования моделей классификации изображений.

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

  • Задайте целевую функцию, которая принимает значения переменных оптимизации как входные параметры, задает сетевую архитектуру и опции обучения, обучает и подтверждает сеть и сохраняет обучивший сеть на диск. Целевая функция задана в конце этого скрипта.

  • Выполните Байесовую оптимизацию путем минимизации ошибки классификации на наборе валидации.

  • Загрузите лучшую сеть от диска и оцените его на наборе тестов.

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

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

datadir = tempdir;
downloadCIFARData(datadir);

Загрузите набор данных CIFAR-10, когда обучение отображает и помечает, и тестовые изображения и метки. Чтобы включить сетевую валидацию, используйте 5000 из тестовых изображений для валидации.

[XTrain,YTrain,XTest,YTest] = loadCIFARData(datadir);

idx = randperm(numel(YTest),5000);
XValidation = XTest(:,:,:,idx);
XTest(:,:,:,idx) = [];
YValidation = YTest(idx);
YTest(idx) = [];

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

figure;
idx = randperm(numel(YTrain),20);
for i = 1:numel(idx)
    subplot(4,5,i);
    imshow(XTrain(:,:,:,idx(i)));
end

Выберите Variables to Optimize

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

  • Сетевая глубина раздела. Этот параметр управляет глубиной сети. Сеть имеет три раздела, каждого с SectionDepth идентичные сверточные слои. Таким образом, общим количеством сверточных слоев является 3*SectionDepth. Целевая функция позже в скрипте берет количество сверточных фильтров в каждом слое, пропорциональном 1/sqrt(SectionDepth). В результате количество параметров и необходимое количество расчета для каждой итерации являются примерно тем же самым для различных глубин раздела.

  • Начальная скорость обучения. Лучшая скорость обучения может зависеть от ваших данных, а также сети, вы - обучение.

  • Стохастический импульс градиентного спуска. Импульс добавляет, что инерция к обновлениям параметра при наличии текущего обновления содержит вклад, пропорциональный обновлению в предыдущей итерации. Это приводит к более сглаженным обновлениям параметра и сокращению шума, свойственного к стохастическому градиентному спуску.

  • Сила регуляризации L2. Используйте регуляризацию, чтобы предотвратить сверхподбор кривой. Ищите пробел силы регуляризации, чтобы найти хорошее значение. Увеличение данных и нормализация партии. также помогают упорядочить сеть.

optimVars = [
    optimizableVariable('SectionDepth',[1 3],'Type','integer')
    optimizableVariable('InitialLearnRate',[1e-2 1],'Transform','log')
    optimizableVariable('Momentum',[0.8 0.98])
    optimizableVariable('L2Regularization',[1e-10 1e-2],'Transform','log')];

Выполните байесовую оптимизацию

Создайте целевую функцию для Байесового оптимизатора, с помощью данных об обучении и валидации в качестве входных параметров. Целевая функция обучает сверточную нейронную сеть и возвращает ошибку классификации на наборе валидации. Эта функция задана в конце этого скрипта. Поскольку bayesopt использует коэффициент ошибок набора валидации, чтобы выбрать лучшую модель, возможно, что итоговая сеть сверхсоответствует на наборе валидации. Финал выбранная модель затем тестируется на независимом наборе тестов, чтобы оценить ошибку обобщения.

ObjFcn = makeObjFcn(XTrain,YTrain,XValidation,YValidation);

Выполните Байесовую оптимизацию путем минимизации ошибки классификации на наборе валидации. Задайте общее время оптимизации в секундах. Чтобы лучше всего использовать энергию Байесовой оптимизации, необходимо выполнить по крайней мере 30 оценок целевой функции. Чтобы обучить нейронные сети параллельно на нескольких графических процессорах, установите 'UseParallel' значение к true. Если вы имеете один графический процессор и устанавливаете 'UseParallel' значение к true, затем все рабочие совместно используют тот графический процессор, и вы не получаете учебного ускорения и увеличиваете возможности графического процессора, исчерпывающего память.

После того, как каждая сеть закончила обучение, bayesopt распечатывает результаты к командному окну. bayesopt функционируйте затем возвращает имена файлов в BayesObject.UserDataTrace. Целевая функция сохраняет обучивший нейронные сети на диск и возвращает имена файлов в bayesopt.

BayesObject = bayesopt(ObjFcn,optimVars, ...
    'MaxTime',14*60*60, ...
    'IsObjectiveDeterministic',false, ...
    'UseParallel',false);
|===================================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | SectionDepth | InitialLearn-|     Momentum | L2Regulariza-|
|      | result |             | runtime     | (observed)  | (estim.)    |              | Rate         |              | tion         |
|===================================================================================================================================|
|    1 | Best   |        0.19 |        2201 |        0.19 |        0.19 |            3 |     0.012114 |       0.8354 |    0.0010624 |

|    2 | Accept |      0.3224 |      1734.1 |        0.19 |     0.19636 |            1 |     0.066481 |      0.88231 |    0.0026626 |

|    3 | Accept |      0.2076 |      1688.7 |        0.19 |     0.19374 |            2 |     0.022346 |      0.91149 |    8.242e-10 |

|    4 | Accept |      0.1908 |      2167.2 |        0.19 |      0.1904 |            3 |      0.97586 |      0.83613 |   4.5143e-08 |

|    5 | Accept |      0.1972 |      2157.4 |        0.19 |     0.19274 |            3 |      0.21193 |      0.97995 |   1.4691e-05 |

|    6 | Accept |      0.2594 |      2152.8 |        0.19 |        0.19 |            3 |      0.98723 |      0.97931 |   2.4847e-10 |

|    7 | Best   |      0.1882 |      2257.5 |      0.1882 |     0.18819 |            3 |       0.1722 |       0.8019 |   4.2149e-06 |

|    8 | Accept |      0.8116 |      1989.7 |      0.1882 |     0.18818 |            3 |      0.42085 |      0.95355 |    0.0092026 |

|    9 | Accept |      0.1986 |        1836 |      0.1882 |     0.18821 |            2 |     0.030291 |      0.94711 |   2.5062e-05 |

|   10 | Accept |      0.2146 |      1909.4 |      0.1882 |     0.18816 |            2 |     0.013379 |       0.8785 |   7.6354e-09 |

|   11 | Accept |      0.2194 |        1562 |      0.1882 |     0.18815 |            1 |      0.14682 |      0.86272 |   8.6242e-09 |

|   12 | Accept |      0.2246 |      1591.2 |      0.1882 |     0.18813 |            1 |      0.70438 |      0.82809 |   1.0102e-06 |

|   13 | Accept |      0.2648 |      1621.8 |      0.1882 |     0.18824 |            1 |     0.010109 |      0.89989 |   1.0481e-10 |

|   14 | Accept |      0.2222 |        1562 |      0.1882 |     0.18812 |            1 |      0.11058 |      0.97432 |   2.4101e-07 |

|   15 | Accept |      0.2364 |      1625.7 |      0.1882 |     0.18813 |            1 |     0.079381 |       0.8292 |   2.6722e-05 |

|   16 | Accept |        0.26 |      1706.2 |      0.1882 |     0.18815 |            1 |     0.010041 |      0.96229 |   1.1066e-05 |

|   17 | Accept |      0.1986 |      2188.3 |      0.1882 |     0.18635 |            3 |      0.35949 |      0.97824 |    3.153e-07 |

|   18 | Accept |      0.1938 |      2169.6 |      0.1882 |     0.18817 |            3 |     0.024365 |      0.88464 |   0.00024507 |

|   19 | Accept |      0.3588 |      1713.7 |      0.1882 |     0.18216 |            1 |     0.010177 |      0.89427 |    0.0090342 |

|   20 | Accept |      0.2224 |      1721.4 |      0.1882 |     0.18193 |            1 |      0.09804 |      0.97947 |   1.0727e-10 |

|===================================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | SectionDepth | InitialLearn-|     Momentum | L2Regulariza-|
|      | result |             | runtime     | (observed)  | (estim.)    |              | Rate         |              | tion         |
|===================================================================================================================================|
|   21 | Accept |      0.1904 |      2184.7 |      0.1882 |     0.18498 |            3 |     0.017697 |      0.95057 |   0.00022247 |

|   22 | Accept |      0.1928 |      2184.4 |      0.1882 |     0.18527 |            3 |      0.06813 |       0.9027 |   1.3521e-09 |

|   23 | Accept |      0.1934 |      2183.6 |      0.1882 |      0.1882 |            3 |     0.018269 |      0.90432 |    0.0003573 |

|   24 | Accept |       0.303 |      1707.9 |      0.1882 |     0.18809 |            1 |     0.010157 |      0.88226 |   0.00088737 |

|   25 | Accept |       0.194 |      2189.1 |      0.1882 |     0.18808 |            3 |     0.019354 |      0.94156 |   9.6197e-07 |

|   26 | Accept |      0.2192 |      1752.2 |      0.1882 |     0.18809 |            1 |      0.99324 |      0.91165 |   1.1521e-08 |

|   27 | Accept |      0.1918 |        2185 |      0.1882 |     0.18813 |            3 |      0.05292 |       0.8689 |   1.2449e-05 |


__________________________________________________________
Optimization completed.
MaxTime of 50400 seconds reached.
Total function evaluations: 27
Total elapsed time: 51962.3666 seconds.
Total objective function evaluation time: 51942.8833

Best observed feasible point:
    SectionDepth    InitialLearnRate    Momentum    L2Regularization
    ____________    ________________    ________    ________________

         3               0.1722          0.8019        4.2149e-06   

Observed objective function value = 0.1882
Estimated objective function value = 0.18813
Function evaluation time = 2257.4627

Best estimated feasible point (according to models):
    SectionDepth    InitialLearnRate    Momentum    L2Regularization
    ____________    ________________    ________    ________________

         3               0.1722          0.8019        4.2149e-06   

Estimated objective function value = 0.18813
Estimated function evaluation time = 2166.2402

Оцените итоговую сеть

Загрузите лучшую сеть, найденную в оптимизации и ее точности валидации.

bestIdx = BayesObject.IndexOfMinimumTrace(end);
fileName = BayesObject.UserDataTrace{bestIdx};
savedStruct = load(fileName);
valError = savedStruct.valError
valError = 0.1882

Предскажите метки набора тестов и вычислите тестовую ошибку. Обработайте классификацию каждого изображения в наборе тестов как независимые события с определенной вероятностью успеха, что означает, что количество неправильно классифицированных изображений следует за биномиальным распределением. Используйте это, чтобы вычислить стандартную погрешность (testErrorSE) и аппроксимированный 95%-й доверительный интервал (testError95CI) из коэффициента ошибок обобщения. Этот метод часто называется Вальдовым методом. bayesopt определяет лучшую сеть с помощью набора валидации, не подвергая сеть набору тестов. Затем возможно, что тестовая ошибка выше, чем ошибка валидации.

[YPredicted,probs] = classify(savedStruct.trainedNet,XTest);
testError = 1 - mean(YPredicted == YTest)
testError = 0.1864

NTest = numel(YTest);
testErrorSE = sqrt(testError*(1-testError)/NTest);
testError95CI = [testError - 1.96*testErrorSE, testError + 1.96*testErrorSE]
testError95CI = 1×2

    0.1756    0.1972

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

figure('Units','normalized','Position',[0.2 0.2 0.4 0.4]);
cm = confusionchart(YTest,YPredicted);
cm.Title = 'Confusion Matrix for Test Data';
cm.ColumnSummary = 'column-normalized';
cm.RowSummary = 'row-normalized';

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

figure
idx = randperm(numel(YTest),9);
for i = 1:numel(idx)
    subplot(3,3,i)
    imshow(XTest(:,:,:,idx(i)));
    prob = num2str(100*max(probs(idx(i),:)),3);
    predClass = char(YPredicted(idx(i)));
    label = [predClass,', ',prob,'%'];
    title(label)
end

Целевая функция для оптимизации

Задайте целевую функцию для оптимизации. Эта функция выполняет следующие шаги:

  1. Принимает значения переменных оптимизации как входные параметры. bayesopt вызывает целевую функцию с текущими значениями переменных оптимизации в таблице с каждым именем столбца, равным имени переменной. Например, текущим значением сетевой глубины раздела является optVars.SectionDepth.

  2. Задает сетевую архитектуру и опции обучения.

  3. Обучает и подтверждает сеть.

  4. Сохраняет обучивший сеть, ошибку валидации и опции обучения к диску.

  5. Возвращает ошибку валидации и имя файла сохраненной сети.

function ObjFcn = makeObjFcn(XTrain,YTrain,XValidation,YValidation)
ObjFcn = @valErrorFun;
    function [valError,cons,fileName] = valErrorFun(optVars)

Задайте архитектуру сверточной нейронной сети.

  • Добавьте дополнение в сверточные слои так, чтобы пространственный выходной размер всегда был тем же самым как входным размером.

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

  • Выберите количество фильтров, пропорциональных 1/sqrt(SectionDepth), так, чтобы сети различных глубин имели примерно то же количество параметров и потребовали о том же объеме расчета на итерацию. Чтобы увеличить число сетевых параметров и полной сетевой гибкости, увеличьте numF. Чтобы обучить еще более глубокие сети, измените область значений SectionDepth переменная.

  • Используйте convBlock(filterSize,numFilters,numConvLayers) создать блок numConvLayers сверточные слои, каждый с заданным filterSize и numFilters фильтры и каждый сопровождаемый слоем нормализации партии. и слоем ReLU. convBlock функция задана в конце этого примера.

        imageSize = [32 32 3];
        numClasses = numel(unique(YTrain));
        numF = round(16/sqrt(optVars.SectionDepth));
        layers = [
            imageInputLayer(imageSize)
            
            % The spatial input and output sizes of these convolutional
            % layers are 32-by-32, and the following max pooling layer
            % reduces this to 16-by-16.
            convBlock(3,numF,optVars.SectionDepth)
            maxPooling2dLayer(3,'Stride',2,'Padding','same')
            
            % The spatial input and output sizes of these convolutional
            % layers are 16-by-16, and the following max pooling layer
            % reduces this to 8-by-8.
            convBlock(3,2*numF,optVars.SectionDepth)
            maxPooling2dLayer(3,'Stride',2,'Padding','same')
            
            % The spatial input and output sizes of these convolutional
            % layers are 8-by-8. The global average pooling layer averages
            % over the 8-by-8 inputs, giving an output of size
            % 1-by-1-by-4*initialNumFilters. With a global average
            % pooling layer, the final classification output is only
            % sensitive to the total amount of each feature present in the
            % input image, but insensitive to the spatial positions of the
            % features.
            convBlock(3,4*numF,optVars.SectionDepth)
            averagePooling2dLayer(8)
            
            % Add the fully connected layer and the final softmax and
            % classification layers.
            fullyConnectedLayer(numClasses)
            softmaxLayer
            classificationLayer];

Задайте опции для сетевого обучения. Оптимизируйте начальную скорость обучения, импульс SGD и силу регуляризации L2.

Задайте данные о валидации и выберите 'ValidationFrequency' оцените таким образом что trainNetwork подтверждает сеть однажды в эпоху. Обучайтесь для постоянного числа эпох и понизьте скорость обучения фактором 10 в течение прошлых эпох. Это уменьшает шум обновлений параметра и позволяет сетевым параметрам успокоиться ближе к минимуму функции потерь.

        miniBatchSize = 256;
        validationFrequency = floor(numel(YTrain)/miniBatchSize);
        options = trainingOptions('sgdm', ...
            'InitialLearnRate',optVars.InitialLearnRate, ...
            'Momentum',optVars.Momentum, ...
            'MaxEpochs',60, ...
            'LearnRateSchedule','piecewise', ...
            'LearnRateDropPeriod',40, ...
            'LearnRateDropFactor',0.1, ...
            'MiniBatchSize',miniBatchSize, ...
            'L2Regularization',optVars.L2Regularization, ...
            'Shuffle','every-epoch', ...
            'Verbose',false, ...
            'Plots','training-progress', ...
            'ValidationData',{XValidation,YValidation}, ...
            'ValidationFrequency',validationFrequency);

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

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

Обучите сеть и постройте процесс обучения во время обучения. Закройте все учебные графики после того, как обучение закончится.

        trainedNet = trainNetwork(datasource,layers,options);
        close(findall(groot,'Tag','NNET_CNN_TRAININGPLOT_FIGURE'))

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

        YPredicted = classify(trainedNet,XValidation);
        valError = 1 - mean(YPredicted == YValidation);

Создайте имя файла, содержащее ошибку валидации, и сохраните сеть, ошибку валидации и опции обучения к диску. Целевая функция возвращает fileName как выходной аргумент и bayesopt возвращает все имена файлов в BayesObject.UserDataTrace. Дополнительный необходимый выходной аргумент cons задает ограничения среди переменных. Нет никаких переменных ограничений.

        fileName = num2str(valError) + ".mat";
        save(fileName,'trainedNet','valError','options')
        cons = [];
        
    end
end

convBlock функция создает блок numConvLayers сверточные слои, каждый с заданным filterSize и numFilters фильтры и каждый сопровождаемый слоем нормализации партии. и слоем ReLU.

function layers = convBlock(filterSize,numFilters,numConvLayers)
layers = [
    convolution2dLayer(filterSize,numFilters,'Padding','same')
    batchNormalizationLayer
    reluLayer];
layers = repmat(layers,numConvLayers,1);
end

Ссылки

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

Смотрите также

| |

Похожие темы

Документация Deep Learning Toolbox
Поддержка
Для просмотра документации необходимо авторизоваться на сайте