fitcnb

単純ベイズ分類器の学習

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

load fisheriris
X = meas(:,3:4);
Y = species;
tabulate(Y)

       Value    Count   Percent
      setosa       50     33.33%
  versicolor       50     33.33%
   virginica       50     33.33%

単純ベイズメソッドを使用して、3 つ以上のクラスがあるデータを分類することができます。

単純ベイズ分類器を学習させます。クラスの順序を指定することをお勧めします。

Mdl = fitcnb(X,Y,'ClassNames',{'setosa','versicolor','virginica'})

Mdl = 
  ClassificationNaiveBayes
              ResponseName: 'Y'
     CategoricalPredictors: []
                ClassNames: {'setosa'  'versicolor'  'virginica'}
            ScoreTransform: 'none'
           NumObservations: 150
         DistributionNames: {'normal'  'normal'}
    DistributionParameters: {3×2 cell}


  Properties, Methods

Mdl は学習させた ClassificationNaiveBayes 分類器です。

既定の設定では、いくつかの平均と標準偏差をもつガウス分布を使用して、各クラス内で予測子分布がモデル化されます。ドット表記を使用して特定のガウス近似のパラメーターを表示します。たとえば、setosa 内にある最初の特徴の近似を表示します。

setosaIndex = strcmp(Mdl.ClassNames,'setosa');
estimates = Mdl.DistributionParameters{setosaIndex,1}

estimates = 2×1

    1.4620
    0.1737

平均値は 1.4620 で、標準偏差は 0.1737 です。

ガウス等高線をプロットします。

figure
gscatter(X(:,1),X(:,2),Y);
h = gca;
cxlim = h.XLim;
cylim = h.YLim;
hold on
Params = cell2mat(Mdl.DistributionParameters); 
Mu = Params(2*(1:3)-1,1:2); % Extract the means
Sigma = zeros(2,2,3);
for j = 1:3
    Sigma(:,:,j) = diag(Params(2*j,:)).^2; % Create diagonal covariance matrix
    xlim = Mu(j,1) + 4*[-1 1]*sqrt(Sigma(1,1,j));
    ylim = Mu(j,2) + 4*[-1 1]*sqrt(Sigma(2,2,j));
    f = @(x,y) arrayfun(@(x0,y0) mvnpdf([x0 y0],Mu(j,:),Sigma(:,:,j)),x,y);
    fcontour(f,[xlim ylim]) % Draw contours for the multivariate normal distributions 
end
h.XLim = cxlim;
h.YLim = cylim;
title('Naive Bayes Classifier -- Fisher''s Iris Data')
xlabel('Petal Length (cm)')
ylabel('Petal Width (cm)')
legend('setosa','versicolor','virginica')
hold off

Figure contains an axes object. The axes object with title Naive Bayes Classifier -- Fisher's Iris Data, xlabel Petal Length (cm), ylabel Petal Width (cm) contains 6 objects of type line, functioncontour. One or more of the lines displays its values using only markers These objects represent setosa, versicolor, virginica.

名前と値のペアの引数 'DistributionNames' を使用すると、既定の分布を変更できます。たとえば、一部の予測子がカテゴリカルである場合、'DistributionNames','mvmn' を使用して、これらの予測子が多変量多項確率変数となるよう指定することができます。

単純ベイズ分類器に学習をさせるときの事前確率の指定

フィッシャーのアヤメのデータセット用に単純ベイズ分類器を構築します。また、学習中の事前確率を指定します。

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

load fisheriris
X = meas;
Y = species;
classNames = {'setosa','versicolor','virginica'}; % Class order

X は、150 本のアヤメについて 4 つの測定値が含まれている数値行列です。Y は、対応するアヤメの種類が含まれている文字ベクトルの cell 配列です。

既定では、前のクラス確率分布はデータセット内のクラスの相対頻度の分布です。この場合、事前確率は各種類に対して 33% です。ただし、母集団の 50% は setosa、20% は versicolor、30% は virginica であることはわかっているとします。学習中にこの分布を事前確率として指定すると、この情報を組み込むことができます。

単純ベイズ分類器を学習させます。クラスの順序と前のクラスの確率分布を指定します。

prior = [0.5 0.2 0.3];
Mdl = fitcnb(X,Y,'ClassNames',classNames,'Prior',prior)

Mdl = 
  ClassificationNaiveBayes
              ResponseName: 'Y'
     CategoricalPredictors: []
                ClassNames: {'setosa'  'versicolor'  'virginica'}
            ScoreTransform: 'none'
           NumObservations: 150
         DistributionNames: {'normal'  'normal'  'normal'  'normal'}
    DistributionParameters: {3×4 cell}


  Properties, Methods

Mdl は学習させた ClassificationNaiveBayes 分類器であり、一部のプロパティはコマンドウィンドウに表示されます。クラスが与えられている場合、予測子は独立しているとして扱われ、また既定では、正規分布を使用して当てはめが行われます。

単純ベイズアルゴリズムは前のクラスの確率を学習中に使用しません。したがって、前のクラス確率を学習後にドット表記を使用して指定できます。たとえば、既定のクラスの事前確率を使用するモデルと異なる prior を使用するモデルの間でパフォーマンスの違いを比較するとします。

Mdl に基づいて新しい単純ベイズモデルを作成し、前のクラスの確率分布に経験的クラス分布を指定します。

defaultPriorMdl = Mdl;
FreqDist = cell2table(tabulate(Y));
defaultPriorMdl.Prior = FreqDist{:,3};

前のクラスの確率は合計が 1 になるように正規化されます。

10 分割交差検証を使用して、両方のモデルの交差検証誤差を推定します。

rng(1); % For reproducibility
defaultCVMdl = crossval(defaultPriorMdl);
defaultLoss = kfoldLoss(defaultCVMdl)

defaultLoss = 
0.0533

CVMdl = crossval(Mdl);
Loss = kfoldLoss(CVMdl)

Loss = 
0.0340

Mdl の方が defaultPriorMdl よりパフォーマンスが優れています。

