fitrensemble
Подходящий ансамбль учеников для регрессии
Синтаксис
Описание
Mdl = fitrensemble(Tbl,ResponseVarName)Mdl) это содержит результаты повышения 100 деревьев регрессии с помощью LSBoost и предиктора и данных об ответе в таблице Tbl. ResponseVarName имя переменной отклика в Tbl.
Mdl = fitrensemble(Tbl,formula)formula подбирать модель к предиктору и данным об ответе в таблице Tbl. formula объяснительная модель ответа и подмножество переменных предикторов в Tbl используемый, чтобы соответствовать Mdl. Например, 'Y~X1+X2+X3' соответствует переменной отклика Tbl.Y как функция переменных предикторов Tbl.X1, Tbl.X2, и Tbl.X3.
Mdl = fitrensemble(___,Name,Value)Name,Value парные аргументы и любой из входных параметров в предыдущих синтаксисах. Например, можно задать количество изучения циклов, метода агрегации ансамбля, или реализовывать 10-кратную перекрестную проверку.
Примеры
Обучите ансамбль регрессии
Создайте ансамбль регрессии, который предсказывает экономию топлива автомобиля, учитывая количество цилиндров, объем, перемещенный цилиндрами, лошадиной силой и весом. Затем обучите другой ансамбль, использующий меньше предикторов. Сравните прогнозирующую точность в выборке ансамблей.
Загрузите carsmall набор данных. Сохраните переменные, которые будут использоваться в обучении в таблице.
load carsmall
Tbl = table(Cylinders,Displacement,Horsepower,Weight,MPG);Обучите ансамбль регрессии.
Mdl1 = fitrensemble(Tbl,'MPG');Mdl1 RegressionEnsemble модель. Некоторые известные характеристики Mdl1 :
Алгоритмом агрегации ансамбля является
'LSBoost'.Поскольку метод агрегации ансамбля является повышающим алгоритмом, деревья регрессии, которые позволяют максимум 10 разделений, составляют ансамбль.
Сто деревьев составляют ансамбль.
Поскольку MPG переменная в MATLAB® Workspace, можно получить тот же результат путем ввода
Mdl1 = fitrensemble(Tbl,MPG);
Используйте обученный ансамбль регрессии, чтобы предсказать экономию топлива для автомобиля с четырьмя цилиндрами с 200-кубическим смещением дюйма, 150 лошадиных сил и весящие 3 000 фунтов.
pMPG = predict(Mdl1,[4 200 150 3000])
pMPG = 25.6467
Обучите новый ансамбль, использующий все предикторы в Tbl кроме Displacement.
formula = 'MPG ~ Cylinders + Horsepower + Weight';
Mdl2 = fitrensemble(Tbl,formula);Сравните перезамену MSEs между Mdl1 и Mdl2.
mse1 = resubLoss(Mdl1)
mse1 = 0.3096
mse2 = resubLoss(Mdl2)
mse2 = 0.5861
MSE в выборке для ансамбля, который обучается на всех предикторах, ниже.
Ускорьте обучение раскладыванием числовые значения предиктора
Обучите ансамбль повышенных деревьев регрессии при помощи fitrensemble. Уменьшайте учебное время путем определения 'NumBins' аргумент пары "имя-значение" интервалу числовые предикторы. После обучения можно воспроизвести сгруппированные данные о предикторе при помощи BinEdges свойство обученной модели и discretize функция.
Сгенерируйте набор выборочных данных.
rng('default') % For reproducibility N = 1e6; X1 = randi([-1,5],[N,1]); X2 = randi([5,10],[N,1]); X3 = randi([0,5],[N,1]); X4 = randi([1,10],[N,1]); X = [X1 X2 X3 X4]; y = X1 + X2 + X3 + X4 + normrnd(0,1,[N,1]);
Обучите ансамбль повышенных деревьев регрессии с помощью повышения наименьших квадратов (LSBoost, значение по умолчанию). Время функция в целях сравнения.
tic Mdl1 = fitrensemble(X,y); toc
Elapsed time is 78.662954 seconds.
Ускорьте обучение при помощи 'NumBins' аргумент пары "имя-значение". Если вы задаете 'NumBins' значение как положительный целочисленный скаляр, затем интервалы программного обеспечения каждый числовой предиктор в конкретное количество равновероятных интервалов, и затем выращивает деревья на индексах интервала вместо исходных данных. Программное обеспечение не делает интервала категориальные предикторы.
tic
Mdl2 = fitrensemble(X,y,'NumBins',50);
tocElapsed time is 43.353208 seconds.
Процесс приблизительно в два раза быстрее, когда вы используете сгруппированные данные вместо исходных данных. Обратите внимание на то, что прошедшее время может варьироваться в зависимости от вашей операционной системы.
Сравните ошибки регрессии перезаменой.
rsLoss = resubLoss(Mdl1)
rsLoss = 1.0134
rsLoss2 = resubLoss(Mdl2)
rsLoss2 = 1.0133
В этом примере значения предиктора раскладывания уменьшают учебное время без значительной потери точности. В общем случае, когда у вас есть большой набор данных как тот в этом примере, использование опции раскладывания ускоряет обучение, но вызывает потенциальное уменьшение в точности. Если вы хотите уменьшать учебное время далее, задайте меньшее число интервалов.
Воспроизведите сгруппированные данные о предикторе при помощи 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.
Оцените ошибку обобщения повышения ансамбля
Оцените ошибку обобщения ансамбля повышенных деревьев регрессии.
Загрузите carsmall набор данных. Выберите количество цилиндров, объем, перемещенный цилиндрами, лошадиной силой и весом как предикторы экономии топлива.
load carsmall
X = [Cylinders Displacement Horsepower Weight];Перекрестный подтвердите ансамбль деревьев регрессии с помощью 10-кратной перекрестной проверки. Используя шаблон дерева решений, укажите, что каждое дерево должно быть разделением однажды только.
rng(1); % For reproducibility t = templateTree('MaxNumSplits',1); Mdl = fitrensemble(X,MPG,'Learners',t,'CrossVal','on');
Mdl RegressionPartitionedEnsemble модель.
Постройте совокупное, перекрестное подтвержденное 10-кратное, среднеквадратическая ошибка (MSE). Отобразите предполагаемую ошибку обобщения ансамбля.
kflc = kfoldLoss(Mdl,'Mode','cumulative'); figure; plot(kflc); ylabel('10-fold cross-validated MSE'); xlabel('Learning cycle');
estGenError = kflc(end)
estGenError = 24.8521
kfoldLoss возвращает ошибку обобщения по умолчанию. Однако графический вывод совокупной потери позволяет вам контролировать, как потеря изменяется, когда слабые ученики накапливаются в ансамбле.
Ансамбль достигает MSE приблизительно 23,5 после накопления приблизительно 30 слабых учеников.
Если вы удовлетворены ошибкой обобщения ансамбля, то, чтобы создать прогнозную модель, обучают ансамбль, снова использующий все настройки кроме перекрестной проверки. Однако это - хорошая практика, чтобы настроить гиперпараметры, такие как максимальное количество разделений решения на дерево и количество изучения циклов..
Оптимизируйте ансамбль регрессии
В этом примере показано, как оптимизировать гиперпараметры автоматически с помощью fitrensemble. Пример использует carsmall данные.
Загрузите данные.
load carsmallМожно найти гиперпараметры, которые минимизируют пятикратную потерю перекрестной проверки при помощи автоматической гипероптимизации параметров управления.
Mdl = fitrensemble([Horsepower,Weight],MPG,'OptimizeHyperparameters','auto')
В этом примере, для воспроизводимости, устанавливает случайный seed и используют 'expected-improvement-plus' функция приобретения. Кроме того, для воспроизводимости случайного лесного алгоритма задайте 'Reproducible' аргумент пары "имя-значение" как true для древовидных учеников.
rng('default') t = templateTree('Reproducible',true); Mdl = fitrensemble([Horsepower,Weight],MPG,'OptimizeHyperparameters','auto','Learners',t, ... 'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName','expected-improvement-plus'))
|===================================================================================================================================| | Iter | Eval | Objective: | Objective | BestSoFar | BestSoFar | Method | NumLearningC-| LearnRate | MinLeafSize | | | result | log(1+loss) | runtime | (observed) | (estim.) | | ycles | | | |===================================================================================================================================| | 1 | Best | 2.9743 | 10.177 | 2.9743 | 2.9743 | Bag | 413 | - | 1 |
| 2 | Accept | 6.2619 | 1.4109 | 2.9743 | 3.6147 | LSBoost | 57 | 0.0016067 | 6 |
| 3 | Best | 2.9562 | 0.70324 | 2.9562 | 2.9654 | Bag | 32 | - | 2 |
| 4 | Accept | 4.1884 | 1.0749 | 2.9562 | 2.9573 | Bag | 55 | - | 40 |
| 5 | Accept | 4.1881 | 4.776 | 2.9562 | 2.957 | LSBoost | 258 | 0.096683 | 50 |
| 6 | Accept | 3.1479 | 1.546 | 2.9562 | 2.9569 | LSBoost | 75 | 0.092525 | 6 |
| 7 | Accept | 3.7831 | 0.39071 | 2.9562 | 2.9568 | LSBoost | 17 | 0.08882 | 1 |
| 8 | Accept | 4.2759 | 0.3212 | 2.9562 | 2.9564 | LSBoost | 12 | 0.094908 | 1 |
| 9 | Accept | 3.124 | 3.0992 | 2.9562 | 2.9564 | LSBoost | 157 | 0.083222 | 8 |
| 10 | Accept | 3.6349 | 10.054 | 2.9562 | 2.991 | LSBoost | 494 | 0.070612 | 2 |
| 11 | Accept | 3.0526 | 0.2414 | 2.9562 | 2.9615 | Bag | 10 | - | 1 |
| 12 | Accept | 3.1469 | 1.3287 | 2.9562 | 2.9627 | LSBoost | 62 | 0.08423 | 4 |
| 13 | Accept | 4.7629 | 0.43122 | 2.9562 | 2.9629 | LSBoost | 21 | 0.055294 | 48 |
| 14 | Accept | 4.1881 | 3.9945 | 2.9562 | 2.9629 | LSBoost | 213 | 0.99467 | 46 |
| 15 | Accept | 3.5337 | 1.3169 | 2.9562 | 3.0164 | LSBoost | 63 | 0.73987 | 1 |
| 16 | Accept | 3.2481 | 1.2691 | 2.9562 | 2.9689 | LSBoost | 59 | 0.2363 | 6 |
| 17 | Accept | 2.9732 | 1.621 | 2.9562 | 3.0016 | Bag | 83 | - | 1 |
| 18 | Best | 2.9361 | 9.6119 | 2.9361 | 2.9648 | Bag | 498 | - | 2 |
| 19 | Accept | 3.5859 | 2.5096 | 2.9361 | 2.9987 | LSBoost | 123 | 0.1522 | 2 |
| 20 | Accept | 2.9406 | 9.5226 | 2.9361 | 2.9559 | Bag | 496 | - | 2 |
|===================================================================================================================================| | Iter | Eval | Objective: | Objective | BestSoFar | BestSoFar | Method | NumLearningC-| LearnRate | MinLeafSize | | | result | log(1+loss) | runtime | (observed) | (estim.) | | ycles | | | |===================================================================================================================================| | 21 | Accept | 2.9419 | 9.4082 | 2.9361 | 2.9517 | Bag | 491 | - | 2 |
| 22 | Accept | 5.7918 | 0.73879 | 2.9361 | 2.9525 | LSBoost | 35 | 0.0094806 | 1 |
| 23 | Accept | 5.9584 | 5.1211 | 2.9361 | 2.9533 | LSBoost | 272 | 0.0010255 | 50 |
| 24 | Accept | 6.4218 | 0.24342 | 2.9361 | 2.9538 | LSBoost | 10 | 0.0010003 | 1 |
| 25 | Accept | 4.7662 | 3.8496 | 2.9361 | 2.9531 | LSBoost | 202 | 0.0058776 | 50 |
| 26 | Accept | 3.4231 | 4.1306 | 2.9361 | 2.9537 | LSBoost | 208 | 0.99319 | 6 |
| 27 | Accept | 5.6829 | 0.33705 | 2.9361 | 2.954 | LSBoost | 13 | 0.02954 | 1 |
| 28 | Accept | 4.7428 | 1.3736 | 2.9361 | 2.954 | LSBoost | 72 | 0.01677 | 50 |
| 29 | Accept | 5.9554 | 1.5838 | 2.9361 | 2.9544 | LSBoost | 78 | 0.0031809 | 1 |
| 30 | Accept | 4.1881 | 1.1862 | 2.9361 | 2.9547 | LSBoost | 62 | 0.35508 | 50 |
__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 139.2993 seconds.
Total objective function evaluation time: 93.3718
Best observed feasible point:
Method NumLearningCycles LearnRate MinLeafSize
______ _________________ _________ ___________
Bag 498 NaN 2
Observed objective function value = 2.9361
Estimated objective function value = 2.9547
Function evaluation time = 9.6119
Best estimated feasible point (according to models):
Method NumLearningCycles LearnRate MinLeafSize
______ _________________ _________ ___________
Bag 491 NaN 2
Estimated objective function value = 2.9547
Estimated function evaluation time = 9.5465
Mdl =
classreg.learning.regr.RegressionBaggedEnsemble
ResponseName: 'Y'
CategoricalPredictors: []
ResponseTransform: 'none'
NumObservations: 94
HyperparameterOptimizationResults: [1×1 BayesianOptimization]
NumTrained: 491
Method: 'Bag'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: []
FitInfoDescription: 'None'
Regularization: []
FResample: 1
Replace: 1
UseObsForLearner: [94×491 logical]
Properties, Methods
Оптимизация, искавшая по методам регрессию (Bag и LSBoost), по NumLearningCycles, по LearnRate для LSBoost, и по древовидному ученику MinLeafSize. Выход является регрессией ансамбля с минимальной предполагаемой потерей перекрестной проверки.
Оптимизируйте ансамбль регрессии Используя перекрестную проверку
Один способ создать ансамбль повышенных деревьев регрессии, который имеет удовлетворительную прогнозирующую производительность, состоит в том, чтобы настроить уровень сложности дерева решений с помощью перекрестной проверки. При поиске оптимального уровня сложности настройте скорость обучения, чтобы минимизировать количество изучения циклов также.
Этот пример вручную находит оптимальные параметры при помощи опции перекрестной проверки ('KFold' аргумент пары "имя-значение") и kfoldLoss функция. В качестве альтернативы можно использовать 'OptimizeHyperparameters' аргумент пары "имя-значение", чтобы оптимизировать гиперпараметры автоматически. Смотрите Оптимизируют Ансамбль Регрессии.
Загрузите carsmall набор данных. Выберите количество цилиндров, объем, перемещенный цилиндрами, лошадиной силой и весом как предикторы экономии топлива.
load carsmall
Tbl = table(Cylinders,Displacement,Horsepower,Weight,MPG);Значения по умолчанию древовидных контроллеров глубины для повышения деревьев регрессии:
10
дляMaxNumSplits.5
дляMinLeafSize10
дляMinParentSize
Искать оптимальный уровень древовидной сложности:
Перекрестный подтвердите набор ансамблей. Экспоненциально увеличьте уровень древовидной сложности для последующих ансамблей от пня решения (одно разделение) к в большей части n - 1 разделение. n является объемом выборки. Кроме того, варьируйтесь скорость обучения для каждого ансамбля между 0,1 к 1.
Оцените перекрестную подтвержденную среднеквадратическую ошибку (MSE) для каждого ансамбля.
Для уровня древовидной сложности , , сравните совокупный, перекрестный подтвержденный MSE ансамблей путем графического вывода их против количества изучения циклов. Постройте отдельные кривые для каждой скорости обучения на той же фигуре.
Выберите кривую, которая достигает минимального MSE, и отметьте соответствующий цикл изучения и скорость обучения.
Перекрестный подтвердите глубокое дерево регрессии и пень. Поскольку данные содержат отсутствующие значения, используйте суррогатные разделения. Эти деревья регрессии служат сравнительными тестами.
rng(1) % For reproducibility MdlDeep = fitrtree(Tbl,'MPG','CrossVal','on','MergeLeaves','off', ... 'MinParentSize',1,'Surrogate','on'); MdlStump = fitrtree(Tbl,'MPG','MaxNumSplits',1,'CrossVal','on', ... 'Surrogate','on');
Перекрестный подтвердите ансамбль 150 повышенных деревьев регрессии с помощью 5-кратной перекрестной проверки. Используя древовидный шаблон:
Варьируйтесь максимальное количество разделений с помощью значений в последовательности . m таков что не больше, чем n - 1.
Включите суррогатные разделения.
Для каждого варианта настройте скорость обучения с помощью каждого значения в наборе {0.1, 0.25, 0.5, 1}.
n = size(Tbl,1); m = floor(log2(n - 1)); learnRate = [0.1 0.25 0.5 1]; numLR = numel(learnRate); maxNumSplits = 2.^(0:m); numMNS = numel(maxNumSplits); numTrees = 150; Mdl = cell(numMNS,numLR); for k = 1:numLR for j = 1:numMNS t = templateTree('MaxNumSplits',maxNumSplits(j),'Surrogate','on'); Mdl{j,k} = fitrensemble(Tbl,'MPG','NumLearningCycles',numTrees, ... 'Learners',t,'KFold',5,'LearnRate',learnRate(k)); end end
Оцените совокупный, перекрестный подтвержденный MSE каждого ансамбля.
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);
Постройте, как перекрестный подтвержденный MSE ведет себя как количество деревьев в увеличениях ансамбля. Постройте кривые относительно скорости обучения на том же графике и постройте отдельные графики для различных уровней древовидной сложности. Выберите подмножество древовидных уровней сложности, чтобы построить.
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 = [10 50]; xlabel('Number of trees') ylabel('Cross-validated MSE') title(sprintf('MaxNumSplits = %0.3g', maxNumSplits(mnsPlot(k)))) hold off end hL = legend([cellstr(num2str(learnRate','Learning Rate = %0.2f')); ... 'Deep Tree';'Stump';'Min. MSE']); hL.Position(1) = 0.6;
Каждая кривая содержит минимум перекрестный подтвержденный MSE, происходящий в оптимальном количестве деревьев в ансамбле.
Идентифицируйте максимальное количество разделений, количество деревьев и скорость обучения, которая дает к самому низкому MSE в целом.
[minErr,minErrIdxLin] = min(error(:));
[idxNumTrees,idxMNS,idxLR] = ind2sub(size(error),minErrIdxLin);
fprintf('\nMin. MSE = %0.5f',minErr)Min. MSE = 17.00516
fprintf('\nOptimal Parameter Values:\nNum. Trees = %d',idxNumTrees);Optimal Parameter Values: Num. Trees = 38
fprintf('\nMaxNumSplits = %d\nLearning Rate = %0.2f\n',... maxNumSplits(idxMNS),learnRate(idxLR))
MaxNumSplits = 4 Learning Rate = 0.10
Создайте прогнозирующий ансамбль на основе оптимальных гиперпараметров и целого набора обучающих данных.
tFinal = templateTree('MaxNumSplits',maxNumSplits(idxMNS),'Surrogate','on'); MdlFinal = fitrensemble(Tbl,'MPG','NumLearningCycles',idxNumTrees, ... 'Learners',tFinal,'LearnRate',learnRate(idxLR))
MdlFinal =
classreg.learning.regr.RegressionEnsemble
PredictorNames: {'Cylinders' 'Displacement' 'Horsepower' 'Weight'}
ResponseName: 'MPG'
CategoricalPredictors: []
ResponseTransform: 'none'
NumObservations: 94
NumTrained: 38
Method: 'LSBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [38×1 double]
FitInfoDescription: {2×1 cell}
Regularization: []
Properties, Methods
MdlFinal RegressionEnsemble. Чтобы предсказать экономию топлива автомобиля, учитывая его количество цилиндров, объем, перемещенный цилиндрами, лошадиной силой и весом, можно передать данные о предикторе и MdlFinal к predict.
Вместо того, чтобы искать оптимальные значения вручную при помощи опции перекрестной проверки ('KFold') и kfoldLoss функция, можно использовать 'OptimizeHyperparameters' аргумент пары "имя-значение". Когда вы задаете 'OptimizeHyperparameters', программное обеспечение находит оптимальные параметры автоматически с помощью Байесовой оптимизации. Оптимальные значения получены при помощи 'OptimizeHyperparameters' может отличаться от тех полученный поиск руководства использования.
t = templateTree('Surrogate','on'); mdl = fitrensemble(Tbl,'MPG','Learners',t, ... 'OptimizeHyperparameters',{'NumLearningCycles','LearnRate','MaxNumSplits'})
|====================================================================================================================| | Iter | Eval | Objective: | Objective | BestSoFar | BestSoFar | NumLearningC-| LearnRate | MaxNumSplits | | | result | log(1+loss) | runtime | (observed) | (estim.) | ycles | | | |====================================================================================================================| | 1 | Best | 3.3985 | 0.67095 | 3.3985 | 3.3985 | 26 | 0.072054 | 3 |
| 2 | Accept | 6.0976 | 4.1242 | 3.3985 | 3.5578 | 170 | 0.0010295 | 70 |
| 3 | Best | 3.2868 | 5.9884 | 3.2868 | 3.287 | 273 | 0.61026 | 6 |
| 4 | Accept | 6.1839 | 1.6681 | 3.2868 | 3.2868 | 80 | 0.0016871 | 1 |
| 5 | Best | 3.027 | 0.35792 | 3.027 | 3.0275 | 14 | 0.21079 | 85 |
| 6 | Accept | 3.0553 | 0.27277 | 3.027 | 3.0323 | 10 | 0.25194 | 19 |
| 7 | Accept | 3.3577 | 0.26363 | 3.027 | 3.0486 | 10 | 0.17901 | 4 |
| 8 | Accept | 3.0491 | 0.27427 | 3.027 | 3.0328 | 10 | 0.28136 | 98 |
| 9 | Accept | 3.0735 | 0.27294 | 3.027 | 3.0288 | 10 | 0.25459 | 99 |
| 10 | Accept | 3.1252 | 1.3338 | 3.027 | 3.0403 | 58 | 0.25562 | 9 |
| 11 | Accept | 3.0613 | 0.28222 | 3.027 | 3.0325 | 10 | 0.26363 | 99 |
| 12 | Accept | 3.3299 | 0.27812 | 3.027 | 3.0312 | 10 | 0.96285 | 93 |
| 13 | Accept | 5.2994 | 0.2922 | 3.027 | 3.0301 | 11 | 0.052366 | 93 |
| 14 | Accept | 3.0946 | 0.26976 | 3.027 | 3.0313 | 10 | 0.49134 | 92 |
| 15 | Accept | 3.2499 | 2.7489 | 3.027 | 3.0287 | 119 | 0.27613 | 49 |
| 16 | Accept | 3.1039 | 0.26627 | 3.027 | 3.0268 | 10 | 0.90888 | 1 |
| 17 | Best | 2.8971 | 0.40282 | 2.8971 | 2.8975 | 17 | 0.35714 | 1 |
| 18 | Accept | 4.5501 | 0.2607 | 2.8971 | 2.897 | 10 | 0.097401 | 4 |
| 19 | Accept | 2.923 | 1.2505 | 2.8971 | 2.897 | 60 | 0.088079 | 1 |
| 20 | Accept | 2.9257 | 0.6109 | 2.8971 | 2.897 | 28 | 0.17524 | 1 |
|====================================================================================================================| | Iter | Eval | Objective: | Objective | BestSoFar | BestSoFar | NumLearningC-| LearnRate | MaxNumSplits | | | result | log(1+loss) | runtime | (observed) | (estim.) | ycles | | | |====================================================================================================================| | 21 | Accept | 3.0642 | 0.63736 | 2.8971 | 2.8968 | 30 | 0.95959 | 1 |
| 22 | Accept | 3.0486 | 0.9568 | 2.8971 | 2.8966 | 41 | 0.11378 | 91 |
| 23 | Accept | 2.9682 | 1.6611 | 2.8971 | 2.8965 | 81 | 0.041244 | 1 |
| 24 | Accept | 2.934 | 0.4262 | 2.8971 | 2.8982 | 19 | 0.25643 | 1 |
| 25 | Accept | 2.9839 | 0.36893 | 2.8971 | 2.8995 | 16 | 0.58473 | 1 |
| 26 | Best | 2.8895 | 0.31171 | 2.8895 | 2.8892 | 13 | 0.34786 | 1 |
| 27 | Accept | 2.9215 | 2.9311 | 2.8895 | 2.8893 | 145 | 0.061728 | 1 |
| 28 | Accept | 3.0827 | 1.5154 | 2.8895 | 2.8894 | 74 | 0.99934 | 1 |
| 29 | Accept | 2.9234 | 1.7442 | 2.8895 | 2.8893 | 85 | 0.059513 | 1 |
| 30 | Accept | 2.924 | 4.437 | 2.8895 | 2.8894 | 222 | 0.031299 | 1 |
__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 70.0647 seconds.
Total objective function evaluation time: 36.879
Best observed feasible point:
NumLearningCycles LearnRate MaxNumSplits
_________________ _________ ____________
13 0.34786 1
Observed objective function value = 2.8895
Estimated objective function value = 2.8894
Function evaluation time = 0.31171
Best estimated feasible point (according to models):
NumLearningCycles LearnRate MaxNumSplits
_________________ _________ ____________
13 0.34786 1
Estimated objective function value = 2.8894
Estimated function evaluation time = 0.31548
mdl =
classreg.learning.regr.RegressionEnsemble
PredictorNames: {'Cylinders' 'Displacement' 'Horsepower' 'Weight'}
ResponseName: 'MPG'
CategoricalPredictors: []
ResponseTransform: 'none'
NumObservations: 94
HyperparameterOptimizationResults: [1×1 BayesianOptimization]
NumTrained: 13
Method: 'LSBoost'
LearnerNames: {'Tree'}
ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
FitInfo: [13×1 double]
FitInfoDescription: {2×1 cell}
Regularization: []
Properties, Methods
Входные параметры
Выходные аргументы
Советы
NumLearningCyclesможет варьироваться от нескольких дюжин до нескольких тысяч. Обычно, ансамбль с хорошей предсказательной силой требует от нескольких сотен до нескольких тысяч слабых учеников. Однако вы не должны обучать ансамбль который много циклов целиком. Можно запустить путем роста нескольких дюжин учеников, смотреть производительность ансамбля и затем, при необходимости, обучить более слабых учеников, использующихresume.Производительность ансамбля зависит от установки ансамбля и установки слабых учеников. Таким образом, если вы задаете слабых учеников параметрами по умолчанию, затем ансамбль может выполнить плохо. Поэтому как настройки ансамбля, это - хорошая практика, чтобы настроить параметры слабых шаблонов использования учеников и выбрать значения, которые минимизируют ошибку обобщения.
Если вы задаете, чтобы передискретизировать использование
Resample, затем это - хорошая практика, чтобы передискретизировать к целому набору данных. Таким образом, используйте настройку по умолчанию1дляFResample.После обучения модель можно сгенерировать код C/C++, который предсказывает ответы для новых данных. Генерация кода C/C++ требует MATLAB Coder™. Для получения дополнительной информации смотрите Введение в Генерацию кода.
Алгоритмы
Для получения дополнительной информации алгоритмов агрегации ансамбля, см. Алгоритмы Ансамбля.
Если вы задаете
'Method','LSBoost', затем программное обеспечение выращивает мелкие деревья решений по умолчанию. Можно настроить древовидную глубину путем определенияMaxNumSplits,MinLeafSize, иMinParentSizeаргументы пары "имя-значение" с помощьюtemplateTree.Для двухъядерных систем и выше,
fitrensembleпараллелизирует обучение с помощью 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. и Р. Э. Шапайр. “Теоретическое Решением Обобщение Дистанционного обучения и Приложения к Повышению”. J. Компьютерных и Системных Наук, Издания 55, стр 119–139, 1997.
[4] Фридман, J. “Жадное приближение функций: машина повышения градиента”. Летопись Статистики, Издания 29, № 5, стр 1189–1232, 2001.
[5] Hastie, T., Р. Тибширэни и Дж. Фридман. Выпуск раздела Elements of Statistical Learning, Спрингер, Нью-Йорк, 2008.
Расширенные возможности
Смотрите также
RegressionBaggedEnsemble | RegressionEnsemble | RegressionPartitionedEnsemble | predict | templateTree