fitcecoc

サポートベクターマシンまたはその他の分類器向けのマルチクラスモデルの当てはめ

ページ内をすべて折りたたむ

構文

Mdl = fitcecoc(Tbl,ResponseVarName)

Mdl = fitcecoc(Tbl,formula)

Mdl = fitcecoc(Tbl,Y)

Mdl = fitcecoc(X,Y)

Mdl = fitcecoc(___,Name,Value)

[Mdl,HyperparameterOptimizationResults] = fitcecoc(___,Name,Value)

説明

Mdl = fitcecoc(Tbl,ResponseVarName) は、テーブル Tbl 内の予測子と Tbl.ResponseVarName 内のクラスラベルを使用して、学習済みの完全なマルチクラス誤り訂正出力符号 (ECOC) モデルを返します。fitcecoc は、1 対 1 の符号化設計により K(K – 1)/2 個のバイナリサポートベクターマシン (SVM) モデルを使用します。K は一意なクラスラベル (レベル) の数です。Mdl は ClassificationECOC モデルです。

Mdl = fitcecoc(Tbl,formula) は、テーブル Tbl 内の予測子とクラスラベルを使用して ECOC モデルを返します。formula は、学習に使用する応答および Tbl 内の予測子変数サブセットの説明モデルです。

Mdl = fitcecoc(Tbl,Y) は、テーブル Tbl の予測子とベクトル Y のクラスラベルを使用して ECOC モデルを返します。

例

Mdl = fitcecoc(X,Y) は、予測子 X とクラスラベル Y を使用して学習をさせた ECOC モデルを返します。

例

Mdl = fitcecoc(___,Name,Value) は、前の構文のいずれかを使用し、1 つ以上の Name,Value ペア引数で指定されたオプションを追加して ECOC モデルを返します。

たとえば、異なるバイナリ学習器、異なる符号化設計、または交差検証の実行を指定します。Name,Value ペア引数 Kfold を使用して交差検証を実行することをお勧めします。交差検証の結果により、モデルがどの程度一般化を行うかを判断します。

[Mdl,HyperparameterOptimizationResults] = fitcecoc(___,Name,Value) は、名前と値のペアの引数 OptimizeHyperparameters を指定して線形またはカーネルバイナリ学習器を使用する場合に、ハイパーパラメーター最適化の詳細も返します。他の Learners の場合、Mdl の HyperparameterOptimizationResults プロパティには結果が格納されます。

例

すべて折りたたむ

SVM 学習器を使用したマルチクラスモデルの学習

ライブスクリプトを開く

サポートベクターマシン (SVM) バイナリ学習器を使用して、マルチクラス誤り訂正出力符号 (ECOC) モデルに学習をさせます。

フィッシャーのアヤメのデータセットを読み込みます。予測子データ X と応答データ Y を指定します。

load fisheriris
X = meas;
Y = species;

既定のオプションを使用して、マルチクラス ECOC モデルに学習をさせます。

Mdl = fitcecoc(X,Y)

Mdl = 
  ClassificationECOC
             ResponseName: 'Y'
    CategoricalPredictors: []
               ClassNames: {'setosa'  'versicolor'  'virginica'}
           ScoreTransform: 'none'
           BinaryLearners: {3x1 cell}
               CodingName: 'onevsone'

Mdl は ClassificationECOC モデルです。既定では、fitcecoc は SVM バイナリ学習器および 1 対 1 符号化設計を使用します。ドット表記を使用して Mdl プロパティにアクセスできます。

クラス名および符号化設計行列を表示します。

Mdl.ClassNames

ans = 3x1 cell
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

CodingMat = Mdl.CodingMatrix

CodingMat = 3×3

     1     1     0
    -1     0     1
     0    -1    -1

3 つのクラスに対して 1 対 1 符号化設計を使用すると、3 つのバイナリ学習器が生成されます。CodingMat の列は学習器に、行はクラスに対応します。クラスの順序は Mdl.ClassNames 内の順序と同じです。たとえば、CodingMat(:,1) は [1; –1; 0] であり、'setosa' または 'versicolor' として分類されるすべての観測値を使用して最初の SVM バイナリ学習器が学習を行うことを示します。'setosa' は 1 に対応するので陽性クラスであり、'versicolor' は –1 に対応するので陰性クラスです。

各バイナリ学習器にセルのインデックス付けおよびドット表記を使用してアクセスすることができます。

Mdl.BinaryLearners{1}   % The first binary learner

ans = 
  CompactClassificationSVM
             ResponseName: 'Y'
    CategoricalPredictors: []
               ClassNames: [-1 1]
           ScoreTransform: 'none'
                     Beta: [4x1 double]
                     Bias: 1.4505
         KernelParameters: [1x1 struct]

再代入分類誤差を計算します。

error = resubLoss(Mdl)

error = 0.0067

学習データに対する分類誤差は小さくなっていますが、分類器が過適合モデルになる可能性があります。代わりに、crossval を使用して分類器を交差検証し、交差検証分類誤差を計算することができます。

マルチクラス線形分類モデルの学習

ライブスクリプトを開く

既定の線形学習器テンプレートを作成し、これを使用して複数のバイナリ線形分類モデルを含む ECOC モデルに学習をさせます。

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

load nlpdata

X は予測子データのスパース行列、Y はクラスラベルの categorical ベクトルです。データには 13 個のクラスが含まれています。

既定の線形学習器テンプレートを作成します。

t = templateLinear

t = 
Fit template for Linear.
    Learner: 'svm'

t は線形学習器のテンプレートオブジェクトです。t のプロパティはすべて空です。t を学習関数 (ECOC マルチクラス分類用の fitcecoc など) に渡す場合、空のプロパティはそれぞれの既定値に設定されます。たとえば、Type は "classification" に設定されます。既定値を変更するには、templateLinear の名前と値の引数を参照してください。

複数のバイナリ線形分類モデルで構成される ECOC モデルに学習させます。これらの分類モデルは、ドキュメンテーション Web ページにおける単語の度数分布からソフトウェア製品を特定します。学習時間を短縮するため、予測子データを転置し、観測値が列に対応することを指定します。

X = X';
rng(1); % For reproducibility 
Mdl = fitcecoc(X,Y,'Learners',t,'ObservationsIn','columns')

Mdl = 
  CompactClassificationECOC
      ResponseName: 'Y'
        ClassNames: [comm    dsp    ecoder    fixedpoint    hdlcoder    phased    physmod    simulink    stats    supportpkg    symbolic    vision    xpc]
    ScoreTransform: 'none'
    BinaryLearners: {78x1 cell}
      CodingMatrix: [13x78 double]

または、Learners","Linear" を指定して、既定の線形分類モデルを含む ECOC モデルに学習をさせることができます。

メモリを節約するため、fitcecoc は線形分類学習器を含む学習済みの ECOC モデルを CompactClassificationECOC モデルオブジェクトで返します。

ECOC 分類器の交差検証

ライブスクリプトを開く

SVM バイナリ学習器による ECOC 分類器を交差検証し、一般化分類誤差を推定します。

フィッシャーのアヤメのデータセットを読み込みます。予測子データ X と応答データ Y を指定します。

load fisheriris
X = meas;
Y = species;
rng(1); % For reproducibility

SVM テンプレートを作成し、予測子を標準化します。

t = templateSVM('Standardize',true)

t = 
Fit template for SVM.
    Standardize: 1

t は SVM テンプレートです。テンプレートオブジェクトのプロパティは、ほとんとが空です。ECOC 分類器に学習をさせると、該当するプロパティが既定値に設定されます。

ECOC 分類器に学習をさせ、クラスの順序を指定します。

Mdl = fitcecoc(X,Y,'Learners',t,...
    'ClassNames',{'setosa','versicolor','virginica'});

Mdl は ClassificationECOC 分類器です。ドット表記を使用してプロパティにアクセスできます。

10 分割交差検証を使用して Mdl を交差検証します。

CVMdl = crossval(Mdl);

CVMdl は ClassificationPartitionedECOC 交差検証 ECOC 分類器です。

一般化分類誤差を推定します。

genError = kfoldLoss(CVMdl)

genError = 0.0400

一般化分類誤差が 4% なので、ECOC 分類器がかなり良好に一般化を行うことがわかります。

ECOC 分類器を使用した事後確率の推定

ライブスクリプトを開く

SVM バイナリ学習器を使用して ECOC 分類器に学習をさせます。はじめに、学習標本のラベルとクラス事後確率を予測します。次に、グリッド内の各点における最大のクラス事後確率を予測します。結果を可視化します。

フィッシャーのアヤメのデータセットを読み込みます。予測子として花弁の寸法を、応答として種の名前を指定します。

load fisheriris
X = meas(:,3:4);
Y = species;
rng(1); % For reproducibility

SVM テンプレートを作成します。予測子を標準化し、ガウスカーネルを指定します。

t = templateSVM('Standardize',true,'KernelFunction','gaussian');

t は SVM テンプレートです。ほとんどのプロパティは空です。ECOC 分類器を学習させると、適用可能なプロパティが既定値に設定されます。

SVM テンプレートを使用して ECOC 分類器を学習させます。'FitPosterior' 名前と値のペアの引数を使用して分類スコアをクラス事後確率 (predict または resubPredict により返されます) へ変換します。名前と値のペアの引数 'ClassNames' を使用して、クラスの順序を指定します。名前と値のペアの引数 'Verbose' を使用して、学習中に診断メッセージを表示します。

Mdl = fitcecoc(X,Y,'Learners',t,'FitPosterior',true,...
    'ClassNames',{'setosa','versicolor','virginica'},...
    'Verbose',2);

Training binary learner 1 (SVM) out of 3 with 50 negative and 50 positive observations.
Negative class indices: 2
Positive class indices: 1

Fitting posterior probabilities for learner 1 (SVM).
Training binary learner 2 (SVM) out of 3 with 50 negative and 50 positive observations.
Negative class indices: 3
Positive class indices: 1

Fitting posterior probabilities for learner 2 (SVM).
Training binary learner 3 (SVM) out of 3 with 50 negative and 50 positive observations.
Negative class indices: 3
Positive class indices: 2

Fitting posterior probabilities for learner 3 (SVM).

Mdl は ClassificationECOC モデルです。同じ SVM テンプレートが各バイナリ学習器に適用されますが、テンプレートの cell ベクトルを渡すことで各バイナリ学習器のオプションを調整できます。

学習標本のラベルとクラス事後確率を予測します。名前と値のペアの引数 'Verbose' を使用して、ラベルとクラス事後確率の計算中に診断メッセージを表示します。

[label,~,~,Posterior] = resubPredict(Mdl,'Verbose',1);

Predictions from all learners have been computed.
Loss for all observations has been computed.
Computing posterior probabilities...

Mdl.BinaryLoss

