ドキュメンテーション

最新のリリースでは、このページがまだ翻訳されていません。 このページの最新版は英語でご覧になれます。

fitrensemble

アンサンブル学習器を回帰用に準備

説明

Mdl = fitrensemble(Tbl,ResponseVarName) は、LSBoost とテーブル Tbl 内の予測子および応答データを使用して 100 本の回帰木をブースティングした結果が格納されている学習済みのアンサンブル回帰モデル オブジェクト (Mdl) を返します。ResponseVarName は、Tbl 内の応答変数の名前です。

Mdl = fitrensemble(Tbl,formula) は、formula を適用して、モデルをテーブル Tbl 内の予測子および応答のデータにあてはめます。formula は、Mdl のあてはめに使用する応答および Tbl 内の予測子変数サブセットの説明モデルです。たとえば、'Y~X1+X2+X3' は応答変数 Tbl.Y を予測子変数 Tbl.X1Tbl.X2 および Tbl.X3 の関数としてあてはめます。

Mdl = fitrensemble(Tbl,Y) は、テーブル Tbl 内の変数をすべて予測子変数として扱います。Y は、Tbl に含まれていない応答のベクトルです。

Mdl = fitrensemble(X,Y) は、行列 X 内の予測子データとベクトル Y 内の応答データを使用します。

Mdl = fitrensemble(___,Name,Value) は、1 つ以上の Name,Value ペア引数で指定される追加のオプションと、前の構文の入力引数のいずれかを使用します。たとえば、学習サイクル数、アンサンブル集約法、10 分割交差検証の実施を指定できます。

すべて折りたたむ

与えられた気筒数、気筒ごとの排気量、馬力および重量に対して自動車の燃費を予測するアンサンブル回帰を作成します。次に、予測子の数を減らして、別のアンサンブルに学習をさせます。これらのアンサンブルの標本内予測精度を比較します。

carsmall データセットを読み込みます。学習に使用する変数をテーブルに格納します。

load carsmall
Tbl = table(Cylinders,Displacement,Horsepower,Weight,MPG);

アンサンブル回帰に学習をさせます。

Mdl1 = fitrensemble(Tbl,'MPG');

Mdl1RegressionEnsemble モデルです。Mdl1 には、次のような顕著な特徴があります。

  • アンサンブル集約アルゴリズムは 'LSBoost' です。

  • アンサンブル集約アルゴリズムがブースティング アルゴリズムなので、最大 10 分割を許容する回帰木がアンサンブルを構成します。

  • 100 本の木がアンサンブルを構成します。

MPG は MATLAB® ワークスペースの変数なので、次のように入力すると同じ結果を得ることができます。

Mdl1 = fitrensemble(Tbl,MPG);

学習させたアンサンブル回帰を使用して、排気量が 200 立方インチ、150 馬力、重量 3,000 lbs の 4 気筒搭載車の燃費を予測します。

pMPG = predict(Mdl1,[4 200 150 3000])
pMPG = 25.6467

Displacement を除く Tbl 内の予測子をすべて使用して、新しいアンサンブルに学習をさせます。

formula = 'MPG ~ Cylinders + Horsepower + Weight';
Mdl2 = fitrensemble(Tbl,formula);

Mdl1Mdl2 の再代入 MSE を比較します。

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);
toc
Elapsed time is 43.353208 seconds.

元のデータではなくビン化されたデータを使用すると、処理が約 2 倍高速になります。経過時間はオペレーティング システムによって変化する可能性があることに注意してください。

再代入による回帰誤差を比較します。

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

数値予測子の場合、1 からビンの個数までの範囲にあるビンのインデックスが Xbinned に格納されます。カテゴリカル予測子の場合、Xbinned の値は 0 になります。XNaN が含まれている場合、対応する Xbinned の値は NaN になります。

ブースティングされた回帰木のアンサンブルの汎化誤差を推定します。

carsmall データセットを読み込みます。燃費の予測子として、気筒数、気筒ごとの排気量、馬力、重量を選択します。

load carsmall
X = [Cylinders Displacement Horsepower Weight];

10 分割の交差検証を使用して、回帰木のアンサンブルを交差検証します。決定木テンプレートを使用して、各木を 1 回だけ分割するように指定します。

rng(1); % For reproducibility
t = templateTree('MaxNumSplits',1);
Mdl = fitrensemble(X,MPG,'Learners',t,'CrossVal','on');

MdlRegressionPartitionedEnsemble モデルです。

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 は汎化誤差を返します。しかし、累積損失をプロットすると、アンサンブル内に弱学習器が蓄積するにつれて損失がどのように変化するかを観察できます。

このアンサンブルでは、約 30 個の弱学習器が蓄積した後の MSE が約 23.5 になっています。

アンサンブルの汎化誤差が満足できるものになった場合は、予測モデルを作成するため、交差検証以外の設定をすべて使用して、再度アンサンブルに学習をさせます。ただし、木あたりの決定分岐の最大数や学習サイクル数などのハイパーパラメーターを調整することをお勧めします。

この例では、fitrensemble を使用して自動的にハイパーパラメーターを最適化する方法を示します。この例では、carsmall データを使用します。

データを読み込みます。

load carsmall

自動的なハイパーパラメーター最適化を使用して、5 分割交差検証損失を最小化するハイパーパラメーターを求めることができます。

Mdl = fitrensemble([Horsepower,Weight],MPG,'OptimizeHyperparameters','auto')

