fitcsvm

SVM 分類器の学習

フィッシャーのアヤメのデータセットを読み込みます。がく片の長さと幅および観測済みのすべての setosa 種のアヤメを削除します。

load fisheriris
inds = ~strcmp(species,'setosa');
X = meas(inds,3:4);
y = species(inds);

処理済みのデータセットを使用して SVM 分類器に学習させます。

SVMModel = fitcsvm(X,y)

SVMModel = 
  ClassificationSVM
             ResponseName: 'Y'
    CategoricalPredictors: []
               ClassNames: {'versicolor'  'virginica'}
           ScoreTransform: 'none'
          NumObservations: 100
                    Alpha: [24×1 double]
                     Bias: -14.4149
         KernelParameters: [1×1 struct]
           BoxConstraints: [100×1 double]
          ConvergenceInfo: [1×1 struct]
          IsSupportVector: [100×1 logical]
                   Solver: 'SMO'


  Properties, Methods

SVMModel は学習させた ClassificationSVM 分類器です。SVMModel のプロパティを表示します。たとえば、クラスの順序を確認するには、ドット表記を使用します。

classOrder = SVMModel.ClassNames

classOrder = 2×1 cell
    {'versicolor'}
    {'virginica' }

最初のクラス ('versicolor') は陰性のクラスで、2 番目のクラス ('virginica') は陽性のクラスです。'ClassNames' 名前と値のペアの引数を使用すると、学習中にクラスの順序を変更できます。

データの散布図をプロットし、サポートベクターを円で囲みます。

sv = SVMModel.SupportVectors;
figure
gscatter(X(:,1),X(:,2),y)
hold on
plot(sv(:,1),sv(:,2),'ko','MarkerSize',10)
legend('versicolor','virginica','Support Vector')
hold off

Figure contains an axes object. The axes object contains 3 objects of type line. One or more of the lines displays its values using only markers These objects represent versicolor, virginica, Support Vector.

サポートベクターは、推定されたクラス境界の上または外側で発生する観測値です。

名前と値のペアの引数 'BoxConstraint' を使用して学習時のボックス制約を設定すると、境界 (および結果的にサポートベクターの個数) を調整できます。

2 クラス SVM 分類器の判定境界とマージンのラインのプロット

この例では、2 つの予測子変数をもつ 2 クラス (バイナリ) SVM 分類器の判定境界とマージンのラインをプロットする方法を示します。

フィッシャーのアヤメのデータセットを読み込みます。versicolor 種のアヤメはすべて除外し (setosa 種と virginica 種だけを残し)、がく片の長さと幅の測定値のみを残します。

load fisheriris;
inds = ~strcmp(species,'versicolor');
X = meas(inds,1:2);
s = species(inds);

線形カーネル SVM 分類器に学習させます。

SVMModel = fitcsvm(X,s);

SVMModel は学習させた ClassificationSVM 分類器です。プロパティには、サポートベクター、線形予測子の係数、およびバイアス項が含まれます。

sv = SVMModel.SupportVectors; % Support vectors
beta = SVMModel.Beta; % Linear predictor coefficients
b = SVMModel.Bias; % Bias term

データの散布図をプロットし、サポートベクターを円で囲みます。サポートベクターは、推定されたクラス境界の上または外側で発生する観測値です。

hold on
gscatter(X(:,1),X(:,2),s)
plot(sv(:,1),sv(:,2),'ko','MarkerSize',10)

SVMModel 分類器の最適な分離超平面は、 $β_{1} X_{1} + β_{2} X_{2} + b = 0$ で指定される直線です。2 つの種類の間の判定境界を実線でプロットします。

X1 = linspace(min(X(:,1)),max(X(:,1)),100);
X2 = -(beta(1)/beta(2)*X1)-b/beta(2);
plot(X1,X2,'-')

線形予測子の係数 $β$ で判定境界と直交するベクトルが定義されます。マージンの最大幅は $2 {| | β ‖}^{- 1}$ です (詳細については、バイナリ分類のサポートベクターマシンを参照してください)。マージンの最大境界を破線でプロットします。軸のラベルを設定し、凡例を追加します。

m = 1/sqrt(beta(1)^2 + beta(2)^2);  % Margin half-width
X1margin_low = X1+beta(1)*m^2;
X2margin_low = X2+beta(2)*m^2;
X1margin_high = X1-beta(1)*m^2;
X2margin_high = X2-beta(2)*m^2;
plot(X1margin_high,X2margin_high,'b--')
plot(X1margin_low,X2margin_low,'r--')
xlabel('X_1 (Sepal Length in cm)')
ylabel('X_2 (Sepal Width in cm)')
legend('setosa','virginica','Support Vector', ...
    'Boundary Line','Upper Margin','Lower Margin')
hold off

Figure contains an axes object. The axes object with xlabel X_1 (Sepal Length in cm), ylabel X_2 (Sepal Width in cm) contains 6 objects of type line. One or more of the lines displays its values using only markers These objects represent setosa, virginica, Support Vector, Boundary Line, Upper Margin, Lower Margin.

SVM 分類器の学習と交差検証

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

load ionosphere
rng(1); % For reproducibility

放射基底関数を使用して SVM 分類器に学習させます。本ソフトウェアを使用してカーネル関数のスケール値を検出します。予測子を標準化します。

SVMModel = fitcsvm(X,Y,'Standardize',true,'KernelFunction','RBF',...
    'KernelScale','auto');

SVMModel は学習させた ClassificationSVM 分類器です。

SVM 分類器を交差検証します。既定では、10 分割交差検証が使用されます。

CVSVMModel = crossval(SVMModel);

CVSVMModel は ClassificationPartitionedModel 交差検証分類器です。

標本外誤分類率を推定します。

classLoss = kfoldLoss(CVSVMModel)

classLoss = 
0.0484

汎化率は約 5% です。

SVM および 1 クラス学習を使用した外れ値の検出

すべてのアヤメを同じクラスに割り当てることにより、フィッシャーのアヤメのデータセットを変更します。修正したデータセットの外れ値を検出し、外れ値である観測値の比率が予想どおりであることを確認します。

フィッシャーのアヤメのデータセットを読み込みます。花弁の長さと幅を削除します。すべてのアヤメを同じクラスとして扱います。

load fisheriris
X = meas(:,1:2);
y = ones(size(X,1),1);

修正したデータセットを使用して SVM 分類器に学習させます。観測値のうち 5% が外れ値であるとします。予測子を標準化します。

rng(1);
SVMModel = fitcsvm(X,y,'KernelScale','auto','Standardize',true,...
    'OutlierFraction',0.05);

SVMModel は学習させた ClassificationSVM 分類器です。既定では、1 クラス学習にはガウスカーネルが使用されます。

観測値と判定境界をプロットします。サポートベクターと外れ値の可能性がある値にフラグを設定します。

svInd = SVMModel.IsSupportVector;
h = 0.02; % Mesh grid step size
[X1,X2] = meshgrid(min(X(:,1)):h:max(X(:,1)),...
    min(X(:,2)):h:max(X(:,2)));
[~,score] = predict(SVMModel,[X1(:),X2(:)]);
scoreGrid = reshape(score,size(X1,1),size(X2,2));

figure
plot(X(:,1),X(:,2),'k.')
hold on
plot(X(svInd,1),X(svInd,2),'ro','MarkerSize',10)
contour(X1,X2,scoreGrid)
colorbar;
title('{\bf Iris Outlier Detection via One-Class SVM}')
xlabel('Sepal Length (cm)')
ylabel('Sepal Width (cm)')
legend('Observation','Support Vector')
hold off

Figure contains an axes object. The axes object with title Iris Outlier Detection via One-Class SVM, xlabel Sepal Length (cm), ylabel Sepal Width (cm) contains 3 objects of type line, contour. One or more of the lines displays its values using only markers These objects represent Observation, Support Vector.

外れ値と他のデータとの境界は、等高線値が 0 である場所で発生します。

交差検証データで負のスコアをもつ観測値のごく一部が、約 5% であることを確認します。