ans = 
'quadratic'

バイナリ損失の平均が最小となるクラスに観測が割り当てられます。すべてのバイナリ学習器が事後確率を計算しているので、バイナリ損失関数は quadratic になります。

無作為な結果の集合を表示します。

idx = randsample(size(X,1),10,1);
Mdl.ClassNames

ans = 3x1 cell
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

table(Y(idx),label(idx),Posterior(idx,:),...
    'VariableNames',{'TrueLabel','PredLabel','Posterior'})

ans=10×3 table
      TrueLabel         PredLabel                     Posterior               
    ______________    ______________    ______________________________________

    {'virginica' }    {'virginica' }     0.0039322      0.003987       0.99208
    {'virginica' }    {'virginica' }      0.017067      0.018263       0.96467
    {'virginica' }    {'virginica' }      0.014948      0.015856        0.9692
    {'versicolor'}    {'versicolor'}    2.2197e-14       0.87318       0.12682
    {'setosa'    }    {'setosa'    }         0.999    0.00025092    0.00074638
    {'versicolor'}    {'virginica' }    2.2195e-14       0.05943       0.94057
    {'versicolor'}    {'versicolor'}    2.2194e-14       0.97001      0.029985
    {'setosa'    }    {'setosa'    }         0.999    0.00024991     0.0007474
    {'versicolor'}    {'versicolor'}     0.0085642       0.98259     0.0088487
    {'setosa'    }    {'setosa'    }         0.999    0.00025013    0.00074717

Posterior の列は Mdl.ClassNames のクラスの順序に対応します。

観測された予測子領域の値のグリッドを定義します。グリッド内の各インスタンスの事後確率を予測します。

xMax = max(X);
xMin = min(X);

x1Pts = linspace(xMin(1),xMax(1));
x2Pts = linspace(xMin(2),xMax(2));
[x1Grid,x2Grid] = meshgrid(x1Pts,x2Pts);

[~,~,~,PosteriorRegion] = predict(Mdl,[x1Grid(:),x2Grid(:)]);

各グリッドの座標では、クラス間の最大クラス事後確率をプロットします。

contourf(x1Grid,x2Grid,...
        reshape(max(PosteriorRegion,[],2),size(x1Grid,1),size(x1Grid,2)));
h = colorbar;
h.YLabel.String = 'Maximum posterior';
h.YLabel.FontSize = 15;

hold on
gh = gscatter(X(:,1),X(:,2),Y,'krk','*xd',8);
gh(2).LineWidth = 2;
gh(3).LineWidth = 2;

title('Iris Petal Measurements and Maximum Posterior')
xlabel('Petal length (cm)')
ylabel('Petal width (cm)')
axis tight
legend(gh,'Location','NorthWest')
hold off

ビン化と並列計算の使用による ECOC 分類器の学習の高速化

この例では次を使用します。

ライブスクリプトを開く

代理分岐をもつ決定木の GentleBoost アンサンブルを使用して、1 対他の ECOC 分類器に学習をさせます。学習を高速化するため、数値予測子をビン化し、並列計算を使用します。ビン化は、fitcecoc が木学習器を使用する場合のみ有効です。学習後、10 分割交差検証を使用して分類誤差を推定します。並列計算には Parallel Computing Toolbox™ が必要であることに注意してください。

標本データの読み込み

arrhythmia データセットを読み込み検証します。

load arrhythmia
[n,p] = size(X)

n = 452

p = 279

isLabels = unique(Y);
nLabels = numel(isLabels)

nLabels = 13

tabulate(categorical(Y))

  Value    Count   Percent
      1      245     54.20%
      2       44      9.73%
      3       15      3.32%
      4       15      3.32%
      5       13      2.88%
      6       25      5.53%
      7        3      0.66%
      8        2      0.44%
      9        9      1.99%
     10       50     11.06%
     14        4      0.88%
     15        5      1.11%
     16       22      4.87%

このデータセットには 279 個の予測子が含まれ、452 という標本サイズは相対的に小さいものです。16 個の異なるラベルのうち、13 個のみが応答 (Y) で表現されています。各ラベルは不整脈のさまざまな段階を表しており、観測値の 54.20% がクラス 1 に含まれています。

1 対他 ECOC 分類器の学習

アンサンブルテンプレートを作成します。少なくとも 3 つの引数を指定しなければなりません。手法、学習器の数、および学習器のタイプです。この例では、手法として 'GentleBoost'、学習器の個数として 100 を指定します。欠損観測値があるので、代理分岐を使用する決定木テンプレートを指定します。

tTree = templateTree('surrogate','on');
tEnsemble = templateEnsemble('GentleBoost',100,tTree);

tEnsemble はテンプレートオブジェクトです。ほとんどのプロパティは空ですが、学習中に既定値が入力されます。

決定木のアンサンブルをバイナリ学習器として使用して、1 対他の ECOC 分類器を学習させます。学習を高速化するため、ビン化と並列計算を使用します。

ビン化 ('NumBins',50) — 学習データセットが大きい場合、名前と値のペアの引数 'NumBins' を使用することにより学習を高速化できます (精度が低下する可能性があります)。この引数は、fitcecoc が木学習器を使用する場合のみ有効です。'NumBins' の値を指定した場合、指定した個数の同確率のビンにすべての数値予測子がビン化され、元のデータではなくビンのインデックスに対して木が成長します。はじめに 'NumBins',50 を試してから、精度と学習速度に応じて 'NumBins' の値を変更できます。
並列計算 ('Options',statset('UseParallel',true)) — Parallel Computing Toolbox のライセンスがある場合、プール内のワーカーに各バイナリ学習器を送る並列計算を使用して、計算を高速化できます。ワーカーの個数はシステム構成によって異なります。デュアルコア以上のシステムの場合、バイナリ学習器について決定木を使用すると、fitcecoc は Intel® スレッディングビルディングブロック (TBB) を使用して学習を並列化します。したがって、単一のコンピューターで 'UseParallel' オプションを指定しても役に立ちません。このオプションは、クラスターに対して使用します。

さらに、事前確率として 1/K を指定します。K = 13 は異なるクラスの個数です。

options = statset('UseParallel',true);
Mdl = fitcecoc(X,Y,'Coding','onevsall','Learners',tEnsemble,...
                'Prior','uniform','NumBins',50,'Options',options);

Starting parallel pool (parpool) using the 'local' profile ...
Connected to the parallel pool (number of workers: 6).

Mdl は ClassificationECOC モデルです。

交差検証

10 分割交差検証を使用して ECOC 分類器の交差検証を実行します。

CVMdl = crossval(Mdl,'Options',options);

Warning: One or more folds do not contain points from all the groups.

CVMdl は ClassificationPartitionedECOC モデルです。少なくとも 1 つの分割の学習中に、いくつかのクラスが表示されないことが警告でわかります。したがって、これらの分割は欠損クラスに対するラベルを予測できません。cell のインデックス指定とドット表記を使用して、分割の結果を調査できます。たとえば、1 番目の分割の結果にアクセスするには CVMdl.Trained{1} と入力します。

交差検証済みの ECOC 分類器を使用して、検証分割のラベルを予測します。混同行列は、confusionchart を使用して計算できます。内側の位置のプロパティを変更してチャートを移動およびサイズ変更することにより、行要約の内部にパーセントが表示されるようにします。

oofLabel = kfoldPredict(CVMdl,'Options',options);
ConfMat = confusionchart(Y,oofLabel,'RowSummary','total-normalized');
ConfMat.InnerPosition = [0.10 0.12 0.85 0.85];

ビン化されたデータの再現

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

X = Mdl.X; % Predictor data
Xbinned = zeros(size(X));
edges = Mdl.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 になります。

ECOC 分類器の最適化

ライブスクリプトを開く

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

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

load fisheriris
X = meas;
Y = species;

自動的なハイパーパラメーター最適化を使用して、5 分割交差検証損失を最小化するハイパーパラメーターを求めます。再現性を得るために、乱数シードを設定し、'expected-improvement-plus' の獲得関数を使用します。

rng default
Mdl = fitcecoc(X,Y,'OptimizeHyperparameters','auto',...
    'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName',...
    'expected-improvement-plus'))

|===================================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Coding | BoxConstraint|  KernelScale |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |              |
|===================================================================================================================================|
|    1 | Best   |         0.3 |      10.183 |         0.3 |         0.3 |     onevsall |       76.389 |    0.0012205 |         true |
|    2 | Best   |     0.10667 |     0.24339 |     0.10667 |      0.1204 |     onevsone |    0.0013787 |       41.108 |        false |
|    3 | Best   |        0.04 |     0.61568 |        0.04 |       0.135 |     onevsall |       16.632 |      0.18987 |        false |
|    4 | Accept |    0.046667 |     0.28006 |        0.04 |    0.079094 |     onevsone |      0.04843 |    0.0042504 |         true |
|    5 | Accept |    0.046667 |     0.87165 |        0.04 |     0.04019 |     onevsall |       15.204 |      0.15933 |        false |
|    6 | Accept |        0.08 |     0.26063 |        0.04 |    0.043201 |     onevsall |       77.055 |       4.7599 |        false |
|    7 | Accept |        0.16 |       5.628 |        0.04 |     0.04347 |     onevsall |     0.037396 |    0.0010042 |        false |
|    8 | Accept |    0.046667 |     0.28251 |        0.04 |    0.043477 |     onevsone |    0.0041486 |      0.32592 |         true |
|    9 | Accept |    0.046667 |     0.17691 |        0.04 |    0.043118 |     onevsone |       4.6545 |     0.041226 |         true |
|   10 | Accept |     0.16667 |     0.21055 |        0.04 |    0.043001 |     onevsone |    0.0030987 |       300.86 |         true |
|   11 | Accept |    0.046667 |      2.2763 |        0.04 |    0.042997 |     onevsone |       128.38 |     0.005555 |        false |
|   12 | Accept |    0.046667 |      0.1973 |        0.04 |    0.043207 |     onevsone |     0.081215 |      0.11353 |        false |
|   13 | Accept |     0.33333 |     0.17174 |        0.04 |    0.043431 |     onevsall |       243.89 |       987.69 |         true |
|   14 | Accept |        0.14 |      2.3999 |        0.04 |    0.043265 |     onevsone |       27.177 |    0.0010036 |         true |
|   15 | Accept |        0.04 |     0.20516 |        0.04 |    0.040139 |     onevsone |    0.0011464 |     0.001003 |        false |
|   16 | Accept |    0.046667 |     0.21421 |        0.04 |    0.040165 |     onevsone |    0.0010135 |     0.021485 |         true |
|   17 | Accept |    0.046667 |      1.4984 |        0.04 |    0.040381 |     onevsone |      0.42331 |    0.0010054 |        false |
|   18 | Accept |        0.14 |      6.9426 |        0.04 |     0.04025 |     onevsall |       956.72 |     0.053616 |        false |
|   19 | Accept |     0.26667 |     0.19625 |        0.04 |     0.04023 |     onevsall |     0.058487 |       1.2227 |        false |
|   20 | Best   |        0.04 |     0.17327 |        0.04 |    0.039873 |     onevsone |      0.79359 |       1.4535 |         true |
|===================================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Coding | BoxConstraint|  KernelScale |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |              |
|===================================================================================================================================|
|   21 | Accept |        0.04 |     0.18817 |        0.04 |    0.039837 |     onevsone |       8.8581 |        1.123 |        false |
|   22 | Accept |        0.04 |     0.18307 |        0.04 |    0.039802 |     onevsone |       755.56 |        21.24 |        false |
|   23 | Accept |     0.10667 |     0.22622 |        0.04 |    0.039824 |     onevsone |       41.541 |       966.05 |        false |
|   24 | Accept |        0.04 |     0.22357 |        0.04 |    0.039764 |     onevsone |       966.21 |      0.33603 |        false |
|   25 | Accept |     0.39333 |      8.2608 |        0.04 |    0.040001 |     onevsall |       11.928 |     0.001094 |        false |
|   26 | Accept |        0.04 |     0.15107 |        0.04 |    0.039986 |     onevsone |      0.12946 |     0.092435 |         true |
|   27 | Accept |        0.04 |     0.14517 |        0.04 |    0.039984 |     onevsone |       6.8428 |     0.039038 |        false |
|   28 | Accept |        0.04 |     0.15996 |        0.04 |    0.039983 |     onevsone |    0.0010014 |     0.019004 |        false |
|   29 | Accept |        0.04 |     0.28119 |        0.04 |    0.039985 |     onevsone |       194.14 |       1.8004 |         true |
|   30 | Accept |    0.046667 |     0.31234 |        0.04 |    0.039985 |     onevsone |       769.43 |       141.77 |         true |

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

