ドキュメンテーション

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

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 は一意なクラス ラベル (レベル) の数です。MdlClassificationECOC モデルです。

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) は、Learners = 'linear' という設定で名前と値のペア OptimizeHyperparameters が渡された場合に、ハイパーパラメーターの最適化の詳細も返します。他の Learners の場合、MdlHyperparameterOptimizationResults プロパティには結果が格納されます。カーネル バイナリ学習器では、ハイパーパラメーターの最適化を使用できません。

すべて折りたたむ

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

フィッシャーのアヤメのデータセットを読み込みます。

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'


  Properties, Methods

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

符号化設計行列を表示します。

Mdl.ClassNames
ans = 3x1 cell array
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

CodingMat = Mdl.CodingMatrix
CodingMat = 3×3

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

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

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

Mdl.BinaryLearners{1}                % The first binary learner
ans = 
  classreg.learning.classif.CompactClassificationSVM
             ResponseName: 'Y'
    CategoricalPredictors: []
               ClassNames: [-1 1]
           ScoreTransform: 'none'
                     Beta: [4x1 double]
                     Bias: 1.4505
         KernelParameters: [1x1 struct]


  Properties, Methods

標本内分類誤差を計算します。

isLoss = resubLoss(Mdl)
isLoss = 0.0067

分類誤差が小さくても、分類器に過適合が発生する場合があります。crossval を使用して分類器の交差検証を実行できます。

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

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

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

t = templateSVM('Standardize',1)
t = 
Fit template for classification SVM.

                     Alpha: [0x1 double]
             BoxConstraint: []
                 CacheSize: []
             CachingMethod: ''
                ClipAlphas: []
    DeltaGradientTolerance: []
                   Epsilon: []
              GapTolerance: []
              KKTTolerance: []
            IterationLimit: []
            KernelFunction: ''
               KernelScale: []
              KernelOffset: []
     KernelPolynomialOrder: []
                  NumPrint: []
                        Nu: []
           OutlierFraction: []
          RemoveDuplicates: []
           ShrinkagePeriod: []
                    Solver: ''
           StandardizeData: 1
        SaveSupportVectors: []
            VerbosityLevel: []
                   Version: 2
                    Method: 'SVM'
                      Type: 'classification'

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

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

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

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

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

CVMdl = crossval(Mdl);

CVMdlClassificationPartitionedECOC 交差検証 ECOC 分類器です。

分類誤差を推定します。

loss = kfoldLoss(CVMdl)
loss = 0.0400

分類誤差は 4% であり、ECOC 分類器がかなり良好に一般化を行うことを示しています。

フィッシャーのアヤメのデータセットを読み込みます。花弁の寸法を予測子として使用して、分類器を学習させます。

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

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

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

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

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

Mdl = fitcecoc(X,Y,'Learners',t,'FitPosterior',1,...
    '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).

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

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

[label,~,~,Posterior] = resubPredict(Mdl,'Verbose',1);
Mdl.BinaryLoss
Predictions from all learners have been computed.
Loss for all observations has been computed.
Computing posterior probabilities...

ans =

    'quadratic'

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

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

idx = randsample(size(X,1),10,1);
Mdl.ClassNames
table(Y(idx),label(idx),Posterior(idx,:),...
    'VariableNames',{'TrueLabel','PredLabel','Posterior'})
ans =

  3x1 cell array

    {'setosa'    }
    {'versicolor'}
    {'virginica' }


ans =

  10x3 table

     TrueLabel       PredLabel                    Posterior               
    ____________    ____________    ______________________________________

    'virginica'     'virginica'      0.0039321     0.0039869       0.99208
    'virginica'     'virginica'       0.017067      0.018263       0.96467
    'virginica'     'virginica'       0.014948      0.015856        0.9692
    'versicolor'    'versicolor'    2.2197e-14       0.87317       0.12683
    'setosa'        'setosa'             0.999    0.00025091    0.00074639
    'versicolor'    'virginica'     2.2195e-14      0.059429       0.94057
    'versicolor'    'versicolor'    2.2194e-14       0.97001      0.029986
    'setosa'        'setosa'             0.999     0.0002499    0.00074741
    'versicolor'    'versicolor'     0.0085646       0.98259      0.008849
    'setosa'        'setosa'             0.999    0.00025013    0.00074718

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(:)]);

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

