fitcensemble

アンサンブル学習器を分類用に準備

構文

Mdl = fitcensemble(Tbl,ResponseVarName)

Mdl = fitcensemble(Tbl,formula)

Mdl = fitcensemble(Tbl,Y)

Mdl = fitcensemble(X,Y)

Mdl = fitcensemble(___,Name,Value)

説明

Mdl = fitcensemble(Tbl,ResponseVarName) は、100 本の分類木のブースティングの結果および予測子と応答データのテーブル Tbl が格納されている学習済みアンサンブル分類モデル オブジェクト (Mdl) を返します。ResponseVarName は、Tbl 内の応答変数の名前です。既定では、fitcensemble はバイナリ分類に LogitBoost を、マルチクラス分類に AdaBoostM2 を使用します。

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

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

Mdl = fitcensemble(X,Y) は、行列 X 内の予測子データと Y 内のクラス ラベルの配列を使用します。

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

例

アンサンブル分類に学習をさせる

データ内の使用可能な予測子変数をすべて使用して、予測アンサンブル分類を作成します。次に、予測子の数を減らして、別のアンサンブルに学習をさせます。これらのアンサンブルの標本内予測精度を比較します。

census1994 データ セットを読み込みます。

load census1994

データ セット全体と既定のオプションを使用して、分類モデルのアンサンブルに学習をさせます。

Mdl1 = fitcensemble(adultdata,'salary')

Mdl1 = 
  ClassificationEnsemble
           PredictorNames: {'age'  'workClass'  'fnlwgt'  'education'  'education_num'  'marital_status'  'occupation'  'relationship'  'race'  'sex'  'capital_gain'  'capital_loss'  'hours_per_week'  'native_country'}
             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}

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

• データには 2 つのクラスがあるので、アンサンブル集約アルゴリズムは LogitBoost です。

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

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

このアンサンブル分類を使用して、データから無作為に抽出した 5 つの観測値のラベルを予測します。予測されたラベルと真の値を比較します。

rng(1) % For reproducibility
[pX,pIdx] = datasample(adultdata,5);
label = predict(Mdl1,pX);
table(label,adultdata.salary(pIdx),'VariableNames',{'Predicted','Truth'})

ans=5×2 table
    Predicted    Truth
    _________    _____

      <=50K      <=50K
      <=50K      <=50K
      <=50K      <=50K
      <=50K      <=50K
      <=50K      <=50K

age と education のみを使用して、新しいアンサンブルに学習をさせます。

Mdl2 = fitcensemble(adultdata,'salary ~ age + education');

Mdl1 と Mdl2 の再代入損失を比較します。

rsLoss1 = resubLoss(Mdl1)

rsLoss1 = 0.1058

rsLoss2 = resubLoss(Mdl2)

rsLoss2 = 0.2037

すべての予測子を使用するアンサンブルの方が、標本内誤分類率が小さくなります。

数値予測子の値のビン化による学習の高速化

fitcensemble を使用して、ブースティング分類木のアンサンブルに学習をさせます。名前と値のペアの引数 'NumBins' を指定して数値予測子をビン化することにより、学習時間を短縮します。この引数は、fitcensemble が木学習器を使用する場合のみ有効です。学習後、学習済みモデルの BinEdges プロパティと関数discretizeを使用して、ビン化された予測子データを再現できます。

標本データ セットを生成します。

rng('default') % For reproducibility
N = 1e6;
X = [mvnrnd([-1 -1],eye(2),N); mvnrnd([1 1],eye(2),N)];
y = [zeros(N,1); ones(N,1)];

データ セットを可視化します。

figure
scatter(X(1:N,1),X(1:N,2),'Marker','.','MarkerEdgeAlpha',0.01)
hold on
scatter(X(N+1:2*N,1),X(N+1:2*N,2),'Marker','.','MarkerEdgeAlpha',0.01)

適応ロジスティック回帰 (LogitBoost、バイナリ分類の既定) を使用して、ブースティング分類木のアンサンブルに学習をさせます。比較のため、関数の実行時間を測定します。

tic
Mdl1 = fitcensemble(X,y);
toc

Elapsed time is 478.988422 seconds.

名前と値のペアの引数 'NumBins' を使用して、学習を高速化します。'NumBins' の値として正の整数スカラーを指定した場合、指定した個数の同確率のビンにすべての数値予測子がビン化され、元のデータではなくビンのインデックスに対して木が成長します。カテゴリカル予測子はビン化されません。

tic
Mdl2 = fitcensemble(X,y,'NumBins',50);
toc

Elapsed time is 165.598434 seconds.

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

再代入による分類誤差を比較します。

rsLoss1 = resubLoss(Mdl1)

rsLoss1 = 0.0788

rsLoss2 = resubLoss(Mdl2)

rsLoss2 = 0.0788

この例では、予測子の値をビン化することにより、精度を失わずに学習時間が短縮されました。一般に、この例のような大規模な学習データ セットを使用する場合、ビン化オプションを使用すると学習を高速化できますが、精度が低下する可能性があります。さらに学習時間を短縮するには、指定するビンの個数を少なくします。

学習済みモデルの BinEdges プロパティと関数discretizeを使用して、ビン化された予測子データを再現します。

X = Mdl2.X; % Predictor data
Xbinned = zeros(size(X));
edges = Mdl2.BinEdges;
% Find indices of binned predictors.
idxNumeric = find(~cellfun(@isempty,edges));
if iscolumn(idxNumeric)
    idxNumeric = idxNumeric';
end
for j = idxNumeric 
    x = X(:,j);
    % Convert x to array if x is a table.
    if istable(x)
        x = table2array(x);
    end
    % Group x into bins by using the discretize function.
    xbinned = discretize(x,[-inf; edges{j}; inf]);
    Xbinned(:,j) = xbinned;
end

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

ブースティング アンサンブルの汎化誤差の推定

ブースティング分類木のアンサンブルの汎化誤差を推定します。

ionosphere データ セットを読み込みます。

load ionosphere

AdaBoostM1 と 10 分割の交差検証を使用して、分類木のアンサンブルを交差検証します。決定木テンプレートを使用して各木を最大 5 回分割するように指定します。

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

このアンサンブルでは、約 50 個の弱学習器が蓄積した後の誤分類率が約 0.06 になっています。そして、弱学習器がさらにアンサンブルに加わると、誤分類率がわずかに増加しています。

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

アンサンブル分類の最適化

fitcensemble を使用してハイパーパラメーターを自動的に最適化します。

ionosphere データ セットを読み込みます。