Best observed feasible point:
     Coding     BoxConstraint    KernelScale    Standardize
    ________    _____________    ___________    ___________

    onevsone       0.79359         1.4535          true    

Observed objective function value = 0.04
Estimated objective function value = 0.040004
Function evaluation time = 0.17327

Best estimated feasible point (according to models):
     Coding     BoxConstraint    KernelScale    Standardize
    ________    _____________    ___________    ___________

    onevsone       0.12946        0.092435         true    

Estimated objective function value = 0.039985
Estimated function evaluation time = 0.15394

Mdl = 
  ClassificationECOC
                         ResponseName: 'Y'
                CategoricalPredictors: []
                           ClassNames: {'setosa'  'versicolor'  'virginica'}
                       ScoreTransform: 'none'
                       BinaryLearners: {3x1 cell}
                           CodingName: 'onevsone'
    HyperparameterOptimizationResults: [1x1 BayesianOptimization]

SVM と tall 配列を使用したマルチクラス ECOC モデルの学習

ライブスクリプトを開く

tall データに対して学習をさせた 2 つのマルチクラス ECOC モデルを作成します。一方のモデルに対して線形バイナリ学習器を、もう一方に対してカーネルバイナリ学習器を使用します。2 つのモデルの再代入分類誤差を比較します。

一般に、tall データのマルチクラス分類は、fitcecoc と線形バイナリ学習器またはカーネルバイナリ学習器を使用して実行できます。fitcecoc を使用して tall 配列に対してモデルに学習をさせる場合、SVM バイナリ学習器を直接使用することはできません。しかし、SVM を使用する線形バイナリ分類モデルまたはカーネルバイナリ分類モデルは使用できます。

tall 配列に対する計算を実行する場合、MATLAB® は並列プール (Parallel Computing Toolbox™ がある場合は既定) またはローカルの MATLAB セッションを使用します。Parallel Computing Toolbox がある場合でもローカルの MATLAB セッションを使用して例を実行するには、関数mapreducerを使用してグローバルな実行環境を変更できます。

フィッシャーのアヤメのデータセットが含まれているフォルダーを参照するデータストアを作成します。datastore によって NaN 値に置き換えられるようにするため、'NA' 値を欠損データとして指定します。tall バージョンの予測子および応答データを作成します。

ds = datastore('fisheriris.csv','TreatAsMissing','NA');
t = tall(ds);

Starting parallel pool (parpool) using the 'local' profile ...
Connected to the parallel pool (number of workers: 6).

X = [t.SepalLength t.SepalWidth t.PetalLength t.PetalWidth];
Y = t.Species;

予測子データを標準化します。

Z = zscore(X);

tall データと線形バイナリ学習器を使用するマルチクラス ECOC モデルに学習をさせます。既定では、tall 配列を fitcecoc に渡すと、SVM を使用する線形バイナリ学習器の学習が行われます。応答データに含まれている一意なクラスは 3 つだけなので、符号化方式を 1 対他 (tall データを使用する場合の既定) から 1 対 1 (インメモリデータを使用する場合の既定) に変更します。

再現性を得るため、rng と tallrng を使用して乱数発生器のシードを設定します。tall 配列の場合、ワーカーの個数と実行環境によって結果が異なる可能性があります。詳細については、コードの実行場所の制御を参照してください。

rng('default') 
tallrng('default')
mdlLinear = fitcecoc(Z,Y,'Coding','onevsone')

Training binary learner 1 (Linear) out of 3.
Training binary learner 2 (Linear) out of 3.
Training binary learner 3 (Linear) out of 3.

mdlLinear = 
  CompactClassificationECOC
      ResponseName: 'Y'
        ClassNames: {'setosa'  'versicolor'  'virginica'}
    ScoreTransform: 'none'
    BinaryLearners: {3×1 cell}
      CodingMatrix: [3×3 double]


  Properties, Methods

mdlLinear は、3 つのバイナリ学習器から構成される CompactClassificationECOC モデルです。

tall データとカーネルバイナリ学習器を使用するマルチクラス ECOC モデルに学習をさせます。はじめに、templateKernel オブジェクトを作成して、カーネルバイナリ学習器のプロパティを指定します。具体的には、拡張次元数を $2^{16}$ に増やします。

tKernel = templateKernel('NumExpansionDimensions',2^16)

tKernel = 
Fit template for classification Kernel.

             BetaTolerance: []
                 BlockSize: []
             BoxConstraint: []
                   Epsilon: []
    NumExpansionDimensions: 65536
         GradientTolerance: []
        HessianHistorySize: []
            IterationLimit: []
               KernelScale: []
                    Lambda: []
                   Learner: 'svm'
              LossFunction: []
                    Stream: []
            VerbosityLevel: []
                   Version: 1
                    Method: 'Kernel'
                      Type: 'classification'

既定では、カーネルバイナリ学習器は SVM を使用します。

templateKernel オブジェクトを fitcecoc に渡し、符号化方式を 1 対 1 に変更します。

mdlKernel = fitcecoc(Z,Y,'Learners',tKernel,'Coding','onevsone')

Training binary learner 1 (Kernel) out of 3.
Training binary learner 2 (Kernel) out of 3.
Training binary learner 3 (Kernel) out of 3.

mdlKernel = 
  CompactClassificationECOC
      ResponseName: 'Y'
        ClassNames: {'setosa'  'versicolor'  'virginica'}
    ScoreTransform: 'none'
    BinaryLearners: {3×1 cell}
      CodingMatrix: [3×3 double]


  Properties, Methods

mdlKernel も、3 つのバイナリ学習器から構成される CompactClassificationECOC モデルです。

2 つのモデルの再代入分類誤差を比較します。

errorLinear = gather(loss(mdlLinear,Z,Y))

Evaluating tall expression using the Parallel Pool 'local':
- Pass 1 of 1: Completed in 1.4 sec
Evaluation completed in 1.6 sec

errorLinear = 0.0333

errorKernel = gather(loss(mdlKernel,Z,Y))

Evaluating tall expression using the Parallel Pool 'local':
- Pass 1 of 1: Completed in 15 sec
Evaluation completed in 16 sec

errorKernel = 0.0067

mdlKernel が誤分類した学習データの比率は、mdlLinear より少なくなっています。

入力引数

すべて折りたたむ

`Tbl` — 標本データ
テーブル

標本データ。テーブルとして指定します。Tbl の各行は 1 つの観測値に、各列は 1 つの予測子に対応します。オプションとして、Tbl に応答変数用の列を 1 つ追加できます。文字ベクトルの cell 配列ではない cell 配列と複数列の変数は使用できません。

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

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

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

データ型: table

`ResponseVarName` — 応答変数名
`Tbl` 内の変数の名前

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

ResponseVarName には文字ベクトルまたは string スカラーを指定しなければなりません。たとえば、応答変数 Y が Tbl.Y として格納されている場合、"Y" として指定します。それ以外の場合、モデルを学習させるときに、Tbl の列は Y を含めてすべて予測子として扱われます。

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

名前と値の引数 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

`Y` — クラスラベル
categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

ECOC モデルに学習させるクラスラベル。categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列を指定します。

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

Y の長さと Tbl または X の行数は、同じでなければなりません。

ClassNames 名前と値のペアの引数を使用したクラスの順序を指定することをお勧めします。

`X` — 予測子データ
非スパース行列 | スパース行列

予測子データ。非スパース行列またはスパース行列を指定します。

Y の長さと X の観測値数は同じでなければなりません。

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

メモ

線形分類学習器の場合、観測値が列に対応するように X を配置して 'ObservationsIn','columns' を指定すると、最適化実行時間が大幅に短縮される可能性があります。
他のすべての学習器では、観測値が行に対応するように X を配置します。
fitcecoc は、線形分類モデルの学習のみについてスパース行列をサポートします。

データ型: double | single

メモ

NaN、空の文字ベクトル ('')、空の string ("")、<missing> および <undefined> 要素は欠損データとして扱われます。Y の欠損値に対応する行 X は削除されます。ただし、X の欠損値の処理はバイナリ学習器によって異なります。詳細については、バイナリ学習器の学習関数 fitcdiscr、fitckernel、fitcknn、fitclinear、fitcnb、fitcsvm、fitctree または fitcensemble を参照してください。観測の削除により、有効な学習や交差検証の標本サイズが小さくなります。

名前と値の引数

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

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

例: 'Learners','tree','Coding','onevsone','CrossVal','on' は、すべてのバイナリ学習器について決定木を使用し、1 対 1 の符号化設計を使用し、10 分割の交差検証を実装することを指定します。

メモ

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

ECOC 分類器オプション

すべて折りたたむ

`Coding` — 符号化設計
`'onevsone'` (既定値) | `'allpairs'` | `'binarycomplete'` | `'denserandom'` | `'onevsall'` | `'ordinal'` | `'sparserandom'` | `'ternarycomplete'` | 数値行列