figure;
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 モデルに学習をさせます。

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

load nlpdata

X は予測子データのスパース行列、Y はクラス ラベルの categorical ベクトルです。データには 2 つを超えるクラスがあります。

既定の線形分類モデル テンプレートを作成します。

t = templateLinear();

既定値を調整する方法については、templateLinear のページの名前と値のペアの引数を参照してください。

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

X = X';
rng(1); % For reproducibility 
Mdl = fitcecoc(X,Y,'Learners',t,'ObservationsIn','columns')
Mdl = 
  classreg.learning.classif.CompactClassificationECOC
      ResponseName: 'Y'
        ClassNames: [1x13 categorical]
    ScoreTransform: 'none'
    BinaryLearners: {78x1 cell}
      CodingMatrix: [13x78 double]


  Properties, Methods

または、'Learners','Linear' を使用して、既定の線形分類モデルから構成されている ECOC モデルに学習をさせることができます。

メモリを節約するため、fitcecoc は線形分類学習器から構成されている学習済みの ECOC モデルを CompactClassificationECOC モデル オブジェクトで返します。

代理分岐をもつ決定木の GentleBoost アンサンブルを使用して 1 対他の ECOC 分類器を学習させます。10 分割交差検証を使用して分類誤差を推定します。

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 に含まれています。

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

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

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

決定木のアンサンブルをバイナリ学習器として使用して、1 対他の ECOC 分類器を学習させます。Parallel Computing Toolbox のライセンスがある場合、プール内のワーカーに各バイナリ学習器を送信する並列計算を使用して、計算を高速化できます (ワーカーの個数はシステム構成によって異なります)。さらに、事前確率として 1/K を指定します。K = 13 は異なるクラスの個数です。

pool = parpool; % Invoke workers
Starting parallel pool (parpool) using the 'local' profile ...
connected to 6 workers.
options = statset('UseParallel',true);
Mdl = fitcecoc(X,Y,'Coding','onevsall','Learners',tEnsemble,...
                'Prior','uniform','Options',options);

MdlClassificationECOC モデルです。

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

CVMdl = crossval(Mdl,'Options',options);
Warning: One or more folds do not contain points from all the groups.

CVMdlClassificationPartitionedECOC モデルです。少なくとも 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];

この例では、fitcecoc を使用して自動的にハイパーパラメーターを最適化する方法を示します。この例では、フィッシャーのアヤメのデータを使用します。