load ionosphere

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

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 |      2.8201 |     0.10256 |     0.10256 |     RUSBoost |           11 |     0.010199 |           17 |
|    2 | Best   |    0.082621 |      6.3089 |    0.082621 |    0.083414 |   LogitBoost |          206 |      0.96537 |           33 |
|    3 | Accept |    0.099715 |      4.0004 |    0.082621 |    0.082624 |   AdaBoostM1 |          130 |    0.0072814 |            2 |
|    4 | Best   |    0.068376 |      1.5887 |    0.068376 |    0.068395 |          Bag |           25 |            - |            5 |
|    5 | Best   |    0.059829 |      1.7618 |    0.059829 |    0.062829 |   LogitBoost |           58 |      0.19016 |            5 |
|    6 | Accept |    0.068376 |      1.6662 |    0.059829 |    0.065561 |   LogitBoost |           58 |      0.10005 |            5 |
|    7 | Accept |    0.088319 |       13.07 |    0.059829 |    0.065786 |   LogitBoost |          494 |     0.014474 |            3 |
|    8 | Accept |    0.065527 |     0.79673 |    0.059829 |    0.065894 |   LogitBoost |           26 |      0.75515 |            8 |
|    9 | Accept |     0.15385 |     0.93354 |    0.059829 |    0.061156 |   LogitBoost |           32 |    0.0010037 |           59 |
|   10 | Accept |    0.059829 |      3.8828 |    0.059829 |    0.059731 |   LogitBoost |          143 |      0.44428 |            1 |
|   11 | Accept |     0.35897 |      2.3272 |    0.059829 |    0.059826 |          Bag |           54 |            - |          175 |
|   12 | Accept |    0.068376 |     0.53634 |    0.059829 |    0.059825 |          Bag |           10 |            - |            1 |
|   13 | Accept |     0.12251 |      9.5155 |    0.059829 |    0.059826 |   AdaBoostM1 |          442 |      0.57897 |          102 |
|   14 | Accept |     0.11966 |      4.9323 |    0.059829 |    0.059827 |     RUSBoost |           95 |      0.80822 |            1 |
|   15 | Accept |    0.062678 |      4.2429 |    0.059829 |    0.059826 |  GentleBoost |          156 |      0.99502 |            1 |
|   16 | Accept |    0.065527 |      3.0688 |    0.059829 |    0.059824 |  GentleBoost |          115 |      0.99693 |           13 |
|   17 | Best   |     0.05698 |       1.659 |     0.05698 |    0.056997 |  GentleBoost |           60 |    0.0010045 |            3 |
|   18 | Accept |     0.13675 |      2.0647 |     0.05698 |    0.057002 |  GentleBoost |           86 |    0.0010263 |          108 |
|   19 | Accept |    0.062678 |      2.4037 |     0.05698 |     0.05703 |  GentleBoost |           88 |       0.6344 |            4 |
|   20 | Accept |    0.065527 |       1.029 |     0.05698 |    0.057228 |  GentleBoost |           35 |    0.0010155 |            1 |
|===================================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Method | NumLearningC-|    LearnRate |  MinLeafSize |
|      | result |             | runtime     | (observed)  | (estim.)    |              | ycles        |              |              |
|===================================================================================================================================|
|   21 | Accept |    0.079772 |     0.44308 |     0.05698 |    0.057214 |   LogitBoost |           11 |       0.9796 |            2 |
|   22 | Accept |    0.065527 |      21.191 |     0.05698 |    0.057523 |          Bag |          499 |            - |            1 |
|   23 | Accept |    0.068376 |      20.294 |     0.05698 |    0.057671 |          Bag |          494 |            - |            2 |
|   24 | Accept |     0.64103 |      1.2793 |     0.05698 |    0.057468 |     RUSBoost |           30 |     0.088421 |          174 |
|   25 | Accept |    0.088319 |     0.53606 |     0.05698 |    0.057456 |     RUSBoost |           10 |     0.010292 |            5 |
|   26 | Accept |    0.074074 |     0.36802 |     0.05698 |     0.05753 |   AdaBoostM1 |           11 |      0.14192 |           13 |
|   27 | Accept |    0.099715 |      12.133 |     0.05698 |    0.057646 |   AdaBoostM1 |          498 |    0.0010096 |            6 |
|   28 | Accept |    0.079772 |      10.877 |     0.05698 |    0.057886 |   AdaBoostM1 |          474 |     0.030547 |           31 |
|   29 | Accept |    0.068376 |      12.326 |     0.05698 |    0.061326 |  GentleBoost |          493 |      0.36142 |            2 |
|   30 | Accept |    0.065527 |      0.3945 |     0.05698 |    0.061165 |   LogitBoost |           11 |      0.71408 |           16 |

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

Best observed feasible point:
      Method       NumLearningCycles    LearnRate    MinLeafSize
    ___________    _________________    _________    ___________

    GentleBoost           60            0.0010045         3     

Observed objective function value = 0.05698
Estimated objective function value = 0.061165
Function evaluation time = 1.659

Best estimated feasible point (according to models):
      Method       NumLearningCycles    LearnRate    MinLeafSize
    ___________    _________________    _________    ___________

    GentleBoost           60            0.0010045         3     

Estimated objective function value = 0.061165
Estimated function evaluation time = 1.6503

Mdl = 
  ClassificationEnsemble
                         ResponseName: 'Y'
                CategoricalPredictors: []
                           ClassNames: {'b'  'g'}
                       ScoreTransform: 'none'
                      NumObservations: 351
    HyperparameterOptimizationResults: [1×1 BayesianOptimization]
                           NumTrained: 60
                               Method: 'GentleBoost'
                         LearnerNames: {'Tree'}
                 ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
                              FitInfo: [60×1 double]
                   FitInfoDescription: {2×1 cell}


  Properties, Methods

最適化では、バイナリ分類のアンサンブル集約法、NumLearningCycles、適用可能な手法の LearnRate、および木学習器の MinLeafSize に対して探索を行いました。出力は、推定交差検証損失が最小になるアンサンブル分類器です。

交差検証の使用によるアンサンブル分類の最適化

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

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

ionosphere データ セットを読み込みます。

load ionosphere

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

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

2. 各アンサンブルの交差検証済み誤分類率を推定します。

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

4. 誤分類率が最小になる曲線を選択し、対応する学習サイクルおよび学習率に注目します。

深い分類木と切り株を交差検証します。これらの分類木は基準として機能します。

rng(1) % For reproducibility
MdlDeep = fitctree(X,Y,'CrossVal','on','MergeLeaves','off', ...
    'MinParentSize',1);
MdlStump = fitctree(X,Y,'MaxNumSplits',1,'CrossVal','on');

5 分割の交差検証を使用して、150 本のブースティング分類木のアンサンブルを交差検証します。木のテンプレートを使用して、$$\{3^0,3^1,...,3^m\}$$ という数列の値を使用して分割の最大数を変化させます。m は、$$3^m$$ が n - 1 を超えない値です。各バリアントについて、{0.1, 0.25, 0.5, 1} という集合の各値を使用して、それぞれの学習率を調整します。

n = size(X,1);
m = floor(log(n - 1)/log(3));
learnRate = [0.1 0.25 0.5 1];
numLR = numel(learnRate);
maxNumSplits = 3.^(0:m);
numMNS = numel(maxNumSplits);
numTrees = 150;
Mdl = cell(numMNS,numLR);

for k = 1:numLR
    for j = 1:numMNS
        t = templateTree('MaxNumSplits',maxNumSplits(j));
        Mdl{j,k} = fitcensemble(X,Y,'NumLearningCycles',numTrees,...
            'Learners',t,'KFold',5,'LearnRate',learnRate(k));
    end
end

各アンサンブルについて、および基準として機能する分類木について、交差検証済み累積誤分類率を推定します。

kflAll = @(x)kfoldLoss(x,'Mode','cumulative');
errorCell = cellfun(kflAll,Mdl,'Uniform',false);
error = reshape(cell2mat(errorCell),[numTrees numel(maxNumSplits) numel(learnRate)]);
errorDeep = kfoldLoss(MdlDeep);
errorStump = kfoldLoss(MdlStump);

アンサンブル内の木の本数が増加すると交差検証済み誤分類率がどのように変化するかをプロットします。同じプロットに学習率ごとの曲線をプロットし、木の複雑度レベルを変えた別のプロットをそれぞれ作成します。木の複雑度レベルからプロット対象となるサブセットを選択します。