符号化設計名。'Coding' と数値行列または次の表の値から構成されるコンマ区切りのペアとして指定します。

値	バイナリ学習器の数	説明
`'allpairs'` および `'onevsone'`	K(K – 1)/2	各バイナリ学習器では、1 つのクラスが陽性であり、もう 1 つのクラスは陰性です。残りは無視されます。この計画はすべてのクラスペアの割り当ての組み合わせを使用します。
`'binarycomplete'`	$2^{(K - 1)} - 1$	この計画はクラスをすべて 2 つの組み合わせに分割します。いずれのクラスも無視されません。各バイナリ学習器では、すべてのクラス割り当てが `–1` および `1` になり、割り当てに陽性クラスと陰性クラスが少なくとも 1 つずつ含まれます。
`'denserandom'`	ランダム。ただし、約 10 log₂K	各バイナリ学習器には、陽性または陰性クラス (少なくとも各 1 つ) が無作為に割り当てられます。詳細については、ランダム符号化設計行列を参照してください。
`'onevsall'`	K	各バイナリ学習器では、1 つのクラスは陽性で残りは陰性です。この計画は陽性クラス割り当てのすべての組み合わせを使用します。
`'ordinal'`	K – 1	1 番目のバイナリ学習器では、1 番目のクラスが陰性であり、残りは陽性です。2 番目のバイナリ学習器では、最初の 2 つのクラスが陰性であり、残りは陽性です。他についても同様です。
`'sparserandom'`	ランダム。ただし、約 15 log₂K	各バイナリ学習器では、各クラスに確率 0.25 で陽性または陰性が無作為に割り当てられ、確率が 0.5 の場合にクラスが無視されます。詳細については、ランダム符号化設計行列を参照してください。
`'ternarycomplete'`	$(3^{K} - 2^{(K + 1)} + 1) / 2$	この計画はクラスをすべて 3 つの組み合わせに分割します。すべてのクラス割り当てが `0`、`–1`、および `1` になり、各割り当てに陽性クラスと陰性クラスが少なくとも 1 つずつ含まれます。

符号化設計は、カスタム符号化行列を使用して指定することもできます。K 行 L 列の行列を使用します。各行はクラスに対応し、各列はバイナリ学習器に対応します。クラス順 (行) は ClassNames での順序に対応します。以下のガイドラインに従って行列を作成します。

カスタム符号化行列は、すべての要素が –1、0、または 1 でなければなりません。また、値は二分法によるクラス割り当てに対応しなければなりません。Coding(i,j) は、学習器 j がクラス i の観測値に割り当てるクラスとなります。

値	二分法によるクラス割り当て
`–1`	学習器 `j` は、クラス `i` の観測値を陰性クラスに割り当てます。
`0`	学習の前に、学習器 `j` はクラス `i` の観測値をデータセットから削除します。
`1`	学習器 `j` は、クラス `i` の観測値を陽性クラスに割り当てます。

すべての列に –1 および 1 が少なくとも 1 つずつ含まれていなければなりません。
i ≠ j となるすべての列インデックス i および j について、Coding(:,i) は Coding(:,j) と等しくなることができず、Coding(:,i) は –Coding(:,j) と等しくなることができません。
カスタム符号化行列のすべての行は異なっていなければなりません。

カスタム符号化設計行列の形式の詳細については、カスタム符号化設計行列を参照してください。

例: 'Coding','ternarycomplete'

データ型: char | string | double | single | int16 | int32 | int64 | int8

`FitPosterior` — スコアを事後確率に変換するかどうかを示すフラグ
`false` または `0` (既定値) | `true` または `1`

スコアを変換して事後確率にするかどうかを示すフラグ。'FitPosterior' および true (1) または false (0) で構成されるコンマ区切りのペアで指定します。

FitPosterior が true の場合、バイナリ学習器分類スコアは事後確率に変換されます。事後確率は、kfoldPredict、predict または resubPredict を使用して取得できます。

以下の場合、fitcecoc は事後確率の当てはめをサポートしません。

アンサンブル法が AdaBoostM2、LPBoost、RUSBoost、RobustBoost または TotalBoost である。
バイナリ学習器 (Learners) が、SVM を実装する線形分類モデルまたはカーネル分類モデルである。線形分類モデルまたはカーネル分類モデルの事後確率を得るには、代わりにロジスティック回帰を実装してください。

例: 'FitPosterior',true

データ型: logical

`Learners` — バイナリ学習器テンプレート
`"svm"` (既定値) | `"discriminant"` | `"ensemble"` | `"kernel"` | `"knn"` | `"linear"` | `"naivebayes"` | `"tree"` | テンプレートオブジェクト | テンプレートオブジェクトの cell ベクトル

バイナリ学習器テンプレート。文字ベクトル、string スカラー、テンプレートオブジェクト、またはテンプレートオブジェクトの cell ベクトルとして指定します。特に、SVM などのバイナリ学習器と、GentleBoost、LogitBoost および RobustBoost を使用するアンサンブルを指定すると、マルチクラス問題の解を求めることができます。ただし、fitcecoc もバイナリ分類器としてマルチクラスモデルをサポートしています。

Learners が文字ベクトルまたは string スカラーである場合、指定されたアルゴリズムの既定値を使用して各バイナリ学習器の学習が行なわれます。次の表は、使用可能なアルゴリズムをまとめたものです。

値	説明
`"discriminant"`	判別分析。既定のオプションについては、`templateDiscriminant` を参照してください。
`"ensemble"` (R2024a 以降)	アンサンブル学習モデル。既定では、適応ロジスティック回帰 (`"LogitBoost"`) 集約法、100 学習サイクル、木弱学習器を使用するアンサンブルになります。その他の既定のオプションについては、`templateEnsemble` を参照してください。
`"kernel"`	カーネル分類モデル。既定のオプションについては、`templateKernel` を参照してください。
`"knn"`	k 最近傍。既定のオプションについては、`templateKNN` を参照してください。
`"linear"`	線形分類モデル。既定のオプションについては、`templateLinear` を参照してください。
`"naivebayes"`	単純ベイズ。既定のオプションについては、`templateNaiveBayes` を参照してください。
`"svm"`	SVM。既定のオプションについては、`templateSVM` を参照してください。
`"tree"`	分類木。既定のオプションについては、`templateTree` を参照してください。

Learners がテンプレートオブジェクトの場合、各バイナリ学習器は格納されているオプションに従って学習します。テンプレートオブジェクトは以下を使用して作成できます。
- templateDiscriminant、判別分析用。
- templateEnsemble、アンサンブル学習用。少なくとも学習の方式 (Method)、学習器の数 (NLearn) および学習器のタイプ (Learners) を指定しなくてはなりません。バイナリ学習にはアンサンブル法 "AdaBoostM2" を使用できません。名前と値の引数 OptimizeHyperparameters を使用してハイパーパラメーターの最適化を実行する場合、アンサンブル法は "AdaBoostM1"、"GentleBoost"、または "LogitBoost" でなければならず、アンサンブルの弱学習器は木でなければなりません。
- templateKernel、カーネル分類用。
- k 最近傍向けの templateKNN。
- templateLinear、線形分類用。
- templateNaiveBayes、単純ベイズ用。
- templateSVM、SVM 用。
- templateTree、分類木用。
Learners がテンプレートオブジェクトの cell ベクトルである場合、以下のようになります。
- セル j は、バイナリ学習器 j (符号化設計行列の j 列目) に対応します。cell ベクトルの長さは L でなければなりません。L は、符号化設計行列の列数です。詳細については、Coding を参照してください。
- 予測に組み込み損失関数のいずれかを使用するには、すべてのバイナリ学習器は同じ範囲のスコアを返さなくてはなりません。たとえば、既定の SVM バイナリ学習器と既定の単純ベイズ学習器を同時に含めることはできません。前者は (-∞,∞) の範囲にあるスコアを、後者はスコアとして事後確率を返します。それ以外の場合は、カスタム損失を関数ハンドルとして関数 predict や loss などに指定しなくてはなりません。
- 線形分類モデル学習器のテンプレートを他のテンプレートとともに指定することはできません。
- 同様に、カーネル分類モデル学習器のテンプレートを他のテンプレートとともに指定することはできません。

既定では、既定の SVM テンプレートが学習器の学習に使用されます。

例: "Learners","tree"

`NumBins` — 数値予測子のビンの個数
`[]` (空) (既定値) | 正の整数スカラー

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

'NumBins' の値が空 (既定) である場合、fitcecoc はどの予測子もビン化しません。
'NumBins' の値として正の整数スカラー (numBins) を指定した場合、fitcecoc は最大 numBins 個の同確率のビンにすべての数値予測子をビン化し、元のデータではなくビンのインデックスに対して木が成長します。
- 予測子に含まれる一意の値が numBins より少なければ、ビンの数を numBins より少なくすることができます。
- fitcecoc は、カテゴリカル予測子をビン化しません。

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

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

例: 'NumBins',50

データ型: single | double

`NumConcurrent` — 同時に学習をさせるバイナリ学習器の個数
`1` (既定値) | 正の整数スカラー

同時に学習をさせるバイナリ学習器の個数。'NumConcurrent' と正の整数スカラーから構成されるコンマ区切りのペアとして指定します。既定値は、fitcecoc が逐次的にバイナリ学習器に学習をさせることを意味する 1 です。

メモ

このオプションは、tall 配列に対して fitcecoc を使用する場合のみ適用されます。詳細は、tall 配列を参照してください。

データ型: single | double

`ObservationsIn` — 予測子データにおける観測値の次元
`'rows'` (既定値) | `'columns'`

予測子データにおける観測値の次元。'ObservationsIn' と 'columns' または 'rows' から構成されるコンマ区切りのペアとして指定します。

メモ

線形分類学習器の場合、観測値が列に対応するように X を配置して 'ObservationsIn','columns' を指定すると、最適化実行時間が大幅に短縮される可能性があります。
他のすべての学習器では、観測値が行に対応するように X を配置します。

例: 'ObservationsIn','columns'

`Verbose` — 詳細レベル
`0` (既定値) | `1` | `2`

詳細レベル。'Verbose' および 0、1 または 2 のいずれかで構成されるコンマ区切りのペアとして指定します。Verbose により、コマンドウィンドウに表示されるバイナリ学習器ごとの診断情報の量が制御されます。

次の表は、使用できる詳細レベルオプションの一覧です。

値	説明
`0`	診断情報は表示されません。
`1`	新しいバイナリ学習器を学習させるたびに診断メッセージが表示されます。
`2`	新しいバイナリ学習器を学習させるたびに追加の診断メッセージが表示されます。