データを読み込みます。

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 |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |
|====================================================================================================================|
|    1 | Best   |     0.10667 |      3.6028 |     0.10667 |     0.10667 |     onevsone |       5.6939 |       200.36 |
|    2 | Best   |        0.08 |      10.577 |        0.08 |    0.081379 |     onevsone |       94.849 |    0.0032549 |
|    3 | Accept |        0.08 |        1.09 |        0.08 |     0.08003 |     onevsall |      0.01378 |     0.076021 |
|    4 | Accept |        0.08 |      0.6157 |        0.08 |    0.080001 |     onevsall |          889 |       38.798 |
|    5 | Best   |    0.073333 |     0.99526 |    0.073333 |    0.073337 |     onevsall |       17.142 |       1.7174 |
|    6 | Accept |        0.38 |      28.866 |    0.073333 |    0.073338 |     onevsall |      0.88995 |    0.0010029 |
|    7 | Best   |    0.046667 |     0.47562 |    0.046667 |    0.046688 |     onevsall |        4.246 |       0.3356 |
|    8 | Best   |    0.033333 |     0.84864 |    0.033333 |    0.033341 |     onevsone |      0.22406 |      0.37399 |
|    9 | Best   |    0.026667 |     0.43498 |    0.026667 |    0.026678 |     onevsone |       14.237 |       3.5166 |
|   10 | Accept |     0.33333 |     0.49517 |    0.026667 |    0.026676 |     onevsall |    0.0064689 |       999.31 |
|   11 | Accept |        0.04 |     0.53707 |    0.026667 |      0.0268 |     onevsone |        982.5 |      0.51146 |
|   12 | Accept |    0.046667 |     0.55849 |    0.026667 |    0.026694 |     onevsone |     0.018266 |     0.047347 |
|   13 | Accept |     0.10667 |      1.0967 |    0.026667 |    0.029124 |     onevsone |    0.0010243 |       13.372 |
|   14 | Accept |        0.04 |      1.2937 |    0.026667 |    0.032336 |     onevsone |       156.11 |       1.7366 |
|   15 | Accept |    0.046667 |      1.4345 |    0.026667 |      0.0327 |     onevsone |       986.23 |       10.731 |
|   16 | Accept |    0.046667 |      2.9826 |    0.026667 |    0.032045 |     onevsone |       371.63 |     0.056453 |
|   17 | Accept |        0.04 |      1.0206 |    0.026667 |    0.033569 |     onevsone |    0.0010311 |    0.0010175 |
|   18 | Accept |    0.046667 |     0.95108 |    0.026667 |    0.034256 |     onevsone |    0.0011574 |      0.16436 |
|   19 | Accept |        0.06 |      25.552 |    0.026667 |    0.032699 |     onevsall |       968.86 |       0.2494 |
|   20 | Accept |        0.04 |     0.64111 |    0.026667 |    0.031457 |     onevsone |       985.47 |       2.8942 |
|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Coding | BoxConstraint|  KernelScale |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |
|====================================================================================================================|
|   21 | Accept |        0.04 |     0.70606 |    0.026667 |     0.03134 |     onevsone |     0.001037 |    0.0044045 |
|   22 | Best   |        0.02 |     0.62679 |        0.02 |    0.023771 |     onevsone |       1.9507 |       1.3991 |
|   23 | Best   |    0.013333 |      1.0619 |    0.013333 |    0.018605 |     onevsone |      0.84926 |       1.3538 |
|   24 | Accept |    0.026667 |      1.1226 |    0.013333 |    0.021089 |     onevsone |       0.2101 |       1.5222 |
|   25 | Accept |    0.026667 |     0.61465 |    0.013333 |    0.022321 |     onevsone |       1.7108 |       1.2127 |
|   26 | Accept |     0.10667 |     0.71357 |    0.013333 |    0.022359 |     onevsone |    0.0010149 |       986.98 |
|   27 | Accept |     0.33333 |     0.67893 |    0.013333 |    0.021789 |     onevsall |    0.0010002 |        21.18 |
|   28 | Accept |    0.013333 |     0.72433 |    0.013333 |    0.019873 |     onevsone |       1.5298 |       1.6373 |
|   29 | Accept |        0.02 |     0.92909 |    0.013333 |    0.019708 |     onevsone |       1.2119 |       1.9178 |
|   30 | Accept |     0.33333 |     0.51972 |    0.013333 |    0.019544 |     onevsall |       940.08 |       979.72 |

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

Best observed feasible point:
     Coding     BoxConstraint    KernelScale
    ________    _____________    ___________

    onevsone       0.84926         1.3538   

Observed objective function value = 0.013333
Estimated objective function value = 0.019544
Function evaluation time = 1.0619

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

    onevsone       1.5298          1.6373   

Estimated objective function value = 0.019544
Estimated function evaluation time = 0.74034
Mdl = 
  ClassificationECOC
                         ResponseName: 'Y'
                CategoricalPredictors: []
                           ClassNames: {'setosa'  'versicolor'  'virginica'}
                       ScoreTransform: 'none'
                       BinaryLearners: {3x1 cell}
                           CodingName: 'onevsone'
    HyperparameterOptimizationResults: [1x1 BayesianOptimization]


  Properties, Methods

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

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

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

ds = datastore('fisheriris.csv','TreatAsMissing','NA');
t = tall(ds);
Starting parallel pool (parpool) using the 'local' profile ...
connected to 6 workers.
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('default') % For reproducibility
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 = 
  classreg.learning.classif.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 オブジェクトを作成して、カーネル バイナリ学習器のプロパティを指定します。具体的には、拡張次元数を に増やします。

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 = 
  classreg.learning.classif.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.7 sec