CVSVMModel = crossval(SVMModel);
[~,scorePred] = kfoldPredict(CVSVMModel);
outlierRate = mean(scorePred<0)

outlierRate = 
0.0467

バイナリ SVM を使用した複数クラス境界の検出

fisheriris データセットの散布図を作成します。プロット内のグリッドの座標をデータセットの分布から派生する新しい観測値として扱い、データセット内の 3 つのクラスのいずれかに座標を割り当てることによりクラスの境界を求めます。

フィッシャーのアヤメのデータセットを読み込みます。花弁の長さと幅を予測子として使用します。

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

データの散布図を調べます。

figure
gscatter(X(:,1),X(:,2),Y);
h = gca;
lims = [h.XLim h.YLim]; % Extract the x and y axis limits
title('{\bf Scatter Diagram of Iris Measurements}');
xlabel('Petal Length (cm)');
ylabel('Petal Width (cm)');
legend('Location','Northwest');

Figure contains an axes object. The axes object with title Scatter Diagram of Iris Measurements, xlabel Petal Length (cm), ylabel Petal Width (cm) contains 3 objects of type line. One or more of the lines displays its values using only markers These objects represent setosa, versicolor, virginica.

データには 3 つのクラスが含まれており、そのうち 1 つは他のクラスから線形分離可能です。

各クラスに対して、以下を実行します。

観測値がクラスのメンバーであるかどうかを示す logical ベクトル (indx) を作成します。
予測子データと indx を使用して SVM 分類器に学習させます。
分類器を cell 配列のセルに保存します。

クラスの順序を定義します。

SVMModels = cell(3,1);
classes = unique(Y);
rng(1); % For reproducibility

for j = 1:numel(classes)
    indx = strcmp(Y,classes(j)); % Create binary classes for each classifier
    SVMModels{j} = fitcsvm(X,indx,'ClassNames',[false true],'Standardize',true,...
        'KernelFunction','rbf','BoxConstraint',1);
end

SVMModels は 3 行 1 列の cell 配列です。ここで、各セルには ClassificationSVM 分類器が格納されています。各セルで、陽性のクラスはそれぞれ setosa、versicolor、virginica です。

プロット内で細かいグリッドを定義し、座標を学習データの分布からの新しい観測値として扱います。各分類器を使用して、この新しい測定値のスコアを推定します。

d = 0.02;
[x1Grid,x2Grid] = meshgrid(min(X(:,1)):d:max(X(:,1)),...
    min(X(:,2)):d:max(X(:,2)));
xGrid = [x1Grid(:),x2Grid(:)];
N = size(xGrid,1);
Scores = zeros(N,numel(classes));

for j = 1:numel(classes)
    [~,score] = predict(SVMModels{j},xGrid);
    Scores(:,j) = score(:,2); % Second column contains positive-class scores
end

Scores の各行には 3 つのスコアが格納されています。スコアが最大の要素のインデックスは、新しいクラスの観測値の所属先となる可能性が最も高いと思われるクラスのインデックスです。

新しいそれぞれの観測値を、当該の観測値に最大スコアを設定する分類器に関連付けます。

[~,maxScore] = max(Scores,[],2);

プロットの各領域の色は、対応する新しい観測値が属するクラスに基づいています。

figure
h(1:3) = gscatter(xGrid(:,1),xGrid(:,2),maxScore,...
    [0.1 0.5 0.5; 0.5 0.1 0.5; 0.5 0.5 0.1]);
hold on
h(4:6) = gscatter(X(:,1),X(:,2),Y);
title('{\bf Iris Classification Regions}');
xlabel('Petal Length (cm)');
ylabel('Petal Width (cm)');
legend(h,{'setosa region','versicolor region','virginica region',...
    'observed setosa','observed versicolor','observed virginica'},...
    'Location','Northwest');
axis tight
hold off

Figure contains an axes object. The axes object with title Iris Classification Regions, xlabel Petal Length (cm), ylabel Petal Width (cm) contains 6 objects of type line. One or more of the lines displays its values using only markers These objects represent setosa region, versicolor region, virginica region, observed setosa, observed versicolor, observed virginica.

SVM 分類器の最適化

fitcsvm を使用して、SVM 分類器のハイパーパラメーターを自動的に最適化します。

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

load ionosphere

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

rng(0,"twister")
hpoOptions = hyperparameterOptimizationOptions(AcquisitionFunctionName="expected-improvement-plus");
Mdl = fitcsvm(X,Y,OptimizeHyperparameters="auto", ...
    HyperparameterOptimizationOptions=hpoOptions)

|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstraint|  KernelScale |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |
|====================================================================================================================|
|    1 | Best   |     0.35897 |     0.27976 |     0.35897 |     0.35897 |       3.8653 |       961.53 |         true |
|    2 | Best   |     0.13105 |      12.092 |     0.13105 |     0.15896 |       429.99 |       0.2378 |        false |
|    3 | Accept |     0.35897 |    0.064184 |     0.13105 |     0.13431 |      0.11801 |       8.9479 |        false |
|    4 | Accept |      0.1339 |      7.3098 |     0.13105 |     0.13255 |    0.0010694 |    0.0032063 |         true |
|    5 | Accept |     0.16239 |      13.671 |     0.13105 |     0.13109 |       973.65 |      0.13813 |        false |
|    6 | Best   |     0.12536 |     0.11891 |     0.12536 |     0.12532 |       223.81 |        6.196 |        false |
|    7 | Accept |      0.1339 |      11.315 |     0.12536 |     0.12531 |    0.0067168 |    0.0026321 |         true |
|    8 | Accept |     0.13675 |      11.482 |     0.12536 |      0.1253 |    0.0027249 |    0.0012541 |         true |
|    9 | Accept |     0.31339 |    0.053827 |     0.12536 |     0.12536 |     0.035943 |       6.0851 |         true |
|   10 | Accept |     0.12821 |      4.9377 |     0.12536 |     0.12536 |       66.992 |      0.41702 |        false |
|   11 | Accept |     0.35897 |    0.056392 |     0.12536 |     0.12538 |       930.37 |       823.95 |        false |
|   12 | Accept |     0.12821 |      4.4998 |     0.12536 |      0.1254 |       728.45 |       1.5307 |        false |
|   13 | Accept |      0.1339 |      1.0319 |     0.12536 |     0.12541 |       170.98 |       1.3159 |        false |
|   14 | Accept |     0.14245 |     0.21369 |     0.12536 |     0.12721 |       992.32 |       7.3318 |        false |
|   15 | Accept |     0.16239 |      13.484 |     0.12536 |     0.12646 |       13.581 |     0.015371 |        false |
|   16 | Accept |     0.27066 |      13.714 |     0.12536 |       0.127 |       1.4909 |    0.0010177 |         true |
|   17 | Accept |     0.12821 |     0.24894 |     0.12536 |     0.12624 |    0.0021047 |     0.020054 |         true |
|   18 | Accept |     0.12821 |      3.8586 |     0.12536 |      0.1271 |    0.0032708 |    0.0076637 |         true |
|   19 | Accept |     0.13675 |      11.038 |     0.12536 |     0.12575 |       89.802 |       0.1289 |        false |
|   20 | Accept |     0.14815 |      12.705 |     0.12536 |     0.12634 |     0.036244 |    0.0010077 |        false |
|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstraint|  KernelScale |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |
|====================================================================================================================|
|   21 | Accept |     0.13105 |      10.679 |     0.12536 |      0.1263 |    0.0010013 |    0.0011445 |        false |
|   22 | Accept |     0.13675 |     0.19196 |     0.12536 |     0.12622 |     0.001046 |    0.0080913 |        false |
|   23 | Accept |      0.1339 |      5.1959 |     0.12536 |     0.12606 |    0.0046362 |    0.0030446 |        false |
|   24 | Accept |     0.13105 |     0.57732 |     0.12536 |      0.1273 |       296.46 |       2.4359 |        false |
|   25 | Accept |     0.12536 |     0.24028 |     0.12536 |     0.12773 |    0.0010225 |     0.013235 |         true |
|   26 | Accept |      0.1339 |      5.3144 |     0.12536 |     0.12826 |      0.15678 |      0.01574 |        false |
|   27 | Accept |      0.1339 |      4.2487 |     0.12536 |     0.12786 |       2.3173 |     0.070668 |        false |
|   28 | Accept |     0.12821 |      2.2724 |     0.12536 |     0.12684 |    0.0010144 |     0.013827 |         true |
|   29 | Accept |     0.13675 |      7.2154 |     0.12536 |     0.12715 |       309.12 |      0.47893 |        false |
|   30 | Accept |     0.13105 |     0.85752 |     0.12536 |     0.12767 |    0.0020705 |    0.0089169 |         true |

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