各バイナリ学習器には、この名前と値のペアの引数とは無関係な独自の詳細レベルがあります。バイナリ学習器の詳細レベルを変更するには、テンプレートオブジェクトを作成し、名前と値のペアの引数 'Verbose' を指定します。その後、名前と値のペアの引数 'Learners' を使用してテンプレートオブジェクトを fitcecoc に渡します。

例: 'Verbose',1

データ型: double | single

交差検証オプション

すべて折りたたむ

`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 を指定した場合、以下の手順が実行されます。

p*100% のデータを無作為に選択して検証データとして確保し、残りのデータを使用してモデルに学習をさせる。
コンパクトな学習済みモデルを交差検証済みモデルの Trained プロパティに格納する。

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

例: Holdout=0.1

データ型: double | single

`KFold` — 分割の数
`10` (既定値) | 1 より大きい正の整数値

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

データを無作為に k 個のセットに分割する。
各セットについて、そのセットを検証データとして確保し、他の k – 1 個のセットを使用してモデルに学習をさせる。
k 個のコンパクトな学習済みモデルを、交差検証済みモデルの Trained プロパティに含まれている k 行 1 列の cell ベクトルに格納する。

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

例: KFold=5

データ型: single | double

`Leaveout` — Leave-one-out 法の交差検証のフラグ
`'off'` (既定値) | `'on'`

Leave-one-out 法の交差検証のフラグ。'Leaveout' と 'on' または 'off' で構成されるコンマ区切りのペアとして指定します。'Leaveout','on' を指定する場合、n 個の各観察に対して、次が実行されます。ここで、n は size(Mdl.X,1) です。

観測は検証データとして予約され、モデルは他の n – 1 個の観測を使用して学習させる
n 個のコンパクトな学習済みモデルを、交差検証済みモデルの Trained プロパティに含まれている n 行 1 列の cell ベクトルのセルに格納する。

交差検証済みモデルを作成するために使用できるオプションは、CVPartition、Holdout、KFold、Leaveout のいずれかのみです。

メモ

線形分類モデル学習器またはカーネル分類モデル学習器から構成される ECOC モデルの交差検証では、Leave-one-out は推奨されません。

例: 'Leaveout','on'

その他の分類オプション

すべて折りたたむ

`CategoricalPredictors` — カテゴリカル予測子のリスト
正の整数のベクトル | logical ベクトル | 文字行列 | string 配列 | 文字ベクトルの cell 配列 | `'all'`

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

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

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

少なくとも 1 つの予測子がカテゴリカルであり、すべてのバイナリ学習器が分類木、単純ベイズ学習器、SVM、線形学習器、カーネル学習器、または分類木のアンサンブルである場合。
すべての予測子がカテゴリカルで少なくとも 1 つのバイナリ学習器が kNN である場合。

他の学習器の場合に 'CategoricalPredictors' を指定すると、そのバイナリ学習器に学習をさせることはできないという警告が出力されます。たとえば、ソフトウェアは、カテゴリカル予測子を使用して判別分析分類器に学習させることはできません。

各学習器は、学習器に対応する近似関数と同じ方法でカテゴリカル予測子を特定して処理します。カーネル学習器については fitckernel の 'CategoricalPredictors' を、k 最近傍学習器については fitcknn の 'CategoricalPredictors' を、線形学習器については fitclinear の 'CategoricalPredictors' を、単純ベイズ学習器については fitcnb の 'CategoricalPredictors' を、SVM 学習器については fitcsvm の 'CategoricalPredictors' を、木学習器については fitctree の 'CategoricalPredictors' を参照してください。

例: 'CategoricalPredictors','all'

`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"]

`Cost` — 誤分類のコスト
正方行列 | 構造体配列

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

正方行列 Cost の場合、Cost(i,j) は真のクラスが i である点をクラス j に分類するコストです。つまり、行は真のクラスに、列は予測するクラスに対応します。Cost の対応する行および列についてクラスの順序を指定するには、名前と値のペアの引数 ClassNames をさらに指定します。
構造体 S の場合、次の 2 つのフィールドが必要となります。
- S.ClassNames: Y と同じデータ型のクラス名を表す変数を含む。
- S.ClassificationCosts。行と列の順序が S.ClassNames と同じコスト行列。

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

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

データ型: double | single | struct

`Options` — 並列計算オプション
`[]` (既定値) | `statset` によって返される構造体配列

並列計算。'Options' と statset により返される構造体配列で構成されるコンマ区切りのペアとして指定します。並列計算には Parallel Computing Toolbox™ が必要です。fitcecoc はフィールド 'Streams'、'UseParallel' および 'UseSubtreams' を使用します。

次の表は、使用できるオプションの一覧です。

オプション説明

オプション	説明
`'Streams'`	`RandStream` オブジェクトまたはそのようなオブジェクトの cell 配列。`Streams` を指定しない場合、既定のストリームが使用されます。`Streams` を指定する場合、以下が真である場合を除き、単一オブジェクトを使用します。開いている並列プールがある。 `UseParallel` が `true`。 `UseSubstreams` が `false`。これらが真の場合は、並列プールと同じサイズの cell 配列を使用します。並列プールが開いていない場合、1 つ (基本設定に依存) が開かれます。`Streams` は単一の乱数ストリームを提供しなければなりません。
`'UseParallel'`	Parallel Computing Toolbox を保有している場合、`'UseParallel',true` を設定してワーカーのプールを呼び出すことができます。関数 `fitcecoc` は、各バイナリ学習器をプール内のワーカーに送ります。デュアルコア以上のシステムの場合、バイナリ学習器について決定木を使用すると、`fitcecoc` は Intel^® スレッディングビルディングブロック (TBB) を使用して学習を並列化します。したがって、単一のコンピューターで `'UseParallel'` オプションを指定しても役に立ちません。このオプションは、クラスターに対して使用します。Intel TBB の詳細については、https://www.intel.com/content/www/us/en/developer/tools/oneapi/onetbb.htmlを参照してください。
`'UseSubstreams'`	`'Streams'` で指定されたストリームを使用して計算する場合は `true` に設定します。既定値は `false` です。たとえば、`Streams` を`'mlfg6331_64'` または `'mrg32k3a'` といったサブストリームを許可するタイプに設定します。

'Streams'

RandStream オブジェクトまたはそのようなオブジェクトの cell 配列。Streams を指定しない場合、既定のストリームが使用されます。Streams を指定する場合、以下が真である場合を除き、単一オブジェクトを使用します。

開いている並列プールがある。
UseParallel が true。
UseSubstreams が false。

これらが真の場合は、並列プールと同じサイズの cell 配列を使用します。並列プールが開いていない場合、1 つ (基本設定に依存) が開かれます。Streams は単一の乱数ストリームを提供しなければなりません。

'UseParallel'

Parallel Computing Toolbox を保有している場合、'UseParallel',true を設定してワーカーのプールを呼び出すことができます。関数 fitcecoc は、各バイナリ学習器をプール内のワーカーに送ります。

デュアルコア以上のシステムの場合、バイナリ学習器について決定木を使用すると、fitcecoc は Intel^® スレッディングビルディングブロック (TBB) を使用して学習を並列化します。したがって、単一のコンピューターで 'UseParallel' オプションを指定しても役に立ちません。このオプションは、クラスターに対して使用します。Intel TBB の詳細については、https://www.intel.com/content/www/us/en/developer/tools/oneapi/onetbb.htmlを参照してください。

'UseSubstreams' 'Streams' で指定されたストリームを使用して計算する場合は true に設定します。既定値は false です。たとえば、Streams を'mlfg6331_64' または 'mrg32k3a' といったサブストリームを許可するタイプに設定します。

確実に結果を予測しやすくなるベストプラクティスは、parpool (Parallel Computing Toolbox) を使用し、fitcecoc によって並列計算を呼び出す前に並列プールを明示的に生成します。

例: 'Options',statset('UseParallel',true)

データ型: struct

`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 を使用して学習に使用する予測子変数を選択できます。つまり、fitcecoc は、学習中に PredictorNames の予測子変数と応答変数のみを使用します。
- PredictorNames は Tbl.Properties.VariableNames のサブセットでなければならず、応答変数の名前を含めることはできません。
- 既定では、すべての予測子変数の名前が PredictorNames に格納されます。
- PredictorNames と formula の両方ではなく、いずれか一方を使用して学習用の予測子を指定することをお勧めします。

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

データ型: string | cell

`Prior` — 事前確率
`'empirical'` (既定値) | `'uniform'` | 数値ベクトル | 構造体配列

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

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

クラスの事前確率を組み込む方法については、事前確率と誤分類コストを参照してください。

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

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

`ResponseName` — 応答変数名
`"Y"` (既定値) | 文字ベクトル | string スカラー

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

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

例: "ResponseName","response"

データ型: char | string

`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

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

すべて折りたたむ

`OptimizeHyperparameters` — 最適化するパラメーター
`"none"` (既定値) | `"auto"` | `"all"` | 使用可能パラメーター名の string 配列または cell 配列 | `optimizableVariable` オブジェクトのベクトル

最適化するパラメーター。次のいずれかを指定します。

"none" — 最適化を行いません。
"auto" — 指定された Learners の既定パラメーターと共に "Coding" を使用します。
- Learners = "svm" (既定) — ["BoxConstraint","KernelScale","Standardize"]
- Learners = "discriminant" — ["Delta","Gamma"]
- Learners = "ensemble" — ["LearnRate","Method","MinLeafSize","NumLearningCycles"]
- Learners = "kernel" — ["KernelScale","Lambda","Standardize"]
- Learners = "knn" — ["Distance","NumNeighbors","Standardize"]
- Learners = "linear" — ["Lambda","Learner"]
- Learners = "tree" — "MinLeafSize"
"all" — すべての使用可能パラメーターを最適化します。
使用可能パラメーター名の string 配列または cell 配列
optimizableVariable オブジェクトのベクトル。通常は hyperparameters の出力です。

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

メモ

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

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

Coding — fitcecoc は "onevsall" と "onevsone" で探索します。

次の表で指定されている、選択した Learners に対する使用可能ハイパーパラメーター。

学習器	使用可能ハイパーパラメーター (太字は既定の設定)	既定の範囲
`"discriminant"`	`Delta`	範囲 `[1e-6,1e3]` の対数スケール
	`Gamma`	`[0,1]` の実数値
	`DiscrimType`	`"linear"`、`"quadratic"`、`"diagLinear"`、`"diagQuadratic"`、`"pseudoLinear"` および `"pseudoQuadratic"`
`"ensemble"` (R2024a 以降)	`Method`	`"AdaBoostM1"`、`"GentleBoost"` および `"LogitBoost"`
	`NumLearningCycles`	範囲 `[10,500]` の対数スケールの整数
	`LearnRate`	範囲 `[1e-3,1]` の対数スケールの正の値
	`MinLeafSize`	範囲 `[1,max(2,floor(NumObservations/2))]` の対数スケールの整数
	`MaxNumSplits`	範囲 `[1,max(2,NumObservations-1)]` の対数スケールの整数
	`SplitCriterion`	`"deviance"`、`"gdi"` および `"twoing"`