Evaluation completed in 2 sec
errorLinear = 0.0333
errorKernel = gather(loss(mdlKernel,Z,Y))
Evaluating tall expression using the Parallel Pool 'local':
- Pass 1 of 1: Completed in 17 sec
Evaluation completed in 17 sec
errorKernel = 0.0067

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

入力引数

すべて折りたたむ

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

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

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

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

メモ

学習済みの線形分類モデルまたはカーネル分類モデルの場合、fitcecoc は table をサポートしません。つまり、Learners'linear' または 'kernel' で、線形分類モデル学習器テンプレート (templateLinear 参照) が含まれている、またはカーネル分類モデル学習器テンプレート (templateKernel 参照) が含まれている場合、TblResponseVarNameformula は指定できません。代わりに、予測子データの行列 (X) と応答の配列 (Y) を指定します。

データ型: テーブル

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

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

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

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

データ型: char | string

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

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

データ型: char | string

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

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

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

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

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

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

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

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

メモ

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

  • 他のすべての学習器では、観測値が行に対応するように X を配置します。

  • fitcecoc は、線形分類モデルの学習のみについてスパース行列をサポートします。

データ型: double | single

メモ

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

名前と値のペアの引数

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

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

メモ

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

ECOC 分類器オプション

すべて折りたたむ

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

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

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

  • カスタム コーディング行列は、すべての要素が -10 または 1 でなければなりません。また、値は二分法によるクラス割り当てに対応しなければなりません。この表は Coding(i,j) の意味を説明します。つまり、学習器 j がクラス i の観測値に割り当てるクラスです。

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

  • すべての列には少なくとも 1 つの -1 または 1 がなければなりません。

  • ij となるすべての列インデックス i および j に対して、Coding(:,i)Coding(:,j) に等しくなることができず、Coding(:,i)-Coding(:,j) に等しくなることができません。

  • カスタム コーディング行列のすべての行は異なっていなければなりません。

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

例: 'Coding','ternarycomplete'

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

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

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

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

  • アンサンブル法が AdaBoostM2LPBoostRUSBoostRobustBoost または TotalBoost である。

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

例: 'FitPosterior',true

データ型: logical

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

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

    説明
    'discriminant'判別分析。既定のオプションについては、templateDiscriminant を参照してください。
    'kernel'カーネル分類モデル。既定のオプションについては、templateKernel を参照してください。
    'knn'k 最近傍。既定のオプションについては、templateKNN を参照してください。
    'linear'線形分類モデル。既定のオプションについては、templateLinear を参照してください。
    'naivebayes'単純ベイズ。既定のオプションについては、templateNaiveBayes を参照してください。
    'svm'SVM。既定のオプションについては、templateSVM を参照してください。
    'tree'分類木。既定のオプションについては、templateTree を参照してください。

  • Learners がテンプレート オブジェクトの場合、各バイナリ学習器は格納されているオプションに従って学習します。テンプレート オブジェクトは以下を使用して作成できます。

  • Learners がテンプレート オブジェクトの cell ベクトルである場合、以下のようになります。

    • セル j は、バイナリ学習器 j (符号化設計行列の j 列目) に対応します。cell ベクトルの長さは L でなければなりません。L は、符号化設計行列の列数です。詳細は、Coding を参照してください。

    • 予測に組み込み損失関数のいずれかを使用するには、すべてのバイナリ学習器は同じ範囲のスコアを返さなくてはなりません。たとえば、既定の SVM バイナリ学習器と既定の単純ベイズ学習器を同時に含めることはできません。前者は (-∞,∞) の範囲にあるスコアを、後者はスコアとして事後確率を返します。それ以外の場合は、カスタム損失を関数ハンドルとして関数 predictloss などに指定しなくてはなりません。

    • 線形分類モデル学習器のテンプレートを他のテンプレートとともに指定することはできません。

    • 同様に、カーネル分類モデル学習器のテンプレートを他のテンプレートとともに指定することはできません。

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

例: 'Learners','tree'

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

メモ

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

データ型: single | double

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

メモ

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

  • 他のすべての学習器では、観測値が行に対応するように X を配置します。

例: 'ObservationsIn','columns'

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

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

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

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

例: 'Verbose',1

データ型: double | single