単純ベイズ分類器の予測子分布の指定

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

load fisheriris
X = meas;
Y = species;

すべての予測子を使用して単純ベイズ分類器を学習させます。クラスの順序を指定することをお勧めします。

Mdl1 = fitcnb(X,Y,...
    'ClassNames',{'setosa','versicolor','virginica'})

Mdl1 = 
  ClassificationNaiveBayes
              ResponseName: 'Y'
     CategoricalPredictors: []
                ClassNames: {'setosa'  'versicolor'  'virginica'}
            ScoreTransform: 'none'
           NumObservations: 150
         DistributionNames: {'normal'  'normal'  'normal'  'normal'}
    DistributionParameters: {3×4 cell}


  Properties, Methods

Mdl1.DistributionParameters

ans=3×4 cell array
    {2×1 double}    {2×1 double}    {2×1 double}    {2×1 double}
    {2×1 double}    {2×1 double}    {2×1 double}    {2×1 double}
    {2×1 double}    {2×1 double}    {2×1 double}    {2×1 double}

Mdl1.DistributionParameters{1,2}

ans = 2×1

    3.4280
    0.3791

既定の設定では、各クラス内の予測子分布が、いくつかの平均と標準偏差をもつガウス分布としてモデル化されます。予測子は 4 つあり、クラスレベルは 3 つあります。Mdl1.DistributionParameters の各セルは、各分布の平均と標準偏差が格納された数値ベクトルに対応します。たとえば、setosa のがく片の幅の平均と標準偏差はそれぞれ 3.4280 と 0.3791 です。

Mdl1 の混同行列を推定します。

isLabels1 = resubPredict(Mdl1);
ConfusionMat1 = confusionchart(Y,isLabels1);

Figure contains an object of type ConfusionMatrixChart.

混同行列チャートの要素 (j, k) は、k として分類されているが、データに従うと実際にはクラス j に属している観測値の個数を表します。

予測子 1 および 2 (がく片の長さと幅) のガウス分布および予測子 3 と 4 (花弁の長さと幅) の既定の正規カーネル密度を使用して、分類器を再度学習させます。

Mdl2 = fitcnb(X,Y,...
    'DistributionNames',{'normal','normal','kernel','kernel'},...
    'ClassNames',{'setosa','versicolor','virginica'});
Mdl2.DistributionParameters{1,2}

ans = 2×1

    3.4280
    0.3791

カーネル密度のパラメーターの学習は実行されません。その代わりに、最適な幅が自動的に選択されます。ただし、'Width' 名前と値のペアの引数を使用して幅を指定することができます。

Mdl2 の混同行列を推定します。

isLabels2 = resubPredict(Mdl2);
ConfusionMat2 = confusionchart(Y,isLabels2);

Figure contains an object of type ConfusionMatrixChart.

混同行列に基づいて、2 つの分類器は学習標本内で同様に動作します。

交差検証の使用による分類器の比較

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

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

既定のオプションと k 分割交差検証を使用して、単純ベイズ分類器の学習と交差検証を行います。クラスの順序を指定することをお勧めします。

CVMdl1 = fitcnb(X,Y,...
    'ClassNames',{'setosa','versicolor','virginica'},...
    'CrossVal','on');

既定の設定では、何らかの平均と標準偏差をもつガウス分布として各クラス内の予測子分布がモデル化されます。CVMdl1 は ClassificationPartitionedModel モデルです。

既定の単純ベイズバイナリ分類器テンプレートを作成し、誤り訂正出力符号のマルチクラスモデルを学習させます。

t = templateNaiveBayes();
CVMdl2 = fitcecoc(X,Y,'CrossVal','on','Learners',t);

CVMdl2 は ClassificationPartitionedECOC モデルです。単純ベイズバイナリ学習器のオプションを fitcnb と同じ名前と値のペアの引数を使用して指定できます。

標本外の k 分割分類誤差 (誤分類された観測値の比率) を比較します。

classErr1 = kfoldLoss(CVMdl1,'LossFun','ClassifErr')

classErr1 = 
0.0533

classErr2 = kfoldLoss(CVMdl2,'LossFun','ClassifErr')

classErr2 = 
0.0467

Mdl2 の方が汎化誤差が小さくなります。

多項予測子を使用した単純ベイズ分類器の学習

スパムフィルターによっては、電子メール内の単語や句読点 (トークン) の使用頻度を基準にして、受信した電子メールをスパムとして分類します。予測子は電子メールに含まれる特定の単語または句読点が使用される頻度です。したがって、予測子は多項確率変数を作成します。

この例では、単純ベイズ予測子と多項予測子を使用した分類を説明します。

学習データの作成

1,000 件の電子メールを観測し、スパムまたはスパム以外に分類したとします。この処理を行うには、各電子メールに対応する y に -1 または 1 を無作為に割り当てます。

n = 1000;                       % Sample size
rng(1);                         % For reproducibility
Y = randsample([-1 1],n,true);  % Random labels

予測子データを構築するため、語彙集に 5 つのトークンが存在し、電子メールごとに 20 のトークンが観測されたと仮定します。多項偏差を無作為に抽出して 5 つのトークンから予測子データを生成します。スパム電子メールに対応するトークンの相対的頻度は、スパム以外の電子メールとは異なっていなければなりません。

tokenProbs = [0.2 0.3 0.1 0.15 0.25;...
    0.4 0.1 0.3 0.05 0.15];             % Token relative frequencies  
tokensPerEmail = 20;                    % Fixed for convenience
X = zeros(n,5);
X(Y == 1,:) = mnrnd(tokensPerEmail,tokenProbs(1,:),sum(Y == 1));
X(Y == -1,:) = mnrnd(tokensPerEmail,tokenProbs(2,:),sum(Y == -1));

分類器の学習

単純ベイズ分類器を学習させます。予測子が多項予測子となるよう指定します。

Mdl = fitcnb(X,Y,'DistributionNames','mn');

Mdl は学習させた ClassificationNaiveBayes 分類器です。