`"kernel"`	`Learner`	`"svm"` および `"logistic"`
	`KernelScale`	範囲 `[1e-3,1e3]` の対数スケールの正の値
	`Lambda`	範囲 `[1e-3/NumObservations,1e3/NumObservations]` の対数スケールの正の値
	`NumExpansionDimensions`	範囲 `[100,10000]` の対数スケールの整数
	`Standardize`	`"true"` および `"false"`
`"knn"`	`NumNeighbors`	範囲 `[1, max(2,round(NumObservations/2))]` の対数スケールの正の整数値
	`Distance`	`"cityblock"`、`"chebychev"`、`"correlation"`、`"cosine"`、`"euclidean"`、`"hamming"`、`"jaccard"`、`"mahalanobis"`、`"minkowski"`、`"seuclidean"` および `"spearman"`
	`DistanceWeight`	`"equal"`、`"inverse"` および `"squaredinverse"`
	`Exponent`	`[0.5,3]` の正の値
	`Standardize`	`"true"` および `"false"`
`"linear"`	`Lambda`	範囲 `[1e-5/NumObservations,1e5/NumObservations]` の対数スケールの正の値
	`Learner`	`"svm"` および `"logistic"`
	`Regularization`	`"ridge"` および `"lasso"` `Regularization` が `"ridge"` の場合、関数は既定では記憶制限 BFGS (LBFGS) ソルバーを使用します。 `Regularization` が `"lasso"` の場合、関数は既定では可分近似によるスパース再構成 (SpaRSA) ソルバーを使用します。
`"svm"`	`BoxConstraint`	範囲 `[1e-3,1e3]` の対数スケールの正の値
	`KernelScale`	範囲 `[1e-3,1e3]` の対数スケールの正の値
	`KernelFunction`	`"gaussian"`、`"linear"` および `"polynomial"`
	`PolynomialOrder`	範囲 `[2,4]` の整数
	`Standardize`	`"true"` および `"false"`
`"tree"`	`MinLeafSize`	範囲 `[1,max(2,floor(NumObservations/2))]` の対数スケールの整数
	`MaxNumSplits`	範囲 `[1,max(2,NumObservations-1)]` の対数スケールの整数
	`SplitCriterion`	`"gdi"`、`"deviance"` および `"twoing"`
	`NumVariablesToSample`	範囲 `[1,max(2,NumPredictors)]` の整数

または、選択した Learners と共に hyperparameters を次のように使用します。

load fisheriris % hyperparameters requires data and learner
params = hyperparameters("fitcecoc",meas,species,"svm");

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

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

load fisheriris
params = hyperparameters("fitcecoc",meas,species,"svm");
params(2).Range = [1e-4,1e6];

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

既定では、コマンドラインに反復表示が表示され、最適化のハイパーパラメーターの個数に従ってプロットが表示されます。最適化とプロットにおける目的関数は誤分類率です。反復表示を制御するには、名前と値の引数 HyperparameterOptimizationOptions の Verbose フィールドを設定します。プロットを制御するには、名前と値の引数 HyperparameterOptimizationOptions の ShowPlots フィールドを設定します。

たとえば、ECOC 分類器の最適化を参照してください。

例: "OptimizeHyperparameters","auto"

`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"` の場合は `Learners` がアンサンブル学習モデルでなければ `30` `"bayesopt"` および `"randomsearch"` の場合は `Learners` がアンサンブル学習モデルであれば `70` `"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` — 学習させた ECOC モデル
`ClassificationECOC` モデルオブジェクト | `CompactClassificationECOC` モデルオブジェクト | `ClassificationPartitionedECOC` 交差検証済みモデルオブジェクト | `ClassificationPartitionedLinearECOC` 交差検証済みモデルオブジェクト | `ClassificationPartitionedKernelECOC` 交差検証済みモデルオブジェクト

学習済みの ECOC 分類器。ClassificationECOC モデルオブジェクト、CompactClassificationECOC モデルオブジェクト、ClassificationPartitionedECOC 交差検証済みモデルオブジェクト、ClassificationPartitionedLinearECOC 交差検証済みモデルオブジェクト、または ClassificationPartitionedKernelECOC 交差検証済みモデルオブジェクトとして返されます。

次の表は、指定されたバイナリ学習器のタイプ、および交差検証を実行するかどうかに応じて、fitcecoc がどのタイプのモデルオブジェクトを返すかを示しています。

線形分類モデル学習器	カーネル分類モデル学習器	交差検証	返されるモデルオブジェクト
なし	なし	なし	`ClassificationECOC`
なし	なし	あり	`ClassificationPartitionedECOC`
あり	なし	なし	`CompactClassificationECOC`
あり	なし	あり	`ClassificationPartitionedLinearECOC`
なし	あり	なし	`CompactClassificationECOC`
なし	あり	あり	`ClassificationPartitionedKernelECOC`

`HyperparameterOptimizationResults` — ハイパーパラメーターの交差検証最適化の説明
`BayesianOptimization` オブジェクト | ハイパーパラメーターおよび関連する値のテーブル

ハイパーパラメーターの交差検証最適化の説明。BayesianOptimization オブジェクト、またはハイパーパラメーターや関連する値が含まれている table として返されます。名前と値のペアの引数 OptimizeHyperparameters が空以外であり、名前と値のペアの引数 Learners で線形またはカーネルバイナリ学習器を指定した場合、HyperparameterOptimizationResults は空以外になります。値は、名前と値のペアの引数 HyperparameterOptimizationOptions の設定によって決まります。

'bayesopt' (既定) — BayesianOptimization クラスのオブジェクト
'gridsearch' または 'randomsearch' — 使用したハイパーパラメーター、観測された目的関数の値 (交差検証損失)、および最小 (最良) から最大 (最悪) までの観測値の順位が格納されている table

データ型: table

制限

fitcecoc は、線形分類モデルの学習のみについてスパース行列をサポートします。他のすべてのモデルの場合、代わりに予測子データの非スパース行列を指定します。

詳細

すべて折りたたむ

誤り訂正出力符号モデル

"誤り訂正出力符号 (ECOC) モデル" は、3 つ以上のクラスがある分類の問題を一連のバイナリ分類問題に縮小します。

ECOC 分類は、バイナリ学習器が学習するクラスを決定する符号化設計と、バイナリ学習器の結果 (予測) が集計される方法を決定する復号化スキームを必要とします。

以下のように仮定します。

分類問題には 3 つのクラスがある。
符号化設計が 1 対 1 である。3 クラスの場合、この符号化設計は次のようになります。

$\begin{matrix} Learner 1 & Learner 2 & Learner 3 \\ Class 1 & 1 & 1 & 0 \\ Class 2 & - 1 & 0 & 1 \\ Class 3 & 0 & - 1 & - 1 \end{matrix}$
分類モデルを作成するときに、名前と値の引数 Coding を使用して別の符号化設計を指定できます。
モデルでの予測クラスの判定にバイナリ損失関数 g による損失に重みを付けた復号化方式を使用する。ソフトウェアでは損失に基づく復号化方式もサポートされます。復号化方式とバイナリ損失関数は、predict、loss、margin、edge などのオブジェクト関数を呼び出すときに、名前と値の引数 Decoding と BinaryLoss を使用してそれぞれ指定できます。

ECOC アルゴリズムの手順は次のとおりです。

学習器 1 は、クラス 1 またはクラス 2 の観測値について学習を行い、クラス 1 を陽性クラス、クラス 2 を陰性クラスとして扱います。他の学習器の学習も同様に実行します。
次のように仮定します。M は要素 m_kl をもつ符号化設計行列です。s_l は学習器 l の陽性クラスの予測された分類スコアです。新しい観測値は、B 個のバイナリ学習器について損失の合計が最小になるクラス ( $\hat{k}$ ) に割り当てられます。

$\hat{k} = \underset{k}{argmin} \frac{\sum_{l = 1}^{B} | m_{k l} | g (m_{k l}, s_{l})}{\sum_{l = 1}^{B} | m_{k l} |} .$

ECOC モデルは他のマルチクラスモデルと比較して分類精度を向上させることができます[2]。

符号化設計

"符号化設計" は、各バイナリ学習器がどのクラスを学習したのかを要素が指示する行列です。つまり、マルチクラス問題がどのように一連のバイナリ問題にされたのかを示します。

符号化設計の各行は各クラスに対応し、各列はバイナリ学習器に対応します。三項符号化設計では、特定の列 (バイナリ学習器) に対して以下が実行されます。

1 が含まれている行の場合、対応するクラスの観測値をすべて陽性クラスにグループ化するようバイナリ学習器に指示します。
–1 が含まれている行の場合、対応するクラスの観測値をすべて陰性クラスにグループ化するようバイナリ学習器に指示します。
0 が含まれている行の場合、対応するクラスの観測値をすべて無視するようバイナリ学習器に指示します。

ハミング尺度に基づく行の最小ペアワイズ距離が大きい符号化設計行列が最適です。行のペアワイズ距離の詳細については、ランダム符号化設計行列および[3]を参照してください。

次の表は一般的な符号化設計について説明しています。

符号化設計	説明	学習器の数	行の最小ペアワイズ距離
OVA (1 対他)	各バイナリ学習器では、1 つのクラスは陽性で残りは陰性です。この計画は陽性クラス割り当てのすべての組み合わせを使用します。	K	2
OVO (1 対 1)	各バイナリ学習器では、1 つのクラスが陽性で、1 つのクラスが陰性です。残りは無視されます。この計画はすべてのクラスペアの割り当ての組み合わせを使用します。	K(K – 1)/2	1
完全二項	この計画はクラスをすべて 2 つの組み合わせに分割します。いずれのクラスも無視されません。つまり、すべてのクラス割り当てが `–1` および `1` になり、各バイナリ学習器について 1 つ以上の陽性クラスおよび 1 つ以上の陰性クラスが割り当てに含まれます。	2^{K – 1} – 1	2^{K – 2}
完全三項	この計画はクラスをすべて 3 つの組み合わせに分割します。つまり、すべてのクラス割り当てが `0`、`–1` および `1` になり、各バイナリ学習器について 1 つ以上の陽性クラスおよび 1 つ以上の陰性クラスが割り当てに含まれます。	(3^K – 2^{K + 1} + 1)/2	3^{K – 2}
順序	1 番目のバイナリ学習器では、1 番目のクラスが陰性であり、残りは陽性です。2 番目のバイナリ学習器では、最初の 2 つのクラスが陰性であり、残りは陽性です。他についても同様です。	K – 1	1
密なランダム	各バイナリ学習器には、陽性または陰性クラス (少なくとも各 1 つ) が無作為に割り当てられます。詳細については、ランダム符号化設計行列を参照してください。	ランダム。ただし、約 10 log₂K	変数
スパースランダム	各バイナリ学習器では、各クラスに確率 0.25 で陽性または陰性が無作為に割り当てられ、確率が 0.5 の場合にクラスが無視されます。詳細については、ランダム符号化設計行列を参照してください。	ランダム。ただし、約 15 log₂K	変数