交差検証オプション

すべて折りたたむ

交差検証分類器を学習させるためのフラグ。'Crossval''on' または 'off' で構成されるコンマ区切りのペアとして指定します。

'on' を指定すると、10 の分割を使用して交差検証分類器の学習が実行されます。

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

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

例: 'Crossval','on'

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

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

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

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

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

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

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

例: 'Holdout',0.1

データ型: double | single

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

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

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

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

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

例: 'KFold',5

データ型: single | double

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

  1. 観測は検証データとして予約され、モデルは他の n – 1 個の観測を使用して学習させる

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

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

メモ

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

例: 'Leaveout','on'

その他の分類オプション

すべて折りたたむ

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

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

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

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

  • すべての予測子がカテゴリカルで少なくとも 1 つのバイナリ学習器が kNN である場合。

他の学習器の場合に CategoricalPredictors を指定すると、そのバイナリ学習器に学習をさせることはできないという警告が出力されます。たとえば、カテゴリカル予測子を使用して線形分類モデル学習器またはカーネル分類モデル学習器に学習をさせることはできません。

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

例: 'CategoricalPredictors','all'

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

学習に使用するクラスの名前。'ClassNames' と categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列から構成されるコンマ区切りのペアとして指定します。ClassNames のデータ型は Y と同じでなければなりません。

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

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

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

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

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

ClassNames の既定値は、Y に含まれているすべての異なるクラス名の集合です。

例: 'ClassNames',{'b','g'}

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

誤分類のコスト。'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 | 構造体

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

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

オプション説明
'Streams'

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

  • 開いている並列プールがある。

  • UseParalleltrue

  • UseSubstreamsfalse

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

'UseParallel'Parallel Computing Toolbox を保有している場合、'UseParallel',true を設定してワーカーのプールを呼び出すことができます。
'UseSubstreams'並列計算する場合は true に設定して 'Streams' で指定されたストリームを使用します。既定値は false です。たとえば、Streams'mlfg6331_64' または 'mrg32k3a' といったサブストリームを許可するタイプに設定します。

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

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

データ型: 構造体

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

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

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

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

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

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

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

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

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

データ型: string | cell

各クラスの事前確率。'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 | 構造体

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

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

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

例: 'ResponseName','response'

データ型: char | string

スコア変換。'ScoreTransform' と文字ベクトル、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 | 関数ハンドル

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

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

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

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

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

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

すべて折りたたむ

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

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

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

    • Learners = 'svm' (既定) — {'BoxConstraint','KernelScale'}

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

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

    • Learners = 'linear'{'Lambda','Learner'}

    • Learners = 'naivebayes'{'DistributionNames','Width'}

    • Learners = 'tree'{'MinLeafSize'}

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

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

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

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

メモ

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

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

  • Codingfitcecoc'onevsall''onevsone' で探索します。

  • 選択した 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'
    'linear'Lambda範囲 [1e-5/NumObservations,1e5/NumObservations] の対数スケールの正の値
    Learner'svm' および 'logistic'
    Regularization'ridge' および 'lasso'
    'naivebayes'DistributionNames'normal' および 'kernel'
    Width範囲 [MinPredictorDiff/4,max(MaxPredictorRange,MinPredictorDiff)] の対数スケールの正の値
    Kernel'normal''box''epanechnikov'、および 'triangle'
    'svm'BoxConstraint範囲 [1e-3,1e3] の対数スケールの正の値
    KernelScale範囲 [1e-3,1e3] の対数スケールの正の値
    KernelFunction'gaussian''linear' および 'polynomial'
    PolynomialOrder範囲 [2,4] の整数
    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 を次のように使用します。

    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 を渡します。

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

例については、ECOC 分類器の最適化を参照してください。

例: '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'

詳細については、bayesopt の名前と値のペアの引数 AcquisitionFunctionName または獲得関数のタイプを参照してください。

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

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

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

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

  • 0 — 反復表示なし

  • 1 — 反復表示あり

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

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

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

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

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

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

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

データ型: 構造体

出力引数

すべて折りたたむ

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

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

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