この例では、再現性を得るため、乱数シードを設定し、'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 |             | runtime     | (observed)  | (estim.)    |              | ycles        |              |              |
|===================================================================================================================================|
|    1 | Best   |      2.9743 |      9.9614 |      2.9743 |      2.9743 |          Bag |          413 |            - |            1 |
|    2 | Accept |      6.2619 |      1.5009 |      2.9743 |      3.6147 |      LSBoost |           57 |    0.0016067 |            6 |
|    3 | Best   |      2.9562 |     0.77935 |      2.9562 |      2.9654 |          Bag |           32 |            - |            2 |
|    4 | Accept |      4.1884 |      1.2819 |      2.9562 |      2.9573 |          Bag |           55 |            - |           40 |
|    5 | Accept |      4.1881 |      6.0891 |      2.9562 |       2.957 |      LSBoost |          258 |     0.096683 |           50 |
|    6 | Accept |      3.1479 |      1.8558 |      2.9562 |      2.9569 |      LSBoost |           75 |     0.092525 |            6 |
|    7 | Accept |      3.7831 |      0.4946 |      2.9562 |      2.9568 |      LSBoost |           17 |      0.08882 |            1 |
|    8 | Accept |      4.2759 |     0.38923 |      2.9562 |      2.9564 |      LSBoost |           12 |     0.094908 |            1 |
|    9 | Accept |       3.124 |      4.3066 |      2.9562 |      2.9564 |      LSBoost |          157 |     0.083222 |            8 |
|   10 | Accept |      3.6349 |      12.142 |      2.9562 |       2.991 |      LSBoost |          494 |     0.070612 |            2 |
|   11 | Accept |      3.0526 |     0.26891 |      2.9562 |      2.9615 |          Bag |           10 |            - |            1 |
|   12 | Accept |      3.1469 |      1.7301 |      2.9562 |      2.9627 |      LSBoost |           62 |      0.08423 |            4 |
|   13 | Accept |      4.7629 |     0.50284 |      2.9562 |      2.9629 |      LSBoost |           21 |     0.055294 |           48 |
|   14 | Accept |      4.1881 |      4.5671 |      2.9562 |      2.9629 |      LSBoost |          213 |      0.99467 |           46 |
|   15 | Accept |      3.5337 |       1.597 |      2.9562 |      3.0164 |      LSBoost |           63 |      0.73987 |            1 |
|   16 | Accept |      3.2481 |      1.3843 |      2.9562 |      2.9689 |      LSBoost |           59 |       0.2363 |            6 |
|   17 | Accept |      2.9732 |      1.7983 |      2.9562 |      3.0016 |          Bag |           83 |            - |            1 |
|   18 | Best   |      2.9361 |      10.498 |      2.9361 |      2.9648 |          Bag |          498 |            - |            2 |
|   19 | Accept |      3.5859 |      2.9294 |      2.9361 |      2.9987 |      LSBoost |          123 |       0.1522 |            2 |
|   20 | Accept |      2.9406 |      10.689 |      2.9361 |      2.9559 |          Bag |          496 |            - |            2 |
|===================================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Method | NumLearningC-|    LearnRate |  MinLeafSize |
|      | result |             | runtime     | (observed)  | (estim.)    |              | ycles        |              |              |
|===================================================================================================================================|
|   21 | Accept |      2.9419 |      10.833 |      2.9361 |      2.9517 |          Bag |          491 |            - |            2 |
|   22 | Accept |      5.7918 |      1.0162 |      2.9361 |      2.9525 |      LSBoost |           35 |    0.0094806 |            1 |
|   23 | Accept |      5.9584 |       5.718 |      2.9361 |      2.9533 |      LSBoost |          272 |    0.0010255 |           50 |
|   24 | Accept |      6.4218 |     0.29731 |      2.9361 |      2.9538 |      LSBoost |           10 |    0.0010003 |            1 |
|   25 | Accept |      4.7662 |      4.7116 |      2.9361 |      2.9531 |      LSBoost |          202 |    0.0058776 |           50 |
|   26 | Accept |      3.4231 |      4.8838 |      2.9361 |      2.9537 |      LSBoost |          208 |      0.99319 |            6 |
|   27 | Accept |      5.6829 |     0.34583 |      2.9361 |       2.954 |      LSBoost |           13 |      0.02954 |            1 |
|   28 | Accept |      4.7428 |      1.5779 |      2.9361 |       2.954 |      LSBoost |           72 |      0.01677 |           50 |
|   29 | Accept |      5.9554 |      1.8831 |      2.9361 |      2.9544 |      LSBoost |           78 |    0.0031809 |            1 |
|   30 | Accept |      4.1881 |      1.4461 |      2.9361 |      2.9547 |      LSBoost |           62 |      0.35508 |           50 |

__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 167.549 seconds.
Total objective function evaluation time: 107.4784

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 = 10.4983

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 = 10.8111
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)、NumLearningCyclesLSBoostLearnRate、および木学習器の MinLeafSize に対して探索を行いました。出力は、推定交差検証損失が最小になるアンサンブル回帰です。

十分な予測性能をもつブースティングされた回帰木のアンサンブルを作成する方法の 1 つは、交差検証を使用して決定木の複雑度レベルを調整することです。最適な複雑度レベルを求めるときに、学習率を調整して学習サイクル数の最小化も行います。

この例では、交差検証オプション (名前と値のペアの引数 'KFold') と関数 kfoldLoss を使用して、最適なパラメーターを手動で求めます。あるいは、名前と値のペアの引数 'OptimizeHyperparameters' を使用して自動的にハイパーパラメーターを最適化することもできます。アンサンブル回帰の最適化を参照してください。

carsmall データセットを読み込みます。燃費の予測子として、気筒数、気筒ごとの排気量、馬力、重量を選択します。

load carsmall
Tbl = table(Cylinders,Displacement,Horsepower,Weight,MPG);

回帰木をブースティングする場合、木の深さの制御に関する既定値は次のとおりです。

  • MaxNumSplits10

  • 5 (次の場合) MinLeafSize

  • 10 (次の場合) MinParentSize