このプロットは符号化設計のバイナリ学習器の数を増加するクラス数 (K) と比較します。

ヒント

バイナリ学習器の数はクラス数とともに増加します。多数のクラスがある問題では、符号化設計 binarycomplete および ternarycomplete は効率的ではありません。ただし、
- K ≤ 4 の場合、sparserandom ではなく ternarycomplete 符号化設計を使用します。
- K ≤ 5 の場合、denserandom ではなく binarycomplete 符号化設計を使用します。
コマンドウィンドウに Mdl.CodingMatrix を入力して学習させた ECOC 分類器の符号化設計行列を表示できます。
アプリケーションへの詳細な知識を用い、計算上の制約を考慮して符号化行列を作成しなければなりません。十分な計算能力と時間がある場合、いくつかの符号化行列を試し、最大のパフォーマンスが得られるものを選択してください (たとえば、confusionchart を使用して各モデルの混同行列を確認します)。
観測値が多いデータセットの場合、Leave-one-out 交差検証 (Leaveout) では不十分です。代わりに、k 分割交差検証 (KFold) を使用してください。

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

アルゴリズム

すべて折りたたむ

カスタム符号化設計行列

カスタム符号化行列は特定の形式でなければなりません。ソフトウェアによるカスタム符号化行列の検証では、以下について確認されます。

すべての要素が –1、0、または 1 である。
すべての列に –1 および 1 が少なくとも 1 つずつ含まれている。
すべての列ベクトル u と v のそれぞれについて、u ≠ v かつ u ≠ –v である。
すべての行ベクトルが一意である。
行列は任意の 2 つのクラスを分離できます。つまり、任意の行から他の任意の行に次のルールに従って移動できる。
- 1 から –1 または –1 から 1 に垂直方向に移動。
- 非ゼロ要素から別の非ゼロ要素に水平方向に移動。
- 垂直方向の移動に行列の列を一度だけ使用。
上記のルールを使用して、行 i から行 j に移動できない場合、クラス i および j は計画により分離できません。たとえば、次の符号化設計ではクラス 1 および 2 をクラス 3 および 4 から分離できません。

$[\begin{matrix} 1 & 0 \\ - 1 & 0 \\ 0 & 1 \\ 0 & - 1 \end{matrix}]$
2 行目の 2 列目に 0 があるので、2 行目の –1 を 2 列目に水平に移動できません。したがって、この符号化設計は拒否されます。

並列計算

並列計算を使用する場合 (Options を参照)、fitcecoc はバイナリ学習器を並列して学習させます。

事前確率と誤分類コスト

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

各バイナリ学習器について、ソフトウェアは、事前確率を 2 要素のベクトルに正規化し、コスト行列を 2 行 2 列の行列に正規化します。その後、2 行 2 列のコスト行列で指定されているペナルティを組み込むことで事前確率ベクトルを調整し、コスト行列を既定のコスト行列に設定します。Mdl のバイナリ学習器 (Mdl.BinaryLearners) の Cost プロパティと Prior プロパティに調整後の値が格納されます。具体的には、以下の手順が実行されます。

各バイナリ学習器に指定されたクラス事前確率 (Prior) が正規化されます。M は符号化設計行列であり、I(A,c) は指標行列であると仮定します。指標行列の次元数は A と同じです。指標行列の要素は、対応する A の要素が c の場合は 1、それ以外の場合は 0 になります。M₊₁ および M_-1 は、次の条件を満たす K 行 L 列の行列と仮定します。
- M₊₁ = M○I(M,1)、ここで ○ は要素単位の乗算です (つまり、Mplus = M.*(M == 1))。また、M₊₁ の列ベクトル l を $m_{l}^{(+ 1)}$ と表します。
- M_-1 = -M○I(M,-1) (つまり、Mminus = -M.*(M == -1))。また、M_-1 の列ベクトル l を $m_{l}^{(- 1)}$ と表します。
$π_{l}^{+ 1} = m_{l}^{(+ 1)} ° π$ および $π_{l}^{- 1} = m_{l}^{(- 1)} ° π$ と表します。ここで、π はクラスについて指定した事前確率のベクトル (Prior) です。
すると、バイナリ学習器 l について正および負のスカラーのクラス事前確率は次のようになります。

${\hat{π}}_{l}^{(j)} = \frac{{‖ π_{l}^{(j)} ‖}_{1}}{{‖ π_{l}^{(+ 1)} ‖}_{1} + {‖ π_{l}^{(- 1)} ‖}_{1}},$
ここで、j = {-1,1} です。 ${‖ a ‖}_{1}$ は a の 1 ノルムです。
各バイナリ学習器の K 行 K 列のコスト行列 C (Cost) が正規化されます。バイナリ学習器 l で陰性クラスの観測値を陽性クラスに分類するコストは次のようになります。

$c_{l}^{- +} = {(π_{l}^{(- 1)})}^{⊤} C π_{l}^{(+ 1)} .$
同様に、陽性クラスの観測値を陰性クラスに分類するコストは次のようになります。

$c_{l}^{+ -} = {(π_{l}^{(+ 1)})}^{⊤} C π_{l}^{(- 1)} .$
バイナリ学習器 l のコスト行列は次のようになります。

$C_{l} = [\begin{matrix} 0 & c_{l}^{- +} \\ c_{l}^{+ -} & 0 \end{matrix}] .$
ECOC モデルは誤分類のコストをクラス事前確率に組み込むことで対応します。次のようにして、バイナリ学習器のクラス事前確率が調整され、コスト行列が既定のコスト行列に設定されます。

$\begin{matrix} {\bar{π}}_{l}^{- 1} = \frac{c_{l}^{- +} {\hat{π}}_{l}^{- 1}}{c_{l}^{- +} {\hat{π}}_{l}^{- 1} + c^{+ -} {\hat{π}}_{l}^{+ 1}}, \\ {\bar{π}}_{l}^{+ 1} = \frac{c_{l}^{+ -} {\hat{π}}_{l}^{+ 1}}{c_{l}^{- +} {\hat{π}}_{l}^{- 1} + c^{+ -} {\hat{π}}_{l}^{+ 1}}, \\ {\bar{C}}_{l} = [\begin{matrix} 0 & 1 \\ 1 & 0 \end{matrix}] . \end{matrix}$

ランダム符号化設計行列

K 個のクラスに対して、ランダム符号化設計行列が以下のように生成されます。

次のいずれかの行列が生成されます。
1. 密なランダム — K 行 L_d 列の符号化設計行列の各要素に同じ確率で 1 または –1 が割り当てられます。ここで $L_{d} \approx ⌈ 10 \log_{2} K ⌉$ です。
2. スパースランダム — K 行 L_s 列の符号化設計行列の各要素に 0.25 の確率で 1、0.25 の確率で -1、0.5 の確率で 0 が割り当てられます。ここで $L_{s} \approx ⌈ 15 \log_{2} K ⌉$ です。
1 および –1 が少なくとも 1 つずつ列に含まれていない場合、その列は削除されます。
異なる列 u および v について u = v または u = –v である場合、v が符号化設計行列から削除されます。

既定では 10,000 個の行列が無作為に生成されます。次によって与えられるハミング尺度 ([3]) に基づき、行の最小ペアワイズ距離が最大になる行列が保持されます。

$Δ (k_{1}, k_{2}) = 0.5 \sum_{l = 1}^{L} | m_{k_{1} l} | | m_{k_{2} l} | | m_{k_{1} l} - m_{k_{2} l} |,$

ここで、m_{k_jl} は符号化設計行列 j の要素です。

サポートベクターの保存

既定では、効率を向上させるため、fitcecoc はすべての線形 SVM バイナリ学習器の Alpha、SupportVectorLabels および SupportVectors プロパティを空にします。fitcecoc は、Alpha ではなく Beta をモデル表示で出力します。

Alpha、SupportVectorLabels および SupportVectors を保存するには、サポートベクターを fitcecoc に保存するよう指定する線形 SVM テンプレートを渡します。たとえば、次のように入力します。

t = templateSVM('SaveSupportVectors',true)
Mdl = fitcecoc(X,Y,'Learners',t);

サポートベクターおよび関連する値は、生成された ClassificationECOC モデルを discardSupportVectors に渡すことにより削除できます。

参照

[1] Allwein, E., R. Schapire, and Y. Singer. “Reducing multiclass to binary: A unifying approach for margin classiﬁers.” Journal of Machine Learning Research. Vol. 1, 2000, pp. 113–141.

[2] Fürnkranz, Johannes. “Round Robin Classification.” J. Mach. Learn. Res., Vol. 2, 2002, pp. 721–747.

[3] Escalera, S., O. Pujol, and P. Radeva. “Separability of ternary codes for sparse designs of error-correcting output codes.” Pattern Recog. Lett. Vol. 30, Issue 3, 2009, pp. 285–297.

[4] Escalera, S., O. Pujol, and P. Radeva. “On the decoding process in ternary error-correcting output codes.” IEEE Transactions on Pattern Analysis and Machine Intelligence. Vol. 32, Issue 7, 2010, pp. 120–134.

拡張機能

tall 配列
メモリの許容量を超えるような多数の行を含む配列を計算します。

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

詳細は、tall 配列を参照してください。

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

並列実行するには、次のいずれかの方法で 'UseParallel' オプションを true に設定します。

statset を使用してオプション構造体の 'UseParallel' フィールドを true に設定し、fitceoc を呼び出すときに名前と値のペアの引数 'Options' を指定します。
たとえば、次のようにします。'Options',statset('UseParallel',true)
詳細は、名前と値のペアの引数 'Options' を参照してください。
fitceoc を呼び出すときに名前と値のペアの引数 'HyperparameterOptions',struct('UseParallel',true) を指定することにより、ハイパーパラメーターの最適化を並列実行します。
並列的なハイパーパラメーターの最適化の詳細については、並列ベイズ最適化を参照してください。

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

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

名前と値の引数 'Learners' は、次の表で指定されている学習器のいずれかの値としてのみ指定できます。

学習器	学習器名	テンプレートオブジェクト作成関数	`gpuArray` サポートに関する情報
サポートベクターマシン	`'svm'`	`templateSVM`	GPU 配列 (次の場合) `fitcsvm`
k 最近傍	`'knn'`	`templateKNN`	GPU 配列 (次の場合) `fitcknn`
分類木	`'tree'`	`templateTree`	GPU 配列 (次の場合) `fitctree`