mnsPlot = [1 round(numel(maxNumSplits)/2) numel(maxNumSplits)];
figure
for k = 1:3
    subplot(2,2,k)
    plot(squeeze(error(:,mnsPlot(k),:)),'LineWidth',2)
    axis tight
    hold on
    h = gca;
    plot(h.XLim,[errorDeep errorDeep],'-.b','LineWidth',2)
    plot(h.XLim,[errorStump errorStump],'-.r','LineWidth',2)
    plot(h.XLim,min(min(error(:,mnsPlot(k),:))).*[1 1],'--k')
    h.YLim = [0 0.2];    
    xlabel('Number of trees')
    ylabel('Cross-validated misclass. rate')
    title(sprintf('MaxNumSplits = %0.3g', maxNumSplits(mnsPlot(k))))
    hold off
end
hL = legend([cellstr(num2str(learnRate','Learning Rate = %0.2f')); ...
        'Deep Tree';'Stump';'Min. misclass. rate']);
hL.Position(1) = 0.6;

各曲線では、アンサンブルの最適な木の本数の位置で交差検証済み誤分類率が最小になります。

全体的に誤分類率が最小になる最大分割数、木の本数および学習率を特定します。

[minErr,minErrIdxLin] = min(error(:));
[idxNumTrees,idxMNS,idxLR] = ind2sub(size(error),minErrIdxLin);

fprintf('\nMin. misclass. rate = %0.5f',minErr)

Min. misclass. rate = 0.05128

fprintf('\nOptimal Parameter Values:\nNum. Trees = %d',idxNumTrees);

Optimal Parameter Values:
Num. Trees = 130

fprintf('\nMaxNumSplits = %d\nLearning Rate = %0.2f\n',...
    maxNumSplits(idxMNS),learnRate(idxLR))

MaxNumSplits = 9
Learning Rate = 1.00

最適なハイパーパラメーターおよび学習セット全体に基づいて予測アンサンブルを作成します。

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: 130
                   Method: 'LogitBoost'
             LearnerNames: {'Tree'}
     ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
                  FitInfo: [130×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.094017 |      3.7194 |    0.094017 |    0.094017 |          137 |     0.001364 |            3 |
|    2 | Accept |     0.12251 |     0.66511 |    0.094017 |    0.095735 |           15 |     0.013089 |          144 |

|    3 | Best   |    0.065527 |     0.90035 |    0.065527 |    0.067815 |           31 |      0.47201 |            2 |
|    4 | Accept |     0.19943 |      8.6107 |    0.065527 |    0.070015 |          340 |      0.92167 |            7 |
|    5 | Accept |    0.071225 |     0.90081 |    0.065527 |    0.065583 |           32 |      0.14422 |            2 |
|    6 | Accept |    0.099715 |       0.688 |    0.065527 |    0.065573 |           23 |    0.0010566 |            2 |
|    7 | Accept |     0.11681 |     0.90799 |    0.065527 |    0.065565 |           28 |    0.0010156 |          259 |
|    8 | Accept |     0.17379 |     0.82143 |    0.065527 |    0.065559 |           29 |    0.0013435 |            1 |
|    9 | Best   |    0.059829 |     0.59677 |    0.059829 |    0.059844 |           18 |      0.87865 |            3 |
|   10 | Accept |     0.11111 |     0.40132 |    0.059829 |    0.059843 |           10 |    0.0012112 |           48 |
|   11 | Accept |     0.08547 |     0.41121 |    0.059829 |    0.059842 |           10 |      0.62108 |           25 |
|   12 | Accept |     0.11681 |     0.41538 |    0.059829 |    0.059841 |           10 |    0.0012154 |           20 |
|   13 | Accept |    0.082621 |     0.46504 |    0.059829 |    0.059842 |           10 |      0.55351 |           35 |
|   14 | Accept |    0.079772 |     0.46297 |    0.059829 |     0.05984 |           11 |      0.74109 |           74 |
|   15 | Accept |    0.088319 |     0.69297 |    0.059829 |     0.05984 |           19 |      0.91106 |          347 |
|   16 | Accept |    0.062678 |      0.3637 |    0.059829 |    0.059886 |           10 |      0.97239 |            3 |
|   17 | Accept |    0.065527 |      1.9404 |    0.059829 |    0.059887 |           78 |      0.97069 |            3 |
|   18 | Accept |    0.065527 |     0.39816 |    0.059829 |    0.062228 |           11 |      0.75051 |            2 |
|   19 | Best   |    0.054131 |     0.36381 |    0.054131 |    0.059083 |           10 |      0.69072 |            3 |
|   20 | Accept |    0.065527 |     0.38429 |    0.054131 |    0.060938 |           10 |      0.64403 |            3 |
|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | NumLearningC-|    LearnRate | MaxNumSplits |
|      | result |             | runtime     | (observed)  | (estim.)    | ycles        |              |              |
|====================================================================================================================|
|   21 | Accept |    0.079772 |     0.40405 |    0.054131 |    0.060161 |           10 |      0.80548 |           13 |
|   22 | Accept |     0.05698 |     0.37983 |    0.054131 |    0.059658 |           10 |      0.56949 |            5 |
|   23 | Accept |     0.10826 |     0.36128 |    0.054131 |    0.059244 |           10 |    0.0055133 |            5 |
|   24 | Accept |    0.074074 |     0.38056 |    0.054131 |     0.05933 |           10 |      0.92056 |            6 |
|   25 | Accept |     0.11966 |     0.35336 |    0.054131 |    0.059132 |           10 |      0.27254 |            1 |
|   26 | Accept |    0.065527 |     0.77041 |    0.054131 |    0.059859 |           26 |      0.97412 |            3 |
|   27 | Accept |    0.068376 |     0.38116 |    0.054131 |    0.060205 |           10 |      0.82146 |            4 |
|   28 | Accept |    0.062678 |     0.47015 |    0.054131 |    0.060713 |           14 |      0.99445 |            3 |
|   29 | Accept |     0.11966 |     0.41033 |    0.054131 |    0.060826 |           10 |    0.0012621 |          344 |
|   30 | Accept |     0.08547 |     0.45352 |    0.054131 |    0.060771 |           10 |      0.93676 |          187 |

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

Best observed feasible point:
    NumLearningCycles    LearnRate    MaxNumSplits
    _________________    _________    ____________

           10             0.69072          3      

Observed objective function value = 0.054131
Estimated objective function value = 0.061741
Function evaluation time = 0.36381

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

           14             0.99445          3      

Estimated objective function value = 0.060771
Estimated function evaluation time = 0.48009

mdl = 
  ClassificationEnsemble
                         ResponseName: 'Y'
                CategoricalPredictors: []
                           ClassNames: {'b'  'g'}
                       ScoreTransform: 'none'
                      NumObservations: 351
    HyperparameterOptimizationResults: [1×1 BayesianOptimization]
                           NumTrained: 14
                               Method: 'LogitBoost'
                         LearnerNames: {'Tree'}
                 ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'
                              FitInfo: [14×1 double]
                   FitInfoDescription: {2×1 cell}


  Properties, Methods

入力引数

Tbl — 標本データ

テーブル

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

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

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

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

メモ

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

データ型: table

ResponseVarName — 応答変数名

Tbl 内の応答変数の名前

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

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

応答変数は、categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列でなければなりません。応答変数が文字配列の場合、各要素は配列の 1 つの行に対応しなければなりません。

分類の場合、名前と値のペアの引数 ClassNames を使用してクラスの順序を指定できます。それ以外の場合、fitcensemble がクラスの順序を決定して Mdl.ClassNames に格納します。

データ型: char | string

formula — 応答変数および予測子変数サブセットの説明モデル

文字ベクトル | string スカラー

応答変数および予測子変数サブセットの説明モデル。"Y~x1+x2+x3" という形式の文字ベクトルまたは string スカラーを指定します。この形式では、Y は応答変数を、x1、x2 および x3 は予測子変数を表します。

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

式の変数名は Tbl の変数名 (Tbl.Properties.VariableNames) であり、有効な MATLAB^® 識別子でなければなりません。関数 isvarname を使用して Tbl の変数名を検証できます。変数名が有効でない場合、関数 matlab.lang.makeValidName を使用してそれらを変換できます。

データ型: char | string

X — 予測子データ

数値行列

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

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

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

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

データ型: single | double

Y — 応答データ

categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

応答データ。categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列を指定します。Y の各エントリは、X または Tbl の対応する行の観測値に対する応答またはラベルです。Y の長さと X または Tbl の行数は、同じでなければなりません。応答変数が文字配列の場合、各要素は配列の 1 つの行に対応しなければなりません。

名前と値のペアの引数 ClassNames を使用してクラスの順序を指定できます。それ以外の場合、fitcensemble がクラスの順序を決定して Mdl.ClassNames に格納します。

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

名前と値の引数

オプションの引数のペアを Name1=Value1,...,NameN=ValueN として指定します。ここで Name は引数名、Value は対応する値です。名前と値の引数は他の引数の後ろにする必要がありますが、ペアの順序は関係ありません。

R2021a より前では、名前と値をそれぞれコンマを使って区切り、Name を引用符で囲みます。

例: 'CrossVal','on','LearnRate',0.05 は、10 分割交差検証を実施し、学習率として 0.05 を使用するよう指定します。

メモ

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

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

Method — アンサンブル集約法

'Bag' | 'Subspace' | 'AdaBoostM1' | 'AdaBoostM2' | 'GentleBoost' | 'LogitBoost' | 'LPBoost' | 'RobustBoost' | 'RUSBoost' | 'TotalBoost'

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

値	メソッド	分類問題のサポート	関連する名前と値のペアの引数
'Bag'	bootstrap aggregation (バギング、ランダム フォレスト[2]など) — 'Method' が 'Bag' である場合、fitcensemble はバギングを使用し、既定では各分岐で無作為に予測子を選択します。無作為な選択を行わずにバギングを使用するには、'NumVariablesToSample' の値が 'all' であるツリー学習器を使用するか、判別分析学習器を使用します。	バイナリおよびマルチクラス	該当なし
'Subspace'	ランダム部分空間	バイナリおよびマルチクラス	NPredToSample
'AdaBoostM1'	適応ブースティング	バイナリのみ	LearnRate
'AdaBoostM2'	適応ブースティング	マルチクラスのみ	LearnRate
'GentleBoost'	ジェントル適応ブースティング	バイナリのみ	LearnRate
'LogitBoost'	適応ロジスティック回帰	バイナリのみ	LearnRate
'LPBoost'	線形計画ブースティング — Optimization Toolbox™ が必要	バイナリおよびマルチクラス	MarginPrecision
'RobustBoost'	ロバスト ブースティング — Optimization Toolbox が必要	バイナリのみ	RobustErrorGoal, RobustMarginSigma, RobustMaxMargin
'RUSBoost'	ランダム アンダーサンプリング ブースティング	バイナリおよびマルチクラス	LearnRate, RatioToSmallest
'TotalBoost'	完全補正ブースティング — Optimization Toolbox が必要	バイナリおよびマルチクラス	MarginPrecision

バギング ('Bag') またはブースティング ('TotalBoost'、'RUSBoost'、'AdaBoostM1'、'AdaBoostM2'、'GentleBoost'、'LogitBoost'、'RobustBoost' または 'LPBoost') を使用する場合、学習データのサンプリング オプション (FResample、Replace、Resample) を指定できます。

既定値は以下のとおりです。

• 木学習器のみが 'Learners' に含まれている場合、バイナリ問題では 'LogitBoost'、マルチクラス問題では 'AdaBoostM2'

• 木学習器と判別分析学習器の両方が 'Learners' に含まれている場合、バイナリ問題では 'AdaBoostM1'、マルチクラス問題では 'AdaBoostM2'

• 木学習器が 'Learners' に含まれていない場合、'Subspace'

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

例: 'Method','Bag'

NumLearningCycles — アンサンブル学習サイクルの数

100 (既定値) | 正の整数 | 'AllPredictorCombinations'

アンサンブル学習のサイクル数。'NumLearningCycles' と正の整数または 'AllPredictorCombinations' から構成されるコンマ区切りのペアとして指定します。

• 正の整数を指定した場合、すべての学習サイクルで、1 つの弱学習器が Learners 内のすべてのテンプレート オブジェクトについて学習します。この結果、延べ NumLearningCycles*numel(Learners) 個の学習器が学習を行います。

• 'AllPredictorCombinations' を指定する場合は、Method を 'Subspace' に設定し、Learners に対して 1 つの学習器のみを指定します。このように設定すると、予測子が一度に NPredToSample 個抽出され、その可能な組み合わせすべてに対して学習器が学習を行います。この結果、nchoosek(size(X,2),NPredToSample) 個の学習器が学習を行います。

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

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

例: 'NumLearningCycles',500

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

Learners — アンサンブルで使用する弱学習器

'discriminant' | 'knn' | 'tree' | 弱学習器テンプレート オブジェクト | 弱学習器テンプレート オブジェクトの cell ベクトル

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

弱学習器	弱学習器の名前	テンプレート オブジェクト作成関数	Method の設定
判別分析	'discriminant'	templateDiscriminant	'Subspace' を推奨
k 最近傍	'knn'	templateKNN	'Subspace' のみ
決定木	'tree'	templateTree	'Subspace' を除くすべての手法

• 弱学習器の名前 ('discriminant'、'knn' または 'tree') — fitcensemble は、テンプレート オブジェクト作成関数が既定の設定で作成した弱学習器を使用します。たとえば、'Learners','discriminant' という指定は 'Learners',templateDiscriminant() という指定と同じです。弱学習器の既定設定については、テンプレート オブジェクト作成関数のページを参照してください。

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

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

'Method' が 'Subspace' である場合、'Learners' の既定値は 'knn' です。

'Method' が 'Bag' またはいずれかのブースティング法である場合、'Learners' の既定値は 'tree' です。templateTree() の既定値は、'Method' の値に応じて変化します。

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

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

弱学習器の既定設定については、templateTree を参照してください。再現性がある結果を取得するには、'NumVariablesToSample' が 'all' でない場合、templateTree の名前と値のペアの引数 'Reproducible' を true として指定しなければなりません。

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

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

NPrint — 出力頻度

"off" (既定値) | 正の整数

出力頻度。正の整数または "off" として指定します。

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

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

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

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

ヒント

一部のブースティングされた決定木の学習を最速にするには、NPrint を既定値の "off" に設定します。このヒントは、分類の Method が "AdaBoostM1"、"AdaBoostM2"、"GentleBoost"、または "LogitBoost" であるか、回帰の Method が "LSBoost" である場合に有効です。

例: NPrint=5

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

NumBins — 数値予測子のビンの個数

[] (空) (既定値) | 正の整数スカラー

数値予測子のビンの個数。'NumBins' と正の整数スカラーから構成されるコンマ区切りのペアとして指定します。この引数は、fitcensemble が木学習器を使用する場合、つまり、'Learners' が 'tree' であるか、templateTree を使用して作成したテンプレート オブジェクトである場合のみ有効です。

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

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

  • 予測子に含まれる一意の値が numBins より少なければ、ビンの数を numBins より少なくすることができます。

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

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

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

例: 'NumBins',50

データ型: single | double

CategoricalPredictors — カテゴリカル予測子のリスト

正の整数のベクトル | logical ベクトル | 文字行列 | string 配列 | 文字ベクトルの cell 配列 | 'all'

カテゴリカル予測子のリスト。次の表のいずれかの値として指定します。

値	説明
正の整数のベクトル	ベクトルの各エントリは、対応する予測子がカテゴリカルであることを示すインデックス値です。インデックス値の範囲は 1 ～ p です。p はモデルの学習に使用した予測子の数です。 fitcensemble が入力変数のサブセットを予測子として使用する場合、関数はサブセットのみを使用して予測子にインデックスを作成します。応答変数、観測値の重みの変数、および関数で使用されないその他の変数は、CategoricalPredictors 値でカウントされません。
logical ベクトル	true というエントリは、対応する予測子がカテゴリカルであることを意味します。ベクトルの長さは p です。
文字行列	行列の各行は予測子変数の名前です。名前は PredictorNames のエントリに一致しなくてはなりません。文字行列の各行が同じ長さになるように、名前を余分な空白で埋めてください。
文字ベクトルの cell 配列または string 配列	配列の各要素は予測子変数の名前です。名前は PredictorNames のエントリに一致しなくてはなりません。
"all"	すべての予測子がカテゴリカルです。

'CategoricalPredictors' の仕様は以下の場合適切です。

• 'Learners' は木学習器を指定します。

• 'Learners' は、すべての予測子がカテゴリカルである k 最近傍学習器を指定します。

各学習器は、学習器に対応する近似関数と同じ方法でカテゴリカル予測子を特定して処理します。k 最近傍学習器については fitcknn の 'CategoricalPredictors' を、木学習器については fitctree の 'CategoricalPredictors' を参照してください。

例: 'CategoricalPredictors','all'

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

PredictorNames — 予測子変数名

一意な名前の string 配列 | 一意な文字ベクトルの cell 配列

予測子変数名。一意な名前の string 配列または一意な文字ベクトルの cell 配列として指定します。PredictorNames の機能は、学習データの提供方法によって決まります。

• X と Y を指定した場合、PredictorNames を使用して X 内の予測子変数に名前を割り当てることができます。

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

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

• Tbl を指定する場合、PredictorNames を使用して学習に使用する予測子変数を選択できます。つまり、fitcensemble は、学習中に PredictorNames の予測子変数と応答変数のみを使用します。

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

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

  • PredictorNames と formula の両方ではなく、いずれか一方を使用して学習用の予測子を指定することをお勧めします。

例: "PredictorNames",["SepalLength","SepalWidth","PetalLength","PetalWidth"]

データ型: string | cell

ResponseName — 応答変数名

"Y" (既定値) | 文字ベクトル | string スカラー

応答変数名。文字ベクトルまたは string スカラーとして指定します。

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

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

例: "ResponseName","response"

データ型: char | string

並列オプション

Options — 並列計算と乱数設定のオプション

構造体

並列計算と乱数設定のオプション。構造体として指定します。statset を使用して Options 構造体を作成します。

メモ

並列計算を行うには、Parallel Computing Toolbox™ が必要です。

次の表に、オプションのフィールドとその値を示します。

フィールド名	値	既定の設定
UseParallel	並列計算する場合は、この値を true に設定します。並列アンサンブル学習では、名前と値の引数 Method を "Bag" に設定する必要があります。並列学習は Method="Bag" の既定のタイプである木学習器にのみ使用できます。	false
UseSubstreams	再現可能な方法で計算を実行する場合は、この値を true に設定します。 再現性のある計算を行うには、Streams をサブストリームを許可する型 ("mlfg6331_64" または "mrg32k3a") に設定します。また、名前と値の引数 Reproducible が true に設定された木テンプレートを使用します。並列統計計算での再現性を参照してください。	false
Streams	RandStream オブジェクトまたはそのようなオブジェクトの cell 配列としてこの値を指定します。UseParallel の値が true でなく、UseSubstreams の値も false でない場合、単一オブジェクトを使用します。この場合は、並列プールと同じサイズの cell 配列を使用します。	Streams を指定しないと、fitcensemble には既定のストリームが使用されます。

再現性のある並列学習の使用例については、アンサンブル分類の並列学習を参照してください。

デュアルコア以上のシステムの場合、fitcensemble では Intel^® スレッディング ビルディング ブロック (TBB) を使用して学習を並列化します。したがって、UseParallel オプションを true と指定しても、単一のコンピューターではそれほど大きな高速化の効果は得られないことがあります。Intel TBB の詳細については、https://www.intel.com/content/www/us/en/developer/tools/oneapi/onetbb.htmlを参照してください。

例: Options=statset(UseParallel=true)

データ型: struct

交差検証オプション

CrossVal — 交差検証フラグ

'off' (既定値) | 'on'

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

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

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

または、後で Mdl を crossval に渡して交差検証を実行します。

例: 'Crossval','on'

CVPartition — 交差検証分割

[] (既定値) | cvpartition オブジェクト

交差検証分割。交差検証のタイプと学習セットおよび検証セットのインデックス付けを指定する cvpartition オブジェクトとして指定します。

交差検証済みモデルの作成で指定できる名前と値の引数は、CVPartition、Holdout、KFold、Leaveout の 4 つのうちのいずれかのみです。

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

Holdout — ホールドアウト検証の対象データの比率

(0,1) の範囲のスカラー値

ホールドアウト検証に使用するデータの比率。範囲 [0,1] のスカラー値として指定します。Holdout=p を指定した場合、以下の手順が実行されます。

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

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

交差検証済みモデルの作成で指定できる名前と値の引数は、CVPartition、Holdout、KFold、Leaveout の 4 つのうちのいずれかのみです。

例: Holdout=0.1

データ型: double | single

KFold — 分割の数

10 (既定値) | 1 より大きい正の整数値

交差検証済みモデルで使用する分割の数。1 より大きい正の整数値として指定します。KFold=k を指定した場合、以下の手順が実行されます。

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

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

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

交差検証済みモデルの作成で指定できる名前と値の引数は、CVPartition、Holdout、KFold、Leaveout の 4 つのうちのいずれかのみです。

例: KFold=5

データ型: single | double

Leaveout — Leave-one-out 法の交差検証のフラグ

"off" (既定値) | "on"

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

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

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

交差検証済みモデルの作成で指定できる名前と値の引数は、CVPartition、Holdout、KFold、Leaveout の 4 つのうちのいずれかのみです。

例: Leaveout="on"

データ型: char | string

その他の分類オプション

ClassNames — 学習に使用するクラスの名前

categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

学習に使用するクラスの名前。categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列として指定します。ClassNames のデータ型は Tbl 内の応答変数または Y と同じでなければなりません。

ClassNames が文字配列の場合、各要素は配列の 1 つの行に対応しなければなりません。

ClassNames の使用目的は次のとおりです。

• 学習時のクラスの順序を指定する。

• クラスの順序に対応する入力または出力引数の次元の順序を指定する。たとえば、Cost の次元の順序や predict によって返される分類スコアの列の順序を指定するために ClassNames を使用します。

• 学習用にクラスのサブセットを選択する。たとえば、Y に含まれているすべての異なるクラス名の集合が ["a","b","c"] であるとします。クラス "a" および "c" のみの観測値を使用してモデルに学習をさせるには、"ClassNames",["a","c"] を指定します。

ClassNames の既定値は、Tbl 内の応答変数または Y に含まれているすべての異なるクラス名の集合です。

例: "ClassNames",["b","g"]

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

Cost — 誤分類のコスト

正方行列 | 構造体配列

誤分類のコスト。'Cost' と正方行列または構造体から構成されるコンマ区切りペアとして指定します。指定する項目によって、内容は次のように変わります。

• 正方行列 Cost の場合、Cost(i,j) は真のクラスが i である点をクラス j に分類するコストです。つまり、行は真のクラスに、列は予測するクラスに対応します。Cost の対応する行と列についてクラスの順序を指定するには、名前と値のペアの引数 ClassNames も指定します。

• 構造体 S の場合、次の 2 つのフィールドが必要となります。

  • S.ClassNames: Y と同じデータ型のクラス名を表す変数を含む。

  • S.ClassificationCosts。行と列の順序が S.ClassNames と同じコスト行列。

既定値は ones(K) - eye(K) です。K は異なるクラスの数です。

fitcensemble は Cost を使用して、Prior で指定されたクラスの事前確率を調整します。その後、fitcensemble は調整した事前確率を学習に使用します。

例: 'Cost',[0 1 2 ; 1 0 2; 2 2 0]

データ型: double | single | struct

Prior — 事前確率

'empirical' (既定値) | 'uniform' | 数値ベクトル | 構造体配列

各クラスの事前確率。'Prior' と次の表の値から構成されるコンマ区切りのペアとして指定します。

値	説明
'empirical'	クラスの事前確率は、Y のクラスの相対的頻度です。
'uniform'	クラスの事前確率はいずれも 1/K (K はクラス数) となります。
数値ベクトル	各要素はクラスの事前確率です。Mdl.ClassNames に従って要素を並べ替えるか、ClassNames 名前と値のペアの引数を使用して順序を指定します。要素は合計が 1 になるように正規化されます。
構造体配列	構造体 S には 2 つのフィールドがあります。 S.ClassNames: Y と同じ型の変数のクラス名が格納されます。 S.ClassProbs: 対応する事前確率のベクトルが格納されます。要素は合計が 1 になるように正規化されます。

fitcensemble は、合計が 1 になるように Prior の事前確率を正規化します。

例: struct('ClassNames',{{'setosa','versicolor','virginica'}},'ClassProbs',1:3)

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

ScoreTransform — スコア変換

"none" (既定値) | "doublelogit" | "invlogit" | "ismax" | "logit" | 関数ハンドル | ...

スコア変換。文字ベクトル、string スカラー、または関数ハンドルとして指定します。

次の表は、使用可能な文字ベクトルおよび string スカラーをまとめています。

値	説明
"doublelogit"	1/(1 + e–2x)
"invlogit"	log(x / (1 – x))
"ismax"	最大のスコアをもつクラスのスコアを 1 に設定し、他のすべてのクラスのスコアを 0 に設定する
"logit"	1/(1 + e–x)
"none" または "identity"	x (変換なし)
"sign"	x < 0 のとき –1 x = 0 のとき 0 x > 0 のとき 1
"symmetric"	2x – 1
"symmetricismax"	最大のスコアをもつクラスのスコアを 1 に設定し、他のすべてのクラスのスコアを –1 に設定する
"symmetriclogit"	2/(1 + e–x) – 1

MATLAB 関数またはユーザー定義関数の場合は、スコア変換用の関数ハンドルを使用します。関数ハンドルは、行列 (元のスコア) を受け入れて同じサイズの行列 (変換したスコア) を返さなければなりません。

例: "ScoreTransform","logit"

データ型: char | string | function_handle

Weights — 観測値の重み

正の値の数値ベクトル | Tbl 内の変数の名前

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

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

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

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

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

ブースティング法およびバギングのサンプリング オプション

FResample — リサンプリング対象の学習セットの比率

1 (既定値) | (0,1] の正のスカラー

すべての弱学習器についてリサンプリングされる学習セットの比率。(0,1] の正のスカラーとして指定します。'FResample' を使用するには、Resample を 'on' に設定します。

例: 'FResample',0.75

データ型: single | double

Replace — 復元抽出を示すフラグ

'on' (既定値) | 'off'

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

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

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

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

例: 'Replace','off'

Resample — リサンプリングを示すフラグ

'off' | 'on'

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

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

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

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

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

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

AdaBoostM1、AdaBoostM2、LogitBoost および GentleBoost 法のオプション

LearnRate — 縮小学習率

1 (既定値) | (0,1] の数値スカラー

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

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

例: 'LearnRate',0.1

データ型: single | double

RUSBoost 法のオプション

LearnRate — 縮小学習率

1 (既定値) | (0,1] の数値スカラー

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

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

例: 'LearnRate',0.1

データ型: single | double

RatioToSmallest — 最小相当クラスについてのサンプリング比率

正の数値スカラー | 正の値の数値ベクトル

最小相当クラスについてのサンプリング比率。'RatioToSmallest' と数値スカラー、または学習データ内の異なるクラス数と同じ長さをもつ正の値の数値ベクトルから構成されるコンマ区切りのペアとして指定します。

学習データに K 個のクラスがあり、最小相当クラスには m 個の観測値があるとします。

• 正の数値スカラー s を指定した場合、fitcensemble は s*m 個の観測値を各クラスから抽出します。つまり、各クラスでサンプリングの比率が同じになります。詳細は、アルゴリズムを参照してください。

• 数値ベクトル [s1,s2,...,sK] を指定した場合、fitcensemble は si*m 個の観測値をクラス i (i = 1,...,K) から抽出します。RatioToSmallest の要素は、ClassNames を使用して指定されるクラス名に同じ順序で対応します (ヒントを参照)。

既定値は ones(K,1) で、m 個の観測値を各クラスから抽出するよう指定します。

例: 'RatioToSmallest',[2,1]

データ型: single | double

LPBoost および TotalBoost 法のオプション

MarginPrecision — 収束速度を制御するマージン精度

0.1 (既定値) | [0,1] の数値スカラー

収束速度を制御するマージン精度。'MarginPrecision' と区間 [0,1] の数値スカラーから構成されるコンマ区切りのペアとして指定します。MarginPrecision は、収束に必要なブースティング反復回数に影響を与えます。

ヒント

多数の学習器を使用してアンサンブルに学習をさせるには、MarginPrecision に小さい値を指定します。少数の学習器を使用して学習をさせる場合は、大きい値を指定します。

例: 'MarginPrecision',0.5

データ型: single | double

RobustBoost 法のオプション

RobustErrorGoal — 目標分類誤差

0.1 (既定値) | 非負の数値スカラー

目標分類誤差。'RobustErrorGoal' と非負の数値スカラーから構成されるコンマ区切りのペアとして指定します。可能な値の上限は、RobustMarginSigma および RobustMaxMargin の値によって決まります。ただし、上限が 1 を超えることはできません。

ヒント

通常は、特定の学習セットについて RobustErrorGoal の最適な範囲が存在します。小さすぎる値または大きすぎる値を設定した場合、分類精度が低いモデルが生成される可能性があります。適切な値を求めるには、交差検証を試してください。

例: 'RobustErrorGoal',0.05

データ型: single | double

RobustMarginSigma — 分類マージンの分布の広がり

0.1 (既定値) | 正の数値スカラー

学習データに対する分類マージンの分布の広がり。'RobustMarginSigma' と正の数値スカラーから構成されるコンマ区切りのペアとして指定します。RobustMarginSigma を指定する前に、RobustBoost に関する文献 ([19]など) を調べてください。

例: 'RobustMarginSigma',0.5

データ型: single | double

RobustMaxMargin — 最大分類マージン

0 (既定値) | 非負の数値スカラー

学習データの最大分類マージン。'RobustMaxMargin' と非負の数値スカラーから構成されるコンマ区切りのペアとして指定します。分類マージンが RobustMaxMargin 未満になるように学習データ内の観測値数が最小化されます。

例: 'RobustMaxMargin',1

データ型: single | double

ランダム部分空間法のオプション

NPredToSample — サンプリングする予測子の個数

1 (既定値) | 正の整数

各ランダム部分空間学習器についてサンプリングする予測子の個数。'NPredToSample' と区間 1,...,p の正の整数から構成されるコンマ区切りのペアとして指定します。p は予測子変数の個数 (size(X,2) または size(Tbl,2)) です。

データ型: single | double

ハイパーパラメーター最適化オプション

OptimizeHyperparameters — 最適化するパラメーター

'none' (既定値) | 'auto' | 'all' | 使用可能パラメーター名の string 配列または cell 配列 | optimizableVariable オブジェクトのベクトル

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

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

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

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

  • Learners = 'discriminant' — {'Delta','Gamma'}

  • Learners = 'knn' — {'Distance','NumNeighbors','Standardize'}

  メモ

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

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

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

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

最適化では、パラメーターを変化させることにより、fitcensemble の交差検証損失 (誤差) を最小化しようとします。(各種の状況における) 交差検証損失の詳細については、分類損失を参照してください。交差検証のタイプおよびその他の最適化の側面を制御するには、名前と値のペア HyperparameterOptimizationOptions を使用します。

メモ

OptimizeHyperparameters の値は、他の名前と値の引数を使用して指定した値より優先されます。たとえば、OptimizeHyperparameters を "auto" に設定すると、fitcensemble は "auto" オプションに対応するハイパーパラメーターを最適化して、ハイパーパラメーターに指定された値を無視します。

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

• Method — クラスの個数によって異なります。

  • 2 つのクラス — 使用可能な方式は 'Bag'、'GentleBoost'、'LogitBoost'、'AdaBoostM1' および 'RUSBoost' です。

  • 3 つ以上のクラス — 使用可能な方式は 'Bag'、'AdaBoostM2' および 'RUSBoost' です。

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

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

• 選択した Learners について、次のハイパーパラメーターを使用できます。

  学習器	使用可能ハイパーパラメーター (太字は既定で使用)	既定の範囲
  'discriminant'	Delta	範囲 [1e-6,1e3] の対数スケール
  	DiscrimType	'linear'、'quadratic'、'diagLinear'、'diagQuadratic'、'pseudoLinear' および 'pseudoQuadratic'
  	Gamma	[0,1] の実数値
  'knn'	Distance	'cityblock'、'chebychev'、'correlation'、'cosine'、'euclidean'、'hamming'、'jaccard'、'mahalanobis'、'minkowski'、'seuclidean' および 'spearman'
  	DistanceWeight	'equal'、'inverse' および 'squaredinverse'
  	Exponent	[0.5,3] の正の値
  	NumNeighbors	範囲 [1, max(2,round(NumObservations/2))] の対数スケールの正の整数値
  	Standardize	'true' および 'false'
  'tree'	MaxNumSplits	範囲 [1,max(2,NumObservations-1)] の対数スケールの整数
  	MinLeafSize	範囲 [1,max(2,floor(NumObservations/2))] の対数スケールの整数
  	NumVariablesToSample	範囲 [1,max(2,NumPredictors)] の整数
  	SplitCriterion	'gdi'、'deviance' および 'twoing'

  または、選択した Learners と共に hyperparameters を使用します。optimizableVariable オブジェクトを作成するときに予測子データと応答を指定しなければならないことに注意してください。

  load fisheriris
  params = hyperparameters('fitcensemble',meas,species,'Tree');

  使用可能な、または既定のハイパーパラメーターを調べるには、params を確認します。

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

load fisheriris
params = hyperparameters('fitcensemble',meas,species,'Tree');
params(4).Range = [1,30];

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

既定では、コマンド ラインに反復表示が表示され、最適化のハイパーパラメーターの個数に従ってプロットが表示されます。最適化とプロットにおける目的関数は誤分類率です。反復表示を制御するには、名前と値の引数 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	制限時間。正の実数スカラーを指定します。制限時間の単位は、tic と toc によって測定される秒です。MaxTime は関数評価を中断させないため、実行時間が MaxTime を超える可能性があります。	Inf
NumGridDivisions	'gridsearch' における各次元の値の個数。値は、各次元の値の個数を表す正の整数のベクトル、またはすべての次元に適用されるスカラーが可能です。カテゴリカル変数の場合、このフィールドは無視されます。	10
ShowPlots	プロットを表示するかどうかを示す論理値。true の場合、最良の観測された目的関数の値が反復回数に対してプロットされます。ベイズ最適化を使用する場合 (Optimizer が 'bayesopt')、最良の推定された目的関数値もプロットされます。最良の観測された目的関数値および最良の推定された目的関数値は、反復表示の BestSoFar (observed) 列および BestSoFar (estim.) 列の値にそれぞれ対応しています。これらの値は、Mdl.HyperparameterOptimizationResults のプロパティ ObjectiveMinimumTrace および EstimatedObjectiveMinimumTrace で確認できます。問題にベイズ最適化の最適化パラメーターが 1 つまたは 2 つある場合、ShowPlots はパラメーターに対する目的関数のモデルもプロットします。	true
SaveIntermediateResults	Optimizer が '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 つだけ使用できます。
CVPartition	cvpartition によって作成される cvpartition オブジェクト	交差検証フィールドが指定されていない場合 'Kfold',5
Holdout	ホールドアウトの比率を表す範囲 (0,1) のスカラー
Kfold	1 より大きい整数

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

データ型: struct

出力引数

Mdl — 学習済みのアンサンブル分類モデル

ClassificationBaggedEnsemble モデル オブジェクト | ClassificationEnsemble モデル オブジェクト | ClassificationPartitionedEnsemble 交差検証済みモデル オブジェクト

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

モデル オブジェクト	交差検証オプションの指定	Method の設定	Resample の設定
ClassificationBaggedEnsemble	なし	'Bag'	'on'
ClassificationEnsemble	なし	分類用のアンサンブル集約法	'off'
ClassificationPartitionedEnsemble	あり	分類用のアンサンブル集約法	'off' または 'on'

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

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

ヒント

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

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

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

• アンサンブル集約法 (Method) が 'bag' であり、

  • 誤分類コスト (Cost) が非常に不均衡である場合、in-bag の標本について、ペナルティが大きいクラスから一意な観測値がオーバーサンプリングされます。

  • クラスの事前確率 (Prior) の歪みが大きい場合、事前確率が大きいクラスから一意な観測値がオーバーサンプリングされます。

  これらの組み合わせにより、標本サイズが小さい場合、ペナルティまたは事前確率が大きいクラスから抽出される out-of-bag 観測値の相対頻度が低くなる可能性があります。この結果、out-of-bag の推定誤差の変動幅が非常に大きくなり、解釈が困難になる可能性があります。特に標本サイズが小さい場合に、out-of-bag の推定誤差の変動幅が大きくならないようにするには、Cost を使用して誤分類コスト行列をより平衡にするか、Prior を使用して事前確率ベクトルの歪みを小さくします。

• 一部の入力引数および出力引数の順序は学習データ内の各クラスに対応するので、名前と値のペアの引数 ClassNames を使用してクラスの順序を指定することをお勧めします。

  • クラスの順序を簡単に求めるには、未分類の (つまり欠損ラベルがある) 観測値を学習データからすべて削除し、異なるクラスがすべて含まれている配列を取得および表示してから、その配列を ClassNames に指定します。たとえば、応答変数 (Y) がラベルの cell 配列であるとします。次のコードは、変数 classNames でクラスの順序を指定します。

    Ycat = categorical(Y);
    classNames = categories(Ycat)

    categorical は <undefined> を未分類観測値に割り当て、categories は <undefined> を出力から除外します。したがって、このコードをラベルの cell 配列に対して使用するか、同様のコードを categorical 配列に対して使用すると、欠損ラベルがある観測値を削除しなくても各クラスのリストを取得できます。

  • 最小相当ラベルから最大相当ラベルの順になるようにクラスの順序を指定するには、(前の項目のように) クラスの順序を簡単に調べ、リスト内のクラスの順序を頻度順に変更してから、リストを ClassNames に渡します。前の例に従うと、次のコードは最小相当から最大相当の順にクラスの順序を classNamesLH で指定します。

    Ycat = categorical(Y);
    classNames = categories(Ycat);
    freq = countcats(Ycat);
    [~,idx] = sort(freq);
    classNamesLH = classNames(idx);

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

アルゴリズム

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

• Method がブースティング アルゴリズム、Learners が決定木になるように設定した場合、既定では浅い決定木が成長します。木の深さは、templateTree を使用して名前と値のペアの引数 MaxNumSplits、MinLeafSize および MinParentSize を指定することにより調整できます。

• 名前と値の引数 Cost、Prior、および Weights を指定すると、出力モデル オブジェクトに Cost、Prior、および W の各プロパティの指定値がそれぞれ格納されます。Cost プロパティには、ユーザー指定のコスト行列 (C) が変更なしで格納されます。Prior プロパティと W プロパティには、正規化後の事前確率と観測値の重みがそれぞれ格納されます。モデルの学習用に、事前確率と観測値の重みが更新されて、コスト行列で指定されているペナルティが組み込まれます。詳細については、誤分類コスト行列、事前確率、および観測値の重みを参照してください。

• バギング ('Method','Bag') の場合、fitcensemble は、誤分類コストが大きいクラスをオーバーサンプリングし、誤分類コストが小さいクラスをアンダーサンプリングすることにより、in-bag の標本を生成します。その結果、out-of-bag の標本では、誤分類コストが大きいクラスの観測値は少なくなり、誤分類コストが小さいクラスの観測値は多くなります。小さいデータ セットと歪みが大きいコスト行列を使用してアンサンブル分類に学習をさせる場合、クラスあたりの out-of-bag 観測値の数が少なくなる可能性があります。このため、out-of-bag の推定誤差の変動幅が非常に大きくなり、解釈が困難になる可能性があります。事前確率が大きいクラスでも同じ現象が発生する場合があります。

• アンサンブル集約法 ('Method','RUSBoost') が RUSBoost である場合、名前と値のペアの引数 RatioToSmallest では最小相当クラスに関して各クラスのサンプリングの比率を指定します。たとえば、学習データに A および B という 2 つのクラスがあるとします。A には 100 個の観測値、B には 10 個の観測値が含まれています。また、最小相当クラスでは m 個の観測値が学習データに含まれているとします。

  • 'RatioToSmallest',2 を設定した場合、s*m = 2*10 = 20 になります。したがって、fitcensemble はクラス A の 20 個の観測値とクラス B の 20 個の観測値を使用して、すべての学習器に学習をさせます。'RatioToSmallest',[2 2] を設定した場合も同じ結果になります。

  • 'RatioToSmallest',[2,1] を設定した場合、s1*m = 2*10 = 20 および s2*m = 1*10 = 10 になります。したがって、fitcensemble はクラス A の 20 個の観測値とクラス B の 10 個の観測値を使用して、すべての学習器に学習をさせます。

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

参照

[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. “A more robust boosting algorithm.” arXiv:0905.2138v1, 2009.

[4] 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.

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

[6] Friedman, J., T. Hastie, and R. Tibshirani. “Additive logistic regression: A statistical view of boosting.” Annals of Statistics, Vol. 28, No. 2, pp. 337–407, 2000.

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

[8] Ho, T. K. “The random subspace method for constructing decision forests.” IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol. 20, No. 8, pp. 832–844, 1998.

[9] Schapire, R. E., Y. Freund, P. Bartlett, and W.S. Lee. “Boosting the margin: A new explanation for the effectiveness of voting methods.” Annals of Statistics, Vol. 26, No. 5, pp. 1651–1686, 1998.

[10] Seiffert, C., T. Khoshgoftaar, J. Hulse, and A. Napolitano. “RUSBoost: Improving classification performance when training data is skewed.” 19th International Conference on Pattern Recognition, pp. 1–4, 2008.

[11] Warmuth, M., J. Liao, and G. Ratsch. “Totally corrective boosting algorithms that maximize the margin.” Proc. 23rd Int’l. Conf. on Machine Learning, ACM, New York, pp. 1001–1008, 2006.

拡張機能

自動並列サポート

Parallel Computing Toolbox™ を使用して自動的に並列計算を実行することで、コードを高速化します。

fitcensemble は、名前と値の引数 'Options' を使用した並列学習をサポートします。オプションは、options = statset('UseParallel',true) のように、statset を使用して作成します。並列アンサンブル学習では、名前と値の引数 'Method' を 'Bag' に設定する必要があります。並列学習は 'Bag' の既定のタイプである木学習器にのみ使用できます。

ハイパーパラメーターの最適化を並列実行するには、関数 fitcensemble を呼び出すときに名前と値の引数 'HyperparameterOptimizationOptions', struct('UseParallel',true) を指定します。

並列的なハイパーパラメーターの最適化の詳細については、並列ベイズ最適化を参照してください。

並列計算の全般的な情報については、自動並列サポートを使用した MATLAB 関数の実行 (Parallel Computing Toolbox)を参照してください。

GPU 配列

Parallel Computing Toolbox™ を使用してグラフィックス処理装置 (GPU) 上で実行することにより、コードを高速化します。

使用上の注意事項および制限事項:

• fitcensemble は決定木学習器のみサポートします。名前と値の引数 Learners を指定できるのは、"tree"、学習器テンプレート オブジェクト、または templateTree によって作成された学習器テンプレート オブジェクトの cell ベクトルとしてのみです。templateTree を使用する場合、名前と値の引数 Surrogate および PredictorSelection は、それぞれ "off" および "allsplits" としてのみ指定できます。

• 名前と値の引数 Method は、"AdaBoostM1"、"AdaBoostM2"、"GentleBoost"、"LogitBoost"、または "RUSBoost" としてのみ指定できます。

• 名前と値の引数 NPredToSample は指定できません。

• templateTree を使用する場合、カテゴリカル予測子を含むデータに対しては以下が適用されます。

  • マルチクラス分類の場合、fitcensemble は最適な分類を見つけるためのアルゴリズムとして OVAbyClass のみをサポートします。

  • 名前と値の引数 NumVariablesToSample は、"all" としてのみ指定できます。

• fitcensemble は、次のいずれかに該当する場合に GPU でモデルを当てはめます。

  • 入力引数 X が gpuArray オブジェクトである

  • 入力引数 Tbl に gpuArray 予測子変数が含まれている

• templateTree を使用して MaxNumSplits を指定した場合、fitcensemble は決定木が深くなると GPU でも CPU より高速に実行されない可能性があることに注意してください。

バージョン履歴

R2016b で導入

R2023b: 弱学習器が k 最近傍 (KNN) 分類器である場合の OptimizeHyperparameters の "auto" オプションに Standardize を追加

R2023b 以降では、Learners の値として "knn" を指定し、OptimizeHyperparameters の値として "auto" を指定した場合、fitcensemble には最適化可能なハイパーパラメーターとして Standardize が含まれます。

参考

ClassificationEnsemble | ClassificationBaggedEnsemble | ClassificationPartitionedEnsemble | templateDiscriminant | templateKNN | templateTree | predict

トピック

• 教師あり学習のワークフローとアルゴリズム
• アンサンブル学習のフレームワーク
• アンサンブル アルゴリズム