最適な木の複雑度レベルを求めるため、以下を行います。

  1. 一連のアンサンブルを交差検証します。以後のアンサンブルについて、決定株 (1 つの分割) から最大 n - 1 個の分割まで木の複雑度レベルを指数的に増やします。n は標本サイズです。また、各アンサンブル学習率を 0.1 から 1 までの間で変化させます。

  2. アンサンブルごとに交差検証の平均二乗誤差 (MSE) を推定します。

  3. 木の複雑度レベル j (j=1...J) について、学習サイクル数に対してプロットすることにより、アンサンブルの交差検証済み累積 MSE を比較します。同じ Figure に、各学習率に対応する別々の曲線をプロットします。

  4. 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');

5 分割の交差検証を使用して、150 本のブースティングされた回帰木のアンサンブルを交差検証します。木テンプレートを使用して、以下を行います。

  • {20,21,...,2m} という数列の値を使用して分割の最大数を変化させます。m は、2mn - 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.01148
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

MdlFinalRegressionEnsemble です。与えられた気筒数、全気筒の排気量、馬力、重量に対して燃費を予測するため、予測子データと MdlFinalpredict に渡すことができます。

交差検証オプション ('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 |             | runtime     | (observed)  | (estim.)    | ycles        |              |              |
|====================================================================================================================|
|    1 | Best   |      3.3989 |       0.702 |      3.3989 |      3.3989 |           26 |     0.072054 |            3 |
|    2 | Accept |      6.0978 |      4.5175 |      3.3989 |      3.5582 |          170 |    0.0010295 |           70 |
|    3 | Best   |      3.2848 |      7.3601 |      3.2848 |       3.285 |          273 |      0.61026 |            6 |
|    4 | Accept |      6.1839 |      1.9371 |      3.2848 |      3.2849 |           80 |    0.0016871 |            1 |
|    5 | Best   |      3.0154 |     0.33314 |      3.0154 |       3.016 |           12 |      0.21457 |            2 |
|    6 | Accept |      3.3146 |     0.32962 |      3.0154 |        3.16 |           10 |      0.18164 |            8 |
|    7 | Accept |      3.0512 |     0.31776 |      3.0154 |      3.1213 |           10 |      0.26719 |           16 |
|    8 | Best   |      3.0013 |     0.29751 |      3.0013 |      3.0891 |           10 |      0.27408 |            1 |
|    9 | Best   |      2.9797 |     0.31657 |      2.9797 |      2.9876 |           10 |      0.28184 |            2 |
|   10 | Accept |      3.0646 |     0.59906 |      2.9797 |      3.0285 |           23 |       0.9922 |            1 |
|   11 | Accept |      2.9825 |     0.31056 |      2.9797 |       2.978 |           10 |      0.54187 |            1 |
|   12 | Best   |      2.9526 |     0.31189 |      2.9526 |      2.9509 |           10 |      0.49116 |            1 |
|   13 | Best   |      2.9281 |     0.98544 |      2.9281 |      2.9539 |           38 |      0.30709 |            1 |
|   14 | Accept |       2.944 |     0.60449 |      2.9281 |      2.9305 |           20 |      0.40583 |            1 |
|   15 | Best   |      2.9128 |     0.50753 |      2.9128 |      2.9237 |           20 |      0.39672 |            1 |
|   16 | Best   |      2.9077 |     0.58614 |      2.9077 |       2.919 |           21 |      0.38157 |            1 |
|   17 | Accept |      3.3932 |     0.36691 |      2.9077 |       2.919 |           10 |      0.97862 |           99 |
|   18 | Accept |      6.2938 |     0.33318 |      2.9077 |      2.9204 |           10 |    0.0074886 |           95 |
|   19 | Accept |      3.0049 |      0.4842 |      2.9077 |      2.9114 |           15 |      0.45073 |            9 |
|   20 | Best   |      2.9072 |      2.2091 |      2.9072 |      2.9111 |           87 |        0.152 |            1 |
|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | NumLearningC-|    LearnRate | MaxNumSplits |
|      | result |             | runtime     | (observed)  | (estim.)    | ycles        |              |              |
|====================================================================================================================|
|   21 | Accept |      2.9217 |     0.53329 |      2.9072 |      2.9154 |           21 |      0.31845 |            1 |
|   22 | Best   |      2.8994 |      4.8548 |      2.8994 |       2.917 |          189 |     0.098534 |            1 |
|   23 | Accept |      2.9055 |      7.6922 |      2.8994 |      2.9166 |          310 |      0.15505 |            1 |
|   24 | Accept |      2.9264 |      1.4456 |      2.8994 |      2.9012 |           61 |      0.23387 |            1 |
|   25 | Accept |      3.0869 |     0.34623 |      2.8994 |      2.9169 |           10 |      0.48674 |           27 |
|   26 | Best   |      2.8942 |      7.7285 |      2.8942 |      2.8912 |          319 |      0.11093 |            1 |
|   27 | Accept |      3.0175 |     0.97891 |      2.8942 |      2.8889 |           38 |      0.32187 |            4 |
|   28 | Accept |      2.9049 |      3.4053 |      2.8942 |      2.8941 |          141 |      0.13325 |            1 |
|   29 | Accept |      3.0477 |     0.30373 |      2.8942 |      2.8939 |           10 |      0.28155 |           97 |
|   30 | Accept |      3.0563 |      0.3135 |      2.8942 |       2.894 |           10 |      0.53101 |            3 |

__________________________________________________________
Optimization completed.
MaxObjectiveEvaluations of 30 reached.
Total function evaluations: 30
Total elapsed time: 91.847 seconds.
Total objective function evaluation time: 51.012

Best observed feasible point:
    NumLearningCycles    LearnRate    MaxNumSplits
    _________________    _________    ____________

           319            0.11093          1      

Observed objective function value = 2.8942
Estimated objective function value = 2.894
Function evaluation time = 7.7285

Best estimated feasible point (according to models):
    NumLearningCycles    LearnRate    MaxNumSplits
    _________________    _________    ____________

           319            0.11093          1      

Estimated objective function value = 2.894
Estimated function evaluation time = 7.9767
mdl = 
  classreg.learning.regr.RegressionEnsemble
                       PredictorNames: {'Cylinders'  'Displacement'  'Horsepower'  'Weight'}
                         ResponseName: 'MPG'
                CategoricalPredictors: []
                    ResponseTransform: 'none'
                      NumObservations: 94
    HyperparameterOptimizationResults: [1×1 BayesianOptimization]
                           NumTrained: 319
                               Method: 'LSBoost'
                         LearnerNames: {'Tree'}
                 ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
                              FitInfo: [319×1 double]
                   FitInfoDescription: {2×1 cell}
                       Regularization: []


  Properties, Methods

入力引数

すべて折りたたむ

モデルを学習させるために使用する標本データ。テーブルとして指定します。Tbl の各行は 1 つの観測値に、各列は 1 つの予測子変数に対応します。Tbl には、応答変数用の追加の 1 列を含めることができます。文字ベクトルの cell 配列ではない cell 配列と複数列の変数は使用できません。

  • Tbl に応答変数が含まれている場合に他の変数をすべて予測子として使用するには、ResponseVarName を使用して応答変数を指定します。

  • Tbl に応答変数が含まれている場合に他の変数の一部のみを予測子として使用するには、formula を使用して式を指定します。

  • Tbl に応答変数が含まれていない場合は、Y を使用して応答データを指定します。応答変数の長さと Tbl の行数は、同じでなければなりません。

メモ

メモリと実行時間を節約するには、Tbl ではなく XY を指定します。

データ型: テーブル

応答変数名。Tbl 内の応答変数の名前を指定します。

ResponseVarName には文字ベクトルまたは string スカラーを指定しなければなりません。たとえば、Tbl.Y が応答変数である場合、ResponseVarName には 'Y' を指定します。それ以外の場合、fitrensembleTbl の列をすべて予測子変数として扱います。

データ型: char | string

予測子変数のサブセットおよび応答の説明モデル。'Y~X1+X2+X3' という形式の文字ベクトルまたは string スカラーを指定します。この式では、Y は応答変数を、X1X2 および X3 は予測子変数を表します。変数は、Tbl (Tbl.Properties.VariableNames) に含まれている変数の名前でなければなりません。

モデルに学習をさせるための予測子として Tbl 内の変数のサブセットを指定するには、式を使用します。式を指定した場合、formula に現れない Tbl 内の変数は使用されません。

データ型: char | string

予測子データ。数値行列を指定します。

各行は 1 つの観測値に、各列は 1 つの予測子変数に対応します。

Y の長さと X の行数は等しくなければなりません。

予測子の名前を X に表示される順序で指定するには、PredictorNames 名前と値のペアの引数を使用します。

データ型: single | double

応答。数値ベクトルを指定します。Y の各要素は、X または Tbl の対応する行の観測値に対する応答です。Y の長さと X または Tbl の行数は、同じでなければなりません。

データ型: single | double

名前と値のペアの引数

オプションの Name,Value 引数のコンマ区切りペアを指定します。Name は引数名で、Value は対応する値です。Name は引用符で囲まなければなりません。Name1,Value1,...,NameN,ValueN のように、複数の名前と値のペアの引数を、任意の順番で指定できます。

例: 'NumLearningCycles',500,'Method','Bag','Learners',templateTree(),'CrossVal','on' は、10 分割の交差検証を使用して、500 本のバギングされた回帰木のアンサンブルを交差検証します。

メモ

交差検証の名前と値のペアの引数を名前と値のペアの引数 'OptimizeHyperparameters' と同時に使用することはできません。'OptimizeHyperparameters' の場合の交差検証は、名前と値のペアの引数 'HyperparameterOptimizationOptions' を使用することのみによって変更できます。

一般的なアンサンブル オプション

すべて折りたたむ

アンサンブル集約法。'Method''LSBoost' または 'Bag' から構成されるコンマ区切りのペアとして指定します。

メソッドメモ:
'LSBoost'最小二乗ブースティング (LSBoost)縮小学習率は、名前と値のペアの引数 'LearnRate' を使用して指定できます。
'Bag'bootstrap aggregation (バギング、ランダム フォレスト[2]など)既定では、fitrensemble は各分岐で無作為に予測子を選択するバギング (ランダム フォレスト) を使用します。無作為な選択を行わずにバギングを使用するには、'NumVariablesToSample' の値が 'all' である木学習器を使用します。

アンサンブル集約アルゴリズムの詳細と例については、アルゴリズムアンサンブル アルゴリズムおよび適用するアンサンブル集約法の選択を参照してください。

例: 'Method','Bag'

アンサンブル学習のサイクル数。'NumLearningCycles' と正の整数から構成されるコンマ区切りのペアとして指定します。すべての学習サイクルで、Learners 内のすべてのテンプレート オブジェクトに対して 1 つの弱学習器が学習を行います。この結果、延べ NumLearningCycles*numel(Learners) 個の学習器が学習を行います。

アンサンブルはすべての訓練済み学習器を使用して構成され、Mdl.Trained に格納されます。

詳細は、ヒントを参照してください。

例: 'NumLearningCycles',500

データ型: single | double

アンサンブルで使用する弱学習器。'Learners''tree'、木テンプレート オブジェクト、または木テンプレート オブジェクトの cell ベクトルから構成されるコンマ区切りのペアとして指定します。

  • 'tree' (既定) — fitrensemble は、既定の回帰木学習器を使用します。これは、templateTree() を使用することと同じです。templateTree() の既定値は、'Method' の値に応じて変化します。

    • バギングされた決定木の場合、決定分岐の最大数 ('MaxNumSplits') は n–1 です。n は観測値の個数です。各分岐で無作為に選択する予測子の個数 ('NumVariablesToSample') は、予測子の個数の 1/3 です。したがって、fitrensemble は深い決定木を成長させます。モデルの複雑さや計算時間の削減のために、より浅い木を成長させることもできます。

    • ブースティングされた決定木の場合、'MaxNumSplits' は 10、'NumVariablesToSample''all' です。したがって、fitrensemble は浅い決定木を成長させます。木を深くすると、精度を向上させることができます。

    弱学習器の既定設定については、templateTree を参照してください。

  • 木テンプレート オブジェクト — fitrensemble は、templateTree が作成した木テンプレート オブジェクトを使用します。木学習器の設定を指定するには、templateTree の名前と値のペアの引数を使用します。

  • m 個の木テンプレート オブジェクトによる cell ベクトル — fitrensemble は、各学習サイクルで m 個の回帰木を成長させます (NumLearningCycles を参照)。たとえば、2 種類の回帰木から構成されるアンサンブルの場合、{t1 t2} を指定します。t1t2 は、templateTree によって返される回帰木テンプレート オブジェクトです。

学習器の学習回数の詳細については、NumLearningCyclesヒントを参照してください。

例: 'Learners',templateTree('MaxNumSplits',5)

出力頻度。'NPrint' と正の整数または 'off' から構成されるコンマ区切りのペアとして指定します。

それまでに fitrensemble が "弱学習器" または "分割" に学習をさせた回数を追跡するには、正の整数を指定します。つまり、正の整数 m を指定した場合、次のようになります。

  • 交差検証オプション (CrossVal など) を指定していない場合、fitrensemble で m 個の弱学習器の学習が完了するたびに、コマンド ラインにメッセージが表示されます。

  • 交差検証オプションを指定した場合、fitrensemble で m 個の分割の学習が完了するたびに、コマンド ラインにメッセージが表示されます。

'off' を指定した場合、fitrensemble で弱学習器の学習が完了してもメッセージは表示されません。

ヒント

大規模なデータセットに対して多数の弱学習器のアンサンブルに学習をさせる場合、正の整数を NPrint に指定してください。

例: 'NPrint',5

データ型: single | double | char | string

数値予測子のビンの個数。'NumBins' と正の整数スカラーから構成されるコンマ区切りのペアとして指定します。

  • 'NumBins' の値が空 (既定) である場合、どの予測子もビン化されません。

  • 'NumBins' の値として正の整数スカラーを指定した場合、指定した個数の同確率のビンにすべての数値予測子がビン化され、元のデータではなくビンのインデックスに対して木が成長します。

    • 'NumBins' の値が一意な予測子の値の個数 (u) を超える場合、fitrensemble は u 個のビンに予測子をビン化します。

    • fitrensemble は、カテゴリカル予測子をビン化しません。

大規模な学習データセットを使用する場合、このビン化オプションを使用すると、学習を高速化できますが、精度が低下する可能性があります。はじめに 'NumBins',50 を試してから、精度と学習速度に応じて 'NumBins' の値を変更できます。

学習済みのモデルでは、ビンのエッジは BinEdges プロパティに格納されます。

例: 'NumBins',50

データ型: single | double

カテゴリカル予測子のリスト。'CategoricalPredictors' と次の表のいずれかの値から構成されるコンマ区切りのペアとして指定します。

説明
正の整数のベクトルベクトルのエントリは、カテゴリカル変数が含まれている予測子データ (X または Tbl) の列に対応するインデックス値です。
logical ベクトルtrue というエントリは、予測子データ (X または Tbl) の対応する列がカテゴリカル変数であることを意味します。
文字行列行列の各行は予測子変数の名前です。名前は PredictorNames のエントリに一致しなくてはなりません。文字行列の各行が同じ長さになるように、名前を余分な空白で埋めてください。
文字ベクトルの cell 配列または string 配列配列の各要素は予測子変数の名前です。名前は PredictorNames のエントリに一致しなくてはなりません。
'all'すべての予測子がカテゴリカルです。

既定では、予測子データが table (Tbl) 内にあり、この table に論理値、カテゴリカル値、string 配列、または文字ベクトルの cell 配列が格納されている場合、fitrensemble は変数がカテゴリカルであると見なします。予測子データが行列 (X) である場合、fitrensemble はすべての予測子が連続的であると見なします。データが行列の場合にカテゴリカル予測子を確認するには、名前と値のペアの引数 'CategoricalPredictors' を使用します。

例: 'CategoricalPredictors','all'

データ型: single | double | logical | char | string | cell

予測子変数名。'PredictorNames' と一意な名前の string 配列または一意な文字ベクトルの cell 配列から構成されるコンマ区切りのペアとして指定します。'PredictorNames' の機能は、学習データの提供方法によって決まります。

  • XY を指定した場合、'PredictorNames' を使用して X の名前で予測子変数を指定できます。

    • PredictorNames 内の名前の順序は、X の列の順序に一致しなければなりません。つまり、PredictorNames{1}X(:,1) の名前、PredictorNames{2}X(:,2) の名前であり、他も同様です。また、size(X,2)numel(PredictorNames) は等しくなければなりません。

    • 既定では PredictorNames{'x1','x2',...} です。

  • Tbl が与えられた場合、'PredictorNames' を使用して学習に使用する予測子変数を選択できます。つまり、fitrensemblePredictorNames の予測子変数と応答変数のみを学習で使用します。

    • PredictorNamesTbl.Properties.VariableNames のサブセットでなければならず、応答変数の名前を含めることはできません。

    • 既定では、すべての予測子変数の名前が PredictorNames に格納されます。

    • 'PredictorNames'formula のいずれか一方のみを使用して学習用の予測子を指定することをお勧めします。

例: 'PredictorNames',{'SepalLength','SepalWidth','PetalLength','PetalWidth'}

データ型: string | cell

応答変数名。'ResponseName' と文字ベクトルまたは string スカラーから構成されるコンマ区切りのペアとして指定します。

  • Y を指定した場合、'ResponseName' を使用して応答変数の名前を指定できます。

  • ResponseVarName または formula を指定した場合、'ResponseName' を使用することはできません。

例: 'ResponseName','response'

データ型: char | string

応答の変換。'ResponseTransform''none' または関数ハンドルのいずれかから構成されるコンマ区切りのペアとして指定します。既定の設定は 'none' です。これは @(y)y、つまり変換なしを表します。MATLAB® 関数またはユーザー定義関数の場合は、関数ハンドルを使用します。関数ハンドルは、ベクトル (元の応答値) を受け入れて同じサイズのベクトル (変換した応答値) を返さなければなりません。

例: myfunction = @(y)exp(y) を使用して、指数変換を入力ベクトルに適用する関数のハンドルを作成するとします。この場合、応答変換として 'ResponseTransform',myfunction を指定できます。

データ型: char | string | function_handle

交差検証オプション

すべて折りたたむ

交差検証フラグ。'Crossval''on' または 'off' から構成されるコンマ区切りのペアとして指定します。

'on' を指定した場合、10 分割の交差検証が実施されます。

この交差検証の設定をオーバーライドするには、名前と値のペアの引数 CVPartitionHoldoutKFoldLeaveout のいずれかを使用します。交差検証済みモデルを作成するために使用できる交差検証の名前と値のペアの引数は、一度に 1 つだけです。

あるいは、crossval または crossvalMdl を渡すことにより、後で交差検証を実行します。

例: 'Crossval','on'

交差検証分割。'CVPartition' と、cvpartition で作成した cvpartition 分割オブジェクトから構成されるコンマ区切りのペアとして指定します。分割オブジェクトは、交差検証のタイプと、学習セットおよび検証セットのインデックス付けを指定します。

交差検証済みモデルの作成に使用できる名前と値のペアの引数は、CVPartitionHoldoutKFoldLeaveout の 4 つのうちのいずれかのみです。

例: cvp = cvpartition(500,'KFold',5) を使用して、500 個の観測値に対する 5 分割交差検証について無作為な分割を作成するとします。この場合、'CVPartition',cvp を使用して交差検証済みモデルを指定できます。

ホールドアウト検定に使用されるデータの比率。'Holdout' と範囲 (0,1) のスカラー値から構成されるコンマ区切りのペアとして指定します。'Holdout',p を指定した場合、以下の手順が実行されます。

  1. p*100% のデータを無作為に選択して検証データとして確保し、残りのデータを使用してモデルに学習をさせる。

  2. コンパクトな学習済みモデルを交差検証済みモデルの Trained プロパティに格納する。

交差検証済みモデルの作成に使用できる名前と値のペアの引数は、CVPartitionHoldoutKFoldLeaveout の 4 つのうちのいずれかのみです。

例: 'Holdout',0.1

データ型: double | single

交差検証済みモデルで使用する分割数。'KFold' と 1 より大きい正の整数から構成されるコンマ区切りのペアとして指定します。'KFold',k を指定した場合、以下の手順が実行されます。

  1. データを無作為に k 個のセットに分割する。

  2. 各セットについて、そのセットを検定データとして確保し、他の k - 1 個のセットを使用してモデルに学習をさせる。

  3. k 個のコンパクトな学習済みモデルを、交差検証済みモデルの Trained プロパティに含まれている k 行 1 列の cell ベクトルのセルに格納する。

交差検証済みモデルの作成に使用できる名前と値のペアの引数は、CVPartitionHoldoutKFoldLeaveout の 4 つのうちのいずれかのみです。

例: 'KFold',5

データ型: single | double

Leave-one-out 法の交差検証のフラグ。'Leaveout''on' または 'off' で構成されるコンマ区切りのペアとして指定します。'Leaveout','on' を指定した場合、n 個の観測値 (n は、モデルの NumObservations プロパティで指定される、欠損観測値を除外した観測値の個数) のそれぞれについて以下の手順が実行されます。

  1. その観測値を検証データとして確保し、他の n - 1 個の観測値を使用してモデルに学習をさせる。

  2. n 個のコンパクトな学習済みモデルを、交差検証済みモデルの Trained プロパティに含まれている n 行 1 列の cell ベクトルのセルに格納する。

交差検証済みモデルの作成に使用できる名前と値のペアの引数は、CVPartitionHoldoutKFoldLeaveout の 4 つのうちのいずれかのみです。

例: 'Leaveout','on'

他の回帰のオプション

すべて折りたたむ

観測値の重み。'Weights' と、正の値の数値ベクトルまたは Tbl 内の変数の名前から構成されるコンマ区切りのペアとして指定します。X または Tbl の各行に含まれている観測値は、Weights の対応する値で重み付けされます。Weights のサイズは、X または Tbl の行数と等しくなければなりません。

入力データをテーブル Tbl として指定した場合、Weights は数値ベクトルが含まれている Tbl 内の変数の名前にすることができます。この場合、Weights には文字ベクトルまたは string スカラーを指定しなければなりません。たとえば、重みベクトル WTbl.W として格納されている場合、'W' として指定します。それ以外の場合、モデルに学習をさせるときに、Tbl の列は W を含めてすべて予測子または応答として扱われます。

合計が各クラスの事前確率の値と等しくなるように Weights が正規化されます。

既定の設定では、Weightsones(n,1) です。nX または Tbl の観測値数です。

データ型: double | single | char | string

サンプリング オプション

すべて折りたたむ

すべての弱学習器についてリサンプリングされる学習セットの比率。'FResample' と (0,1] の正のスカラーから構成されるコンマ区切りのペアとして指定します。

'FResample' を使用するには、Method'bag' を指定するか、Resample'on' に設定します。

例: 'FResample',0.75

データ型: single | double

復元抽出を示すフラグ。'Replace''off' または 'on' から構成されるコンマ区切りのペアとして指定します。

  • 'on' の場合、学習観測値が復元抽出されます。

  • 'off' の場合、学習観測値が非復元抽出されます。Resample'on' に設定した場合、重みが均一であるという前提で学習観測値がサンプリングされます。ブースティング法も指定した場合、観測値が再重み付けされてブースティングが行われます。

Method'bag' に設定した場合と Resample'on' に設定した場合を除いて、Replace の効果はありません。

例: 'Replace','off'

リサンプリングを示すフラグ。'Resample''off' または 'on' から構成されるコンマ区切りのペアとして指定します。

  • Method がブースティング法である場合、次のようになります。

    • 'Resample','on' は、更新された重みを多項サンプリング確率として使用することにより学習観測値をサンプリングするよう指定します。

    • 'Resample','off' (既定) は、すべての学習反復で観測値を再重み付けするよう指定します。

  • Method'bag' の場合、'Resample''on' でなければなりません。一定の比率 (FResample を参照) の学習観測値が復元抽出または非復元抽出 (Replace を参照) でリサンプリングされます。

Resample を使用してリサンプリングを指定する場合は、データセット全体に対してのリサンプリングをお勧めします。つまり、FResample の既定設定である 1 を使用します。

LSBoost 法のオプション

すべて折りたたむ

縮小学習率。区間 (0,1] の数値スカラーから構成されるコンマ区切りのペアとして指定します。

縮小を使用してアンサンブルに学習をさせるには、LearnRate1 未満の値 (一般的な 0.1 など) に設定します。縮小を使用してアンサンブルに学習をさせると、学習反復数を増やす必要がありますが、多くの場合精度が向上します。

例: 'LearnRate',0.1

データ型: single | double

ハイパーパラメーターの最適化

すべて折りたたむ

最適化するパラメーター。'OptimizeHyperparameters' と次のいずれかから構成されるコンマ区切りのペアとして指定します。

  • 'none' — 最適化を行いません。

  • 'auto' — 指定された Learners の既定パラメーターと共に {'Method','NumLearningCycles','LearnRate'} を使用します。

    • Learners = 'tree' (既定) — {'MinLeafSize'}

    メモ

    ハイパーパラメーターの最適化の場合、Learners は string 配列や cell 配列ではなく単一の引数でなければなりません。

  • 'all' — すべての使用可能パラメーターを最適化します。

  • 使用可能パラメーター名の string 配列または cell 配列

  • optimizableVariable オブジェクトのベクトル。通常は hyperparameters の出力です。

最適化では、パラメーターを変化させることにより、fitrensemble の交差検証損失 (誤差) を最小化しようとします。交差検証のタイプおよびその他の最適化の側面を制御するには、名前と値のペア HyperparameterOptimizationOptions を使用します。

メモ

'OptimizeHyperparameters' の値は、他の名前と値のペアの引数を使用して設定した値より優先されます。たとえば、'OptimizeHyperparameters''auto' に設定すると、'auto' の値が適用されます。

fitrensemble では、以下のパラメーターを使用できます。

  • Method — 使用可能な方式は 'Bag' または 'LSBoost' です。

  • NumLearningCyclesfitrensemble は、既定では範囲 [10,500] の対数スケールで、正の整数を探索します。

  • LearnRatefitrensemble は、既定では範囲 [1e-3,1] の対数スケールで、正の実数を探索します。

  • MinLeafSizefitrensemble は、範囲 [1,max(2,floor(NumObservations/2))] の対数スケールで整数を探索します。

  • MaxNumSplitsfitrensemble は、範囲 [1,max(2,NumObservations-1)] の対数スケールで整数を探索します。

  • NumVariablesToSamplefitrensemble は、範囲 [1,max(2,NumPredictors)] の整数値を探索します。

既定以外のパラメーターを設定するには、既定以外の値が含まれている optimizableVariable オブジェクトのベクトルを渡します。たとえば、以下のようにします。

load carsmall
params = hyperparameters('fitrensemble',[Horsepower,Weight],MPG,'Tree');
params(4).Range = [1,20];

OptimizeHyperparameters の値として params を渡します。

既定では、コマンド ラインに反復表示が表示され、最適化のハイパーパラメーターの個数に従ってプロットが表示されます。最適化とプロットにおける目的関数は、回帰の場合は log(1 + 交差検証損失)、分類の場合は誤分類率です。反復表示を制御するには、名前と値のペアの引数 'HyperparameterOptimizationOptions'Verbose フィールドを設定します。プロットを制御するには、名前と値のペアの引数 'HyperparameterOptimizationOptions'ShowPlots フィールドを設定します。

たとえば、アンサンブル回帰の最適化を参照してください。

例: 'OptimizeHyperparameters',{'Method','NumLearningCycles','LearnRate','MinLeafSize','MaxNumSplits'}

最適化のオプション。'HyperparameterOptimizationOptions' と構造体から構成されるコンマ区切りのペアとして指定します。この引数を指定すると、名前と値のペアの引数 OptimizeHyperparameters の効果が変化します。この構造体のフィールドは、すべてオプションです。

フィールド名既定の設定
Optimizer
  • 'bayesopt' — ベイズ最適化を使用。内部的には bayesopt が呼び出されます。

  • 'gridsearch' — 次元ごとに NumGridDivisions の値があるグリッド探索を使用。

  • 'randomsearch'MaxObjectiveEvaluations 個の点で無作為に探索。

'gridsearch' では、グリッドからの一様な非復元抽出により、無作為な順序で探索します。最適化後、sortrows(Mdl.HyperparameterOptimizationResults) コマンドを使用してグリッド順のテーブルを取得できます。

'bayesopt'
AcquisitionFunctionName

  • 'expected-improvement-per-second-plus'

  • 'expected-improvement'

  • 'expected-improvement-plus'

  • 'expected-improvement-per-second'

  • 'lower-confidence-bound'

  • 'probability-of-improvement'

オブジェクト関数のランタイムによって最適化が異なるので、名前に per-second が含まれている獲得関数は、再現性がある結果を生成しません。名前に plus が含まれている獲得関数は、領域を過剰利用している場合に動作を変更します。詳細は、獲得関数のタイプを参照してください。

'expected-improvement-per-second-plus'
MaxObjectiveEvaluations目的関数評価の最大数。'bayesopt' または 'randomsearch' の場合は 30'gridsearch' の場合はグリッド全体
MaxTime

制限時間。正の実数を指定します。制限時間の単位は、tictoc によって測定される秒です。MaxTime は関数評価を中断させないため、実行時間が MaxTime を超える可能性があります。

Inf
NumGridDivisions'gridsearch' における各次元の値の個数。値は、各次元の値の個数を表す正の整数のベクトル、またはすべての次元に適用されるスカラーが可能です。カテゴリカル変数の場合、このフィールドは無視されます。10
ShowPlotsプロットを表示するかどうかを示す論理値。true の場合、最良の目的関数の値が反復回数に対してプロットされます。1 つまたは 2 つの最適化パラメーターがあり、Optimizer'bayesopt' である場合、ShowPlots はパラメーターに対する目的関数のモデルのプロットも行います。true
SaveIntermediateResultsOptimizer'bayesopt' である場合に結果を保存するかどうかを示す論理値。true の場合、'BayesoptResults' という名前のワークスペース変数が反復ごとに上書きされます。この変数は BayesianOptimization オブジェクトです。false
Verbose

コマンド ラインへの表示。

  • 0 — 反復表示なし

  • 1 — 反復表示あり

  • 2 — 追加情報付きで反復表示あり

詳細については、bayesopt の名前と値のペアの引数 Verbose を参照してください。

1
UseParallelベイズ最適化を並列実行するかどうかを示す論理値。並列実行には Parallel Computing Toolbox™ が必要です。詳細については、並列ベイズ最適化を参照してください。false
Repartition

反復ごとに交差検証を再分割するかどうかを示す論理値。false の場合、オプティマイザーは単一の分割を最適化に使用します。

分割ノイズが考慮されるので、通常は true にすると最も確実な結果が得られます。ただし、true で良好な結果を得るには、2 倍以上の関数評価が必要になります。

false
以下の 3 つのフィールド名は 1 つだけ使用できます。
CVPartitioncvpartition によって作成される cvpartition オブジェクト。交差検証フィールドが指定されていない場合 'Kfold',5
Holdoutホールドアウトの比率を表す範囲 (0,1) のスカラー。
Kfold1 より大きい整数。

例: 'HyperparameterOptimizationOptions',struct('MaxObjectiveEvaluations',60)

データ型: 構造体

出力引数

すべて折りたたむ

学習済みのアンサンブル モデル。次の表のモデル オブジェクトのいずれかとして返されます。

モデル オブジェクト交差検証オプションの指定Method の設定Resample の設定
RegressionBaggedEnsembleなし'Bag''on'
RegressionEnsembleなし'LSBoost''off'
RegressionPartitionedEnsembleあり'LSBoost' または 'Bag''off' または 'on'

交差検証を制御する名前と値のペアの引数は CrossValHoldoutKFoldLeaveout および CVPartition です。

Mdl のプロパティを参照するには、ドット表記を使用します。たとえば、交差検証されていないアンサンブルについて弱学習器モデル オブジェクトの cell ベクトルのアクセスまたは表示を行うには、コマンド ラインで Mdl.Trained を入力します。

ヒント

  • NumLearningCycles は数十から数千までさまざまな数になります。通常、予測力が高いアンサンブルでは数百から数千の弱学習器が必要です。しかし、このような多数のサイクルの学習をアンサンブルが一度に行う必要はありません。数十個の学習器の学習から開始してアンサンブルの性能を調査し、必要な場合は resume を使用して弱学習器の数を増やすことができます。

  • アンサンブルの性能は、アンサンブルの設定と弱学習器の設定によって決まります。つまり、既定のパラメーターを使用する弱学習器を指定すると、アンサンブルの性能が低下する可能性があります。このため、アンサンブルの設定と同じように、テンプレートを使用して弱学習器のパラメーターを調整し、汎化誤差が最小になる値を選択することをお勧めします。

  • Resample を使用してリサンプリングを指定する場合は、データセット全体に対してのリサンプリングをお勧めします。つまり、FResample の既定設定である 1 を使用します。

  • モデルに学習をさせた後で、新しいデータについて応答を予測する C/C++ コードを生成できます。C/C++ コードの生成には MATLAB Coder™ が必要です。詳細については、コード生成の紹介を参照してください。

アルゴリズム

  • アンサンブル集約アルゴリズムの詳細については、アンサンブル アルゴリズムを参照してください。

  • 'Method','LSBoost' を指定した場合、既定では浅い決定木が成長します。木の深さは、templateTree を使用して名前と値のペアの引数 MaxNumSplitsMinLeafSize および MinParentSize を指定することにより調整できます。

  • デュアルコア以上のシステムの場合、fitrensemble では Intel® スレッディング ビルディング ブロック (TBB) を使用して学習を並列化します。Intel TBB についての詳細は、https://software.intel.com/en-us/intel-tbb を参照してください。

参照

[1] Breiman, L. “Bagging Predictors.” Machine Learning. Vol. 26, pp. 123–140, 1996.

[2] Breiman, L. “Random Forests.” Machine Learning. Vol. 45, pp. 5–32, 2001.

[3] Freund, Y. and R. E. Schapire. “A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting.” J. of Computer and System Sciences, Vol. 55, pp. 119–139, 1997.

[4] Friedman, J. “Greedy function approximation: A gradient boosting machine.” Annals of Statistics, Vol. 29, No. 5, pp. 1189–1232, 2001.

[5] Hastie, T., R. Tibshirani, and J. Friedman. The Elements of Statistical Learning section edition, Springer, New York, 2008.

拡張機能

R2016b で導入