詳細は、GPU での MATLAB 関数の実行 (Parallel Computing Toolbox)を参照してください。

バージョン履歴

R2014b で導入

すべて展開する

R2024a: アンサンブルバイナリ学習器のハイパーパラメーターの最適化

fitcecoc では、アンサンブルバイナリ学習器を使用するときにハイパーパラメーターの最適化がサポートされます。Learners の値が "ensemble" であるか、関数 templateEnsemble を使用して作成されたアンサンブルテンプレートである場合に、名前と値の引数 OptimizeHyperparameters を指定できます。

アンサンブルバイナリ学習器を使用してハイパーパラメーターの最適化を実行する場合、アンサンブル法は "AdaBoostM1"、"GentleBoost"、または "LogitBoost" でなければならず、アンサンブルの弱学習器は木でなければなりません。
値 "ensemble" は、適応ロジスティック回帰集約法 (LogitBoost)、100 学習サイクル、木弱学習器を使用するアンサンブルに対応します。

fitcecoc でアンサンブルバイナリ学習器を使用してベイズ最適化を実行する場合、MaxObjectiveEvaluations に使用される既定値は 70 です。詳細については、HyperparameterOptimizationOptions を参照してください。

関数 hyperparameters を使用して、アンサンブルバイナリ学習器に対する使用可能なハイパーパラメーターと既定のハイパーパラメーターを確認できます。さらに、この関数を使用してハイパーパラメーターとその範囲を調整できます。"fitcecoc" を近似関数の名前として指定し、"ensemble" またはアンサンブルテンプレートを学習器タイプとして指定します。

R2023b: バイナリ学習器がカーネル、k 最近傍 (KNN)、またはサポートベクターマシン (SVM) の分類器である場合の `OptimizeHyperparameters` の `"auto"` オプションに `Standardize` を追加

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

R2022a: ハイパーパラメーターの最適化で使用される線形学習器ソルバーを正則化手法に基づいて決定

R2022a 以降では、線形バイナリ学習器 ('linear' または templateLinear) をもつ ECOC モデルのハイパーパラメーターを最適化するように指定した場合に、特定のソルバーを使用するように指定しないと、最適化プロセスの各反復で選択された正則化タイプに応じて、記憶制限 BFGS (LBFGS) ソルバーまたは可分近似によるスパース再構成 (SpaRSA) ソルバーのいずれかが fitcecoc で使用されます。

Regularization が 'ridge' の場合、Solver の値は既定では 'lbfgs' に設定されます。
Regularization が 'lasso' の場合、Solver の値は既定では 'sparsa' に設定されます。

以前のリリースでは、ハイパーパラメーターの最適化での既定のソルバーの選択には、正則化タイプ、学習器タイプ、予測子の数など、さまざまな要因が関係していました。詳細については、Solver を参照してください。

参考

fitcecoc

構文

説明

例

SVM 学習器を使用したマルチクラス モデルの学習

マルチクラス線形分類モデルの学習

ECOC 分類器の交差検証

ECOC 分類器を使用した事後確率の推定

ビン化と並列計算の使用による ECOC 分類器の学習の高速化

ECOC 分類器の最適化

SVM と tall 配列を使用したマルチクラス ECOC モデルの学習

入力引数

Tbl — 標本データ テーブル

ResponseVarName — 応答変数名 Tbl 内の変数の名前

formula — 応答変数および予測子変数サブセットの説明モデル 文字ベクトル | string スカラー

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

X — 予測子データ 非スパース行列 | スパース行列

名前と値の引数

Coding — 符号化設計 'onevsone' (既定値) | 'allpairs' | 'binarycomplete' | 'denserandom' | 'onevsall' | 'ordinal' | 'sparserandom' | 'ternarycomplete' | 数値行列

FitPosterior — スコアを事後確率に変換するかどうかを示すフラグ false または 0 (既定値) | true または 1

Learners — バイナリ学習器テンプレート "svm" (既定値) | "discriminant" | "ensemble" | "kernel" | "knn" | "linear" | "naivebayes" | "tree" | テンプレート オブジェクト | テンプレート オブジェクトの cell ベクトル

NumBins — 数値予測子のビンの個数 [] (空) (既定値) | 正の整数スカラー

NumConcurrent — 同時に学習をさせるバイナリ学習器の個数 1 (既定値) | 正の整数スカラー

ObservationsIn — 予測子データにおける観測値の次元 'rows' (既定値) | 'columns'

Verbose — 詳細レベル 0 (既定値) | 1 | 2

CrossVal — 交差検証分類器を学習させるためのフラグ 'off' (既定値) | 'on'

CVPartition — 交差検証分割 [] (既定値) | cvpartition オブジェクト

Holdout — ホールドアウト検証の対象データの比率 (0,1) の範囲のスカラー値

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

Leaveout — Leave-one-out 法の交差検証のフラグ 'off' (既定値) | 'on'

CategoricalPredictors — カテゴリカル予測子のリスト 正の整数のベクトル | logical ベクトル | 文字行列 | string 配列 | 文字ベクトルの cell 配列 | 'all'

ClassNames — 学習に使用するクラスの名前 categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

Cost — 誤分類のコスト 正方行列 | 構造体配列

Options — 並列計算オプション [] (既定値) | statset によって返される構造体配列

PredictorNames — 予測子変数名 一意な名前の string 配列 | 一意な文字ベクトルの cell 配列

Prior — 事前確率 'empirical' (既定値) | 'uniform' | 数値ベクトル | 構造体配列

ResponseName — 応答変数名 "Y" (既定値) | 文字ベクトル | string スカラー

Weights — 観測値の重み 正の値の数値ベクトル | Tbl 内の変数の名前

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

HyperparameterOptimizationOptions — 最適化のオプション 構造体

出力引数

HyperparameterOptimizationResults — ハイパーパラメーターの交差検証最適化の説明 BayesianOptimization オブジェクト | ハイパーパラメーターおよび関連する値のテーブル

制限

詳細

誤り訂正出力符号モデル

符号化設計

ヒント

アルゴリズム

カスタム符号化設計行列

並列計算

事前確率と誤分類コスト

ランダム符号化設計行列

サポート ベクターの保存

参照

拡張機能

tall 配列 メモリの許容量を超えるような多数の行を含む配列を計算します。

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

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

バージョン履歴

R2024a: アンサンブル バイナリ学習器のハイパーパラメーターの最適化

R2023b: バイナリ学習器がカーネル、k 最近傍 (KNN)、またはサポート ベクター マシン (SVM) の分類器である場合の OptimizeHyperparameters の "auto" オプションに Standardize を追加

R2022a: ハイパーパラメーターの最適化で使用される線形学習器ソルバーを正則化手法に基づいて決定

参考

トピック

SVM 学習器を使用したマルチクラスモデルの学習

`Tbl` — 標本データ
テーブル

`ResponseVarName` — 応答変数名
`Tbl` 内の変数の名前

`formula` — 応答変数および予測子変数サブセットの説明モデル
文字ベクトル | string スカラー

`Y` — クラスラベル
categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

`X` — 予測子データ
非スパース行列 | スパース行列

`Coding` — 符号化設計
`'onevsone'` (既定値) | `'allpairs'` | `'binarycomplete'` | `'denserandom'` | `'onevsall'` | `'ordinal'` | `'sparserandom'` | `'ternarycomplete'` | 数値行列

`FitPosterior` — スコアを事後確率に変換するかどうかを示すフラグ
`false` または `0` (既定値) | `true` または `1`

`Learners` — バイナリ学習器テンプレート
`"svm"` (既定値) | `"discriminant"` | `"ensemble"` | `"kernel"` | `"knn"` | `"linear"` | `"naivebayes"` | `"tree"` | テンプレートオブジェクト | テンプレートオブジェクトの cell ベクトル

`NumBins` — 数値予測子のビンの個数
`[]` (空) (既定値) | 正の整数スカラー

`NumConcurrent` — 同時に学習をさせるバイナリ学習器の個数
`1` (既定値) | 正の整数スカラー

`ObservationsIn` — 予測子データにおける観測値の次元
`'rows'` (既定値) | `'columns'`

`Verbose` — 詳細レベル
`0` (既定値) | `1` | `2`

`CrossVal` — 交差検証分類器を学習させるためのフラグ
`'off'` (既定値) | `'on'`

`CVPartition` — 交差検証分割
`[]` (既定値) | `cvpartition` オブジェクト

`Holdout` — ホールドアウト検証の対象データの比率
(0,1) の範囲のスカラー値

`KFold` — 分割の数
`10` (既定値) | 1 より大きい正の整数値

`Leaveout` — Leave-one-out 法の交差検証のフラグ
`'off'` (既定値) | `'on'`

`CategoricalPredictors` — カテゴリカル予測子のリスト
正の整数のベクトル | logical ベクトル | 文字行列 | string 配列 | 文字ベクトルの cell 配列 | `'all'`

`ClassNames` — 学習に使用するクラスの名前
categorical 配列 | 文字配列 | string 配列 | logical ベクトル | 数値ベクトル | 文字ベクトルの cell 配列

`Cost` — 誤分類のコスト
正方行列 | 構造体配列

`Options` — 並列計算オプション
`[]` (既定値) | `statset` によって返される構造体配列

`PredictorNames` — 予測子変数名
一意な名前の string 配列 | 一意な文字ベクトルの cell 配列

`Prior` — 事前確率
`'empirical'` (既定値) | `'uniform'` | 数値ベクトル | 構造体配列

`ResponseName` — 応答変数名
`"Y"` (既定値) | 文字ベクトル | string スカラー

`Weights` — 観測値の重み
正の値の数値ベクトル | `Tbl` 内の変数の名前

`OptimizeHyperparameters` — 最適化するパラメーター
`"none"` (既定値) | `"auto"` | `"all"` | 使用可能パラメーター名の string 配列または cell 配列 | `optimizableVariable` オブジェクトのベクトル

`HyperparameterOptimizationOptions` — 最適化のオプション
構造体

`HyperparameterOptimizationResults` — ハイパーパラメーターの交差検証最適化の説明
`BayesianOptimization` オブジェクト | ハイパーパラメーターおよび関連する値のテーブル

サポートベクターの保存

tall 配列
メモリの許容量を超えるような多数の行を含む配列を計算します。

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

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

R2024a: アンサンブルバイナリ学習器のハイパーパラメーターの最適化

R2023b: バイナリ学習器がカーネル、k 最近傍 (KNN)、またはサポートベクターマシン (SVM) の分類器である場合の `OptimizeHyperparameters` の `"auto"` オプションに `Standardize` を追加