ハイパーパラメーターの交差検証最適化の説明。BayesianOptimization オブジェクト、またはハイパーパラメーターおよび関連する値が含まれているテーブルとして返されます。名前と値のペア OptimizeHyperparameters が空ではなく、Learners'linear' であった場合、これは空ではありません。値は、名前と値のペア HyperparameterOptimizationOptions の設定によって決まります。

  • 'bayesopt' (既定) — BayesianOptimization クラスのオブジェクト。

  • 'gridsearch' または 'randomsearch' — 使用したハイパーパラメーター、観測された目的関数の値(交差検証損失)、および最小 (最良) から最大 (最悪) までの観測値の順位が格納されているテーブル。

データ型: テーブル

制限

  • 学習済みの線形分類モデルまたはカーネル分類モデルの場合、fitcecoc は table をサポートしません。つまり、Learners'linear' または 'kernel' で、線形分類モデル学習器テンプレート (templateLinear 参照) が含まれている、またはカーネル分類モデル学習器テンプレート (templateKernel 参照) が含まれている場合、TblResponseVarNameformula は指定できません。代わりに、予測子データの行列 (X) と応答の配列 (Y) を指定します。

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

詳細

すべて折りたたむ

バイナリ損失

"バイナリ損失" は、バイナリ学習器がどの程度の精度で観測値をクラスに分類するかを判断する、クラスと分類スコアの関数です。

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

  • mkj は符号化設計行列 M の要素 (k,j)、つまりバイナリ学習器 j のクラス k に対応するコード。

  • sj は観測値に対するバイナリ学習器 j のスコア。

  • g はバイナリ損失関数。

  • k^ は観測値の予測クラス。

"損失に基づく復号化" [Escalera 他] では、バイナリ学習器全体のバイナリ損失の和が最小になるクラスにより、観測値の予測クラスが決まります。つまり、次のようになります。

k^=argminkj=1L|mkj|g(mkj,sj).

"損失に重みを付けた復号化" [Escalera 他] では、バイナリ学習器全体のバイナリ損失の平均が最小になるクラスにより、観測値の予測クラスが決まります。つまり、次のようになります。

k^=argminkj=1L|mkj|g(mkj,sj)j=1L|mkj|.

Allwein 他によると、すべてのクラスで損失値が同じ動的範囲に収まるので、損失に重みを付けた復号化では分類精度が向上します。

次の表は、サポートされる損失関数をまとめています。ここで、yj は (集合 {–1,1,0} の) 特定のバイナリ学習器のクラス ラベルです。sj は観測値 j および g(yj,sj) のスコアです。

説明スコア領域g(yj,sj)
'binodeviance'二項分布からの逸脱度(–∞,∞)log[1 + exp(–2yjsj)]/[2log(2)]
'exponential'指数(–∞,∞)exp(–yjsj)/2
'hamming'ハミング[0,1] または (–∞,∞)[1 – sign(yjsj)]/2
'hinge'ヒンジ(–∞,∞)max(0,1 – yjsj)/2
'linear'線形(–∞,∞)(1 – yjsj)/2
'logit'ロジスティック(–∞,∞)log[1 + exp(–yjsj)]/[2log(2)]
'quadratic'2 次[0,1][1 – yj(2sj – 1)]2/2

バイナリ損失は、yj = 0 のときに損失が 0.5 になるように正規化され、バイナリ学習器の平均を使用して集計されます。[Allwein 他]

ECOC 分類器の全体的な性能の尺度である全体の分類損失 (オブジェクト関数 loss および predict の名前と値のペアの引数 'LossFun' により指定) とバイナリ損失を混同しないでください。

符号化設計

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

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

  • 1 を 1 つ含む行は、対応するクラス内のすべての観測値を陽性クラスにグループ化するようにバイナリ学習器に指示します。

  • -1 が 1 つ含まれる行は、対応するクラス内のすべての観測値が陰性クラスでグループ化されるようバイナリ学習器に指示します。

  • 0 が 1 つ含まれる行は、対応するクラス内のすべての観測値を無視するようバイナリ学習器に指示します。

ハミング尺度に基づいたペア間の行の最小距離が大きいコーディング行列が推奨されます。ペア間の行の距離の詳細については、ランダム符号化設計行列および[4]を参照してください。