誤分類誤差を推定して、Mdl の標本内パフォーマンスを評価します。

isGenRate = resubLoss(Mdl,'LossFun','ClassifErr')

isGenRate = 
0.0320

標本内の誤分類率は 2% です。

新しいデータの作成

電子メールの新しいバッチを表す偏差を無作為に生成します。

newN = 500;
newY = randsample([-1 1],newN,true);
newX = zeros(newN,5);
newX(newY == 1,:) = mnrnd(tokensPerEmail,tokenProbs(1,:),...
    sum(newY == 1));
newX(newY == -1,:) = mnrnd(tokensPerEmail,tokenProbs(2,:),...
    sum(newY == -1));

分類器のパフォーマンス評価

学習させた単純ベイズ分類器 Mdl を使用して新しい電子メールを分類し、アルゴリズムが一般化するかどうかを判別します。

oosGenRate = loss(Mdl,newX,newY)

oosGenRate = 
0.0160

標本外の誤分類率が 2.6% であるため、分類器が良好に一般化されていることを示しています。

単純ベイズ分類器の最適化

この例では、fitcnb で名前と値のペア OptimizeHyperparameters を使用して単純ベイズ分類器の交差検証損失を最小化する方法を示します。この例では、フィッシャーのアヤメのデータを使用します。

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

load fisheriris
X = meas;
Y = species;
classNames = {'setosa','versicolor','virginica'};

'auto' パラメーターを使用して分類を最適化します。

再現性を得るために、乱数シードを設定し、'expected-improvement-plus' の獲得関数を使用します。

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

|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | Distribution-|        Width |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    | Names        |              |              |
|====================================================================================================================|
|    1 | Best   |    0.093333 |     0.63009 |    0.093333 |    0.093333 |       kernel |       5.6939 |        false |
|    2 | Accept |     0.13333 |     0.17381 |    0.093333 |     0.11333 |       kernel |       94.849 |         true |
|    3 | Best   |    0.053333 |     0.11507 |    0.053333 |     0.05765 |       normal |            - |            - |
|    4 | Accept |    0.053333 |    0.063932 |    0.053333 |    0.053336 |       normal |            - |            - |
|    5 | Accept |     0.26667 |     0.14426 |    0.053333 |    0.053338 |       kernel |     0.001001 |         true |
|    6 | Accept |    0.093333 |     0.13298 |    0.053333 |    0.053337 |       kernel |       10.043 |        false |
|    7 | Accept |     0.26667 |     0.13179 |    0.053333 |     0.05334 |       kernel |    0.0010132 |        false |
|    8 | Accept |    0.093333 |     0.13444 |    0.053333 |    0.053338 |       kernel |       985.05 |        false |
|    9 | Accept |     0.13333 |     0.12713 |    0.053333 |    0.053338 |       kernel |       993.63 |         true |
|   10 | Accept |    0.053333 |    0.053321 |    0.053333 |    0.053336 |       normal |            - |            - |
|   11 | Accept |    0.053333 |    0.044385 |    0.053333 |    0.053336 |       normal |            - |            - |
|   12 | Best   |    0.046667 |     0.14863 |    0.046667 |    0.046679 |       kernel |      0.30205 |         true |
|   13 | Accept |     0.11333 |     0.12714 |    0.046667 |    0.046685 |       kernel |       1.3021 |         true |
|   14 | Accept |    0.053333 |     0.13106 |    0.046667 |    0.046695 |       kernel |      0.10521 |         true |
|   15 | Accept |    0.046667 |     0.14308 |    0.046667 |    0.046677 |       kernel |      0.25016 |        false |
|   16 | Accept |        0.06 |     0.12311 |    0.046667 |    0.046686 |       kernel |      0.58328 |        false |
|   17 | Accept |    0.046667 |     0.14466 |    0.046667 |    0.046656 |       kernel |      0.07969 |        false |
|   18 | Accept |    0.093333 |     0.12182 |    0.046667 |    0.046654 |       kernel |       131.33 |        false |
|   19 | Accept |    0.046667 |     0.12394 |    0.046667 |     0.04648 |       kernel |      0.13384 |        false |
|   20 | Best   |        0.04 |     0.12122 |        0.04 |    0.040132 |       kernel |      0.19525 |         true |
|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | Distribution-|        Width |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    | Names        |              |              |
|====================================================================================================================|
|   21 | Accept |        0.04 |     0.12331 |        0.04 |    0.040066 |       kernel |      0.19458 |         true |
|   22 | Accept |        0.04 |     0.15832 |        0.04 |    0.040043 |       kernel |      0.19601 |         true |
|   23 | Accept |        0.04 |     0.13994 |        0.04 |    0.040031 |       kernel |      0.19412 |         true |
|   24 | Accept |     0.10667 |     0.12335 |        0.04 |    0.040018 |       kernel |    0.0084391 |         true |
|   25 | Accept |    0.073333 |     0.12343 |        0.04 |    0.040022 |       kernel |      0.02769 |        false |
|   26 | Accept |        0.04 |     0.12232 |        0.04 |     0.04002 |       kernel |       0.2037 |         true |
|   27 | Accept |     0.13333 |     0.12301 |        0.04 |    0.040021 |       kernel |       12.501 |         true |
|   28 | Accept |     0.11333 |     0.13749 |        0.04 |    0.040006 |       kernel |    0.0048728 |        false |
|   29 | Accept |         0.1 |     0.12412 |        0.04 |    0.039993 |       kernel |     0.028653 |         true |
|   30 | Accept |    0.046667 |     0.14424 |        0.04 |    0.041008 |       kernel |      0.18725 |         true |

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

Best observed feasible point:
    DistributionNames     Width     Standardize
    _________________    _______    ___________

         kernel          0.19525       true    

Observed objective function value = 0.04
Estimated objective function value = 0.041117
Function evaluation time = 0.12122

Best estimated feasible point (according to models):
    DistributionNames    Width     Standardize
    _________________    ______    ___________

         kernel          0.2037       true    

