fitcensemble
Подходящий ансамбль учеников для классификации
Синтаксис
Описание
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 =
classreg.learning.classif.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
misclassification уровень в выборке для ансамбля, который использует все предикторы, ниже.
Ускорьте обучение раскладыванием числовые значения предиктора
Обучите ансамбль повышенных деревьев классификации при помощи 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
В этом примере значения предиктора раскладывания уменьшают учебное время без потери точности. В общем случае, когда у вас есть большой набор данных как тот в этом примере, использование опции раскладывания ускоряет обучение, но вызывает потенциальное уменьшение в точности. Если вы хотите уменьшать учебное время далее, задайте меньшее число интервалов.
Воспроизведите сгруппированные данные о предикторе при помощи 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 значениями является NaNs.
Оцените ошибку обобщения повышения ансамбля
Оцените ошибку обобщения ансамбля повышенных деревьев классификации.
Загрузите 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-кратное, misclassification уровень. Отобразите предполагаемую ошибку обобщения ансамбля.
kflc = kfoldLoss(Mdl,'Mode','cumulative'); figure; plot(kflc); ylabel('10-fold Misclassification rate'); xlabel('Learning cycle');
estGenError = kflc(end)
estGenError = 0.0712
kfoldLoss возвращает ошибку обобщения по умолчанию. Однако графический вывод совокупной потери позволяет вам контролировать, как потеря изменяется, когда слабые ученики накапливаются в ансамбле.
Ансамбль достигает misclassification уровня приблизительно 0,06 после накопления приблизительно 50 слабых учеников. Затем misclassification повышение ставки немного как более слабые ученики вводит ансамбль.
Если вы удовлетворены ошибкой обобщения ансамбля, то, чтобы создать прогнозную модель, обучают ансамбль, снова использующий все настройки кроме перекрестной проверки. Однако это - хорошая практика, чтобы настроить гиперпараметры, такие как максимальное количество разделений решения на дерево и количество изучения циклов.
Оптимизируйте ансамбль классификации
Оптимизируйте гиперпараметры автоматически с помощью 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.8347 | 0.10256 | 0.10256 | RUSBoost | 11 | 0.010199 | 17 |
| 2 | Best | 0.062678 | 7.9241 | 0.062678 | 0.064264 | LogitBoost | 206 | 0.96537 | 33 |
| 3 | Accept | 0.099715 | 6.9431 | 0.062678 | 0.062688 | AdaBoostM1 | 130 | 0.0072814 | 2 |
| 4 | Accept | 0.065527 | 1.2539 | 0.062678 | 0.062681 | Bag | 25 | - | 5 |
| 5 | Accept | 0.065527 | 6.6932 | 0.062678 | 0.062695 | LogitBoost | 178 | 0.52008 | 40 |
| 6 | Accept | 0.068376 | 5.6617 | 0.062678 | 0.062693 | GentleBoost | 146 | 0.46233 | 8 |
| 7 | Accept | 0.076923 | 16.873 | 0.062678 | 0.063613 | GentleBoost | 456 | 0.0018323 | 3 |
| 8 | Accept | 0.068376 | 17.823 | 0.062678 | 0.063878 | LogitBoost | 479 | 0.036176 | 7 |
| 9 | Accept | 0.068376 | 10.436 | 0.062678 | 0.065468 | LogitBoost | 277 | 0.99964 | 42 |
| 10 | Accept | 0.17379 | 0.49145 | 0.062678 | 0.064692 | LogitBoost | 11 | 0.0012008 | 1 |
| 11 | Accept | 0.065527 | 4.506 | 0.062678 | 0.064854 | Bag | 100 | - | 1 |
| 12 | Accept | 0.076923 | 0.92904 | 0.062678 | 0.062571 | GentleBoost | 23 | 0.0096328 | 2 |
| 13 | Accept | 0.082621 | 0.74291 | 0.062678 | 0.064919 | GentleBoost | 18 | 0.0078878 | 61 |
| 14 | Accept | 0.065527 | 21.655 | 0.062678 | 0.06557 | Bag | 499 | - | 7 |
| 15 | Accept | 0.079772 | 13.489 | 0.062678 | 0.064962 | GentleBoost | 359 | 0.080649 | 1 |
| 16 | Accept | 0.35897 | 0.44838 | 0.062678 | 0.062491 | Bag | 10 | - | 171 |
| 17 | Accept | 0.35897 | 0.68438 | 0.062678 | 0.062483 | AdaBoostM1 | 14 | 0.0029975 | 174 |
| 18 | Accept | 0.10826 | 26.872 | 0.062678 | 0.062484 | RUSBoost | 498 | 0.35355 | 1 |
| 19 | Accept | 0.64103 | 0.99918 | 0.062678 | 0.062469 | RUSBoost | 20 | 0.11564 | 175 |
| 20 | Accept | 0.091168 | 9.9199 | 0.062678 | 0.062474 | RUSBoost | 187 | 0.0010337 | 5 |
|===================================================================================================================================| | Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | Method | NumLearningC-| LearnRate | MinLeafSize | | | result | | runtime | (observed) | (estim.) | | ycles | | | |===================================================================================================================================| | 21 | Accept | 0.076923 | 12.002 | 0.062678 | 0.062473 | GentleBoost | 322 | 0.020651 | 174 |
| 22 | Accept | 0.068376 | 2.513 | 0.062678 | 0.062473 | AdaBoostM1 | 47 | 0.96063 | 1 |
| 23 | Accept | 0.17379 | 6.2411 | 0.062678 | 0.062357 | LogitBoost | 166 | 0.0011034 | 175 |
| 24 | Accept | 0.17379 | 0.45444 | 0.062678 | 0.062629 | LogitBoost | 10 | 0.0027609 | 15 |
| 25 | Accept | 0.062678 | 4.7119 | 0.062678 | 0.064312 | LogitBoost | 125 | 0.9709 | 4 |
| 26 | Accept | 0.065527 | 22.026 | 0.062678 | 0.062645 | Bag | 500 | - | 3 |
| 27 | Accept | 0.11396 | 12.641 | 0.062678 | 0.062648 | RUSBoost | 237 | 0.61788 | 5 |
| 28 | Accept | 0.079772 | 18.228 | 0.062678 | 0.064369 | GentleBoost | 494 | 0.96149 | 74 |
| 29 | Accept | 0.076923 | 17.529 | 0.062678 | 0.063871 | GentleBoost | 470 | 0.0014504 | 21 |
| 30 | Accept | 0.062678 | 18.438 | 0.062678 | 0.063378 | LogitBoost | 498 | 0.21952 | 3 |
__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 302.4207 seconds.
Total objective function evaluation time: 270.9631
Best observed feasible point:
Method NumLearningCycles LearnRate MinLeafSize
__________ _________________ _________ ___________
LogitBoost 206 0.96537 33
Observed objective function value = 0.062678
Estimated objective function value = 0.064468
Function evaluation time = 7.9241
Best estimated feasible point (according to models):
Method NumLearningCycles LearnRate MinLeafSize
__________ _________________ _________ ___________
LogitBoost 277 0.99964 42
Estimated objective function value = 0.063378
Estimated function evaluation time = 10.4954
Mdl =
classreg.learning.classif.ClassificationEnsemble
ResponseName: 'Y'
CategoricalPredictors: []
ClassNames: {'b' 'g'}
ScoreTransform: 'none'
NumObservations: 351
HyperparameterOptimizationResults: [1×1 BayesianOptimization]
NumTrained: 277
Method: 'LogitBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [277×1 double]
FitInfoDescription: {2×1 cell}
Properties, Methods
Оптимизация, искавшая по методам агрегации ансамбля бинарную классификацию, по NumLearningCycles, по LearnRate для применимых методов, и по древовидному ученику MinLeafSize. Выход является классификатором ансамбля с минимальной предполагаемой потерей перекрестной проверки.
Оптимизируйте ансамбль классификации Используя перекрестную проверку
Один способ создать ансамбль повышенных деревьев классификации, который имеет удовлетворительную прогнозирующую производительность, путем настройки уровня сложности дерева решений с помощью перекрестной проверки. При поиске оптимального уровня сложности настройте скорость обучения, чтобы минимизировать количество изучения циклов.
Этот пример вручную находит оптимальные параметры при помощи опции перекрестной проверки ('KFold' аргумент пары "имя-значение") и kfoldLoss функция. В качестве альтернативы можно использовать 'OptimizeHyperparameters' аргумент пары "имя-значение", чтобы оптимизировать гиперпараметры автоматически. Смотрите Оптимизируют Ансамбль Классификации.
Загрузите ionosphere набор данных.
load ionosphereИскать оптимальный уровень древовидной сложности:
Перекрестный подтвердите набор ансамблей. Экспоненциально увеличьте уровень древовидной сложности для последующих ансамблей от пня решения (одно разделение) к в большей части n - 1 разделение. n является объемом выборки. Кроме того, варьируйтесь скорость обучения для каждого ансамбля между 0,1 к 1.
Оцените перекрестный подтвержденный misclassification уровень каждого ансамбля.
Для уровня древовидной сложности , , сравните совокупный, перекрестный подтвержденный misclassification уровень ансамблей путем графического вывода их против количества изучения циклов. Постройте отдельные кривые для каждой скорости обучения на той же фигуре.
Выберите кривую, которая достигает минимального misclassification уровня, и отметьте соответствующий цикл изучения и скорость обучения.
Перекрестный подтвердите глубокое дерево классификации и пень. Эти деревья классификации служат сравнительными тестами.
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
Оцените совокупный, перекрестный подтвержденный misclassification уровень для каждого ансамбля и деревьев классификации, служащих сравнительными тестами.
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);
Постройте, как перекрестный подтвержденный misclassification уровень ведет себя как количество деревьев в увеличениях ансамбля. Постройте кривые относительно скорости обучения на том же графике и постройте отдельные графики для различных уровней древовидной сложности. Выберите подмножество древовидных уровней сложности, чтобы построить.
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;
Каждая кривая содержит минимум перекрестный подтвержденный misclassification уровень, происходящий в оптимальном количестве деревьев в ансамбле.
Идентифицируйте максимальное количество разделений, количество деревьев и скорость обучения, которая дает к самому низкому misclassification уровню в целом.
[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 =
classreg.learning.classif.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.5879 | 0.17379 | 0.17379 | 137 | 0.001364 | 3 |
| 2 | Accept | 0.17379 | 0.86125 | 0.17379 | 0.17379 | 15 | 0.013089 | 144 |
| 3 | Best | 0.065527 | 1.5839 | 0.065527 | 0.065538 | 31 | 0.47201 | 2 |
| 4 | Accept | 0.074074 | 16.044 | 0.065527 | 0.065549 | 340 | 0.92167 | 7 |
| 5 | Accept | 0.088319 | 1.1615 | 0.065527 | 0.065562 | 20 | 0.24336 | 55 |
| 6 | Accept | 0.076923 | 0.65064 | 0.065527 | 0.072693 | 11 | 0.64021 | 1 |
| 7 | Accept | 0.071225 | 0.58602 | 0.065527 | 0.072095 | 10 | 0.99816 | 5 |
| 8 | Accept | 0.076923 | 0.60015 | 0.065527 | 0.072986 | 10 | 0.75338 | 90 |
| 9 | Accept | 0.096866 | 0.59733 | 0.065527 | 0.06506 | 10 | 0.42369 | 2 |
| 10 | Best | 0.062678 | 1.8773 | 0.062678 | 0.062667 | 37 | 0.99202 | 63 |
| 11 | Accept | 0.065527 | 1.0259 | 0.062678 | 0.062575 | 19 | 0.97944 | 1 |
| 12 | Best | 0.059829 | 4.2008 | 0.059829 | 0.059766 | 86 | 0.40411 | 1 |
| 13 | Best | 0.05698 | 3.0948 | 0.05698 | 0.057382 | 63 | 0.60537 | 1 |
| 14 | Accept | 0.062678 | 3.2667 | 0.05698 | 0.059783 | 69 | 0.6167 | 4 |
| 15 | Accept | 0.065527 | 3.5624 | 0.05698 | 0.060842 | 76 | 0.49778 | 2 |
| 16 | Accept | 0.065527 | 2.1858 | 0.05698 | 0.061283 | 44 | 0.99938 | 4 |
| 17 | Accept | 0.065527 | 2.6444 | 0.05698 | 0.062047 | 55 | 0.59384 | 46 |
| 18 | Accept | 0.059829 | 6.0262 | 0.05698 | 0.061494 | 128 | 0.29635 | 48 |
| 19 | Accept | 0.062678 | 8.417 | 0.05698 | 0.061481 | 182 | 0.25896 | 9 |
| 20 | Accept | 0.062678 | 4.8812 | 0.05698 | 0.061248 | 107 | 0.38775 | 2 |
|====================================================================================================================|
| Iter | Eval | Objective | Objective | BestSoFar | BestSoFar | NumLearningC-| LearnRate | MaxNumSplits |
| | result | | runtime | (observed) | (estim.) | ycles | | |
|====================================================================================================================|
| 21 | Accept | 0.17379 | 0.53809 | 0.05698 | 0.0612 | 10 | 0.0010009 | 53 |
| 22 | Accept | 0.17379 | 0.56404 | 0.05698 | 0.061382 | 10 | 0.051241 | 2 |
| 23 | Best | 0.05698 | 4.1022 | 0.05698 | 0.060531 | 87 | 0.3124 | 1 |
| 24 | Accept | 0.05698 | 4.1749 | 0.05698 | 0.058776 | 85 | 0.259 | 5 |
| 25 | Accept | 0.065527 | 4.5086 | 0.05698 | 0.059405 | 93 | 0.20081 | 4 |
| 26 | Accept | 0.17379 | 0.53874 | 0.05698 | 0.059578 | 10 | 0.0035026 | 2 |
| 27 | Accept | 0.17379 | 1.4021 | 0.05698 | 0.059534 | 30 | 0.0036169 | 1 |
| 28 | Accept | 0.151 | 1.9551 | 0.05698 | 0.059446 | 41 | 0.028937 | 1 |
| 29 | Accept | 0.17379 | 1.4866 | 0.05698 | 0.059485 | 29 | 0.0010049 | 2 |
| 30 | Accept | 0.1453 | 0.55298 | 0.05698 | 0.059371 | 10 | 0.13172 | 3 |
__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 122.1601 seconds.
Total objective function evaluation time: 89.6783
Best observed feasible point:
NumLearningCycles LearnRate MaxNumSplits
_________________ _________ ____________
87 0.3124 1
Observed objective function value = 0.05698
Estimated objective function value = 0.059371
Function evaluation time = 4.1022
Best estimated feasible point (according to models):
NumLearningCycles LearnRate MaxNumSplits
_________________ _________ ____________
87 0.3124 1
Estimated objective function value = 0.059371
Estimated function evaluation time = 4.1152
mdl =
classreg.learning.classif.ClassificationEnsemble
ResponseName: 'Y'
CategoricalPredictors: []
ClassNames: {'b' 'g'}
ScoreTransform: 'none'
NumObservations: 351
HyperparameterOptimizationResults: [1×1 BayesianOptimization]
NumTrained: 87
Method: 'LogitBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [87×1 double]
FitInfoDescription: {2×1 cell}
Properties, Methods
Входные параметры
Выходные аргументы
Советы
NumLearningCyclesможет варьироваться от нескольких дюжин до нескольких тысяч. Обычно, ансамбль с хорошей предсказательной силой требует от нескольких сотен до нескольких тысяч слабых учеников. Однако вы не должны обучать ансамбль который много циклов целиком. Можно запустить путем роста нескольких дюжин учеников, смотреть производительность ансамбля и затем, при необходимости, обучить более слабых учеников, использующихresumeдля проблем классификации.Производительность ансамбля зависит от установки ансамбля и установки слабых учеников. Таким образом, если вы задаете слабых учеников параметрами по умолчанию, затем ансамбль может выполнить плохо. Поэтому как настройки ансамбля, это - хорошая практика, чтобы настроить параметры слабых шаблонов использования учеников и выбрать значения, которые минимизируют ошибку обобщения.
Если вы задаете, чтобы передискретизировать использование
Resample, затем это - хорошая практика, чтобы передискретизировать к целому набору данных. Таким образом, используйте настройку по умолчанию1дляFResample.Если метод агрегации ансамбля (
Method)'bag'и:Стоимость misclassification (
Cost) является очень неустойчивым, затем, для выборок в сумке, программное обеспечение сверхдискретизировало уникальные наблюдения от класса, который имеет большой штраф.Априорные вероятности класса (
Prior) высоко скашиваются, программное обеспечение сверхдискретизировало уникальные наблюдения от класса, который имеет большую априорную вероятность.
Для меньших объемов выборки эти комбинации могут привести к низкой относительной частоте наблюдений из сумки от класса, который имеет большой штраф или априорную вероятность. Следовательно, предполагаемая ошибка из сумки является очень переменной, и она может затруднить, чтобы интерпретировать. Чтобы избежать больших предполагаемых ошибочных отклонений из сумки, особенно для размеров небольшой выборки, устанавливают более сбалансированную матрицу стоимости misclassification использование
Costили менее скошенный вектор априорной вероятности использованиеPrior.Поскольку порядок некоторых аргументов ввода и вывода соответствует отличным классам в обучающих данных, это - хорошая практика, чтобы задать порядок класса с помощью
ClassNamesаргумент пары "имя-значение".Чтобы определить порядок класса быстро, удалите все наблюдения из обучающих данных, которые являются несекретными (то есть, имейте недостающую метку), получите и отобразите массив всех отличных классов, и затем задайте массив для
ClassNames. Например, предположите переменную отклика (Y) массив ячеек меток. Этот код задает порядок класса в переменнойclassNames.Ycat = categorical(Y); classNames = categories(Ycat)
categoricalприсвоения<undefined>к несекретным наблюдениям иcategoriesисключает<undefined>от его выхода. Поэтому, если вы используете этот код в массивах ячеек меток или подобный код для категориальных массивов, затем вы не должны удалять наблюдения с пропавшими без вести меток, чтобы получить список отличных классов.Чтобы указать что порядок класса от представленной самым низким образом метки до наиболее представленного, затем быстро определите порядок класса (как в предыдущем маркере), но расположите классы в списке частотой прежде, чем передать список
ClassNames. Следуя из предыдущего примера, этот код задает порядок класса от самого низкого - к наиболее представленному вclassNamesLH.Ycat = categorical(Y); classNames = categories(Ycat); freq = countcats(Ycat); [~,idx] = sort(freq); classNamesLH = classNames(idx);
После обучения модель можно сгенерировать код C/C++, который предсказывает метки для новых данных. Генерация кода C/C++ требует MATLAB Coder™. Для получения дополнительной информации смотрите Введение в Генерацию кода.
Алгоритмы
Для получения дополнительной информации алгоритмов агрегации ансамбля, см. Алгоритмы Ансамбля.
Если вы устанавливаете
Methodбыть повышающим алгоритмом иLearnersчтобы быть деревьями решений, затем программное обеспечение выращивает мелкие деревья решений по умолчанию. Можно настроить древовидную глубину путем определенияMaxNumSplits,MinLeafSize, иMinParentSizeаргументы пары "имя-значение" с помощьюtemplateTree.Для укладывания в мешки (
'Method','Bag'),fitcensembleгенерирует выборки в сумке путем сверхдискретизации классов с большими затратами misclassification и субдискретизации классов с маленькими затратами misclassification. Следовательно, выборки из сумки имеют меньше наблюдений от классов с большими затратами misclassification и больше наблюдений от классов с маленькими затратами misclassification. Если вы обучаете ансамбль классификации, использующий небольшой набор данных и очень скошенную матрицу стоимости, то количество наблюдений из сумки в классе может быть низким. Поэтому предполагаемая ошибка из сумки может иметь большое отклонение и может затруднить, чтобы интерпретировать. То же явление может произойти для классов с большими априорными вероятностями.Для метода агрегации ансамбля RUSBoost (
'Method','RUSBoost'), аргумент пары "имя-значение"RatioToSmallestзадает пропорцию выборки для каждого класса относительно представленного самым низким образом класса. Например, предположите, что существует два класса в обучающих данных: A и B. A имеет 100 наблюдений, и B имеет 10 наблюдений. Предположим также, что представленный самым низким образом класс имеетmнаблюдения в обучающих данных.Если вы устанавливаете
'RatioToSmallest',2, затемsM= 20. Следовательно,fitcensembleобучает каждого ученика, использующего 20 наблюдений от класса A и 20 наблюдений от класса B. Если вы устанавливаете'RatioToSmallest',[2 2], затем вы получаете тот же результат.Если вы устанавливаете
'RatioToSmallest',[2,1], затемs1M= 20иs2M= 10. Следовательно,fitcensembleобучает каждого ученика, использующего 20 наблюдений от класса A и 10 наблюдений от класса B.
Для двухъядерных систем и выше,
fitcensembleпараллелизирует обучение с помощью Intel® Threading Building Blocks (TBB). Для получения дополнительной информации на Intel TBB, см. https://software.intel.com/en-us/intel-tbb.
Ссылки
[1] Бреимен, L. “Укладывание в мешки Предикторов”. Машинное обучение. Издание 26, стр 123–140, 1996.
[2] Бреимен, L. “Случайные Леса”. Машинное обучение. Издание 45, стр 5–32, 2001.
[3] Freund, Y. “Более устойчивый повышающий алгоритм”. arXiv:0905.2138v1, 2009.
[4] Freund, Y. и Р. Э. Шапайр. “Теоретическое Решением Обобщение Дистанционного обучения и Приложения к Повышению”. J. Компьютерных и Системных Наук, Издания 55, стр 119–139, 1997.
[5] Фридман, J. “Жадное приближение функций: машина повышения градиента”. Летопись Статистики, Издания 29, № 5, стр 1189–1232, 2001.
[6] Фридман, J., Т. Хэсти и Р. Тибширэни. “Аддитивная логистическая регрессия: статистическое представление повышения”. Летопись Статистики, Издания 28, № 2, стр 337–407, 2000.
[7] Hastie, T., Р. Тибширэни и Дж. Фридман. Выпуск раздела Elements of Statistical Learning, Спрингер, Нью-Йорк, 2008.
[8] Хо, T. K. “Случайный метод подпространства для построения лесов решения”. Транзакции IEEE согласно Анализу Шаблона и Искусственному интеллекту, Изданию 20, № 8, стр 832–844, 1998.
[9] Schapire, R. E. И. Фреунд, П. Бартлетт и В.С. Ли. “Повышение поля: новое объяснение эффективности голосующих методов”. Летопись Статистики, Издания 26, № 5, стр 1651–1686, 1998.
[10] Seiffert, C., Т. Хошгофтаар, Дж. Хулс и А. Наполитано. “RUSBoost: Улучшание производительности классификации, когда обучающие данные скашивается”. 19-я Международная конференция по вопросам Распознавания образов, стр 1–4, 2008.
[11] Warmuth, M., Цз. Ляо и Г. Рэч. “Полностью корректирующие повышающие алгоритмы, которые максимизируют поле”. Proc. 23-й Int’l. Конференция по Машинному обучению, ACM, Нью-Йорк, стр 1001–1008, 2006.
Расширенные возможности
Смотрите также
ClassificationBaggedEnsemble | ClassificationEnsemble | ClassificationPartitionedEnsemble | predict | templateDiscriminant | templateKNN | templateTree