Подгонка ансамбля учащихся для классификации
Mdl = fitcensemble(Tbl,ResponseVarName)Mdl), который содержит результаты увеличения 100 деревьев классификации и данных предиктора и отклика в таблице Tbl. ResponseVarName - имя переменной отклика в Tbl. По умолчанию, fitcensemble использует LogitBoost для двоичной классификации и AdaBoostM2 для многоклассовой классификации.
Mdl = fitcensemble(Tbl,formula)formula для подгонки модели к предиктору и данным отклика в таблице Tbl. formula является объяснительной моделью отклика и подмножеством переменных предиктора в Tbl используется для подгонки Mdl. Для примера, 'Y~X1+X2+X3' соответствует переменной отклика Tbl.Y как функция от переменных предиктора Tbl.X1, Tbl.X2, и Tbl.X3.
Mdl = fitcensemble(___,Name,Value)Name,Value аргументы в виде пар и любой из входных параметров в предыдущих синтаксисах. Например, можно задать количество циклов обучения, метод агрегации ансамбля или реализовать 10-кратную перекрестную валидацию.
Создайте прогнозирующий классификационный ансамбль, используя все доступные переменные предиктора в данных. Затем обучите другой ансамбль, используя меньше предикторов. Сравните прогнозирующие точности в выборке ансамблей.
Загрузите census1994 набор данных.
load census1994Обучите ансамбль классификационных моделей с помощью всего набора данных и опций по умолчанию.
Mdl1 = fitcensemble(adultdata,'salary')Mdl1 =
ClassificationEnsemble
PredictorNames: {1x14 cell}
ResponseName: 'salary'
CategoricalPredictors: [2 4 6 7 8 9 10 14]
ClassNames: [<=50K >50K]
ScoreTransform: 'none'
NumObservations: 32561
NumTrained: 100
Method: 'LogitBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [100x1 double]
FitInfoDescription: {2x1 cell}
Properties, Methods
Mdl является ClassificationEnsemble модель. Некоторые заметные характеристики Mdl являются:
Поскольку в данных представлены два класса, LogitBoost является алгоритмом агрегации ансамблей.
Поскольку метод агрегации ансамбля является алгоритмом ускорения, классификационные деревья, которые допускают максимум 10 разделений, составляют ансамбль.
Сто деревьев составляют ансамбль.
Используйте классификационный ансамбль, чтобы предсказать метки случайного набора из пяти наблюдений из данных. Сравните предсказанные метки с их истинными значениями.
rng(1) % For reproducibility [pX,pIdx] = datasample(adultdata,5); label = predict(Mdl1,pX); table(label,adultdata.salary(pIdx),'VariableNames',{'Predicted','Truth'})
ans=5×2 table
Predicted Truth
_________ _____
<=50K <=50K
<=50K <=50K
<=50K <=50K
<=50K <=50K
<=50K <=50K
Обучите новый ансамбль с помощью age и education только.
Mdl2 = fitcensemble(adultdata,'salary ~ age + education');Сравните потери реституции между Mdl1 и Mdl2.
rsLoss1 = resubLoss(Mdl1)
rsLoss1 = 0.1058
rsLoss2 = resubLoss(Mdl2)
rsLoss2 = 0.2037
Скорость неправильной классификации в выборке для ансамбля, который использует все предикторы, ниже.
Обучите ансамбль ускоренных классификационных деревьев при помощи fitcensemble. Сократите время обучения путем определения 'NumBins' аргумент пары "имя-значение" для числовых предикторов интервала. Этот аргумент действителен только при fitcensemble использует ученика дерева. После обучения можно воспроизвести привязанные данные предиктора с помощью BinEdges свойство обученной модели и discretize функция.
Сгенерируйте выборочные данные набор.
rng('default') % For reproducibility N = 1e6; X = [mvnrnd([-1 -1],eye(2),N); mvnrnd([1 1],eye(2),N)]; y = [zeros(N,1); ones(N,1)];
Визуализируйте набор данных.
figure scatter(X(1:N,1),X(1:N,2),'Marker','.','MarkerEdgeAlpha',0.01) hold on scatter(X(N+1:2*N,1),X(N+1:2*N,2),'Marker','.','MarkerEdgeAlpha',0.01)
Обучите ансамбль ускоренных классификационных деревьев с помощью адаптивной логистической регрессии (LogitBoost, по умолчанию для двоичной классификации). Определите время для функции в целях сравнения.
tic Mdl1 = fitcensemble(X,y); toc
Elapsed time is 478.988422 seconds.
Ускорите обучение при помощи 'NumBins' аргумент пары "имя-значение". Если вы задаете 'NumBins' значение как положительный целочисленный скаляр, затем программное обеспечение помещает каждый числовой предиктор в заданное количество уравнительных интервалов, а затем выращивает деревья индексов интервала вместо исходных данных. Программное обеспечение не встраивает категориальные предикторы.
tic
Mdl2 = fitcensemble(X,y,'NumBins',50);
tocElapsed time is 165.598434 seconds.
Процесс примерно в три раза быстрее, когда вы используете привязанные данные вместо исходных данных. Обратите внимание, что прошедшее время может варьироваться в зависимости от вашей операционной системы.
Сравните классификационные ошибки по реподституции.
rsLoss1 = resubLoss(Mdl1)
rsLoss1 = 0.0788
rsLoss2 = resubLoss(Mdl2)
rsLoss2 = 0.0788
В этом примере значения предиктора раскладывания сокращают время обучения без потери точности. В целом, когда у вас есть большой набор данных, такой как в этом примере, использование опции binning ускоряет обучение, но вызывает потенциальное снижение точности. Если необходимо дополнительно сократить время обучения, укажите меньшее количество интервалов.
Воспроизведите привязанные данные предиктора при помощи BinEdges свойство обученной модели и discretize функция.
X = Mdl2.X; % Predictor data Xbinned = zeros(size(X)); edges = Mdl2.BinEdges; % Find indices of binned predictors. idxNumeric = find(~cellfun(@isempty,edges)); if iscolumn(idxNumeric) idxNumeric = idxNumeric'; end for j = idxNumeric x = X(:,j); % Convert x to array if x is a table. if istable(x) x = table2array(x); end % Group x into bins by using the discretize function. xbinned = discretize(x,[-inf; edges{j}; inf]); Xbinned(:,j) = xbinned; end
Xbinned содержит индексы интервала в диапазоне от 1 до количества интервалов для числовых предикторов. Xbinned значения 0 для категориальных предикторов. Если X содержит NaNs, затем соответствующее Xbinned значения NaNс.
Оцените ошибку обобщения ансамбля ускоренных классификационных деревьев.
Загрузите ionosphere набор данных.
load ionosphereПерекрестная валидация ансамбля деревьев классификации с помощью AdaBoostM1 и 10-кратной перекрестной валидации. Укажите, что каждое дерево должно быть разделено максимум пять раз с помощью шаблона дерева принятия решений.
rng(5); % For reproducibility t = templateTree('MaxNumSplits',5); Mdl = fitcensemble(X,Y,'Method','AdaBoostM1','Learners',t,'CrossVal','on');
Mdl является ClassificationPartitionedEnsemble модель.
Постройте график кумулятивной, 10-кратной перекрестной проверки, скорости неправильной классификации. Отображение предполагаемой ошибки обобщения ансамбля.
kflc = kfoldLoss(Mdl,'Mode','cumulative'); figure; plot(kflc); ylabel('10-fold Misclassification rate'); xlabel('Learning cycle');
estGenError = kflc(end)
estGenError = 0.0769
kfoldLoss возвращает ошибку обобщения по умолчанию. Однако построение графика совокупных потерь позволяет вам контролировать, как изменяется потеря по мере накопления слабых учащихся в ансамбле.
Ансамбль достигает скорости неправильной классификации около 0,06 после накопления около 50 слабых учащихся. Затем коэффициент неправильной классификации немного увеличивается, когда в ансамбль поступает больше слабых учащихся.
Если вас устраивает ошибка обобщения ансамбля, то, чтобы создать прогнозирующую модель, обучите ансамбль снова, используя все настройки, кроме перекрестной валидации. Однако рекомендуется настраивать гиперпараметры, такие как максимальное количество разделений решений на дерево и количество циклов обучения.
Оптимизируйте гиперпараметры автоматически с помощью fitcensemble.
Загрузите ionosphere набор данных.
load ionosphereВы можете найти гиперпараметры, которые минимизируют пятикратные потери перекрестной валидации с помощью автоматической оптимизации гипероптимизации параметров управления.
Mdl = fitcensemble(X,Y,'OptimizeHyperparameters','auto')
В этом примере для воспроизводимости установите случайный seed и используйте 'expected-improvement-plus' функция сбора. Кроме того, для воспроизводимости алгоритма случайного леса задайте 'Reproducible' аргумент пары "имя-значение" как true для учащихся дерева.
rng('default') t = templateTree('Reproducible',true); Mdl = fitcensemble(X,Y,'OptimizeHyperparameters','auto','Learners',t, ... 'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName','expected-improvement-plus'))
|===================================================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | Method | NumLearningC-| LearnRate | MinLeafSize | | | result | | runtime | (observed) | (estim.) | | ycles | | | |===================================================================================================================================| | 1 | Best | 0.10256 | 1.6978 | 0.10256 | 0.10256 | RUSBoost | 11 | 0.010199 | 17 |
| 2 | Best | 0.062678 | 9.4354 | 0.062678 | 0.064264 | LogitBoost | 206 | 0.96537 | 33 |
| 3 | Accept | 0.099715 | 7.614 | 0.062678 | 0.062688 | AdaBoostM1 | 130 | 0.0072814 | 2 |
| 4 | Accept | 0.068376 | 1.6045 | 0.062678 | 0.062681 | Bag | 25 | - | 5 |
| 5 | Accept | 0.065527 | 20.359 | 0.062678 | 0.062699 | LogitBoost | 447 | 0.5405 | 13 |
| 6 | Accept | 0.074074 | 7.1054 | 0.062678 | 0.0627 | GentleBoost | 157 | 0.60495 | 108 |
| 7 | Accept | 0.082621 | 0.9688 | 0.062678 | 0.064102 | GentleBoost | 19 | 0.0010515 | 42 |
| 8 | Accept | 0.17379 | 0.49564 | 0.062678 | 0.06268 | LogitBoost | 10 | 0.001079 | 149 |
| 9 | Accept | 0.076923 | 21.003 | 0.062678 | 0.062676 | GentleBoost | 468 | 0.035181 | 2 |
| 10 | Accept | 0.068376 | 13.575 | 0.062678 | 0.062676 | AdaBoostM1 | 221 | 0.99976 | 7 |
| 11 | Accept | 0.10541 | 3.6394 | 0.062678 | 0.062676 | RUSBoost | 59 | 0.99629 | 31 |
| 12 | Accept | 0.068376 | 3.3423 | 0.062678 | 0.062674 | AdaBoostM1 | 53 | 0.20568 | 26 |
| 13 | Accept | 0.096866 | 1.6005 | 0.062678 | 0.062672 | RUSBoost | 22 | 0.0010042 | 2 |
| 14 | Accept | 0.071225 | 1.201 | 0.062678 | 0.062688 | LogitBoost | 23 | 0.99624 | 1 |
| 15 | Accept | 0.082621 | 0.87944 | 0.062678 | 0.062687 | AdaBoostM1 | 11 | 0.95241 | 2 |
| 16 | Accept | 0.079772 | 29.788 | 0.062678 | 0.062679 | AdaBoostM1 | 486 | 0.23903 | 35 |
| 17 | Accept | 0.35897 | 23.651 | 0.062678 | 0.06267 | Bag | 499 | - | 169 |
| 18 | Accept | 0.074074 | 0.653 | 0.062678 | 0.062674 | Bag | 10 | - | 1 |
| 19 | Accept | 0.088319 | 32.811 | 0.062678 | 0.062674 | RUSBoost | 498 | 0.0010437 | 3 |
| 20 | Accept | 0.068376 | 6.1279 | 0.062678 | 0.062673 | GentleBoost | 130 | 0.0010021 | 3 |
|===================================================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | Method | NumLearningC-| LearnRate | MinLeafSize | | | result | | runtime | (observed) | (estim.) | | ycles | | | |===================================================================================================================================| | 21 | Accept | 0.17379 | 22.601 | 0.062678 | 0.06271 | LogitBoost | 496 | 0.0010096 | 146 |
| 22 | Accept | 0.071225 | 2.9727 | 0.062678 | 0.062713 | GentleBoost | 71 | 0.91141 | 9 |
| 23 | Accept | 0.64103 | 1.1288 | 0.062678 | 0.062706 | RUSBoost | 20 | 0.0012846 | 173 |
| 24 | Accept | 0.11111 | 1.537 | 0.062678 | 0.062697 | RUSBoost | 24 | 0.96694 | 6 |
| 25 | Accept | 0.17379 | 5.5632 | 0.062678 | 0.062686 | LogitBoost | 136 | 0.001 | 3 |
| 26 | Accept | 0.35897 | 8.0556 | 0.062678 | 0.062686 | AdaBoostM1 | 156 | 0.003243 | 174 |
| 27 | Accept | 0.065527 | 1.0791 | 0.062678 | 0.062686 | Bag | 21 | - | 2 |
| 28 | Accept | 0.17379 | 1.7562 | 0.062678 | 0.062689 | LogitBoost | 42 | 0.0010283 | 21 |
| 29 | Accept | 0.074074 | 4.3825 | 0.062678 | 0.062689 | GentleBoost | 108 | 0.0010055 | 173 |
| 30 | Accept | 0.065527 | 1.4893 | 0.062678 | 0.062689 | LogitBoost | 32 | 0.97832 | 4 |
__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 278.5509 seconds.
Total objective function evaluation time: 238.1176
Best observed feasible point:
Method NumLearningCycles LearnRate MinLeafSize
__________ _________________ _________ ___________
LogitBoost 206 0.96537 33
Observed objective function value = 0.062678
Estimated objective function value = 0.062689
Function evaluation time = 9.4354
Best estimated feasible point (according to models):
Method NumLearningCycles LearnRate MinLeafSize
__________ _________________ _________ ___________
LogitBoost 206 0.96537 33
Estimated objective function value = 0.062689
Estimated function evaluation time = 9.4324
Mdl =
ClassificationEnsemble
ResponseName: 'Y'
CategoricalPredictors: []
ClassNames: {'b' 'g'}
ScoreTransform: 'none'
NumObservations: 351
HyperparameterOptimizationResults: [1×1 BayesianOptimization]
NumTrained: 206
Method: 'LogitBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [206×1 double]
FitInfoDescription: {2×1 cell}
Properties, Methods
Оптимизация искала методы агрегации ансамбля для двоичной классификации по NumLearningCycles, по LearnRate для применимых методов и над учеником дерева MinLeafSize. Выходные выходы - классификатор ансамбля с минимальными расчетными потерями перекрестной валидации.
Один из способов создать ансамбль усиленных деревьев классификации, который имеет удовлетворительную прогнозирующую эффективность, заключается в настройке уровня сложности дерева принятия решений с помощью перекрестной валидации. Во время поиска оптимального уровня сложности настройте скорость обучения, чтобы минимизировать количество циклов обучения.
Этот пример вручную находит оптимальные параметры при помощи опции перекрестной валидации ('KFold' аргумент пары "имя-значение") и kfoldLoss функция. Также можно использовать 'OptimizeHyperparameters' аргумент пары "имя-значение" для автоматической оптимизации гиперпараметров. См. «Оптимизация классификационного ансамбля».
Загрузите ionosphere набор данных.
load ionosphereДля поиска оптимального уровня сложности дерева:
Перекрестная проверка набора ансамблей. Экспоненциально повышает уровень сложности дерева для последующих ансамблей от пня принятия решений (один сплит) до не более n - 1 расщеплений. n - размер выборки. Кроме того, варьируйте скорость обучения для каждого ансамбля между 0,1 и 1.
Оцените перекрестно подтвержденную скорость неправильной классификации каждого ансамбля.
Для уровня сложности дерева , , сравните совокупную, перекрестно проверенную скорость неправильной классификации ансамблей путем построения их с количеством циклов обучения. Постройте график отдельных кривых для каждой скорости обучения на одном рисунке.
Выберите кривую, которая достигает минимальной скорости неправильной классификации, и отметьте соответствующий цикл обучения и скорость обучения.
Перекрестная проверка глубокого дерева классификации и пня. Эти классификационные деревья служат ориентирами.
rng(1) % For reproducibility MdlDeep = fitctree(X,Y,'CrossVal','on','MergeLeaves','off', ... 'MinParentSize',1); MdlStump = fitctree(X,Y,'MaxNumSplits',1,'CrossVal','on');
Перекрестная валидация ансамбля из 150 ускоренных классификационных деревьев с помощью 5-кратной перекрестной валидации. Используя шаблон дерева, варьируйте максимальное количество разделений, используя значения в последовательности . m таково, что не больше n-1. Для каждого варианта настройте скорость обучения, используя каждое значение в наборе {0,1, 0,25, 0,5, 1};
n = size(X,1); m = floor(log(n - 1)/log(3)); learnRate = [0.1 0.25 0.5 1]; numLR = numel(learnRate); maxNumSplits = 3.^(0:m); numMNS = numel(maxNumSplits); numTrees = 150; Mdl = cell(numMNS,numLR); for k = 1:numLR for j = 1:numMNS t = templateTree('MaxNumSplits',maxNumSplits(j)); Mdl{j,k} = fitcensemble(X,Y,'NumLearningCycles',numTrees,... 'Learners',t,'KFold',5,'LearnRate',learnRate(k)); end end
Оцените совокупный, перекрестно подтвержденный уровень неправильной классификации для каждого ансамбля и деревьев классификации, служащих в качестве контрольных показателей.
kflAll = @(x)kfoldLoss(x,'Mode','cumulative'); errorCell = cellfun(kflAll,Mdl,'Uniform',false); error = reshape(cell2mat(errorCell),[numTrees numel(maxNumSplits) numel(learnRate)]); errorDeep = kfoldLoss(MdlDeep); errorStump = kfoldLoss(MdlStump);
Постройте график поведения перекрестно проверенной скорости неправильной классификации, когда количество деревьев в ансамбле увеличивается. Постройте график кривых относительно скорости обучения на том же графике и постройте отдельные графики для изменения уровней сложности дерева. Выберите подмножество уровней сложности дерева для построения графика.
mnsPlot = [1 round(numel(maxNumSplits)/2) numel(maxNumSplits)]; figure for k = 1:3 subplot(2,2,k) plot(squeeze(error(:,mnsPlot(k),:)),'LineWidth',2) axis tight hold on h = gca; plot(h.XLim,[errorDeep errorDeep],'-.b','LineWidth',2) plot(h.XLim,[errorStump errorStump],'-.r','LineWidth',2) plot(h.XLim,min(min(error(:,mnsPlot(k),:))).*[1 1],'--k') h.YLim = [0 0.2]; xlabel('Number of trees') ylabel('Cross-validated misclass. rate') title(sprintf('MaxNumSplits = %0.3g', maxNumSplits(mnsPlot(k)))) hold off end hL = legend([cellstr(num2str(learnRate','Learning Rate = %0.2f')); ... 'Deep Tree';'Stump';'Min. misclass. rate']); hL.Position(1) = 0.6;
Каждая кривая содержит минимальную перекрестно подтвержденную скорость неправильной классификации, происходящей при оптимальном количестве деревьев в ансамбле.
Идентифицируйте максимальное количество разделений, количество деревьев и скорость обучения, которые дают самый низкий уровень неправильной классификации в целом.
[minErr,minErrIdxLin] = min(error(:));
[idxNumTrees,idxMNS,idxLR] = ind2sub(size(error),minErrIdxLin);
fprintf('\nMin. misclass. rate = %0.5f',minErr)Min. misclass. rate = 0.05413
fprintf('\nOptimal Parameter Values:\nNum. Trees = %d',idxNumTrees);Optimal Parameter Values: Num. Trees = 47
fprintf('\nMaxNumSplits = %d\nLearning Rate = %0.2f\n',... maxNumSplits(idxMNS),learnRate(idxLR))
MaxNumSplits = 3 Learning Rate = 0.25
Создайте прогнозирующий ансамбль на основе оптимальных гиперпараметров и всего набора обучающих данных.
tFinal = templateTree('MaxNumSplits',maxNumSplits(idxMNS)); MdlFinal = fitcensemble(X,Y,'NumLearningCycles',idxNumTrees,... 'Learners',tFinal,'LearnRate',learnRate(idxLR))
MdlFinal =
ClassificationEnsemble
ResponseName: 'Y'
CategoricalPredictors: []
ClassNames: {'b' 'g'}
ScoreTransform: 'none'
NumObservations: 351
NumTrained: 47
Method: 'LogitBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [47×1 double]
FitInfoDescription: {2×1 cell}
Properties, Methods
MdlFinal является ClassificationEnsemble. Чтобы предсказать, является ли радарный возврат хорошим по данным предиктора, можно передать данные предиктора и MdlFinal на predict.
Вместо поиска оптимальных значений вручную с помощью опции перекрестной валидации ('KFold') и kfoldLoss функция, вы можете использовать 'OptimizeHyperparameters' аргумент пары "имя-значение". Когда вы задаете 'OptimizeHyperparameters', программное обеспечение автоматически находит оптимальные параметры, используя байесовскую оптимизацию. Оптимальные значения, полученные при помощи 'OptimizeHyperparameters' могут отличаться от полученных с помощью ручного поиска.
mdl = fitcensemble(X,Y,'OptimizeHyperparameters',{'NumLearningCycles','LearnRate','MaxNumSplits'})
|====================================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | NumLearningC-| LearnRate | MaxNumSplits | | | result | | runtime | (observed) | (estim.) | ycles | | | |====================================================================================================================| | 1 | Best | 0.17379 | 6.2592 | 0.17379 | 0.17379 | 137 | 0.001364 | 3 |
| 2 | Accept | 0.17379 | 0.79961 | 0.17379 | 0.17379 | 15 | 0.013089 | 144 |
| 3 | Best | 0.065527 | 1.4585 | 0.065527 | 0.065538 | 31 | 0.47201 | 2 |
| 4 | Accept | 0.074074 | 13.988 | 0.065527 | 0.065549 | 340 | 0.92167 | 7 |
| 5 | Accept | 0.088319 | 0.92718 | 0.065527 | 0.072102 | 22 | 0.2432 | 1 |
| 6 | Accept | 0.074074 | 0.44748 | 0.065527 | 0.071237 | 10 | 0.7177 | 48 |
| 7 | Accept | 0.08547 | 0.52207 | 0.065527 | 0.074847 | 10 | 0.57238 | 2 |
| 8 | Accept | 0.074074 | 0.59154 | 0.065527 | 0.065556 | 11 | 0.97207 | 3 |
| 9 | Best | 0.059829 | 1.6809 | 0.059829 | 0.059648 | 42 | 0.92135 | 343 |
| 10 | Best | 0.054131 | 2.2481 | 0.054131 | 0.054148 | 49 | 0.97807 | 37 |
| 11 | Accept | 0.065527 | 2.1686 | 0.054131 | 0.059479 | 48 | 0.9996 | 2 |
| 12 | Accept | 0.068376 | 2.5909 | 0.054131 | 0.061923 | 58 | 0.91401 | 323 |
| 13 | Accept | 0.17379 | 0.48621 | 0.054131 | 0.062113 | 10 | 0.0010045 | 4 |
| 14 | Accept | 0.17379 | 0.55949 | 0.054131 | 0.059231 | 10 | 0.059072 | 148 |
| 15 | Accept | 0.065527 | 1.9568 | 0.054131 | 0.062559 | 46 | 0.76657 | 19 |
| 16 | Accept | 0.065527 | 2.5692 | 0.054131 | 0.062807 | 57 | 0.64443 | 311 |
| 17 | Accept | 0.17379 | 0.55723 | 0.054131 | 0.062748 | 10 | 0.0035012 | 2 |
| 18 | Accept | 0.12821 | 1.9669 | 0.054131 | 0.062043 | 47 | 0.055757 | 197 |
| 19 | Accept | 0.05698 | 1.2814 | 0.054131 | 0.060837 | 27 | 0.98997 | 12 |
| 20 | Accept | 0.059829 | 1.1975 | 0.054131 | 0.060881 | 26 | 0.99112 | 13 |
|====================================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | NumLearningC-| LearnRate | MaxNumSplits | | | result | | runtime | (observed) | (estim.) | ycles | | | |====================================================================================================================| | 21 | Accept | 0.065527 | 1.2255 | 0.054131 | 0.061441 | 25 | 0.99183 | 9 |
| 22 | Accept | 0.17379 | 1.3748 | 0.054131 | 0.061461 | 29 | 0.0032434 | 344 |
| 23 | Accept | 0.068376 | 3.055 | 0.054131 | 0.061768 | 67 | 0.18672 | 11 |
| 24 | Accept | 0.059829 | 5.0035 | 0.054131 | 0.061785 | 119 | 0.3125 | 1 |
| 25 | Accept | 0.059829 | 7.6141 | 0.054131 | 0.061793 | 176 | 0.25401 | 304 |
| 26 | Accept | 0.059829 | 5.1133 | 0.054131 | 0.05988 | 115 | 0.34331 | 343 |
| 27 | Accept | 0.059829 | 7.4027 | 0.054131 | 0.059895 | 178 | 0.26684 | 13 |
| 28 | Accept | 0.059829 | 5.2506 | 0.054131 | 0.059872 | 118 | 0.32365 | 3 |
| 29 | Accept | 0.062678 | 10.523 | 0.054131 | 0.059871 | 238 | 0.22465 | 1 |
| 30 | Accept | 0.14815 | 0.57384 | 0.054131 | 0.059705 | 10 | 0.15205 | 2 |
__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 122.7983 seconds.
Total objective function evaluation time: 91.3933
Best observed feasible point:
NumLearningCycles LearnRate MaxNumSplits
_________________ _________ ____________
49 0.97807 37
Observed objective function value = 0.054131
Estimated objective function value = 0.062545
Function evaluation time = 2.2481
Best estimated feasible point (according to models):
NumLearningCycles LearnRate MaxNumSplits
_________________ _________ ____________
119 0.3125 1
Estimated objective function value = 0.059705
Estimated function evaluation time = 5.1842
mdl =
ClassificationEnsemble
ResponseName: 'Y'
CategoricalPredictors: []
ClassNames: {'b' 'g'}
ScoreTransform: 'none'
NumObservations: 351
HyperparameterOptimizationResults: [1×1 BayesianOptimization]
NumTrained: 119
Method: 'LogitBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [119×1 double]
FitInfoDescription: {2×1 cell}
Properties, Methods
NumLearningCycles может варьироваться от нескольких десятков до нескольких тысяч. Обычно ансамбль с хорошей прогностической степенью требует от нескольких сотен до нескольких тысяч слабых учащихся. Однако вам не придется обучать ансамбль для того, чтобы было сразу много циклов. Можно начать с того, что вырастить несколько десятков учащихся, осмотреть эффективность ансамбля и затем, при необходимости, обучить более слабых учащихся, используя resume для задач классификации.
Эффективность ансамбля зависит от обстановки ансамбля и настройки слабых учащихся. То есть, если вы задаете слабых учащихся с параметрами по умолчанию, то ансамбль может выступить плохо. Поэтому, как и настройки ансамбля, рекомендуется настроить параметры слабых учащихся с помощью шаблонов и выбрать значения, которые минимизируют ошибку обобщения.
Если вы задаете, чтобы выполнить повторную выборку с помощью Resample, тогда это хорошая практика, чтобы переопределить на целом наборе данных. То есть используйте настройку по умолчанию 1 для FResample.
Если метод агрегации ансамбля (Method) 'bag' и:
Стоимость неправильной классификации (Cost) является сильно несбалансированным, тогда для выборок в мешке, программное обеспечение переизбирает уникальные наблюдения от класса, который имеет большой штраф.
Предшествующие вероятности класса (Prior) сильно искажены, программное обеспечение переизбирает уникальные наблюдения из класса, который имеет большую предшествующую вероятность.
Для меньших размеров выборки эти комбинации могут привести к низкой относительной частоте наблюдений вне мешка от класса, который имеет большую штраф или предшествующую вероятность. Следовательно, оцененная ошибка вне сумки является сильно переменной, и ее может быть трудно интерпретировать. Чтобы избежать больших предполагаемых отклонений ошибок вне сумки, особенно для небольших размеров выборки, установите более сбалансированную матрицу затрат на неправильную классификацию с помощью Cost или менее искаженный предыдущий вектор вероятностей с использованием Prior.
Поскольку порядок некоторых входных и выходных аргументов соответствует отдельным классам в обучающих данных, рекомендуется задать порядок классов, используя ClassNames аргумент пары "имя-значение".
Чтобы быстро определить порядок классов, удалите из обучающих данных все наблюдения, которые не классифицированы (то есть имеют отсутствующую метку), получите и отобразите массив всех различных классов, а затем укажите массив для ClassNames. Для примера предположим, что переменная отклика (Y) - массив ячеек с метками. Этот код задает порядок классов в переменной classNames.
Ycat = categorical(Y); classNames = categories(Ycat)
categorical присваивает <undefined> к неклассифицированным наблюдениям и categories исключает <undefined> с его выхода. Поэтому, если вы используете этот код для массивов ячеек меток или аналогичный код для категориальных массивов, то вы не должны удалять наблюдения с отсутствующими метками, чтобы получить список различных классов.Чтобы указать, что порядок классов от самой низкой представленной метки до наиболее представленной, затем быстро определите порядок классов (как в предыдущей пуле), но расположите классы в списке по частоте перед передачей списка в ClassNames. Следующий из предыдущего примера, этот код задает порядок классов от lowest- до наиболее представленных в classNamesLH.
Ycat = categorical(Y); classNames = categories(Ycat); freq = countcats(Ycat); [~,idx] = sort(freq); classNamesLH = classNames(idx);
После обучения модели можно сгенерировать код C/C + +, который предсказывает метки для новых данных. Для генерации кода C/C + + требуется MATLAB Coder™. Для получения дополнительной информации смотрите Введение в генерацию кода .
Для получения дополнительной информации об алгоритмах агрегации ансамблей смотрите Ensemble Algorithms.
Если вы задаете Method быть алгоритмом и Learners ускорения чтобы быть деревьями решений, программное обеспечение по умолчанию растёт неглубокими деревьями решений. Можно настроить глубину дерева, задав MaxNumSplits, MinLeafSize, и MinParentSize Аргументы пары "имя-значение" с использованием templateTree.
Для упаковки в мешки ('Method','Bag'), fitcensemble генерирует выборки в мешке путем избыточной дискретизации классов с большими расходами на неправильную классификацию и классов недостаточной дискретизации с небольшими расходами на неправильную классификацию. Следовательно, выборки вне мешка имеют меньше наблюдений от классов с большими расходами на неправильную классификацию и больше наблюдений от классов с небольшими затратами на неправильную классификацию. Если вы обучаете классификационный ансамбль с помощью небольшого набора данных и сильно искаженной матрицы затрат, то количество наблюдений вне мешка на класс может быть низким. Поэтому предполагаемая ошибка вне сумки может иметь большое отклонение и может быть трудной для интерпретации. То же явление может произойти и для классов с большими априорными вероятностями.
Для метода агрегации ансамбля RUSBoost ('Method','RUSBoost'), аргумент пары "имя-значение" RatioToSmallest задает пропорцию дискретизации для каждого класса относительно самого низкопредставленного класса. Например, предположим, что в обучающих данных два класса: A и B. A имеет 100 наблюдений и B имеет 10 наблюдений. Предположим также, что самый низкий представленный класс имеет m наблюдения в обучающих данных.
Если вы задаете 'RatioToSmallest',2, затем s* m2*10 = 20. Следовательно, fitcensemble обучает каждого ученика, используя 20 наблюдений из A класса и 20 наблюдений из B класса. Если вы задаете 'RatioToSmallest',[2 2], затем вы получаете тот же результат.
Если вы задаете 'RatioToSmallest',[2,1], затем s1* m2*10 = 20 и s2* m1*10 = 10. Следовательно, fitcensemble обучает каждого ученика, используя 20 наблюдений из класса A и 10 наблюдений из класса B.
Для двухъядерных систем и выше, fitcensemble параллелизирует обучение с использованием Intel Threading Building Blocks (TBB). Для получения дополнительной информации о Intel TBB смотрите https://software.intel.com/en-us/intel-tbb.
[1] Breiman, L. «Bagging Predictors». Машинное обучение. Том 26, стр. 123-140, 1996.
[2] Breiman, L. «Random Forests». Машинное обучение. Том 45, стр. 5-32, 2001.
[3] Freund, Y. «Более надежный алгоритм усиления». arXiv:0905.2138v1, 2009.
[4] Freund, Y. and R. E. Schapire. Теоретически решающее обобщение онлайн-обучения и приложение к бустингу. J. Computer and System Sciences, Vol. 55, pp. 119-139, 1997.
[5] Фридман, Дж. «Жадное приближение функций: градиентная бустерная машина». Анналы статистики, том 29, № 5, стр. 1189 - 1232, 2001.
[6] Фридман, Дж., Т. Хасти и Р. Тибширани. «Аддитивная логистическая регрессия: статистический взгляд на увеличение». Анналы статистики, том 28, № 2, стр. 337 - 407, 2000.
[7] Хасти, Т., Р. Тибширани и Дж. Фридман. Раздел «Элементы статистического обучения», Спрингер, Нью-Йорк, 2008 год.
[8] Ho, T. K. «Метод случайного подпространства для построения лесов для принятия решений». Транзакции IEEE по анализу шаблонов и машинной разведке, том 20, № 8, стр. 832-844, 1998.
[9] Schapire, R. E., Y. Freund, P. Bartlett, and W.S. Lee. «Увеличение разницы: новое объяснение эффективности методов голосования». Анналы статистики, том 26, № 5, стр. 1651 - 1686, 1998.
[10] Seiffert, C., T. Khoshgoftaar, J. Hulse, and A. Napolitano. «RUSBoost: повышение эффективности классификации при искажении обучающих данных». 19-я Международная конференция по распознаванию шаблона, стр. 1-4, 2008.
[11] Warmuth, M., J. Liao, and G. Ratsch. «Полностью корректирующие алгоритмы повышения, которые максимизируют запас». Proc. 23-й Int 'l. Конф. по машинному обучению, ACM, Нью-Йорк, стр. 1001-1008, 2006.
ClassificationBaggedEnsemble | ClassificationEnsemble | ClassificationPartitionedEnsemble | predict | templateDiscriminant | templateKNN | templateTree