Подбор ансамбля обучающихся для классификации
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' аргумент пары имя-значение для числовых предикторов bin. Этот аргумент допустим только в том случае, если 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 значения 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-кратной перекрестной проверки ошибочной классификации. Отображение расчетной ошибки обобщения ансамбля.
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')
В этом примере для воспроизводимости задайте случайное начальное число и используйте '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.
Оцените степень ошибочной классификации каждого ансамбля.
Для уровня сложности дерева , . J сравните кумулятивный, перекрестно проверенный коэффициент неправильной классификации ансамблей, построив их график с количеством циклов обучения. Постройте отдельные кривые для каждой скорости обучения на одном и том же рисунке.
Выберите кривую, которая достигает минимального коэффициента неправильной классификации, и запишите соответствующий цикл обучения и коэффициент обучения.
Выполните перекрестную проверку глубокого дерева классификации и культи. Эти деревья классификации служат ориентирами.
rng(1) % For reproducibility MdlDeep = fitctree(X,Y,'CrossVal','on','MergeLeaves','off', ... 'MinParentSize',1); MdlStump = fitctree(X,Y,'MaxNumSplits',1,'CrossVal','on');
Перекрестная проверка ансамбля 150 усиленных деревьев классификации с использованием пятикратной перекрестной проверки. Используя шаблон дерева, измените максимальное количество разбиений, используя значения в последовательности m}. m является таким, 3m не превышает 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. Следуя предыдущему примеру, этот код определяет порядок классов от нижнего до наиболее представленного в classNamesLH.
Ycat = categorical(Y); classNames = categories(Ycat); freq = countcats(Ycat); [~,idx] = sort(freq); classNamesLH = classNames(idx);
После обучения модели можно создать код C/C + +, который предсказывает метки для новых данных. Для создания кода C/C + + требуется Coder™ MATLAB. Дополнительные сведения см. в разделе Введение в создание кода .
Подробные сведения о алгоритмах агрегации ансамбля см. в разделе Алгоритмы ансамбля.
Если установить 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 наблюдений из класса А и 10 наблюдений из класса В.
Для двухъядерных систем и выше, fitcensemble параллелизует обучение с использованием Intel Threading Building Blocks (TBB). Подробные сведения о TBB Intel см. в разделе https://software.intel.com/en-us/intel-tbb.
[1] Брейман, Л. «Предикторы пакетирования». Машинное обучение. Том 26, стр. 123-140, 1996.
[2] Брейман, Л. «Случайные леса». Машинное обучение. Том 45, стр. 5-32, 2001.
[3] Фрейнд, Y. «Более надежный алгоритм повышения». arXiv:0905.2138v1, 2009.
[4] Фрейнд, Ю. и Р. Э. Шапайр. «Теоретическое обобщение онлайн-обучения и приложения для повышения». J. of 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] Хо, Т. К. «Метод случайного подпространства для построения решающих лесов». IEEE Transactions on Pattern Analysis and Machine Intelligence, том 20, № 8, стр. 832-844, 1998.
[9] Шапайр, Р. Э., Я. Фройнд, П. Бартлетт и В. С. Ли. «Повышение маржи: новое объяснение эффективности методов голосования». Летописи статистики, т. 26, № 5, стр. 1651 - 1686, 1998.
[10] Зайфферт, К., Т. Хошгофтаар, Ж. Хульсе и А. Наполитано. 19-я Международная конференция по распознаванию образов, стр. 1-4, 2008.
[11] Вармут, М., Дж. Ляо и Г. Ратш. «Полностью корректирующие алгоритмы повышения, которые максимизируют запас». Proc. 23-я Int 'l. Conf. on Machine Learning, ACM, Нью-Йорк, стр. 1001-1008, 2006.
ClassificationBaggedEnsemble | ClassificationEnsemble | ClassificationPartitionedEnsemble | predict | templateDiscriminant | templateKNN | templateTree