次の表は一般的な符号化設計について説明しています。例として、K (各クラスの数) を 3 と仮定します。

符号化設計説明学習器の数 ペア間の最小行距離
OVA (1 対他)各バイナリ学習器では、1 つのクラスは正で残りは負です。この計画は陽性クラス割り当てのすべての組み合わせを使用します。K2
OVO (1 対 1)各バイナリ学習器では、1 つのクラスが正であり、もう 1 つのクラスは負です。残りは無視されます。この計画はすべてのクラス ペアの割り当ての組み合わせを使用します。

K(K – 1)/2

1
完全二項

この計画はクラスをすべて 2 つの組み合わせに分割します。いずれのクラスも無視されません。つまり、各バイナリ学習器では、すべてのクラス割り当てが -1 および 1 になり、少なくとも 1 つの陽性クラスおよび陰性クラスが割り当てに含まれます。

2K – 1 – 12K – 2
完全三項

この計画はクラスをすべて 3 つの組み合わせに分割します。つまり、各バイナリ学習器では、すべてのクラス割り当てが 0-1 および 1 になり、少なくとも 1 つの陽性クラスおよび陰性クラスが割り当てに含まれます。

(3K – 2K + 1 + 1)/2

3K – 2
順序最初のバイナリ学習器では、最初のクラスは負であり、残りは正です。2 番目のバイナリ学習器では、最初の 2 つのクラスは負で、残りは正、以下同様になります。K – 11
密なランダム各バイナリ学習器には、正または陰性クラス (少なくとも各 1 つ) が無作為に割り当てられます。詳細は、ランダム符号化設計行列を参照してください。

ランダム。ただし、約 10 log2K

変数
スパース ランダム各バイナリ学習器では、各クラスに確率 0.25 で正または負が無作為に割り当てられ、確率が 0.5 の場合にクラスが無視されます。詳細は、ランダム符号化設計行列を参照してください。

ランダム。ただし、約 15 log2K

変数

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

誤り訂正出力符号モデル

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

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

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

  • 3 つのクラスがある。

  • 符号化設計が 1 対 1 である。

  • 復号化方式で損失 g を使用する。

  • 学習器が SVM である。

ECOC では、次のステップに従ってこの分類モデルを構築します。

  1. 1 対 1 の符号化設計が次のようになっているとします。

    Learner 1Learner 2Learner 3Class 1110Class 2101Class 3011

    学習器 1 は、クラス 1 またはクラス 2 に分類される観測値について学習を行い、クラス 1 を陽性クラス、クラス 2 を陰性クラスとして扱います。他の学習器の学習も同様に実行します。次のように仮定します。M は要素 mkl をもつ符号化設計行列です。sl は学習器 l の陽性クラスの予測された分類スコアです。

  2. L 個のバイナリ学習器について損失の合計が最小になるクラス (k^) に新しい観測値を割り当てます。つまり、次のようになります。

    k^=argminkl=1L|mkl|g(mkl,sl)l=1L|mkl|.

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

ヒント

  • バイナリ学習器の数はクラス数とともに増加します。多数のクラスがある問題では、符号化設計 binarycomplete および ternarycomplete は効率的ではありません。ただし、

    • K ≤ 4 の場合、sparserandom ではなく ternarycomplete 符号化設計を使用します。

    • K ≤ 5 の場合、denserandom ではなく binarycomplete 符号化設計を使用します。

    コマンド ウィンドウに Mdl.CodingMatrix を入力して学習させた ECOC 分類器の符号化設計行列を表示できます。

  • アプリケーションへの詳細な知識を用い、計算上の制約を考慮してコーディング行列を作成しなければなりません。十分な計算能力と時間がある場合、いくつかのコーディング行列を試し、最大のパフォーマンスが得られるものを選択してください (たとえば、confusionmat を使用して各モデルの混同行列を確認します)。

  • 観測値が多いデータセットの場合、Leave-one-out 交差検証 (Leaveout) では不十分です。代わりに、k 分割交差検証 (KFold) を使用してください。

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

アルゴリズム

すべて折りたたむ

カスタム符号化設計行列