Best observed feasible point:
    BoxConstraint    KernelScale    Standardize
    _____________    ___________    ___________

       223.81           6.196          false   

Observed objective function value = 0.12536
Estimated objective function value = 0.13187
Function evaluation time = 0.11891

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

      0.0020705       0.0089169        true    

Estimated objective function value = 0.12767
Estimated function evaluation time = 1.4796

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 = 
  ClassificationSVM
                         ResponseName: 'Y'
                CategoricalPredictors: []
                           ClassNames: {'b'  'g'}
                       ScoreTransform: 'none'
                      NumObservations: 351
    HyperparameterOptimizationResults: [1×1 classreg.learning.paramoptim.SupervisedLearningBayesianOptimization]
                                Alpha: [71×1 double]
                                 Bias: -1.2279
                     KernelParameters: [1×1 struct]
                                   Mu: [0.8917 0 0.6413 0.0444 0.6011 0.1159 0.5501 0.1194 0.5118 0.1813 0.4762 0.1550 0.4008 0.0934 0.3442 0.0711 0.3819 -0.0036 0.3594 -0.0240 0.3367 0.0083 0.3625 -0.0574 0.3961 -0.0712 0.5416 -0.0695 … ] (1×34 double)
                                Sigma: [0.3112 0 0.4977 0.4414 0.5199 0.4608 0.4927 0.5207 0.5071 0.4839 0.5635 0.4948 0.6222 0.4949 0.6528 0.4584 0.6180 0.4968 0.6263 0.5191 0.6098 0.5182 0.6038 0.5275 0.5785 0.5085 0.5162 0.5500 0.5759 … ] (1×34 double)
                       BoxConstraints: [351×1 double]
                      ConvergenceInfo: [1×1 struct]
                      IsSupportVector: [351×1 logical]
                               Solver: 'SMO'


  Properties, Methods

学習させた分類器 Mdl は、最適な推定実行可能点に対応し、BoxConstraint、KernelScale、および Standardize に同じハイパーパラメーター値を使用しています。

bestPoint 関数を使用して、Mdl の学習に使用されたハイパーパラメーター値を調べます。既定では、bestPoint は、ハイパーパラメーターの最適化時に fitcsvm で使用されたものと同じ最適点の基準 ("min-visited-upper-confidence-interval") を使用します。一般に、近似関数では、データセット内のノイズへの過適合を防ぐために、基準 "min-visited-upper-confidence-interval" (基準 "min-observed" ではなく) に基づいて最適なハイパーパラメーター値を判別します。

bestEstimatedPoint = bestPoint(Mdl.HyperparameterOptimizationResults)

bestEstimatedPoint=1×3 table
    BoxConstraint    KernelScale    Standardize
    _____________    ___________    ___________

      0.0020705       0.0089169        true

結果が Mdl のプロパティと一致することを確認します。SVM 分類器で標準化を使用する場合、ClassificationSVM オブジェクトの Mu プロパティと Sigma プロパティは空以外になることに注意してください。

classifierProperties = table(unique(Mdl.BoxConstraints), ...
    Mdl.KernelParameters.Scale, ...
    struct(Means=Mdl.Mu,StandardDeviations=Mdl.Sigma), ...
    VariableNames=["BoxConstraint","KernelScale","Standardize"])

classifierProperties=1×3 table
    BoxConstraint    KernelScale    Standardize
    _____________    ___________    ___________

      0.0020705       0.0089169     1×1 struct

classifierProperties.Standardize

ans = struct with fields:
                 Means: [0.8917 0 0.6413 0.0444 0.6011 0.1159 0.5501 0.1194 0.5118 0.1813 0.4762 0.1550 0.4008 0.0934 0.3442 0.0711 0.3819 -0.0036 0.3594 -0.0240 0.3367 0.0083 0.3625 -0.0574 0.3961 -0.0712 0.5416 -0.0695 0.3784 -0.0279 … ] (1×34 double)
    StandardDeviations: [0.3112 0 0.4977 0.4414 0.5199 0.4608 0.4927 0.5207 0.5071 0.4839 0.5635 0.4948 0.6222 0.4949 0.6528 0.4584 0.6180 0.4968 0.6263 0.5191 0.6098 0.5182 0.6038 0.5275 0.5785 0.5085 0.5162 0.5500 0.5759 0.5080 0.5715 … ] (1×34 double)

入力引数

`Tbl` — 標本データ
table

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

必要に応じて、Tbl に応答変数用の列と観測値の重み用の列を含めることができます。

応答変数は、categorical 配列、文字配列、string 配列、logical ベクトル、数値ベクトル、または文字ベクトルの cell 配列でなければなりません。
- fitcsvm は 1 クラス分類および 2 クラス分類 (バイナリ) のみをサポートします。応答変数に最大で 2 つの異なるクラスを含めるか、名前と値の引数 ClassNames を使用して学習用の 1 つまたは 2 つのクラスを指定しなければなりません。マルチクラス学習については、fitcecoc を参照してください。
- 名前と値の引数 ClassNames を使用して応答変数におけるクラスの順序を指定することをお勧めします。
重みの列は数値ベクトルでなければなりません。
Tbl 内の応答変数は ResponseVarName または formula を使用して指定し、Tbl 内の観測値の重みは Weights を使用して指定しなければなりません。
- ResponseVarName を使用して応答変数を指定 — fitcsvm は、残りの変数を予測子として使用します。Tbl 内の残りの変数のサブセットを予測子として使用するには、PredictorNames を使用して予測子変数を指定します。
- formula を使用してモデル仕様を定義 — fitcsvm は、formula の指定に従って、Tbl 内の変数のサブセットを予測子変数および応答変数として使用します。

Tbl に応答変数が含まれていない場合は、Y を使用して応答変数を指定します。応答変数 Y の長さと Tbl の行数は等しくなければなりません。Tbl 内の変数のサブセットを予測子として使用するには、PredictorNames を使用して予測子変数を指定します。

データ型: 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 配列

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

fitcsvm は 1 クラス分類および 2 クラス分類 (バイナリ) のみをサポートします。Y に最大で 2 つの異なるクラスを含めるか、名前と値の引数 ClassNames を使用して学習用の 1 つまたは 2 つのクラスを指定しなければなりません。マルチクラス学習については、fitcecoc を参照してください。
Y の長さと Tbl または X の行数は同じでなければなりません。
Y が文字配列の場合、各ラベルは配列の 1 つの行に対応しなければなりません。
名前と値のペアの引数 ClassNames を使用してクラスの順序を指定することをお勧めします。

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

SVM 分類器に学習させる予測子データ。数値の行列として指定します。

X の各行は 1 つの観測値 (インスタンスまたは例とも呼ばれます) に、各列は 1 つの予測子 (特徴量とも呼ばれます) に対応します。

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

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

データ型: double | single

名前と値の引数

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

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

例: fitcsvm(X,Y,'KFold',10,'Cost',[0 2;1 0],'ScoreTransform','sign') は、10 分割交差検証を実行し、偽陰性の 2 倍のペナルティを偽陽性に適用し、符号関数を使用してスコアを変換します。

SVM のオプション

`BoxConstraint` — ボックス制約
1 (既定値) | 正のスカラー

ボックス制約。'BoxConstraint' と正のスカラーで構成されるコンマ区切りペアとして指定します。

1 クラス学習の場合、ボックス制約は必ず 1 に設定されます。

BoxConstraint、Cost、Prior、Standardize および Weights の関係とアルゴリズム動作についての詳細は、アルゴリズムを参照してください。