Estimated objective function value = 0.041008
Estimated function evaluation time = 0.1332

Figure contains an axes object. The axes object with title Min objective vs. Number of function evaluations, xlabel Function evaluations, ylabel Min objective contains 2 objects of type line. These objects represent Min observed objective, Estimated min objective.

Mdl = 
  ClassificationNaiveBayes
                         ResponseName: 'Y'
                CategoricalPredictors: []
                           ClassNames: {'setosa'  'versicolor'  'virginica'}
                       ScoreTransform: 'none'
                      NumObservations: 150
    HyperparameterOptimizationResults: [1×1 BayesianOptimization]
                    DistributionNames: {'kernel'  'kernel'  'kernel'  'kernel'}
               DistributionParameters: {3×4 cell}
                               Kernel: {'normal'  'normal'  'normal'  'normal'}
                              Support: {'unbounded'  'unbounded'  'unbounded'  'unbounded'}
                                Width: [3×4 double]
                                   Mu: [5.8433 3.0573 3.7580 1.1993]
                                Sigma: [0.8281 0.4359 1.7653 0.7622]


  Properties, Methods

入力引数

`Tbl` — 標本データ
table

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

Tbl に応答変数が含まれている場合に Tbl 内の他の変数をすべて予測子として使用するには、ResponseVarName を使用して応答変数を指定します。
Tbl に応答変数が含まれている場合に Tbl 内の他の変数の一部のみを予測子として使用するには、formula を使用して式を指定します。
Tbl に応答変数が含まれていない場合は、Y を使用して応答変数を指定します。応答変数の長さと Tbl の行数は等しくなければなりません。