カスタム コーディング行列は特定の形式でなければなりません。カスタム コーディング行列は以下を確認して検証されます。

  • すべての要素は -1、0 または 1 です。

  • すべての列は少なくとも -1 を 1 つおよび 1 を 1 つ含みます。

  • すべての異なる列ベクトル u および v では、u ≠ v および u ≠ -v。

  • すべての行ベクトルは一意です。

  • 行列は任意の 2 つのクラスを分離できます。つまり、任意の行から他の任意の行へ、次のルールに従って移動できます。

    • 1 から -1 または -1 から 1 へ垂直方向に移動できます。

    • 非ゼロ要素から別の非ゼロ要素へ水平方向に移動できます。

    • 垂直方向の移動に行列の列を一度だけ使用できます。

    上記のルールを使用して、行 i から行 j に移動できない場合、クラス i および j は計画により分離できません。たとえば、次の符号化設計ではクラス 1 および 2 をクラス 3 および 4 から分離できません。

    [10100101]

    2 行目の 2 列目には 0 があるので、2 行目の -1 を 2 列目に水平に移動することはできません。したがって、この符号化設計は拒否されます。

並列計算

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

事前確率とコスト

  • 事前確率 — 各バイナリ学習器に指定されたクラス事前確率 (Prior) は正規化されます。 M は符号化設計行列であり、I(A,c) は指標行列であると仮定します。指標行列の次元数は A と同じです。指標行列の要素は、対応する A の要素が c の場合は 1、それ以外の場合は 0 になります。M+1 および M-1 は、次の条件を満たす K 行 L 列の行列と仮定します。

    • M+1 = M○I(M,1)、ここで ○ は要素単位の乗算です (つまり、Mplus = M.*(M == 1))。また、M+1 の列ベクトル l を ml(+1) と表します。

    • M-1 = -M○I(M,-1) (つまり、Mminus = -M.*(M == -1))。また、M-1 の列ベクトル l を ml(1) と表します。

    πl+1=ml(+1)°π および πl1=ml(1)°π と表します。ここで、π はクラスについて指定した事前確率のベクトル (Prior) です。

    すると、バイナリ学習器 l について正および負のスカラーのクラス事前確率は次のようになります。

    π^l(j)=πl(j)1πl(+1)1+πl(1)1,

    ここで、j = {-1,1} です。a1 は a の 1 ノルムです。

  • コスト — 各バイナリ学習器の K 行 K 列のコスト行列 C (Cost) は正規化されます。バイナリ学習器 l で陰性クラスの観測値を陽性クラスに分類するコストは次のようになります。

    cl+=(πl(1))Cπl(+1).

    同様に、陽性クラスの観測値を陰性クラスに分類するコストは次のようになります。

    cl+=(πl(+1))Cπl(1).

    バイナリ学習器 l のコスト行列は次のようになります。

    Cl=[0cl+cl+0].

    ECOC モデルは誤分類のコストをクラス事前確率に組み込むことで対応します。PriorCost を指定した場合、クラスの事前確率は次のように調整されます。

    π¯l1=cl+π^l1cl+π^l1+c+π^l+1π¯l+1=cl+π^l+1cl+π^l1+c+π^l+1.

ランダム符号化設計行列

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

  1. 次のいずれかが生成されます。

    1. 密なランダム — K 行 Ld 列の符号化設計行列の各要素に同じ確率で 1 または -1 が割り当てられます。ここで Ld10log2K です。

    2. スパース ランダム ― K 行 Ls 列の符号化設計行列の各要素に 0.25 の確率で 1、0.25 の確率で -1、0.5 の確率で 0 が割り当てられます。ここで Ls15log2K です。

  2. 少なくとも 1 つの 1 および少なくとも 1 つの -1 が列にない場合、その列は削除されます。

  3. 異なる列 u および v について u = v または u = -v である場合、v が符号化設計行列から削除されます。

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

Δ(k1,k2)=0.5l=1L|mk1l||mk2l||mk1lmk2l|,

ここで、mkjl は符号化設計行列 j の要素です。

サポート ベクターの保存

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

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

t = templateSVM('SaveSupportVectors','on')
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 classifiers.” 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. “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.

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

拡張機能

R2014b で導入