例: 'BoxConstraint',100

データ型: double | single

`KernelFunction` — カーネル関数
`'linear'` | `'gaussian'` | `'rbf'` | `'polynomial'` | 関数名

グラム行列の要素の計算に使用するカーネル関数。'KernelFunction' とカーネル関数名から構成されるコンマ区切りのペアとして指定します。G(x_j,x_k) がグラム行列の要素 (j,k) であるとします。ここで、x_j および x_k は X 内の観測値 j および k を表す p 次元ベクトルです。サポートされるカーネル関数の名前および関数形式を次の表で説明します。

カーネル関数名説明式

カーネル関数名	説明	式
`'gaussian'` または `'rbf'`	ガウスまたは放射基底関数 (RBF) カーネル (1 クラス学習の場合の既定値)	$G (x_{j}, x_{k}) = \exp (- {‖ x_{j} - x_{k} ‖}^{2})$
`'linear'`	線形カーネル (2 クラス学習の場合の既定値)	$G (x_{j}, x_{k}) = x_{j}' x_{k}$
`'polynomial'`	多項式カーネル。`'PolynomialOrder',q` を使用して多項式カーネルの順序 (`q`) を指定します。	$G (x_{j}, x_{k}) = {(1 + x_{j}' x_{k})}^{q}$

'gaussian' または 'rbf'

ガウスまたは放射基底関数 (RBF) カーネル (1 クラス学習の場合の既定値)

$G (x_{j}, x_{k}) = \exp (- {‖ x_{j} - x_{k} ‖}^{2})$

'linear'

線形カーネル (2 クラス学習の場合の既定値)

$G (x_{j}, x_{k}) = x_{j}' x_{k}$

'polynomial'

多項式カーネル。'PolynomialOrder',q を使用して多項式カーネルの順序 (q) を指定します。

$G (x_{j}, x_{k}) = {(1 + x_{j}' x_{k})}^{q}$

独自のカーネル関数を設定することもできます。たとえば、'KernelFunction','kernel' を使用すると kernel が設定されます。値 kernel は次の形式でなければなりません。

function G = kernel(U,V)

ここで

U は、m 行 p 列の行列です。列は予測子変数に、行は観測値に対応します。
V は、n 行 p 列の行列です。列は予測子変数に、行は観測値に対応します。
G は、U と V の行による m 行 n 列のグラム行列です。

kernel.m は、MATLAB パス上になければなりません。

カーネル関数には一般的な名前を使用しないようにしてください。たとえば、シグモイドカーネル関数には 'sigmoid' ではなく 'mysigmoid' などの名前を使用します。

例: 'KernelFunction','gaussian'

データ型: char | string

`KernelScale` — カーネルスケールパラメーター
`1` (既定値) | `'auto'` | 正のスカラー

カーネルスケールパラメーター。'KernelScale' と、'auto' または正のスカラーで構成される、コンマ区切りのペアとして指定します。予測子行列 X のすべての要素が KernelScale の値で除算されます。その後、適切なカーネルノルムが適用され、グラム行列が計算されます。

'auto' を指定した場合、ヒューリスティック手法を使用して適切なスケール係数が選択されます。このヒューリスティック手法では副標本抽出を使用するので、呼び出すたびに推定値が変化する可能性があります。このため、結果を再現するには、学習の前に rng を使用して乱数シードを設定します。
'KernelFunction','kernel' のように KernelScale と独自のカーネル関数を指定すると、エラーが発生します。kernel の内部でスケーリングを適用しなければなりません。

例: 'KernelScale','auto'

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

`PolynomialOrder` — 多項式カーネル関数の次数
`3` (既定値) | 正の整数

多項式カーネル関数の次数。'PolynomialOrder' と正の整数から成るコンマ区切りのペアとして指定されます。

KernelFunction が 'polynomial' ではない場合に 'PolynomialOrder' を設定すると、エラーがスローされます。

例: 'PolynomialOrder',2

データ型: double | single

`KernelOffset` — カーネルオフセットパラメーター
非負のスカラー

カーネルオフセットパラメーター。'KernelOffset' と非負のスカラーで構成されるコンマ区切りのペアとして指定します。

KernelOffset がグラム行列の各要素に追加されます。

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

ソルバーが SMO の場合 (つまり、'Solver','SMO' を設定した場合) は 0
ソルバーが ISDA の場合 (つまり、'Solver','ISDA' を設定した場合) は 0.1

例: 'KernelOffset',0

データ型: double | single

`Standardize` — 予測子データを標準化するためのフラグ
`false` (既定値) | `true`

予測子データを標準化するためのフラグ。'Standardize' と true (1) または false (0) から構成されるコンマ区切りのペアとして指定します。

'Standardize',true を設定した場合、次のようになります。

各予測子変数 (X または Tbl) は、対応する列の加重平均および標準偏差によってセンタリングおよびスケーリングされます。重み付きの標準化の詳細については、アルゴリズムを参照してください。MATLAB では、カテゴリカル予測子について生成されたダミー変数の列に格納されているデータは標準化されません。
分類器の学習には標準化された予測子が使用されますが、分類器の X プロパティには標準化されていないデータが行列または table として格納されます。

例: 'Standardize',true

データ型: logical

`Solver` — 最適化ルーチン
`'ISDA'` | `'L1QP'` | `'SMO'`

最適化ルーチン。'Solver' と次の表の値から構成されるコンマ区切りのペアとして指定します。

値	説明
`'ISDA'`	反復単一データアルゴリズム ([4]参照)
`'L1QP'`	`quadprog` (Optimization Toolbox) を使用して二次計画法による L1 ソフトマージン最小化を実装します。このオプションには Optimization Toolbox™ ライセンスが必要です。詳細は、二次計画法の定義 (Optimization Toolbox)を参照してください。
`'SMO'`	逐次最小最適化 ([2]参照)

既定値は、2 クラス学習で 'OutlierFraction' を正の値に設定した場合は 'ISDA' で、それ以外の場合は 'SMO' です。

例: 'Solver','ISDA'

`Alpha` — アルファ係数の初期推定値
非負値の数値ベクトル

アルファ係数の初期推定値。'Alpha' と非負値の数値ベクトルから構成されるコンマ区切りのペアとして指定します。Alpha の長さは X の行数と等しくなければなりません。

'Alpha' の各要素は X の観測値に対応します。
'Alpha' は NaN を格納できません。
'Alpha' を交差検証の名前と値のペアの引数 ('CrossVal'、'CVPartition'、'Holdout'、'KFold' または 'Leaveout') のいずれかと同時に指定すると、エラーが返されます。

Y に欠損値が含まれている場合は、欠損値に対応するすべての行を Y、X および 'Alpha' から削除してください。つまり、次のように入力します。

idx = ~isundefined(categorical(Y));
Y = Y(idx,:);
X = X(idx,:);
alpha = alpha(idx);

そして、Y、X および alpha をそれぞれ応答、予測子およびアルファの初期推定値として渡します。

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

1 クラス学習の場合: 0.5*ones(size(X,1),1)
2 クラス学習の場合: zeros(size(X,1),1)

例: 'Alpha',0.1*ones(size(X,1),1)

データ型: double | single

`CacheSize` — キャッシュサイズ
`1000` (既定値) | `'maximal'` | 正のスカラー

キャッシュサイズ。'CacheSize' と'maximal' または正のスカラーで構成されるコンマ区切りのペアとして指定します。

CacheSize が 'maximal' の場合、n 行 n 列のグラム行列を保持できる十分なメモリが確保されます。

CacheSize が正のスカラーの場合、モデルの学習用に CacheSize メガバイトのメモリが確保されます。

例: 'CacheSize','maximal'

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

`ClipAlphas` — アルファ係数をクリップするためのフラグ
`true` (既定値) | `false`

アルファ係数をクリップするためのフラグ。'ClipAlphas' と true または false のいずれかから構成されるコンマ区切りのペアとして指定します。

観測値 j のアルファ係数が α_j、観測値 j のボックス制約が C_j であるとします (j = 1,...,n)。n は学習標本のサイズです。

値	説明
`true`	各反復で α_j が 0 または C_j に近い場合、MATLAB で α_j がそれぞれ 0 または C_j に設定されます。
`false`	最適化時に MATLAB でアルファ係数は変更されません。

MATLAB では、学習済みの SVM モデルオブジェクトの Alpha プロパティに最終的な α の値が格納されます。

ClipAlphas は、SMO と ISDA の収束に影響を与える可能性があります。

例: 'ClipAlphas',false

データ型: logical

`Nu` — 1 クラス学習の ν パラメーター
`0.5` (既定値) | 正のスカラー

1 クラス学習の ν パラメーター。'Nu' と正のスカラーから構成されるコンマ区切りのペアとして指定します。Nu は、0 より大きく 1 以下でなければなりません。

Nu の設定により、学習例の大部分を陽性のクラスにするか、スコア関数の重みを最小限にするかのバランスを制御します。

例: 'Nu',0.25

データ型: double | single

`NumPrint` — 最適化診断メッセージ出力の反復回数
`1000` (既定値) | 非負の整数

最適化診断メッセージ出力の反復回数。'NumPrint' と非負の整数で構成されるコンマ区切りのペアとして指定します。

'Verbose',1 と 'NumPrint',numprint を指定すると、numprint 回反復するたびに SMO と ISDA からのすべての最適化診断メッセージがコマンドウィンドウに表示されます。

例: 'NumPrint',500

データ型: double | single

`OutlierFraction` — 学習データで想定される外れ値の比率
`0` (既定値) | 区間 [0,1) の数値スカラー

学習データで想定される外れ値の比率。'OutlierFraction' と区間 [0,1) の数値スカラーから構成されるコンマ区切りのペアとして指定します。

'OutlierFraction',outlierfraction を設定するとします。outlierfraction は 0 より大きい値です。

2 クラス学習では "ロバスト学習" が行われます。この方式では、最適化アルゴリズムが収束すると、観測値のうち 100*outlierfraction% が削除されます。削除された観測値は、勾配の大きいものに対応します。
1 クラス学習では、学習セットに負のスコアをもつ観測 outlierfraction など、適切なバイアス項が検出されます。

例: 'OutlierFraction',0.01

データ型: double | single

`RemoveDuplicates` — 重複する観測値を単一の観測値に置き換えるためのフラグ
`false` (既定値) | `true`

学習データ内の重複する観測値を単一の観測値に置き換えるためのフラグ。'RemoveDuplicates' と true または false から構成されるコンマ区切りのペアとして指定します。

RemoveDuplicates が true の場合、fitcsvm は学習データ内の重複する観測値を同じ値の単一の観測値に置き換えます。単一の観測値の重みは、削除された対応する重複の重みの合計に等しくなります (Weights を参照)。

ヒント

多数の重複する観測値がデータセットに含まれている場合は、'RemoveDuplicates',true を指定すると収束時間が大幅に短くなる可能性があります。

データ型: logical

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

詳細レベル。'Verbose' と 0、1 または 2 から構成されるコンマ区切りのペアとして指定します。Verbose の値は、コマンドウィンドウに表示され構造体として Mdl.ConvergenceInfo.History に保存される最適化情報の量を制御します。

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

値	説明
`0`	収束情報の表示や保存は行われません。
`1`	診断メッセージが表示され、`numprint` 回の反復ごとに収束基準が保存されます。ここで、`numprint` は名前と値のペアの引数 `'NumPrint'` の値です。
`2`	診断メッセージが表示され、1 回の反復ごとに収束基準が保存されます。

例: 'Verbose',1

データ型: double | single

その他の分類オプション

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

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

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

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

特定されたカテゴリカル予測子に対して、fitcsvm はカテゴリカル変数に順序が設定されていないか順序が設定されているかに応じて、2 つの異なる方式を使用してダミー変数を作成します。順序付けのないカテゴリカル変数の場合、fitcsvm は、そのカテゴリカル変数の各レベルについて 1 つずつダミー変数を作成します。順序付けされたカテゴリカル変数の場合、fitcsvm は、カテゴリの数よりも 1 つ少ないダミー変数を作成します。詳細については、ダミー変数の自動作成を参照してください。

例: CategoricalPredictors="all"

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

2 クラス学習に使用するクラスの名前。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 に含まれているすべての異なるクラス名の集合です。

この引数は 2 クラス学習に対してのみ有効です。

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

`Cost` — 2 クラス学習の誤分類コスト
`[0 1; 1 0]` (既定値) | 正方行列 | 構造体配列

2 クラス学習の誤分類のコスト。'Cost' と正方行列または構造体配列から構成されるコンマ区切りのペアとして指定します。

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

コスト行列を指定すると、そのコスト行列で指定されているペナルティが組み込まれ、学習用に事前確率が更新されます。学習済み SVM モデルオブジェクトの Cost プロパティには、ユーザー指定の値が格納されます。BoxConstraint、Cost、Prior、Standardize および Weights の関係とアルゴリズム動作についての詳細は、アルゴリズムを参照してください。

この引数は 2 クラス学習に対してのみ有効です。

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

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

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

データ型: string | cell

`Prior` — 2 クラス学習の各クラスの事前確率
`'empirical'` (既定値) | `'uniform'` | 数値ベクトル | 構造体配列

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

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

コスト行列を指定すると、そのコスト行列で指定されているペナルティが組み込まれ、学習用に事前確率が更新されます。学習済みモデルオブジェクトの Prior プロパティには、ユーザー指定の事前確率が確率の合計が 1 になるように正規化されて格納されます。BoxConstraint、Cost、Prior、Standardize および Weights の関係とアルゴリズム動作についての詳細は、アルゴリズムを参照してください。

この引数は 2 クラス学習に対してのみ有効です。

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

データ型: char | string | double | single | 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` 内の変数の名前

観測値の重み。'Weights' と、正の値の数値ベクトルまたは 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 の重みはサポートされません。BoxConstraint、Cost、Prior、Standardize および Weights の関係とアルゴリズム動作についての詳細は、アルゴリズムを参照してください。

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

メモ

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

交差検証オプション

`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

収束制御オプション

`DeltaGradientTolerance` — 勾配差分の許容誤差
非負のスカラー

SMO (逐次最小最適化) または ISDA (反復単一データアルゴリズム) により取得された上位の違反値と下位の違反値の間に存在する、勾配差分の許容誤差。'DeltaGradientTolerance' と非負のスカラーで構成されるコンマ区切りのペアとして指定します。

DeltaGradientTolerance が 0 の場合、最適化収束を確認するために、勾配差分の許容誤差を使用しません。

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

ソルバーが SMO の場合 (たとえば、'Solver','SMO' を設定した場合など) は 1e-3
ソルバーが ISDA の場合 (たとえば、'Solver','ISDA' を設定した場合など) は 0

例: 'DeltaGradientTolerance',1e-2

データ型: double | single

`GapTolerance` — 実行可能性ギャップの許容誤差
`0` (既定値) | 非負のスカラー

SMO または ISDA により取得された実行可能性ギャップの許容誤差。'GapTolerance' と非負のスカラーで構成されるコンマ区切りのペアとして指定します。

GapTolerance が 0 の場合、最適化収束の確認には、実行可能性ギャップの許容誤差を使用しません。

例: 'GapTolerance',1e-2

データ型: double | single

`IterationLimit` — 数値最適化反復の最大回数
`1e6` (既定値) | 正の整数

数値最適化反復の最大回数。'IterationLimit' と正の整数値で構成されるコンマ区切りのペアとして指定します。

最適化ルーチンが正常に収束したかどうかに関係なく、学習済みのモデルが返されます。Mdl.ConvergenceInfo に収束情報が格納されます。

例: 'IterationLimit',1e8

データ型: double | single

`KKTTolerance` — カルーシュ・キューン・タッカー相補性条件の違反許容誤差
非負のスカラー

KKT (カルーシュ・キューン・タッカー) 相補性条件の違反許容誤差。'KKTTolerance' と非負のスカラーで構成されるコンマ区切りのペアとして指定します。

KKTTolerance が 0 の場合、最適化収束の確認に実行可能性の KKT 相補性条件の違反許容誤差は使用されません。

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

ソルバーが SMO の場合 (たとえば、'Solver','SMO' を設定した場合など) は 0
ソルバーが ISDA の場合 (たとえば、'Solver','ISDA' を設定した場合など) は 1e-3

例: 'KKTTolerance',1e-2

データ型: double | single

`ShrinkagePeriod` — アクティブセットの縮小間の反復数
`0` (既定値) | 非負の整数

アクティブセットの縮小間の反復回数。'ShrinkagePeriod' と非負の整数から構成されるコンマ区切りのペアとして指定します。

'ShrinkagePeriod',0 を設定すると、アクティブセットは縮小されません。

例: 'ShrinkagePeriod',1000

データ型: double | single

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

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

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

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

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

メモ

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

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

BoxConstraint — fitcsvm は、既定では範囲 [1e-3,1e3] の対数スケールで、正の値を探索します。
KernelFunction — fitcsvm は、'gaussian'、'linear' および 'polynomial' で探索します。
KernelScale — fitcsvm は、既定では範囲 [1e-3,1e3] の対数スケールで、正の値を探索します。
PolynomialOrder — fitcsvm は、範囲 [2,4] の整数値を探索します。
Standardize — fitcsvm は、'true' と 'false' で探索します。

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

load fisheriris
params = hyperparameters('fitcsvm',meas,species);
params(1).Range = [1e-4,1e6];

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

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

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

この引数は 2 クラス学習に対してのみ有効です。

例: 'OptimizeHyperparameters','auto'

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

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

オプション	値	既定の設定
`Optimizer`	`"bayesopt"` — ベイズ最適化を使用。内部的には `bayesopt` が呼び出されます。 `"gridsearch"` — 次元ごとに `NumGridDivisions` の値があるグリッド探索を使用。`"gridsearch"` では、グリッドからの一様な非復元抽出により、無作為な順序で探索します。最適化後、`sortrows` 関数を使用してグリッド順の 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"`
`LossFun`	最適化する検証損失のタイプ。`"auto"`、`"classifcost"`、または `"classiferror"` として指定します。`fitcsvm` の場合、`"auto"` オプションと `"classiferror"` オプションは同じになり、どちらでも 10 進数の誤分類率が使用されます。`"classifcost"` は、観測誤分類コストを使用することを示します。	`"auto"`
`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.)` 列の値にそれぞれ対応しています。これらの値は、`SupervisedLearningBayesianOptimization` オブジェクトのプロパティ `ObjectiveMinimumTrace` および `EstimatedObjectiveMinimumTrace` で確認できます。問題にベイズ最適化の最適化パラメーターが 1 つまたは 2 つある場合、`ShowPlots` はパラメーターに対する目的関数のモデルもプロットします。	`true`
`SaveIntermediateResults`	最適化の結果を保存するかどうかを示す logical 値。このオプションが `true` の場合、`SupervisedLearningBayesoptResults` という名前のワークスペース変数が反復ごとに上書きされます。この変数は `SupervisedLearningBayesianOptimization` オブジェクトです。`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 より大きい整数

この引数は 2 クラス学習に対してのみ有効です。

例: HyperparameterOptimizationOptions=struct(MaxObjectiveEvaluations=60)

出力引数

`Mdl` — 学習済みの SVM 分類モデル
`ClassificationSVM` オブジェクト | `ClassificationPartitionedModel` オブジェクト | モデルオブジェクトの cell 配列

学習済みの SVM 分類モデル。ClassificationSVM オブジェクト、ClassificationPartitionedModel オブジェクト、またはモデルオブジェクトの cell 配列として返されます。

名前と値の引数 CrossVal、CVPartition、Holdout、KFold、Leaveout のいずれかを設定した場合、Mdl は ClassificationPartitionedModel オブジェクトになります。
OptimizeHyperparameters を指定して HyperparameterOptimizationOptions の ConstraintType オプションと ConstraintBounds オプションを設定している場合、Mdl はモデルオブジェクトの N 行 1 列の cell 配列になります。ここで、N は ConstraintBounds の行数と等しくなります。いずれの最適化問題からも実行可能なモデルが得られない場合、cell 配列の各値が [] になります。
それ以外の場合、Mdl は ClassificationSVM モデルオブジェクトになります。

モデルオブジェクトのプロパティを参照するには、ドット表記を使用します。

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

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

制限

fitcsvm は、1 クラスまたは 2 クラスの学習アプリケーションの場合に SVM 分類器に学習をさせます。クラスが 3 つ以上あるデータを使用して SVM 分類器を学習させるには、fitcecoc を使用します。
fitcsvm は、低～中次元のデータセットをサポートします。高次元データセットの場合は、代わりに fitclinear を使用してください。

詳細

ボックス制約

ボックス制約は、マージンに違反している観測値に課せられる最大ペナルティを制御するパラメーターであり、過適合の防止 (正則化) に役立ちます。

ボックス制約の値を大きくすると、SVM 分類器が割り当てるサポートベクターは少なくなります。ただし、ボックス制約の値を大きくすると、学習時間が長くなる場合があります。

グラム行列

n 個のベクトルの組 {x₁,..,x_n; x_j ∊ R^p} のグラム行列とは、n 行 n 列の行列で、要素 (j,k) は G(x_j,x_k) = <ϕ(x_j),ϕ(x_k)> (カーネル関数 ϕ を使用して変換された予測子の内積) として定義されます。

非線形 SVM の場合、予測子データ X の行を使用してグラム行列が形成されます。双対形式化により、X 内の観測値の内積が、形成されるグラム行列の対応する要素に置き換えられます ("カーネルトリック" と呼ばれます)。この結果、分離超平面を求めるために、変換された予測子空間で非線形 SVM が作用します。

カルーシュ・キューン・タッカー (KKT) 相補性条件

KKT 相補性条件は、最適な非線形計画法の解決に必要な最適化制約です。

SVM では、すべての j = 1,...,n についてKKT 相補性条件は次のようになります。

${\begin{cases} α_{j} [y_{j} f (x_{j}) - 1 + ξ_{j}] = 0 \\ ξ_{j} (C - α_{j}) = 0 \end{cases}$

ここで、 $f (x_{j}) = ϕ (x_{j})' β + b,$ であり、ϕ はカーネル関数 (グラム行列を参照)、ξ_j はスラック変数です。クラスが完全に可分な場合、すべての j = 1,...,n に対して ξ_j = 0 となります。

1 クラス学習

1 クラス学習 (教師なし SVM) は、(元の予測子空間ではない) 高次元予測子空間の原点からデータを分離することを目的としており、外れ値の検出に使用されるアルゴリズムです。

このアルゴリズムはバイナリ分類の SVM のアルゴリズムと類似しています。目的は、 $α_{1}, ..., α_{n}$ に関して次の双対式を最小化することです。

$0.5 \sum_{j k} α_{j} α_{k} G (x_{j}, x_{k})$

これには、すべての j = 1,...,n について $0 \leq α_{j} \leq 1$ と次の式を満たすという条件があります。

$\sum α_{j} = n ν$

G(x_j,x_k) の値は、グラム行列の要素 (j,k) です。

ν の値が小さいとサポートベクターが少なくなるので、判定境界は起伏が少なく柔軟性が低いものとなります。ν の値が大きいとサポートベクターが多くなるので、判定境界は起伏が多く柔軟性が高いものとなります。ν の最適値は、データの複雑さを取り込めるだけの大きさがあり、過学習が発生しない程度に小さい値です。また、0 < ν ≤ 1 です。

詳細については、[5]を参照してください。

サポートベクター

サポートベクターは、α₁,...,α_n の厳密に正の推定値に対応する観測値です。

特定の学習セットに対して生成されるサポートベクターが少ない SVM 分類器の方が推奨されます。

バイナリ分類のサポートベクターマシン

SVM バイナリ分類アルゴリズムでは、データを 2 つのクラスに分離する最適超平面が検索されます。クラスが可分な場合、最適超平面は周囲の "マージン" (観測値がない領域) を最大化します。これにより、陽性のクラスと陰性のクラスの境界が作成されます。クラスが不可分な場合でも目的は同じですが、クラスの境界の誤った側にあるすべての観測のマージンの長さに対し、アルゴリズムによりペナルティが課されます。

線形 SVM スコア関数は次のようになります。

$f (x) = x' β + b,$

ここで

x は観測値です (X の行に対応します)。
ベクトル β には超平面に直交するベクトルを定義する係数 (Mdl.Beta に対応) が含まれています。可分データの場合、最適なマージンの長さは $2 / ‖ β ‖ .$ です。
b は (Mdl.Bias に対応する) バイアス項です。

特定の係数に対する f(x) の根により超平面が定義されます。特定の超平面について、f(z) は点 z から超平面までの距離です。

このアルゴリズムでは、陽性 (y = 1) のクラスと陰性 (y = -1) のクラスを分離したままマージンの最大長を求めます。

可分クラスの場合、目的は β および b に関して $‖ β ‖$ を最小化することです。これには、すべての j = 1,..,n について y_jf(x_j) ≥ 1 という条件があります。これが可分クラスの "主" 問題の定式化です。
不可分クラスの場合、このアルゴリズムではスラック変数 (ξ_j) を使用して、クラスのマージン境界を超える観測値の目的関数にペナルティを課します。クラスのマージン境界を超えない観測値では ξ_j = 0 であり、そうでない場合は ξ_j ≥ 0 です。
目的は、β、b および ξ_j に関して $0.5 {‖ β ‖}^{2} + C \sum ξ_{j}$ を最小化することです。これには、すべての j = 1,..,n および正のスカラーボックス制約 C について $y_{j} f (x_{j}) \geq 1 - ξ_{j}$ および $ξ_{j} \geq 0$ という条件があります。これは不可分クラスの主問題の定式化です。

このアルゴリズムでは、ラグランジュ乗数法を使用して目的関数を最適化します。これにより、(Mdl.Alpha に対応する) n 個の係数 α₁,...,α_n が導入されます。線形 SVM の双対形式化は次のようになります。

可分クラスの場合、α₁,...,α_n に関して次の式を最小化します。

$0.5 \sum_{j = 1}^{n} \sum_{k = 1}^{n} α_{j} α_{k} y_{j} y_{k} x_{j}' x_{k} - \sum_{j = 1}^{n} α_{j}$
これには、すべての j = 1,...,n について $\sum α_{j} y_{j} = 0$ , α_j ≥ 0 という条件とカルーシュ・キューン・タッカー (KKT) 相補性条件が適用されます。
不可分クラスの場合、目的関数は可分クラスの場合と同じですが、すべての j = 1,..,n について $0 \leq α_{j} \leq C$ という条件が加わります。

生成されるスコア関数は次のようになります。

$\hat{f} (x) = \sum_{j = 1}^{n} {\hat{α}}_{j} y_{j} x' x_{j} + \hat{b} .$

$\hat{b}$ はバイアスの推定値、 ${\hat{α}}_{j}$ はベクトル $\hat{α}$ の j 番目の推定値です (j = 1,...,n)。このように記述すると、主問題を定式化した結果、スコア関数は β の推定値の影響を受けなくなります。

SVM アルゴリズムでは、 $sign (\hat{f} (z)) .$ を使用して新しい観測値 z を分類します。

場合によっては、非線形境界によってクラスが分離されます。"非線形 SVM" は変換済み予測子空間で、最適な分離超平面を検索します。

非線形 SVM の双対問題は、α₁,...,α_n に関して次のように定式化されます。

$0.5 \sum_{j = 1}^{n} \sum_{k = 1}^{n} α_{j} α_{k} y_{j} y_{k} G (x_{j}, x_{k}) - \sum_{j = 1}^{n} α_{j}$

これには、すべての j = 1,..,n について $\sum α_{j} y_{j} = 0$ , $0 \leq α_{j} \leq C$ という条件と KKT 相補性条件が適用されます。G (x_k,x_j) はグラム行列の要素です。生成されるスコア関数は次のようになります。

$\hat{f} (x) = \sum_{j = 1}^{n} {\hat{α}}_{j} y_{j} G (x, x_{j}) + \hat{b} .$

詳細については、サポートベクターマシンについて、[1]および[3]を参照してください。

ヒント

データセットが大規模でない限り、常に予測子を標準化してください (Standardize を参照してください)。標準化を行うと、予測子を測定するスケールの影響を受けなくなります。
名前と値のペアの引数 KFold を使用して交差検証を行うことをお勧めします。この交差検証の結果により、SVM 分類器の一般化の精度がわかります。
1 クラス学習では、以下のようになります。
- 名前と値のペアの引数 Alpha で既定の設定を使用すると、学習時間が長くなる場合があります。学習時間を短縮するには、主に 0 で構成されているベクトルに Alpha を設定します。
- 名前と値のペアの引数 Nu を 0 に近い値に設定すると、サポートベクターの個数が少なくなるので、判定境界は滑らかで大まかなものになります。
サポートベクターのスパース性は SVM 分類器の望ましい特性です。サポートベクターの数を少なくするには、BoxConstraint を大きい値に設定します。この場合、学習時間が長くなります。
学習時間を最適にするには、使用しているコンピューターで許容されるメモリの制限値まで CacheSize を大きくします。
サポートベクターの個数が学習セット内の観測値数よりはるかに少ないと考えられる場合、名前と値のペアの引数 'ShrinkagePeriod' を使用してアクティブセットを縮小すると、収束を大幅に高速化することができます。'ShrinkagePeriod',1000 を指定することをお勧めします。
判定境界から離れている重複する観測値は、収束に影響を与えません。しかし、重複する観測値が判定境界の近くに少しでもあると、収束が大幅に遅くなる可能性があります。収束を高速化するには、次の場合に 'RemoveDuplicates',true を指定します。
- 多数の重複する観測値がデータセットに含まれている。
- 少数の重複する観測値が判定境界の近くにあると考えられる。
学習時に元のデータセットを維持するため、fitcsvm は別々のデータセット、つまり元のデータセットおよび重複する観測値を除外したデータセットを一時的に格納しなければなりません。このため、重複がほとんど含まれていないデータセットの場合に true を指定すると、fitcsvm は元のデータの場合の 2 倍に近いメモリを消費します。
モデルに学習をさせた後で、新しいデータについてラベルを予測する C/C++ コードを生成できます。C/C++ コードの生成には MATLAB Coder™ が必要です。詳細については、統計と機械学習の関数のコード生成の紹介を参照してください。

アルゴリズム

SVM バイナリ分類アルゴリズムの数学的定式化については、バイナリ分類のサポートベクターマシンとサポートベクターマシンについてを参照してください。
NaN、<undefined>、空の文字ベクトル ('')、空の string ("")、および <missing> 値は、欠損値を示します。fitcsvm は、欠損応答に対応するデータ行全体を削除します。fitcsvm は、重みの合計を計算するときに (以下の項目を参照)、欠損している予測子が 1 つ以上ある観測値に対応する重みを無視します。これにより、平衡なクラスの問題で不平衡な事前確率が発生する可能性があります。したがって、観測値のボックス制約が BoxConstraint に等しくならない可能性があります。
名前と値の引数 Cost、Prior、および Weights を指定すると、出力モデルオブジェクトに Cost、Prior、および W の各プロパティの指定値がそれぞれ格納されます。Cost プロパティには、ユーザー指定のコスト行列 (C) が変更なしで格納されます。Prior プロパティと W プロパティには、正規化後の事前確率と観測値の重みがそれぞれ格納されます。モデルの学習用に、事前確率と観測値の重みが更新されて、コスト行列で指定されているペナルティが組み込まれます。詳細については、誤分類コスト行列、事前確率、および観測値の重みを参照してください。
名前と値の引数 Cost および Prior は 2 クラス学習用であることに注意してください。1 クラス学習の場合、Cost プロパティには 0、Prior プロパティには 1 が格納されます。
2 クラス学習の場合、fitcsvm は学習データの各観測値にボックス制約を割り当てます。観測値 j のボックス制約の式は、次のようになります。

$C_{j} = n C_{0} w_{j}^{*},$
ここで、C₀ は初期のボックス制約 (名前と値の引数 BoxConstraint を参照)、w_j^* は観測値 j の Cost と Prior で調整された観測値の重みです。観測値の重みの詳細については、誤分類コスト行列に応じた事前確率と観測値の重みの調整を参照してください。
Standardize を true として指定し、名前と値の引数 Cost、Prior、または Weights を設定した場合、fitcsvm は対応する加重平均および加重標準偏差を使用して予測子を標準化します。つまり、fitcsvm は、以下を使用して予測子 j (x_j) を標準化します。

$x_{j}^{*} = \frac{x_{j} - μ_{j}^{*}}{σ_{j}^{*}},$
ここで、x_jk は予測子 j (列) の観測値 k (行) であり、次のようになります。

$\begin{matrix} μ_{j}^{*} = \frac{1}{\sum_{k} w_{k}^{*}} \sum_{k} w_{k}^{*} x_{j k}, \\ {(σ_{j}^{*})}^{2} = \frac{v_{1}}{v_{1}^{2} - v_{2}} \sum_{k} w_{k}^{*} {(x_{j k} - μ_{j}^{*})}^{2}, \\ v_{1} = \sum_{j} w_{j}^{*}, \\ v_{2} = \sum_{j} {(w_{j}^{*})}^{2} . \end{matrix}$
p は学習データで予期される外れ値の比率であり、'OutlierFraction',p を設定したと仮定します。
- 1 クラス学習では、バイアス項の学習により、学習データの観測値のうち 100p% が負のスコアをもつようになります。
- 2 クラス学習では "ロバスト学習" が行われます。この方式では、最適化アルゴリズムが収束すると、観測値のうち 100p% の削除が試行されます。削除された観測値は、勾配の大きいものに対応します。
予測子データにカテゴリカル変数が含まれている場合、一般にこれらの変数について完全なダミーエンコードが使用されます。各カテゴリカル変数の各レベルについて、1 つずつダミー変数が作成されます。
- PredictorNames プロパティには、元の予測子変数名のそれぞれについて 1 つずつ要素が格納されます。たとえば、3 つの予測子があり、そのうちの 1 つは 3 つのレベルがあるカテゴリカル変数であるとします。この場合、PredictorNames は元の予測子変数名が含まれている 1 行 3 列の文字ベクトルの cell 配列になります。
- ExpandedPredictorNames プロパティには、ダミー変数を含む予測子変数のそれぞれについて 1 つずつ要素が格納されます。たとえば、3 つの予測子があり、そのうちの 1 つは 3 つのレベルがあるカテゴリカル変数であるとします。この場合、ExpandedPredictorNames は予測子変数および新しいダミー変数の名前が含まれている 1 行 5 列の文字ベクトルの cell 配列になります。
- 同様に、Beta プロパティには、ダミー変数を含む各予測子について 1 つずつベータ係数が格納されます。
- SupportVectors プロパティには、ダミー変数を含むサポートベクターの予測子の値が格納されます。たとえば、m 個のサポートベクターと 3 つの予測子があり、そのうちの 1 つは 3 つのレベルがあるカテゴリカル変数であるとします。この場合、SupportVectors は n 行 5 列の行列になります。
- X プロパティには、はじめに入力されたときの状態で学習データが格納され、ダミー変数は含まれません。入力が table の場合、X には予測子として使用した列のみが格納されます。
table で予測子を指定した場合、いずれかの変数に順序付きのカテゴリが含まれていると、これらの変数について順序付きエンコードが使用されます。
- k 個の順序付きレベルが変数に含まれている場合、k – 1 個のダミー変数が作成されます。j 番目のダミー変数は、j までのレベルについては –1、j + 1 から k までのレベルについては +1 になります。
- ExpandedPredictorNames プロパティに格納されるダミー変数の名前は 1 番目のレベルを示し、値は +1 になります。レベル 2, 3, ..., k の名前を含む k – 1 個の追加予測子名がダミー変数について格納されます。
どのソルバーも L1 ソフトマージン最小化を実装します。
1 クラス学習の場合、次の条件を満たすラグランジュ乗数 α₁,...,α_n が推定されます。

$\sum_{j = 1}^{n} α_{j} = n ν .$

代替機能

異常検出用の 1 クラス SVM モデルの学習には、関数 ocsvm も使用できます。

関数 ocsvm は、関数 fitcsvm よりも簡単で推奨される異常検出用のワークフローを提供します。
- 関数 ocsvm は、OneClassSVM オブジェクト、異常インジケーター、および異常スコアを返します。その出力を使用して学習データの異常を特定できます。新規のデータの異常を見つけるには、OneClassSVM のオブジェクト関数 isanomaly を使用できます。関数 isanomaly は、新規データの異常インジケーターおよびスコアを返します。
- 関数 fitcsvm は、1 クラスとバイナリの両方の分類をサポートします。クラスラベル変数に 1 つしかクラスが含まれていない場合 (1 のベクトルの場合など)、fitcsvm は 1 クラス分類用にモデルを学習させ、ClassificationSVM オブジェクトを返します。異常を特定するには、最初に ClassificationSVM のオブジェクト関数 resubPredict または predict を使用して異常スコアを計算してから、負のスコアをもつ観測値を探して異常を特定する必要があります。
- ocsvm では大きい正の異常スコアが異常を示すのに対し、ClassificationSVM の predict では負のスコアが異常を示すことに注意してください。
関数 ocsvm は SVM の主問題形式に基づいて判定境界を求めるのに対し、関数 fitcsvm は SVM の双対問題形式に基づいて判定境界を求めます。
大規模な (n が大きい) データセットについては、ocsvm のソルバーの方が fitcsvm のソルバーよりも計算量が少なくなります。fitcsvm のソルバーでは n 行 n 列のグラム行列の計算が必要ですが、ocsvm のソルバーで必要なのは n 行 m 列の行列の形成だけです。ここで、m は拡張空間の次元数であり、ビッグデータにおいては一般に n よりもはるかに小さくなります。

参照

[1] Christianini, N., and J. C. Shawe-Taylor. An Introduction to Support Vector Machines and Other Kernel-Based Learning Methods. Cambridge, UK: Cambridge University Press, 2000.

[2] Fan, R.-E., P.-H. Chen, and C.-J. Lin. “Working set selection using second order information for training support vector machines.” Journal of Machine Learning Research, Vol. 6, 2005, pp. 1889–1918.

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

[4] Kecman V., T. -M. Huang, and M. Vogt. “Iterative Single Data Algorithm for Training Kernel Machines from Huge Data Sets: Theory and Performance.” Support Vector Machines: Theory and Applications. Edited by Lipo Wang, 255–274. Berlin: Springer-Verlag, 2005.

[5] Scholkopf, B., J. C. Platt, J. C. Shawe-Taylor, A. J. Smola, and R. C. Williamson. “Estimating the Support of a High-Dimensional Distribution.” Neural Comput., Vol. 13, Number 7, 2001, pp. 1443–1471.

[6] Scholkopf, B., and A. Smola. Learning with Kernels: Support Vector Machines, Regularization, Optimization and Beyond, Adaptive Computation and Machine Learning. Cambridge, MA: The MIT Press, 2002.

拡張機能

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

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

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

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

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

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

1 クラス分類はサポートされていません。ラベルには 2 つの異なるクラスが含まれていなければなりません。
名前と値の引数 KernelFunction をカスタムカーネル関数として指定することはできません。
名前と値の引数 Solver は、"SMO" としてのみ指定できます。
名前と値の引数 OutlierFraction または ShrinkagePeriod は指定できません。
予測子データに無限値を含めることはできません。
fitcsvm は、次のいずれかに該当する場合に GPU でモデルを当てはめます。
- 入力引数 X が gpuArray オブジェクトである。
- 入力引数 Tbl に gpuArray 予測子変数が含まれている。

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

バージョン履歴

R2014a で導入