`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 配列

単純ベイズ分類器に学習させるクラスラベル。categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列を指定します。Y の各要素は、X の対応する行のクラスメンバーシップを定義します。Y は K クラスレベルをサポートします。

Y が文字配列の場合、各行は 1 個のクラスラベルに対応しなければなりません。

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

`X` — 予測子データ
数値行列

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

X の各行は 1 件の観測 (インスタンスや例とも呼ばれます) に対応し、各列は 1 個の変数 (特徴とも呼ばれます) に対応します。

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

データ型: double

メモ:

NaN、空の文字ベクトル ('')、空の string ("")、<missing> および <undefined> 要素は欠損データ値として扱われます。

Y に欠損値がある場合、その部分と X の対応する行が削除されます。
X に全体が欠損値で構成される行がある場合、その行と対応する Y の要素は削除されます。
X に欠損値があり、さらに 'DistributionNames','mn' が設定されている場合、X の対象行と Y の対応する要素は削除されます。
予測子がクラス内に表れない場合、つまり、すべての値がクラス内で NaN の場合、エラーが返されます。

X の行および Y の対応する要素を削除すると、有効な学習または交差検証の標本サイズが小さくなります。

名前と値の引数

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

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

例: 'DistributionNames','mn','Prior','uniform','KSWidth',0.5 では、データ分布が多項式であり、すべてのクラスの事前確率が等しく、すべてのクラスのカーネル平滑化ウィンドウ帯域幅が 0.5 単位であると指定しています。

メモ

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

単純ベイズオプション

`DistributionNames` — データ分布
`'kernel'` | `'mn'` | `'mvmn'` | `'normal'` | string 配列 | 文字ベクトルの cell 配列

データをモデル化するために fitcnb が使用するデータ分布。'DistributionNames' と次の表の値をもつ文字ベクトル、string スカラー、string 配列、または文字ベクトルの cell 配列から構成されるコンマ区切りのペアとして指定します。

値	説明
`'kernel'`	カーネル平滑化密度推定。
`'mn'`	多項分布。`mn` を指定するとすべての特徴量は多項分布の成分となります。したがって、`'mn'` を文字ベクトルの cell 配列または string 配列の要素として含めることはできません。詳細は、アルゴリズムを参照してください。
`'mvmn'`	多変量多項分布。詳細は、アルゴリズムを参照してください。
`'normal'`	正規 (ガウス) 分布。

文字ベクトルまたは string スカラーを指定した場合、その分布を使用してすべての特徴量がモデル化されます。1 行 P 列の文字ベクトルの cell 配列または string 配列を指定した場合、配列の要素 j の分布を使用して特徴量 j がモデル化されます。

既定では、カテゴリカル予測子として指定されたすべての予測子は (CategoricalPredictors 名前と値のペア引数を使用して) 'mvmn' に設定されます。それ以外の場合、既定の分布は 'normal' となります。

Kernel、Standardize、Support または Width を追加で指定するには、少なくとも 1 つの予測子が分布 'kernel' をもつように指定しなければなりません。

例: 'DistributionNames','mn'

例: 'DistributionNames',{'kernel','normal','kernel'}

`Kernel` — カーネル平滑化のタイプ
`'normal'` (既定値) | `'box'` | `'epanechnikov'` | `'triangle'` | string 配列 | 文字ベクトルの cell 配列

カーネル平滑化のタイプ。'Kernel' と文字ベクトル、string スカラー、string 配列、または文字ベクトルの cell 配列から構成されるコンマ区切りのペアとして指定します。

次の表は、カーネル平滑化密度領域の設定に使用できるオプションの一覧です。I{u} はインジケーター関数を表すとします。

値	カーネル	式
`'box'`	ボックス (一様)	$f (x) = 0.5 I {\| x \| \leq 1}$
`'epanechnikov'`	Epanechnikov	$f (x) = 0.75 (1 - x^{2}) I {\| x \| \leq 1}$
`'normal'`	ガウス	$f (x) = \frac{1}{\sqrt{2 π}} \exp (- 0.5 x^{2})$
`'triangle'`	三角形	$f (x) = (1 - \| x \|) I {\| x \| \leq 1}$

配列の各要素に table のいずれかの値が格納されている状態で 1 行 P 列の string 配列または cell 配列を指定する場合、X の特徴 j に対して、要素 j のカーネル平滑化タイプを使用して分類器の学習が実行されます。分布が 'kernel' である予測子に対応しない Kernel の要素は無視されます。

Kernel、Standardize、Support または Width を追加で指定するには、少なくとも 1 つの予測子が分布 'kernel' をもつように指定しなければなりません。

例: 'Kernel',{'epanechnikov','normal'}

`Standardize` — カーネル分布をもつ予測子を標準化するためのフラグ
`false` または `0` (既定値) | `true` または `1`

R2023b 以降

カーネル分布をもつ予測子を標準化するためのフラグ。数値または logical の 0 (false) または 1 (true) として指定します。この引数は、DistributionNames 値に 1 つ以上のカーネル分布 ("kernel") が含まれる場合のみ有効です。

Standardize を true に設定すると、カーネル分布をもつ各予測子変数が対応する列の平均値と標準偏差によってセンタリングおよびスケーリングされます。カテゴリカル予測子などのカーネル分布以外をもつ予測子は標準化されません。

例: "Standardize",true

データ型: single | double | logical

`Support` — カーネル平滑化密度のサポート
`'unbounded'` (既定値) | `'positive'` | string 配列 | cell 配列 | 数値行ベクトル

カーネル平滑化密度のサポート。'Support' と 'positive'、'unbounded'、string 配列、cell 配列または数値行ベクトルから構成されるコンマ区切りのペアとして指定します。カーネル平滑化密度が指定した領域に適用されます。

次の表は、カーネル平滑化密度領域の設定に使用できるオプションの一覧です。

値	説明
1 行 2 列の数値行ベクトル	たとえば、`[L,U]` のように指定します。`L` と `U` はそれぞれ、密度サポートの下限と上限を表します。
`'positive'`	密度サポートはすべて正の実数です。
`'unbounded'`	密度サポートはすべて実数です。

string 配列の各要素に table 内のテキスト値が、cell 配列の各要素に table 内の値が含まれている状態で 1 行 P 列の string 配列または cell 配列を指定した場合、X 内の特徴量 j に対して要素 j のカーネルサポートを使用して、分類器の学習が実行されます。分布が 'kernel' である予測子に対応しない Kernel の要素は無視されます。

Kernel、Standardize、Support または Width を追加で指定するには、少なくとも 1 つの予測子が分布 'kernel' をもつように指定しなければなりません。

例: 'Support',{[-10,20],'unbounded'}

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

`Width` — カーネル平滑化ウィンドウの幅
数値の行列 | 数値列ベクトル | 数値行ベクトル | スカラー

カーネル平滑化ウィンドウ幅。'Width' と数値の行列、数値列ベクトル、数値行ベクトルまたはスカラーで構成される、コンマ区切りのペアとして指定します。

K 個のクラスレベルと P 個の予測子があるとします。次の表は、カーネル平滑化ウィンドウ幅の設定に使用できるオプションをまとめています。

値	説明
数値の K 行 P 列の行列	要素 (k,j) はクラス k の予測子 j の幅を指定します。
K 行 1 列の数値列ベクトル	要素 k はクラス k のすべての予測子の幅を指定します。
1 行 P 列の数値行ベクトル	要素 j は予測子 j のすべてのクラスレベルの幅を指定します。
スカラー	すべてのクラスのすべての特徴量に帯域幅を指定します。

既定の設定では、ガウス分布に最適な値を使用して、予測子およびクラスの各組み合わせに対して既定の幅が自動的に選択されます。指定した Width に NaN が含まれる場合、NaN を含む要素に幅が選択されます。

Kernel、Standardize、Support または Width を追加で指定するには、少なくとも 1 つの予測子が分布 'kernel' をもつように指定しなければなりません。

例: 'Width',[NaN NaN]

データ型: double | struct

交差検証オプション

`CrossVal` — 交差検証フラグ
`'off'` (既定値) | `'on'`

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

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

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

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

例: 'CrossVal','on'

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

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

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

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

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

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

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

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

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

例: Leaveout="on"

データ型: char | string

その他の分類オプション

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

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

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

既定では、予測子データが table (Tbl) 内にある場合、fitcnb は、その変数が logical ベクトル、categorical ベクトル、文字配列、string 配列または文字ベクトルの cell 配列のいずれかである場合に、変数を categorical であると見なします。予測子データが行列 (X) である場合、fitcnb はすべての予測子が連続的であると見なします。他の予測子をカテゴリカル予測子として指定するには、名前と値の引数 CategoricalPredictors を使用してそれらを指定します。

特定されたカテゴリカル予測子に対して、fitcnb は多変量多項分布を使用します。詳細については、DistributionNames とアルゴリズムを参照してください。

例: '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(i,j) は真のクラスが i である場合に 1 つの点をクラス j に分類するためのコストです (行は真のクラス、列は予測したクラスに対応します)。Cost の対応する行および列についてクラスの順序を指定するには、名前と値のペアの引数 ClassNames をさらに指定します。
2 つのフィールドをもつ S を構成します。2 つのフィールドは、Y と同じ型のグループ名を表す変数が格納されている S.ClassNames と、コスト行列が格納されている S.ClassificationCosts です。

既定値は、i~=j の場合は Cost(i,j)=1、i=j の場合は Cost(i,j)=0 です。

例: 'Cost',struct('ClassNames',{{'b','g'}},'ClassificationCosts',[0 0.5; 1 0])

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

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

データ型: string | cell

`Prior` — 事前確率
`"empirical"` (既定値) | `"uniform"` | スカラー値のベクトル | 構造体

各クラスの事前確率。次の表の値として指定します。

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

Weights と Prior の両方に値を設定した場合は、重みは合計が対応するクラスの事前確率の値になるように再正規化されます。

例: Prior="uniform"

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

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

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

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

例: ResponseName="response"

データ型: char | string

`ScoreTransform` — スコア変換
`"none"` (既定値) | `"doublelogit"` | `"invlogit"` | `"ismax"` | `"logit"` | 関数ハンドル | ...

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

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

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

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

例: ScoreTransform="logit"

データ型: char | string | function_handle

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

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

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

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

合計が各クラスの事前確率の値と等しくなるように Weights が正規化されます。Inf の重みはサポートされません。

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

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

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

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

'none' — 最適化を行いません。
'auto' — {'DistributionNames','Standardize','Width'} を使用します。
'all' — すべての使用可能パラメーターを最適化します。
使用可能パラメーター名の string 配列または cell 配列。
optimizableVariable オブジェクトのベクトル。通常は hyperparameters の出力です。

最適化では、パラメーターを変化させることにより、fitcnb の交差検証損失 (誤差) を最小化しようとします。交差検証のタイプおよびその他の最適化の側面を制御するには、名前と値の引数 HyperparameterOptimizationOptions を使用します。HyperparameterOptimizationOptions を使用すると、ConstraintType オプションと ConstraintBounds オプションを設定することにより、交差検証損失の代わりに (コンパクトな) モデルサイズを最適化の目的として使用できます。

メモ

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

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

DistributionNames — fitcnb は、'normal' と 'kernel' で探索します。
Kernel — fitcnb は、'normal'、'box'、'epanechnikov' および 'triangle' で探索します。
Standardize — fitcnb は、true と false で探索します。
Width — fitcnb は、既定では範囲 [1e-3,1e3] の対数スケールで、実数値を探索します。

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

load fisheriris
params = hyperparameters('fitcnb',meas,species);
params(2).Range = [1e-2,1e2];

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

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

たとえば、単純ベイズ分類器の最適化を参照してください。

例: 'auto'

`HyperparameterOptimizationOptions` — 最適化のオプション
`HyperparameterOptimizationOptions` オブジェクト | 構造体

最適化のオプション。HyperparameterOptimizationOptions オブジェクトまたは構造体として指定します。この引数を指定すると、名前と値の引数 OptimizeHyperparameters の効果が変化します。HyperparameterOptimizationOptions を指定する場合、OptimizeHyperparameters も指定しなければなりません。オプションはいずれも任意です。ただし、AggregateOptimizationResults を返すには ConstraintBounds と ConstraintType を設定しなければなりません。構造体で設定できるオプションは HyperparameterOptimizationOptions オブジェクトと同じです。

オプション	値	既定の設定
`Optimizer`	`"bayesopt"` — ベイズ最適化を使用。内部的には `bayesopt` が呼び出されます。 `"gridsearch"` — 次元ごとに `NumGridDivisions` の値があるグリッド探索を使用。`"gridsearch"` では、グリッドからの一様な非復元抽出により、無作為な順序で探索します。最適化後、`sortrows(Mdl.HyperparameterOptimizationResults)` コマンドを使用してグリッド順の table を取得できます。 `"randomsearch"` — `MaxObjectiveEvaluations` 個の点で無作為に探索。	`"bayesopt"`
`ConstraintBounds`	N 個の最適化問題の制約範囲。N 行 2 列の数値行列または `[]` として指定します。`ConstraintBounds` の列には最適化問題の下限と上限の値が含まれます。`ConstraintBounds` を数値ベクトルとして指定すると、`ConstraintBounds` の 2 列目に値が代入され、1 列目にはゼロが代入されます。`ConstraintBounds` を指定する場合、`ConstraintType` も指定しなければなりません。	`[]`
`ConstraintTarget`	最適化問題の制約ターゲット。`"matlab"` または `"coder"` として指定します。`ConstraintBounds` と `ConstraintType` が `[]` の場合に `ConstraintTarget` を設定すると、`ConstraintTarget` は `[]` に設定されます。`ConstraintTarget` と `ConstraintType` の値により、目的関数と制約関数が決まります。詳細については、`HyperparameterOptimizationOptions` を参照してください。	`ConstraintBounds` と `ConstraintType` を指定する場合の既定値は `"matlab"` です。そうでない場合、既定値は `[]` となります。
`ConstraintType`	最適化問題の制約タイプ。`"size"` または `"loss"` として指定します。`ConstraintType` を指定する場合、`ConstraintBounds` も指定しなければなりません。`ConstraintTarget` と `ConstraintType` の値により、目的関数と制約関数が決まります。詳細については、`HyperparameterOptimizationOptions` を参照してください。	`[]`
`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`	目的関数評価の最大数。`ConstraintBounds` を使用して最適化問題を複数指定する場合、`MaxObjectiveEvaluations` の値は各最適化問題に個別に適用されます。	`"bayesopt"` および `"randomsearch"` の場合は `30`、`"gridsearch"` の場合はグリッド全体
`MaxTime`	最適化の制限時間。非負の実数スカラーとして指定します。制限時間の単位は、`tic` と `toc` によって測定される秒です。`MaxTime` の値にかかわらず、少なくとも 1 回は最適化反復が実行されます。`MaxTime` は関数評価を中断させないため、実行時間が `MaxTime` を超える可能性があります。`ConstraintBounds` を使用して最適化問題を複数指定する場合、制限時間は各最適化問題に個別に適用されます。	`Inf`
`NumGridDivisions`	`Optimizer="gridsearch"` における各次元の値の個数。値は、各次元の値の個数を表す正の整数のベクトル、またはすべての次元に適用されるスカラーが可能です。カテゴリカル変数の場合、このオプションは無視されます。	`10`
`ShowPlots`	最適化の進行状況のプロットを表示するかどうかを示す logical 値。このオプションが `true` の場合、最適な観測された目的関数値が反復回数に対してプロットされます。ベイズ最適化を使用する場合 (`Optimizer="bayesopt"`)、最適な推定された目的関数値もプロットされます。最適な観測された目的関数値および最適な推定された目的関数値は、反復表示の `BestSoFar (observed)` 列および `BestSoFar (estim.)` 列の値にそれぞれ対応しています。これらの値は、`Mdl.HyperparameterOptimizationResults` のプロパティ `ObjectiveMinimumTrace` および `EstimatedObjectiveMinimumTrace` で確認できます。問題にベイズ最適化の最適化パラメーターが 1 つまたは 2 つある場合、`ShowPlots` はパラメーターに対する目的関数のモデルもプロットします。	`true`
`SaveIntermediateResults`	最適化の結果を保存するかどうかを示す logical 値。このオプションが `true` の場合、`"BayesoptResults"` という名前のワークスペース変数が反復ごとに上書きされます。この変数は `BayesianOptimization` オブジェクトです。`ConstraintBounds` を使用して最適化問題を複数指定する場合、ワークスペース変数は `"AggregateBayesoptResults"` という名前の `AggregateBayesianOptimization` オブジェクトになります。	`false`
`Verbose`	コマンドラインにおける表示レベル: `0` — 反復表示なし `1` — 反復表示あり `2` — 反復表示と追加情報詳細については、`bayesopt` の名前と値の引数 `Verbose` およびベイズ最適化の使用による分類器の当てはめの最適化の例を参照してください。	`1`
`UseParallel`	ベイズ最適化を並列実行するかどうかを示す logical 値。並列実行には Parallel Computing Toolbox™ が必要です。並列でのタイミングに再現性がないため、並列ベイズ最適化で再現性のある結果が生成されるとは限りません。詳細については、並列ベイズ最適化を参照してください。	`false`
`Repartition`	反復ごとに交差検証を再分割するかどうかを示す論理値。このオプションが `false` の場合、オプティマイザーは単一の分割を最適化に使用します。分割ノイズが考慮されるので、通常は値を `true` にすると最も確実な結果が得られます。ただし、`true` で最適な結果を得るには、2 倍以上の関数評価が必要になります。	`false`
次の 3 つのオプションのいずれか 1 つのみを指定してください。
`CVPartition`	`cvpartition` によって作成された `cvpartition` オブジェクト	交差検証オプションが指定されていない場合は `KFold=5`
`Holdout`	ホールドアウトの比率を表す範囲 `(0,1)` のスカラー
`KFold`	1 より大きい整数

例: HyperparameterOptimizationOptions=struct(UseParallel=true)

出力引数

`Mdl` — 学習済みの単純ベイズ分類モデル
`ClassificationNaiveBayes` モデルオブジェクト | `ClassificationPartitionedModel` 交差検証済みモデルオブジェクト

学習済みの単純ベイズ分類モデル。ClassificationNaiveBayes モデルオブジェクトまたは ClassificationPartitionedModel 交差検証済みモデルオブジェクトとして返されます。

名前と値のペアの引数 KFold、Holdout、CrossVal、CVPartition のいずれかを設定した場合、Mdl は ClassificationPartitionedModel 交差検証済みモデルオブジェクトになります。それ以外の場合、Mdl は ClassificationNaiveBayes モデルオブジェクトになります。

Mdl のプロパティを参照するには、ドット表記を使用します。たとえば、推定された分布パラメーターにアクセスするには、Mdl.DistributionParameters を入力します。

`AggregateOptimizationResults` — 最適化の結果の集計
`AggregateBayesianOptimization` オブジェクト

複数の最適化問題についての最適化の結果の集計。AggregateBayesianOptimization オブジェクトとして返されます。AggregateOptimizationResults を返すには、OptimizeHyperparameters と HyperparameterOptimizationOptions を指定しなければなりません。HyperparameterOptimizationOptions の ConstraintType オプションと ConstraintBounds オプションも指定する必要があります。この出力の生成方法を示す例については、Hyperparameter Optimization with Multiple Constraint Boundsを参照してください。

詳細

bag-of-tokens モデル

bag-of-tokens モデルでは、予測子 j の値は観測値のトークン j の発生数を表す非負の数値です。この多項モデルのカテゴリ (ビン) の数は、異なるトークンの数 (予測子の数) です。

単純ベイズ

"単純ベイズ" は密度推定をデータに適用する分類アルゴリズムです。

アルゴリズムはベイズの定理を活用し、クラスが与えられる場合、予測子が条件付きで独立していると (単純に) 仮定します。通常、実際はこの仮定に反して、単純ベイズ分類器から得られる事後分布は、バイアス付きのクラス密度を推定する場合、特に事後分布が 0.5 (判定境界) であれば、信頼性が高い傾向があります[1]。

単純ベイズ分類器は観測を最も確率の高いクラスに割り当てます (つまり、"最大事後確率" 決定ルールです)。明示的に、アルゴリズムは以下の手順を実行します。

各クラス内の予測子の密度を推定します。
ベイズルールに従って、事後確率をモデル化します。つまり、すべての k = 1,...,K について、次のようになります。

$\hat{P} (Y = k | X_{1}, .., X_{P}) = \frac{π (Y = k) \prod_{j = 1}^{P} P (X_{j} | Y = k)}{\sum_{k = 1}^{K} π (Y = k) \prod_{j = 1}^{P} P (X_{j} | Y = k)},$
ここで
- Y は観測のクラスインデックスに対応する確率変数です。
- X₁,...,X_P は観測の無作為な予測子です。
- $π (Y = k)$ は、クラスインデックスが k である事前確率です。
各クラスの事後確率を推定して観測値を分類し、最大の事後確率を発生するクラスに観測値を割り当てます。

予測子が多項分布を構成する場合、事後確率は $\hat{P} (Y = k | X_{1}, .., X_{P}) \propto π (Y = k) P_{m n} (X_{1}, ..., X_{P} | Y = k),$ になります。ここで、 $P_{m n} (X_{1}, ..., X_{P} | Y = k)$ は多項分布の確率密度関数です。

ヒント

bag-of-tokens モデルなどのカウントベースデータを分類するには、多項分布を使用します (たとえば、'DistributionNames','mn' を設定するなど)。
モデルに学習をさせた後で、新しいデータについてラベルを予測する C/C++ コードを生成できます。C/C++ コードの生成には MATLAB Coder™ が必要です。詳細については、コード生成の紹介を参照してください。

アルゴリズム

予測子変数 j が条件付き正規分布をもつ場合 (名前と値の引数 DistributionNames を参照)、クラス固有の加重平均、および加重標準偏差の不偏推定を計算することにより、この分布がデータに当てはめられます。各クラス k に対して以下を実行します。
- 予測子 j の加重平均は次のようになります。
  
  ${\bar{x}}_{j | k} = \frac{\sum_{{i : y_{i} = k}} w_{i} x_{i j}}{\sum_{{i : y_{i} = k}} w_{i}},$
  ここで w_i は観測値 i の重みです。クラス内の重みは、その合計がクラスの事前確率になるように正規化されます。
- 予測子 j の加重標準偏差の不偏推定器は次のようになります。
  
  $s_{j | k} = {[\frac{\sum_{{i : y_{i} = k}} w_{i} {(x_{i j} - {\bar{x}}_{j | k})}^{2}}{z_{1 | k} - \frac{z_{2 | k}}{z_{1 | k}}}]}^{1 / 2},$
  ここで z_1|k はクラス k 内の重みの合計、z_2|k はクラス k 内の重みの 2 乗の合計です。
すべての予測子変数が条件付き多項分布 ('DistributionNames','mn' を指定) を構成する場合、bag-of-tokens モデルを使用して、この分布が当てはめられます。トークン j がプロパティ DistributionParameters{k,j} のクラス k に出現する確率が保存されます。加法平滑化[2]を使用すると、推定確率は次のようになります。

$P (token j | class k) = \frac{1 + c_{j | k}}{P + c_{k}},$
ここで
- $c_{j | k} = n_{k} \frac{\sum_{{i : y_{i} = k}}^{} x_{i j} w_{i}^{}}{\sum_{{i : y_{i} = k}}^{} w_{i}},$ はクラス k におけるトークン j の重み付き発生数です。
- n_k はクラス k 内の観測数です。
- $w_{i}^{}$ は観測値 i の重みです。クラス内の重みは、その合計がクラスの事前確率になるように正規化されます。
- $c_{k} = \sum_{j = 1}^{P} c_{j | k},$ は、クラス k に含まれているすべてのトークンの重み付き発生数の合計です。
予測子変数 j が条件付き多変量多項分布を持つ場合、次のようになります。
1. 一意のレベルのリストが収集され、並べ替えられたリストは CategoricalLevels に保存され、各レベルはビンと見なされます。予測子とクラスの各組み合わせは、個別の独立した多項確率変数です。
2. 各クラス k に対して、CategoricalLevels{j} に保存されたリストを使用して、カテゴリカルレベルごとのインスタンスがカウントされます。
3. クラス k の予測子 j が、プロパティ DistributionParameters{k,j} においてレベル L をもつ場合、すべてのレベルの確率は CategoricalLevels{j} に保存されます。加法平滑化[2]を使用すると、推定確率は次のようになります。
  
  $P (predictor j = L | class k) = \frac{1 + m_{j | k} (L)}{m_{j} + m_{k}},$
  ここで
  - $m_{j | k} (L) = n_{k} \frac{\sum_{{i : y_{i} = k}}^{} I {x_{i j} = L} w_{i}^{}}{\sum_{{i : y_{i} = k}}^{} w_{i}^{}},$ は、クラス k 内の予測子 j が L に等しい観測値の重み付き個数です。
  - n_k はクラス k 内の観測数です。
  - x_ij = L の場合は $I {x_{i j} = L} = 1$ 、それ以外の場合は 0 です。
  - $w_{i}^{}$ は観測値 i の重みです。クラス内の重みは、その合計がクラスの事前確率になるように正規化されます。
  - m_j は予測子 j の異なるレベルの数です。
  - m_k はクラス k 内の重み付けされた観測値の数です。

名前と値の引数 Cost、Prior、および Weights を指定すると、出力モデルオブジェクトに Cost、Prior、および W の各プロパティの指定値がそれぞれ格納されます。Cost プロパティには、ユーザー指定のコスト行列がそのまま格納されます。Prior プロパティと W プロパティには、正規化後の事前確率と観測値の重みがそれぞれ格納されます。詳細については、誤分類コスト行列、事前確率、および観測値の重みを参照してください。
Cost プロパティは予測に使用されますが、学習には使用されません。したがって、Cost は読み取り専用ではなく、学習済みモデルの作成後にドット表記を使用してプロパティの値を変更できます。

参照

[1] Hastie, T., R. Tibshirani, and J. Friedman. The Elements of Statistical Learning, Second Edition. NY: Springer, 2008.

[2] Manning, Christopher D., Prabhakar Raghavan, and Hinrich Schütze. Introduction to Information Retrieval, NY: Cambridge University Press, 2008.

拡張機能

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

この関数は、tall 配列を制限付きでサポートします。

以下の構文がサポートされます。
- Mdl = fitcnb(Tbl,Y)
- Mdl = fitcnb(X,Y)
- Mdl = fitcnb(___,Name,Value)
- [Mdl,AggregateOptimizationResults] = fitcnb(___,Name=Value) — 名前と値の引数 OptimizeHyperparameters と HyperparameterOptimizationOptions を指定している場合に、fitcnb からハイパーパラメーターの最適化の結果が格納された AggregateBayesianOptimization オブジェクト AggregateOptimizationResults が追加で返されます。HyperparameterOptimizationOptions の ConstraintType オプションと ConstraintBounds オプションも指定する必要があります。
カーネル密度、交差検証およびハイパーパラメーター最適化に関連するオプションはサポートされません。以下の名前と値のペアの引数がサポートされます。
- 'DistributionNames' — 'kernel' という値はサポートされません。
- 'CategoricalPredictors'
- 'Cost'
- 'PredictorNames'
- 'Prior'
- 'ResponseName'
- 'ScoreTransform'
- 'Weights' — 値は tall 配列でなければなりません。

詳細は、メモリに収まらないデータの tall 配列を参照してください。

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

ハイパーパラメーターの最適化を並列実行するには、fitcnb 関数を呼び出すときに名前と値の引数 HyperparameterOptimizationOptions で UseParallel=true オプションを使用します。

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

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

バージョン履歴

R2014b で導入