이진 분류를 위한 서포트 벡터 머신

서포트 벡터 머신 이해하기

분리 가능한 데이터
분리가 불가능한 데이터
커널을 사용한 비선형 변환

분리 가능한 데이터

데이터가 정확히 두 개의 클래스를 가지는 경우 서포트 벡터 머신(SVM)을 사용할 수 있습니다. SVM은 두 개의 클래스를 구분하는 최적의 초평면을 찾음으로써 데이터를 분류합니다. SVM에서 최적의 초평면이란 두 클래스 간에 최대의 마진을 갖는 초평면을 의미합니다. 마진은 내부 데이터 점이 없는 초평면에 평행인 슬래브(Slab)의 최대 너비를 의미합니다.

서포트 벡터는 분리 초평면에 가장 가까운 데이터 점입니다. 이러한 점은 슬래브의 경계상에 존재합니다. 다음 그림은 이러한 정의를 시각적으로 보여줍니다. 여기서 +는 유형 1의 데이터 점을 나타내며 -는 유형 -1의 데이터 점을 나타냅니다.

SVM components including support vectors, hyperplane, and margin

수학적 정식화: 원문제(Primal). 아래 논의는 Hastie, Tibshirani, Friedman [1]과 Christianini, Shawe-Taylor [2]의 설명을 따릅니다.

훈련 데이터는 점 집합(벡터) x_j와 점 집합의 범주 y_j입니다. 일부 차원 d의 경우 x_j ∊ R^d이고 y_j = ±1입니다. 초평면의 방정식은 다음과 같습니다.

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

여기서 β ∊ R^d이고 b는 실수입니다.

다음 문제는 가장 적합한 분리 초평면(즉, 결정 경계)을 정의합니다. 모든 데이터 점 (x_j,y_j)에 대해 다음이 성립하는 ||β||를 최소화하는 β와 b를 구합니다.

$y_{j} f (x_{j}) \geq 1.$

서포트 벡터는 경계상에 존재하며 $y_{j} f (x_{j}) = 1.$ 을 충족하는 x_j입니다.

수학적 편의를 위해 이 문제는 일반적으로 $‖ β ‖$ 를 최소화하는 문제와 동일한 문제로 지정됩니다. 이는 2차 계획법 문제입니다. 최적해 $(\hat{β}, \hat{b})$ 를 통해 다음과 같이 벡터 z의 분류를 수행할 수 있습니다.

$class (z) = sign (z' \hat{β} + \hat{b}) = sign (\hat{f} (z)) .$

$\hat{f} (z)$ 는 분류 점수이고 z가 결정 경계로부터 떨어진 거리를 나타냅니다.

수학적 정식화: 쌍대 문제(Dual). 쌍대 2차 계획법 문제를 푸는 것이 계산량 측면에서 더 간단합니다. 쌍대 문제를 얻으려면 양의 라그랑주 승수 α_j에 각 제약 조건을 곱한 값을 취한 후 목적 함수에서 뺍니다.

$L_{P} = \frac{1}{2} β' β - \sum_{j} α_{j} (y_{j} (x_{j}' β + b) - 1),$

여기서는 β와 b에 대한 L_P의 정상점을 찾습니다. L_P의 기울기를 0으로 설정하면 다음을 얻게 됩니다.

\begin{matrix} β = \sum_{j} α_{j} y_{j} x_{j} \\ 0 = \sum_{j} α_{j} y_{j} . \end{matrix}

(1)

L_P에 대입하면 쌍대 문제 L_D를 얻게 됩니다.

$L_{D} = \sum_{j} α_{j} - \frac{1}{2} \sum_{j} \sum_{k} α_{j} α_{k} y_{j} y_{k} x_{j}' x_{k},$

여기서는 α_j ≥ 0에 대해 최대화합니다. 일반적으로, 많은 α_j는 최대 0입니다. 쌍대 문제의 해에서 0이 아닌 α_j는 수식 1에 표시된 대로 초평면을 정의하고, α_jy_jx_j의 합으로 β를 반환합니다. 0이 아닌 α_j에 대응하는 데이터 점 x_j가 서포트 벡터입니다.

0이 아닌 α_j에 대한 L_D의 도함수의 최적값은 0입니다. 이로부터 다음을 얻을 수 있습니다.

$y_{j} f (x_{j}) - 1 = 0.$

특히 이 경우, 0이 아닌 α_j를 갖는 j를 이용하여 해에서 b의 값을 구할 수 있습니다.

쌍대 문제는 표준 2차 계획법 문제입니다. 일례로 Optimization Toolbox™의 quadprog (Optimization Toolbox) 솔버는 이러한 유형의 문제에 대한 해를 구합니다.

분리가 불가능한 데이터

데이터가 분리 초평면에 잘 맞지 않을 수 있습니다. 이 경우, SVM은 소프트 마진(Soft Margin)을 사용할 수 있습니다. 이는 모든 데이터 점은 아니지만 많은 데이터 점을 분리하는 초평면을 의미합니다.

소프트 마진에 대한 표준적인 정식화로는 다음 두 가지가 있습니다. 두 공식 모두 여유 변수 ξ_j와 벌점 모수 C를 가집니다.

L¹-노름(Norm) 문제는 다음과 같습니다.
$\min_{β, b, ξ} (\frac{1}{2} β' β + C \sum_{j} ξ_{j})$
조건
$\begin{matrix} y_{j} f (x_{j}) \geq 1 - ξ_{j} \\ ξ_{j} \geq 0. \end{matrix}$
ξ_j를 제곱 대신 여유 변수로 사용하면 L¹-노름인 것입니다. fitcsvm의 세 가지 솔버 옵션 SMO, ISDA, L1QP는 L¹-노름 문제를 최소화합니다.
L²-노름 문제는 다음과 같습니다.
$\min_{β, b, ξ} (\frac{1}{2} β' β + C \sum_{j} ξ_{j}^{2})$
동일한 제약 조건이 적용됩니다.

이러한 정식화에서는 C를 늘리면 여유 변수 ξ_j에 더 많은 가중치가 적용된다는 것을 알 수 있습니다. 즉, 최적화가 클래스 간에 더 엄격한 분리를 수행하려 한다는 것을 알 수 있습니다. 이와 마찬가지로, C의 크기가 작아지면 오분류에 대한 중요성은 낮아집니다.

수학적 정식화: 쌍대 문제(Dual). 더 손쉬운 계산 방법을 알아보기 위해 이 소프트 마진 정식화에 대한 L¹ 쌍대 문제가 있다고 가정해 보겠습니다. 라그랑주 승수 μ_j를 사용하여 L¹-노름(Norm) 문제에 대한 최소화할 함수는 다음과 같습니다.

$L_{P} = \frac{1}{2} β' β + C \sum_{j} ξ_{j} - \sum_{j} α_{j} (y_{i} f (x_{j}) - (1 - ξ_{j})) - \sum_{j} μ_{j} ξ_{j},$

여기서는 β, b, 양의 ξ_j에 대한 L_P의 정상점을 찾습니다. L_P의 기울기를 0으로 설정하면 다음을 얻게 됩니다.

$\begin{matrix} β = \sum_{j} α_{j} y_{j} x_{j} \\ \sum_{j} α_{j} y_{j} = 0 \\ α_{j} = C - μ_{j} \\ α_{j}, μ_{j}, ξ_{j} \geq 0. \end{matrix}$

이러한 방정식으로부터 다음 쌍대 문제 식을 바로 얻을 수 있습니다.

$\max_{α} \sum_{j} α_{j} - \frac{1}{2} \sum_{j} \sum_{k} α_{j} α_{k} y_{j} y_{k} x_{j}' x_{k}$

이때 제약 조건은 다음과 같습니다.

$\begin{array}{l} \sum_{j} y_{j} α_{j} = 0 \\ 0 \leq α_{j} \leq C . \end{array}$

마지막 부등식 0 ≤ α_j ≤ C는 C가 상자 제약 조건인 이유를 보여줍니다. C는 라그랑주 승수 α_j의 허용 값을 “상자”의 내부, 즉 경계 영역 내로 유지합니다.

b에 대한 기울기 방정식은 서포트 벡터에 대응되는 0이 아닌 α_j의 세트로 해 b를 제공합니다.

유사한 방식으로 L²-노름 문제의 쌍대 문제를 작성하고 이에 대한 해를 구할 수 있습니다. 자세한 내용은 Christianini, Shawe-Taylor [2](6장)을 참조하십시오.

fitcsvm 구현. 두 쌍대 소프트 마진 문제 모두 2차 계획법 문제입니다. 내부적으로, fitcsvm은 문제에 대한 해를 구하는 데 사용할 수 있는 여러 다양한 알고리즘을 가집니다.

단일 클래스나 이진 분류의 경우, 데이터에서 예상되는 이상값에 대한 비율(OutlierFraction 참조)을 설정하지 않으면 디폴트 솔버로 순차적 최소규모 최적화(SMO)가 사용됩니다. SMO는 일련의 2점 최소화를 통해 1-노름 문제를 최소화합니다. 최적화를 수행하는 동안 SMO는 선형 제약 조건 $\sum_{i} α_{i} y_{i} = 0,$ 을 따르고 모델에 편향 항을 명시적으로 포함시킵니다. SMO는 비교적 빠릅니다. SMO에 대한 자세한 내용은 [3] 항목을 참조하십시오.
이진 분류의 경우, 데이터에서 예상되는 이상값에 대한 비율을 설정하면 디폴트 솔버로 반복 단일 데이터 알고리즘(ISDA)이 사용됩니다. SMO와 마찬가지로, ISDA는 1-노름 문제의 해를 구합니다. SMO와 달리, ISDA는 일련의 1점 최소화를 통해 최소화하며, 선형 제약 조건을 따르지 않고, 모델에 편향 항을 명시적으로 포함시키지도 않습니다. ISDA에 대한 자세한 내용은 [4] 항목을 참조하십시오.
단일 클래스 또는 이진 분류의 경우 Optimization Toolbox 라이선스를 가지고 있으면 quadprog (Optimization Toolbox)를 사용하여 1-노름 문제의 해를 구해 볼 수 있습니다. quadprog는 메모리를 많이 사용하지만, 높은 정밀도로 2차 계획법의 해를 구합니다. 자세한 내용은 2차 계획법 정의 (Optimization Toolbox) 항목을 참조하십시오.

커널을 사용한 비선형 변환

일부 이진 분류 문제의 경우, 명확한 분류 기준이 되는 단순한 초평면이 존재하지 않습니다. 이러한 문제를 위해 SVM 분리 초평면의 단순성을 거의 유지하는 수학적 접근 방법의 변형이 존재합니다.

이 접근 방법은 재생 커널 이론에서 나온 다음과 같은 결과를 사용합니다.

다음 속성을 갖는 함수 G(x₁,x₂) 클래스가 있습니다. 선형 공간 S와, 다음 조건에 따라 x를 S로 매핑하는 함수 φ가 있습니다.
G(x₁,x₂) = <φ(x₁),φ(x₂)>. (2)
내적은 공간 S에서 수행됩니다.
이 함수 클래스는 다음을 포함합니다.
- 다항식: 양의 정수 p에 대해 다음과 같습니다.
  G(x₁,x₂) = (1 + x₁′x₂)^p. (3)
- 방사형 기저 함수(가우스):
  G(x₁,x₂) = exp(–∥x₁–x₂∥²). (4)
- 다층 퍼셉트론 또는 시그모이드(신경망): 양수 p₁과 음수 p₂에 대해 다음과 같습니다.
  G(x₁,x₂) = tanh(p₁x₁′x₂ + p₂). (5)
  참고
  p₁과 p₂의 일부 세트는 유효한 재생 커널을 생성하지 않습니다.
  fitcsvm은 시그모이드 커널을 지원하지 않습니다. 대신, 'KernelFunction' 이름-값 쌍의 인수를 사용하여 시그모이드 커널을 정의하고 지정할 수 있습니다. 자세한 내용은 사용자 지정 커널을 사용하여 SVM 분류기 훈련시키기 항목을 참조하십시오.

커널을 사용하는 수학적 접근 방법은 초평면의 계산 방법에 따라 달리집니다. 초평면 분류의 모든 계산은 내적만 사용합니다. 따라서, 비선형 커널에서 동일한 계산과 해 알고리즘을 사용하여 비선형 분류기를 얻을 수 있습니다. 결과로 생성되는 분류기는 특정 공간 S에 있는 초곡면이지만 공간 S를 식별하거나 검토할 필요는 없습니다.

서포트 벡터 머신 사용하기

지도 학습 모델과 마찬가지로, 먼저 서포트 벡터 머신을 훈련시킨 후 분류기를 교차 검증해야 합니다. 훈련된 머신을 사용하여 새 데이터를 분류(예측)합니다. 또한, 만족스러운 예측 정확도를 얻기 위해 다양한 SVM 커널 함수를 사용할 수 있으며, 이 경우 커널 함수의 모수를 조정해야 합니다.

SVM 분류기 훈련시키기
SVM 분류기로 새 데이터 분류하기
SVM 분류기 조정하기

SVM 분류기 훈련시키기

fitcsvm을 사용하여 SVM 분류기를 훈련시키고 필요한 경우 교차 검증합니다. 가장 일반적인 구문은 다음과 같습니다.

SVMModel = fitcsvm(X,Y,'KernelFunction','rbf',...
    'Standardize',true,'ClassNames',{'negClass','posClass'});

입력값은 다음과 같습니다.

X — 예측 변수 데이터로 구성된 행렬입니다(여기서 각 행은 하나의 관측값이고, 각 열은 하나의 예측 변수임).
Y — 클래스 레이블로 구성된 배열로 각 행이 X의 행 값에 대응합니다. Y는 categorical형 배열, 문자형 배열, string형 배열, 논리형 벡터 또는 숫자형 벡터, 또는 문자형 벡터로 구성된 셀형 배열일 수 있습니다.
KernelFunction — 2-클래스 학습의 경우 디폴트 값은 'linear'입니다. 이는 데이터를 초평면으로 분리합니다. 값 'gaussian'(또는 'rbf')은 단일 클래스 학습인 경우 디폴트 값이며, 가우스(또는 방사형 기저 함수) 커널을 사용하도록 지정합니다. SVM 분류기를 성공적으로 훈련시키기 위한 중요한 단계는 적합한 커널 함수를 선택하는 것입니다.
Standardize — 분류기를 훈련시키기 전에 소프트웨어가 예측 변수를 표준화해야 할지 여부를 나타내는 플래그입니다.
ClassNames — 음성 클래스와 양성 클래스 간을 구분하거나 데이터에 포함시킬 클래스를 지정합니다. 음성 클래스는 첫 번째 요소(또는 문자형 배열의 행), 즉, 'negClass'이고 양성 클래스는 두 번째 요소(또는 문자형 배열의 행), 즉, 'posClass'입니다. ClassNames는 Y와 같은 데이터형이어야 합니다. 특히, 다른 분류기의 성능을 비교하는 경우 클래스 이름을 지정하는 것이 좋습니다.

결과로 생성되는 훈련된 모델(SVMModel)은 SVM 알고리즘을 통해 최적화된 모수를 포함합니다. 이를 통해 새 데이터를 분류할 수 있습니다.

훈련을 제어하는 데 사용할 수 있는 추가 이름-값 쌍은 fitcsvm 함수 도움말 페이지를 참조하십시오.

SVM 분류기로 새 데이터 분류하기

predict를 사용하여 새 데이터를 분류합니다. 훈련된 SVM 분류기(SVMModel)를 사용하여 새 데이터를 분류하는 구문은 다음과 같습니다.

[label,score] = predict(SVMModel,newX);

결과로 생성되는 벡터 label은 X의 각 행에 대한 분류를 나타냅니다. score는 소프트 점수로 구성된 n×2 행렬입니다. 각 행은 새 관측값 X의 행에 대응됩니다. 첫 번째 열에는 음성 클래스로 분류되는 관측값의 점수가 포함되고, 두 번째 열에는 양성 클래스로 분류되는 관측값의 점수가 포함됩니다.

점수가 아니라 사후 확률을 추정하려면, 훈련된 SVM 분류기(SVMModel)를 먼저 fitPosterior에 전달해야 합니다. 이 함수는 점수-사후 확률 변환 함수를 점수에 피팅합니다. 구문은 다음과 같습니다.

ScoreSVMModel = fitPosterior(SVMModel,X,Y);

분류기 ScoreSVMModel의 속성 ScoreTransform은 최적의 변환 함수를 포함합니다. ScoreSVMModel을 predict로 전달합니다. 점수를 반환하는 대신, 출력 인수 score는 음성 클래스(score의 1열) 또는 양성 클래스(score의 2열)로 분류되는 관측값의 사후 확률을 포함합니다.

SVM 분류기 조정하기

fitcsvm의 'OptimizeHyperparameters' 이름-값 쌍의 인수를 사용하여 교차 검증 손실을 최소화하는 모수 값을 구할 수 있습니다. 적합한 모수는 'BoxConstraint', 'KernelFunction', 'KernelScale', 'PolynomialOrder', 'Standardize'입니다. 예제는 베이즈 최적화를 사용하여 분류기 피팅 최적화하기 항목을 참조하십시오. 또는, bayesopt를 사용하여 교차 검증된 분류기 최적화하기에 나와 있는 것처럼 bayesopt 함수를 사용할 수도 있습니다. bayesopt 함수를 사용하면 더욱 유연한 사용자 지정 최적화를 구현할 수 있습니다. bayesopt 함수를 사용할 경우, fitcsvm 함수를 사용할 때는 최적화할 수 없는 모수를 포함하여 모든 모수를 최적화할 수 있습니다.

다음 방식에 따라 분류기의 모수를 수동으로 조정해 볼 수도 있습니다.

데이터를 fitcsvm으로 전달하고 이름-값 쌍의 인수 'KernelScale','auto'를 설정합니다. 훈련된 SVM 모델을 SVMModel이라고 한다고 가정합니다. 소프트웨어는 발견적(heuristic) 절차에 따라 커널 스케일을 선택합니다. 발견적 절차는 부표본추출을 사용합니다. 따라서 결과를 재현하려면 분류기를 훈련시키기 전에 rng를 사용하여 난수 시드값을 설정하십시오.
분류기를 crossval로 전달하여 교차 검증합니다. 기본적으로, 소프트웨어는 10겹 교차 검증을 수행합니다.
교차 검증된 SVM 모델을 kfoldLoss로 전달하여 분류 오차를 추정하고 유지합니다.
SVM 분류기를 유지하되, 'KernelScale' 및 'BoxConstraint' 이름-값 쌍의 인수를 조정합니다.
- BoxConstraint — 한 가지 전략은 상자 제약 조건 모수의 등비 수열을 사용해 보는 것입니다. 예를 들어, 인자 10으로 1e-5부터 1e5까지 11개 값을 취합니다. BoxConstraint를 늘리면 서포트 벡터의 개수가 줄어들 수 있지만, 훈련 시간이 늘어날 수도 있습니다.
- KernelScale — 한 가지 전략은 원래 커널 스케일로 스케일링된 RBF 시그마 모수의 등비 수열을 사용해 보는 것입니다. 다음과 같은 방법으로 이 작업을 수행합니다.
  1. 점 표기법을 사용하여 원래 커널 스케일 즉, ks를 가져옵니다(ks = SVMModel.KernelParameters.Scale).
  2. 원래 커널 스케일에 대한 새 스케일링 인자를 사용합니다. 예를 들어, 인자 10을 사용하여 ks에 1e-5에서 1e5까지 11개 값을 곱합니다.

가장 낮은 분류 오차를 생성하는 모델을 선택합니다. 정확도를 더 향상시키기 위해 모수를 추가로 미세 조정해야 할 수 있습니다. 초기 모수로 시작하고, 이번에는 인자 1.2를 사용하여 또 다른 교차 검증 단계를 수행합니다.

가우스 커널을 사용하여 SVM 분류기를 훈련시키기

라이브 스크립트 열기

이 예제에서는 가우스 커널 함수를 사용하여 비선형 분류기를 생성하는 방법을 보여줍니다. 먼저, 2차원 단위 원판 내부의 점들로 하나의 클래스를 구성하고 반지름 1에서 반지름 2까지의 원환에 포함된 점들로 또 하나의 클래스를 구성합니다. 그런 다음, 가우스 방사형 기저 함수 커널을 사용하여 데이터를 기준으로 분류기를 생성합니다. 모델이 대칭 원형이기 때문에 디폴트 선형 분류기는 이 문제에 부적합합니다. 상자 제약 조건 모수를 Inf로 설정하여 오분류되는 훈련 점이 없는 엄격한 분류를 합니다. 다른 커널 함수는 엄격한 분류를 제공하지 못할 수 있으므로 이러한 엄격한 상자 제약 조건에서 동작하지 않을 수 있습니다. rbf 분류기가 클래스를 분리할 수 있는 경우에도 결과가 과잉훈련될 수 있습니다.

반지름이 1인 단위 원판 내부에 균등 분포된 100개의 점을 생성합니다. 반지름 r을 균등 확률 변수의 제곱근으로 생성하고, 각도 t를 (0, $2 π$ ) 범위에서 균등하게 생성하여 데이터 점을 (r cos(t), r sin(t))에 배치하면 됩니다.

rng(1); % For reproducibility
r = sqrt(rand(100,1)); % Radius
t = 2*pi*rand(100,1);  % Angle
data1 = [r.*cos(t), r.*sin(t)]; % Points

원환에 균등분포된 100개 점을 생성합니다. 반지름이 제곱근에 비례하지만, 이번에는 1부터 4 사이 균등분포된 제곱근에 비례합니다.

r2 = sqrt(3*rand(100,1)+1); % Radius
t2 = 2*pi*rand(100,1);      % Angle
data2 = [r2.*cos(t2), r2.*sin(t2)]; % Points

점을 플로팅하고, 비교를 위해 반지름 1과 반지름 2를 사용한 원을 플로팅합니다.

figure
plot(data1(:,1),data1(:,2),"r.","MarkerSize",15)
hold on
plot(data2(:,1),data2(:,2),"b.","MarkerSize",15)
fplot(@(t)sin(t),@(t)cos(t))
fplot(@(t)2*sin(t),@(t)2*cos(t))
axis equal
hold off

Figure contains an axes object. The axes object contains 4 objects of type line, parameterizedfunctionline. One or more of the lines displays its values using only markers

한 행렬에 두 데이터를 모두 할당하고, 분류 벡터를 생성합니다.

data3 = [data1;data2];
theclass = ones(200,1);
theclass(1:100) = -1;

KernelFunction을 "rbf"로 설정하고 BoxConstraint를 Inf로 설정하여 SVM 분류기를 훈련시킵니다. 결정 경계를 플로팅하고 서포트 벡터에 플래그를 지정합니다.

% Train the SVM classifier
cl = fitcsvm(data3,theclass,"KernelFunction","rbf", ...
    "BoxConstraint",Inf,"ClassNames",[-1 1]);

% Predict scores over the grid
d = 0.02;
[x1Grid,x2Grid] = meshgrid(min(data3(:,1)):d:max(data3(:,1)), ...
    min(data3(:,2)):d:max(data3(:,2)));
xGrid = [x1Grid(:),x2Grid(:)];
[~,scores] = predict(cl,xGrid);

% Plot the data and the decision boundary
figure
h(1:2) = gscatter(data3(:,1),data3(:,2),theclass,"rb",".");
hold on
fplot(@(t)sin(t),@(t)cos(t))
h(3) = plot(data3(cl.IsSupportVector,1),data3(cl.IsSupportVector,2),"ko");
contour(x1Grid,x2Grid,reshape(scores(:,2),size(x1Grid)),[0 0],"k")
legend(h,["-1","+1","Support Vectors"])
axis equal
hold off

Figure contains an axes object. The axes object contains 5 objects of type line, parameterizedfunctionline, contour. One or more of the lines displays its values using only markers These objects represent -1, +1, Support Vectors.

fitcsvm은 반지름이 1인 원에 가까운 분류기를 생성합니다. 훈련 데이터가 무작위 데이터라 차이가 발생하고 있습니다.

디폴트 모수로 훈련시키는 경우 더 근접한 원형 분류 경계가 생성되지만, 이는 일부 훈련 데이터를 오분류합니다. 또한, BoxConstraint의 디폴트 값이 1이어서 서포트 벡터가 더 많이 생성됩니다.

cl2 = fitcsvm(data3,theclass,"KernelFunction","rbf");
[~,scores2] = predict(cl2,xGrid);

figure
h(1:2) = gscatter(data3(:,1),data3(:,2),theclass,"rb",".");
hold on
fplot(@(t)sin(t),@(t)cos(t))
h(3) = plot(data3(cl2.IsSupportVector,1),data3(cl2.IsSupportVector,2),"ko");
contour(x1Grid,x2Grid,reshape(scores2(:,2),size(x1Grid)),[0 0],"k")
legend(h,["-1","+1","Support Vectors"])
axis equal
hold off

사용자 지정 커널을 사용하여 SVM 분류기 훈련시키기

스크립트 열기

이 예제에서는 시그모이드 커널과 같은 사용자 지정 커널 함수를 사용하여 SVM 분류기를 훈련시키고 사용자 지정 커널 함수 모수를 조정하는 방법을 보여줍니다.

단위원 내부 임의의 점으로 구성된 집합을 생성합니다. 제1사분면과 제3사분면의 점은 양성 클래스에 속하는 것으로 레이블을 지정하고 제2사분면과 제4사분면의 점은 음성 클래스에 속하는 것으로 레이블을 지정합니다.

rng(1);  % For reproducibility
n = 100; % Number of points per quadrant

r1 = sqrt(rand(2*n,1));                     % Random radii
t1 = [pi/2*rand(n,1); (pi/2*rand(n,1)+pi)]; % Random angles for Q1 and Q3
X1 = [r1.*cos(t1) r1.*sin(t1)];             % Polar-to-Cartesian conversion

r2 = sqrt(rand(2*n,1));
t2 = [pi/2*rand(n,1)+pi/2; (pi/2*rand(n,1)-pi/2)]; % Random angles for Q2 and Q4
X2 = [r2.*cos(t2) r2.*sin(t2)];

X = [X1; X2];        % Predictors
Y = ones(4*n,1);
Y(2*n + 1:end) = -1; % Labels

데이터를 플로팅합니다.

figure;
gscatter(X(:,1),X(:,2),Y);
title('Scatter Diagram of Simulated Data')

특징 공간의 두 행렬을 입력값으로 받아 시그모이드 커널을 사용하여 이 입력값을 그람 행렬(Gram matrix)로 변환하는 함수를 작성합니다.

function G = mysigmoid(U,V)
% Sigmoid kernel function with slope gamma and intercept c
gamma = 1;
c = -1;
G = tanh(gamma*U*V' + c);
end

이 코드를 MATLAB® 경로에 mysigmoid라는 파일로 저장합니다.

시그모이드 커널 함수를 사용하여 SVM 분류기를 훈련시킵니다. 데이터를 표준화하는 것이 좋습니다.

Mdl1 = fitcsvm(X,Y,'KernelFunction','mysigmoid','Standardize',true);

Mdl1은 추정된 모수를 포함하는 ClassificationSVM 분류기입니다.

데이터를 플로팅하고 서포트 벡터와 결정 경계를 식별합니다.

    % Compute the scores over a grid
d = 0.02; % Step size of the grid
[x1Grid,x2Grid] = meshgrid(min(X(:,1)):d:max(X(:,1)),...
    min(X(:,2)):d:max(X(:,2)));
xGrid = [x1Grid(:),x2Grid(:)];        % The grid
[~,scores1] = predict(Mdl1,xGrid); % The scores

figure;
h(1:2) = gscatter(X(:,1),X(:,2),Y);
hold on
h(3) = plot(X(Mdl1.IsSupportVector,1),...
    X(Mdl1.IsSupportVector,2),'ko','MarkerSize',10);
    % Support vectors
contour(x1Grid,x2Grid,reshape(scores1(:,2),size(x1Grid)),[0 0],'k');
    % Decision boundary
title('Scatter Diagram with the Decision Boundary')
legend({'-1','1','Support Vectors'},'Location','Best');
hold off

분류의 정확도를 향상시키기 위하여, 커널 모수를 조정할 수 있습니다. 이렇게 하면 표본내 오분류율을 줄일 수도 있지만, 우선 표본외 오분류율을 확인해야 합니다.

10겹 교차 검증을 사용하여 표본외 오분류율을 확인합니다.

CVMdl1 = crossval(Mdl1);
misclass1 = kfoldLoss(CVMdl1);
misclass1

misclass1 =

    0.1350

표본외 오분류율은 13.5%입니다.

다른 시그모이드 함수를 작성하되, gamma = 0.5;를 설정합니다.

function G = mysigmoid2(U,V)
% Sigmoid kernel function with slope gamma and intercept c
gamma = 0.5;
c = -1;
G = tanh(gamma*U*V' + c);
end

이 코드를 MATLAB® 경로에 mysigmoid2라는 파일로 저장합니다.

조정한 시그모이드 커널을 사용하여 또 다른 SVM 분류기를 훈련시킵니다. 데이터와 결정 영역을 플로팅하고, 표본외 오분류율을 확인합니다.

Mdl2 = fitcsvm(X,Y,'KernelFunction','mysigmoid2','Standardize',true);
[~,scores2] = predict(Mdl2,xGrid);

figure;
h(1:2) = gscatter(X(:,1),X(:,2),Y);
hold on
h(3) = plot(X(Mdl2.IsSupportVector,1),...
    X(Mdl2.IsSupportVector,2),'ko','MarkerSize',10);
title('Scatter Diagram with the Decision Boundary')
contour(x1Grid,x2Grid,reshape(scores2(:,2),size(x1Grid)),[0 0],'k');
legend({'-1','1','Support Vectors'},'Location','Best');
hold off

CVMdl2 = crossval(Mdl2);
misclass2 = kfoldLoss(CVMdl2);
misclass2

misclass2 =

    0.0450

시그모이드 기울기를 조정한 결과, 더 정확한 표본내 피팅을 이룬 것으로 보이며 교차 검증률 또한 66% 이상 줄어듭니다.

베이즈 최적화를 사용하여 분류기 피팅 최적화하기

라이브 스크립트 열기

이 예제에서는 fitcsvm 함수 및 OptimizeHyperparameters 이름-값 인수를 사용하여 SVM 분류를 최적화하는 방법을 보여줍니다.

데이터 생성하기

이 분류는 가우스 혼합 모델의 점 위치를 사용한 것입니다. The Elements of Statistical Learning, Hastie, Tibshirani, and Friedman (2009)의 17페이지에 이 모델에 대한 설명이 나와 있습니다. 이 모델은 평균 (1,0)과 단위 분산의 2차원 독립 정규분포로 분산되고 "녹색" 클래스에 속하는 10개 기준점을 생성하는 것으로 시작합니다. 또한, 평균 (0,1)과 단위 분산의 2차원 독립 정규분포로 분산되고 "빨간색" 클래스에 속하는 10개 기준점도 생성합니다. 다음과 같이 각 클래스(녹색과 빨간색)에 대해 임의의 100개 점을 생성합니다.

해당 색상별로 임의로 균일하게 분포하는 기준점 m을 선택합니다.
평균이 m이고 분산이 I/5인(여기서 I는 2×2 단위 행렬임) 2차원 정규분포를 띠는 독립적인 임의의 점을 생성합니다. 이 예제에서는 분산 I/50을 사용하여 최적화의 이점을 더 확실하게 보여줍니다.

각 클래스에 대해 10개 기준점을 생성합니다.

rng('default') % For reproducibility
grnpop = mvnrnd([1,0],eye(2),10);
redpop = mvnrnd([0,1],eye(2),10);

기준점을 표시합니다.

plot(grnpop(:,1),grnpop(:,2),'go')
hold on
plot(redpop(:,1),redpop(:,2),'ro')
hold off

Figure contains an axes object. The axes object contains 2 objects of type line. One or more of the lines displays its values using only markers

일부 빨간색 기준점이 녹색 기준점에 가깝기 때문에 위치만 기준으로 하여 데이터 점을 분류하는 것이 어려울 수 있습니다.

각 클래스에 대해 100개 데이터 점을 생성합니다.

redpts = zeros(100,2);
grnpts = redpts;
for i = 1:100
    grnpts(i,:) = mvnrnd(grnpop(randi(10),:),eye(2)*0.02);
    redpts(i,:) = mvnrnd(redpop(randi(10),:),eye(2)*0.02);
end

데이터 점을 표시합니다.

figure
plot(grnpts(:,1),grnpts(:,2),'go')
hold on
plot(redpts(:,1),redpts(:,2),'ro')
hold off

Figure contains an axes object. The axes object contains 2 objects of type line. One or more of the lines displays its values using only markers

분류를 위한 데이터 준비하기

데이터를 한 행렬에 저장하고, 각 점의 클래스에 레이블을 지정하는 벡터 grp를 생성합니다. 1은 녹색 클래스를 나타내고, –1은 빨간색 클래스를 나타냅니다.

cdata = [grnpts;redpts];
grp = ones(200,1);
grp(101:200) = -1;

교차 검증 준비하기

교차 검증에 사용할 분할을 설정합니다.

c = cvpartition(200,'KFold',10);

이는 선택적 단계입니다. 최적화에 사용할 분할을 지정하면, 반환된 모델에 대한 실제 교차 검증 손실을 계산할 수 있습니다.

피팅 최적화하기

양호한 피팅, 즉 교차 검증 손실을 최소화하는 최적의 하이퍼파라미터를 갖는 피팅을 구하려면 베이즈 최적화를 사용하십시오. OptimizeHyperparameters 이름-값 인수를 사용하여 최적화할 하이퍼파라미터 목록을 지정하고 HyperparameterOptimizationOptions 이름-값 인수를 사용하여 최적화 옵션을 지정합니다.

'OptimizeHyperparameters'를 'auto'로 지정합니다. 'auto' 옵션에는 최적화할 일반적인 하이퍼파라미터 세트가 포함되어 있습니다. fitcsvm은 BoxConstraint, KernelScale, Standardize의 최적 값을 구합니다. 재현이 가능하도록 교차 검증 분할 c를 사용하고 'expected-improvement-plus' 획득 함수를 선택하도록 하이퍼파라미터 최적화 옵션을 설정합니다. 디폴트 획득 함수는 실행 시간에 따라 다양한 결과를 반환할 수 있습니다.

opts = struct('CVPartition',c,'AcquisitionFunctionName', ...
    'expected-improvement-plus');
Mdl = fitcsvm(cdata,grp,'KernelFunction','rbf', ...
    'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',opts)

|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstraint|  KernelScale |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |
|====================================================================================================================|
|    1 | Best   |       0.195 |     0.44434 |       0.195 |       0.195 |       193.54 |     0.069073 |        false |
|    2 | Accept |       0.345 |     0.06193 |       0.195 |     0.20398 |       43.991 |       277.86 |        false |
|    3 | Accept |       0.365 |     0.11763 |       0.195 |     0.20784 |    0.0056595 |     0.042141 |        false |
|    4 | Accept |        0.61 |     0.27204 |       0.195 |     0.31714 |       49.333 |    0.0010514 |         true |
|    5 | Best   |         0.1 |     0.22855 |         0.1 |     0.10005 |       996.27 |       1.3081 |        false |
|    6 | Accept |        0.13 |     0.10626 |         0.1 |     0.10003 |       25.398 |       1.7076 |        false |
|    7 | Best   |       0.085 |     0.13146 |       0.085 |     0.08521 |        930.3 |      0.66262 |        false |
|    8 | Accept |        0.35 |    0.076093 |       0.085 |    0.085172 |     0.012972 |        983.4 |         true |
|    9 | Best   |       0.075 |     0.09735 |       0.075 |    0.077959 |       871.26 |      0.40617 |        false |
|   10 | Accept |        0.08 |     0.12536 |       0.075 |    0.077975 |       974.28 |      0.45314 |        false |
|   11 | Accept |       0.235 |     0.19937 |       0.075 |    0.077907 |       920.57 |        6.482 |         true |
|   12 | Accept |       0.305 |    0.099785 |       0.075 |    0.077922 |    0.0010077 |       1.0212 |         true |
|   13 | Best   |        0.07 |     0.11053 |        0.07 |    0.073603 |       991.16 |      0.37801 |        false |
|   14 | Accept |       0.075 |     0.11231 |        0.07 |    0.073191 |       989.88 |      0.24951 |        false |
|   15 | Accept |       0.245 |     0.10308 |        0.07 |    0.073276 |       988.76 |       9.1309 |        false |
|   16 | Accept |        0.07 |    0.090016 |        0.07 |    0.071416 |       957.65 |      0.31271 |        false |
|   17 | Accept |        0.35 |    0.071829 |        0.07 |    0.071421 |    0.0010579 |       33.692 |         true |
|   18 | Accept |       0.085 |    0.060389 |        0.07 |    0.071274 |       48.536 |      0.32107 |        false |
|   19 | Accept |        0.07 |    0.080406 |        0.07 |    0.070587 |       742.56 |      0.30798 |        false |
|   20 | Accept |        0.61 |    0.078278 |        0.07 |    0.070796 |       865.48 |    0.0010165 |        false |
|====================================================================================================================|
| Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | BoxConstraint|  KernelScale |  Standardize |
|      | result |             | runtime     | (observed)  | (estim.)    |              |              |              |
|====================================================================================================================|
|   21 | Accept |         0.1 |    0.085367 |        0.07 |    0.070715 |       970.87 |      0.14635 |         true |
|   22 | Accept |       0.095 |    0.086973 |        0.07 |     0.07087 |       914.88 |      0.46353 |         true |
|   23 | Accept |        0.07 |     0.10781 |        0.07 |    0.070473 |       982.01 |       0.2792 |        false |
|   24 | Accept |        0.51 |    0.089923 |        0.07 |    0.070515 |    0.0010005 |     0.014749 |         true |
|   25 | Accept |       0.345 |     0.10267 |        0.07 |    0.070533 |    0.0010063 |       972.18 |        false |
|   26 | Accept |       0.315 |     0.24552 |        0.07 |     0.07057 |       947.71 |       152.95 |         true |
|   27 | Accept |        0.35 |     0.07371 |        0.07 |    0.070605 |    0.0010028 |        43.62 |        false |
|   28 | Accept |        0.61 |    0.087504 |        0.07 |    0.070598 |    0.0010405 |    0.0010258 |        false |
|   29 | Accept |       0.555 |     0.11435 |        0.07 |    0.070173 |       993.56 |     0.010502 |         true |
|   30 | Accept |        0.07 |     0.16504 |        0.07 |    0.070158 |       965.73 |      0.25363 |         true |

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

Best observed feasible point:
    BoxConstraint    KernelScale    Standardize
    _____________    ___________    ___________

       991.16          0.37801         false   

Observed objective function value = 0.07
Estimated objective function value = 0.072292
Function evaluation time = 0.11053

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

       957.65          0.31271         false   

Estimated objective function value = 0.070158
Estimated function evaluation time = 0.1127

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: [-1 1]
                       ScoreTransform: 'none'
                      NumObservations: 200
    HyperparameterOptimizationResults: [1x1 BayesianOptimization]
                                Alpha: [66x1 double]
                                 Bias: -0.0910
                     KernelParameters: [1x1 struct]
                       BoxConstraints: [200x1 double]
                      ConvergenceInfo: [1x1 struct]
                      IsSupportVector: [200x1 logical]
                               Solver: 'SMO'

fitcsvm은 최상의 추정된 실현가능점을 사용하는 ClassificationSVM 모델 객체를 반환합니다. 최상의 추정된 실현가능점은 베이즈 최적화 과정의 기본 가우스 과정 모델을 기반으로 하여 교차 검증 손실의 신뢰 상한을 최소화하는 하이퍼파라미터 세트입니다.

베이즈 최적화 과정은 내부적으로 목적 함수의 가우스 과정 모델을 유지합니다. 분류의 경우 목적 함수는 교차 검증된 오분류율입니다. 각 반복에 대해 최적화 과정은 가우스 과정 모델을 업데이트하고 이 모델을 사용하여 새 하이퍼파라미터 세트를 구합니다. 반복 표시의 각 라인은 새 하이퍼파라미터 세트와 다음 열 값을 표시합니다.

Objective — 새 하이퍼파라미터 세트에서 계산되는 목적 함수 값.
Objective runtime — 목적 함수 계산 시간.
Eval result — 결과 리포트로, Accept, Best 또는 Error로 지정됩니다. Accept는 목적 함수가 유한 값을 반환함을 나타내고, Error는 목적 함수가 유한 실수형 스칼라가 아닌 값을 반환함을 나타냅니다. Best는 목적 함수가 이전에 계산된 목적 함수 값보다 작은 유한 값을 반환함을 나타냅니다.
BestSoFar(observed) — 지금까지 계산된 최소 목적 함수 값. 이 값은 현재 반복의 목적 함수 값(현재 반복의 Eval result 값이 Best인 경우) 또는 이전 Best 반복의 값입니다.
BestSoFar(estim.) — 각 반복마다, 업데이트된 가우스 과정 모델을 사용하여 지금까지 시도된 모든 하이퍼파라미터 세트에서 목적 함수 값의 신뢰 상한이 추정됩니다. 그런 다음 최소 신뢰 상한을 갖는 점이 선택됩니다. BestSoFar(estim.) 값은 최소 신뢰 상한을 갖는 점에서predictObjective 함수에 의해 반환되는 목적 함수 값입니다.

반복 표시 아래의 플롯은 BestSoFar(observed) 값 및 BestSoFar(estim.) 값을 각각 파란색 및 녹색으로 표시합니다.

반환된 객체 Mdl은 최상의 추정된 실현가능점, 즉 최종 가우스 과정 모델을 기반으로 하여 최종 반복에서 BestSoFar(estim.) 값을 생성하는 하이퍼파라미터 세트를 사용합니다.

HyperparameterOptimizationResults 속성에서 또는 bestPoint 함수를 사용하여 최상의 점을 가져올 수 있습니다.

Mdl.HyperparameterOptimizationResults.XAtMinEstimatedObjective

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

       957.65          0.31271         false

[x,CriterionValue,iteration] = bestPoint(Mdl.HyperparameterOptimizationResults)

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

       957.65          0.31271         false

CriterionValue = 0.0724

iteration = 16

기본적으로, bestPoint 함수는 'min-visited-upper-confidence-interval' 기준을 사용합니다. 이 기준은 16번째 반복에서 얻은 하이퍼파라미터를 최상의 점으로 선택합니다. CriterionValue는 최종 가우스 과정 모델에 의해 계산된 교차 검증 손실의 상한입니다. 분할 c를 사용하여 실제 교차 검증 손실을 계산합니다.

L_MinEstimated = kfoldLoss(fitcsvm(cdata,grp,'CVPartition',c, ...
    'KernelFunction','rbf','BoxConstraint',x.BoxConstraint, ...
    'KernelScale',x.KernelScale,'Standardize',x.Standardize=='true'))

L_MinEstimated = 0.0700

실제 교차 검증 손실은 추정된 값에 가깝습니다. 최적화 결과의 플롯 아래에 Estimated objective function value가 표시됩니다.

HyperparameterOptimizationResults 속성에서 또는 Criterion을 'min-observed'로 지정하여 최상의 관측된 실현가능점(즉, 반복 표시의 마지막 Best 점)을 추출할 수도 있습니다.

Mdl.HyperparameterOptimizationResults.XAtMinObjective

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

       991.16          0.37801         false

[x_observed,CriterionValue_observed,iteration_observed] = ...
    bestPoint(Mdl.HyperparameterOptimizationResults,'Criterion','min-observed')

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

       991.16          0.37801         false

CriterionValue_observed = 0.0700

iteration_observed = 13

'min-observed' 기준은 13번째 반복에서 얻은 하이퍼파라미터를 최상의 점으로 선택합니다. CriterionValue_observed는 선택한 하이퍼파라미터를 사용하여 계산된 실제 교차 검증 손실입니다. 자세한 내용은 bestPoint의 Criterion 이름-값 인수를 참조하십시오.

최적화된 분류기를 시각화합니다.

d = 0.02;
[x1Grid,x2Grid] = meshgrid(min(cdata(:,1)):d:max(cdata(:,1)), ...
    min(cdata(:,2)):d:max(cdata(:,2)));
xGrid = [x1Grid(:),x2Grid(:)];
[~,scores] = predict(Mdl,xGrid);

figure
h(1:2) = gscatter(cdata(:,1),cdata(:,2),grp,'rg','+*');
hold on
h(3) = plot(cdata(Mdl.IsSupportVector,1), ...
    cdata(Mdl.IsSupportVector,2),'ko');
contour(x1Grid,x2Grid,reshape(scores(:,2),size(x1Grid)),[0 0],'k');
legend(h,{'-1','+1','Support Vectors'},'Location','Southeast');

Figure contains an axes object. The axes object contains 4 objects of type line, contour. One or more of the lines displays its values using only markers These objects represent -1, +1, Support Vectors.

새 데이터에 대한 정확도 평가하기

새 검정 데이터 점을 생성하고 분류합니다.

grnobj = gmdistribution(grnpop,.2*eye(2));
redobj = gmdistribution(redpop,.2*eye(2));

newData = random(grnobj,10);
newData = [newData;random(redobj,10)];
grpData = ones(20,1); % green = 1
grpData(11:20) = -1; % red = -1

v = predict(Mdl,newData);

검정 데이터 세트에 대해 오분류율을 계산합니다.

L_Test = loss(Mdl,newData,grpData)

L_Test = 0.2000

어떤 새 데이터 점이 정확하게 분류되었는지 결정합니다. 올바르게 분류된 점에는 빨간색 정사각형을, 잘못 분류된 점에는 검은색 정사각형을 지정합니다.

h(4:5) = gscatter(newData(:,1),newData(:,2),v,'mc','**');

mydiff = (v == grpData); % Classified correctly

for ii = mydiff % Plot red squares around correct pts
    h(6) = plot(newData(ii,1),newData(ii,2),'rs','MarkerSize',12);
end

for ii = not(mydiff) % Plot black squares around incorrect pts
    h(7) = plot(newData(ii,1),newData(ii,2),'ks','MarkerSize',12);
end
legend(h,{'-1 (training)','+1 (training)','Support Vectors', ...
    '-1 (classified)','+1 (classified)', ...
    'Correctly Classified','Misclassified'}, ...
    'Location','Southeast');
hold off

Figure contains an axes object. The axes object contains 8 objects of type line, contour. One or more of the lines displays its values using only markers These objects represent -1 (training), +1 (training), Support Vectors, -1 (classified), +1 (classified), Correctly Classified, Misclassified.

SVM 분류 모델에 대한 사후 확률 영역 플로팅하기

라이브 스크립트 열기

이 예제에서는 관측값으로 구성된 그리드에서 SVM 모델의 사후 확률을 예측하고 그 그리드에 사후 확률을 플로팅하는 방법을 보여줍니다. 사후 확률을 플로팅하면 결정 경계가 분명해집니다.

피셔(Fisher)의 붓꽃 데이터 세트를 불러옵니다. 꽃잎 길이와 꽃잎 너비를 사용하여 분류기를 훈련시키고 데이터에서 virginica 종을 제거합니다.

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

이 데이터를 사용하여 SVM 분류기를 훈련시킵니다. 클래스의 순서를 지정하는 것이 좋습니다.

SVMModel = fitcsvm(X,y,'ClassNames',{'setosa','versicolor'});

최적의 점수 변환 함수를 추정합니다.

rng(1); % For reproducibility
[SVMModel,ScoreParameters] = fitPosterior(SVMModel);

Warning: Classes are perfectly separated. The optimal score-to-posterior transformation is a step function.

ScoreParameters

ScoreParameters = struct with fields:
                        Type: 'step'
                  LowerBound: -0.8431
                  UpperBound: 0.6897
    PositiveClassProbability: 0.5000

클래스는 분리 가능하기 때문에 최적의 점수 변환 함수는 계단 함수입니다. ScoreParameters의 필드 LowerBound와 UpperBound는 클래스 분리 초평면(마진) 내에서 관측값에 대응되는 점수 구간의 하한 끝점과 상한 끝점을 나타냅니다. 어떠한 훈련 관측값도 이 마진 내에 속하지 않습니다. 새 점수가 구간 내에 있으면 소프트웨어가 대응되는 관측값을 양성 클래스 사후 확률, 즉 ScoreParameters의 PositiveClassProbability 필드의 값에 할당합니다.

관측된 예측 변수 공간에서 값의 그리드를 정의합니다. 그리드의 각 인스턴스에 대해 사후 확률을 예측합니다.

xMax = max(X);
xMin = min(X);
d = 0.01;
[x1Grid,x2Grid] = meshgrid(xMin(1):d:xMax(1),xMin(2):d:xMax(2));

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

양성 클래스 사후 확률 영역과 훈련 데이터를 플로팅합니다.

figure;
contourf(x1Grid,x2Grid,...
        reshape(PosteriorRegion(:,2),size(x1Grid,1),size(x1Grid,2)));
h = colorbar;
h.Label.String = 'P({\it{versicolor}})';
h.YLabel.FontSize = 16;
colormap jet;

hold on
gscatter(X(:,1),X(:,2),y,'mc','.x',[15,10]);
sv = X(SVMModel.IsSupportVector,:);
plot(sv(:,1),sv(:,2),'yo','MarkerSize',15,'LineWidth',2);
axis tight
hold off

Figure contains an axes object. The axes object contains 4 objects of type contour, line. One or more of the lines displays its values using only markers These objects represent setosa, versicolor.

2-클래스 학습에는 클래스가 분리 가능한 경우 세 개의 영역이 존재합니다. 하나는 관측값이 양성 클래스 사후 확률 0을 가지고, 다른 하나는 1을 가지며, 나머지는 양성 클래스 사전 확률을 가집니다.

선형 서포트 벡터 머신을 사용하여 이미지 분석하기

라이브 스크립트 열기

이 예제에서는 선형 SVM 이진 학습기로 구성된 오류 수정 출력 코드(ECOC) 모델을 훈련시켜 이미지에서 형상이 차지하는 사분면이 무엇인지 확인하는 방법을 보여줍니다. 이 예제에서는 서포트 벡터, 해당 레이블, 추정된 $α$ 계수를 저장하는 ECOC 모델의 디스크 공간 사용량도 보여줍니다.

데이터 세트 생성하기

50×50 이미지에 반지름이 5인 원을 임의로 배치합니다. 5000개 이미지를 생성합니다. 각 이미지에 대해 원이 차지하는 사분면을 나타내는 레이블을 생성합니다. 1사분면은 오른쪽 위에 있고, 2사분면은 왼쪽 위에 있으며, 3사분면은 왼쪽 아래에 있고, 4사분면은 오른쪽 아래에 있습니다. 예측 변수는 각 픽셀의 농도입니다.

d = 50;  % Height and width of the images in pixels
n = 5e4; % Sample size

X = zeros(n,d^2); % Predictor matrix preallocation 
Y = zeros(n,1);   % Label preallocation
theta = 0:(1/d):(2*pi);
r = 5;            % Circle radius
rng(1);           % For reproducibility

for j = 1:n
    figmat = zeros(d);                       % Empty image
    c = datasample((r + 1):(d - r - 1),2);   % Random circle center
    x = r*cos(theta) + c(1);                 % Make the circle 
    y = r*sin(theta) + c(2);               
    idx = sub2ind([d d],round(y),round(x));  % Convert to linear indexing
    figmat(idx) = 1;                         % Draw the circle
    X(j,:) = figmat(:);                % Store the data
    Y(j) = (c(2) >= floor(d/2)) + 2*(c(2) < floor(d/2)) + ...
        (c(1) < floor(d/2)) + ...
        2*((c(1) >= floor(d/2)) & (c(2) < floor(d/2))); % Determine the quadrant
end

관측값을 플로팅합니다.

figure
imagesc(figmat)
h = gca;
h.YDir = 'normal';
title(sprintf('Quadrant %d',Y(end)))

Figure contains an axes object. The axes object with title Quadrant 1 contains an object of type image.

ECOC 모델 훈련시키기

25% 홀드아웃 표본을 사용하여 훈련 표본 인덱스와 홀드아웃 표본 인덱스를 지정합니다.

p = 0.25;
CVP = cvpartition(Y,'Holdout',p); % Cross-validation data partition
isIdx = training(CVP);            % Training sample indices
oosIdx = test(CVP);               % Test sample indices

이진 학습기의 서포트 벡터를 저장하도록 지정하는 SVM 템플릿을 생성합니다. 이 템플릿과 훈련 데이터를 fitcecoc로 전달하여 모델을 훈련시킵니다. 훈련 표본의 분류 오차를 확인합니다.

t = templateSVM('SaveSupportVectors',true);
MdlSV = fitcecoc(X(isIdx,:),Y(isIdx),'Learners',t);
isLoss = resubLoss(MdlSV)

isLoss = 0

MdlSV는 훈련된 ClassificationECOC 다중클래스 모델입니다. 이는 훈련 데이터와 각 이진 학습기의 서포트 벡터를 저장합니다. 이미지 분석의 데이터 세트와 같은 대규모 데이터 세트의 경우, 이 모델은 많은 메모리를 사용할 수 있습니다.

ECOC 모델이 사용하는 디스크 공간의 크기를 확인합니다.

infoMdlSV = whos('MdlSV');
mbMdlSV = infoMdlSV.bytes/1.049e6

mbMdlSV = 763.6163

이 모델은 763.6MB를 사용합니다.

모델의 효율성 향상시키기

표본외 성과를 평가할 수 있습니다. 또한, 모델이 서포트 벡터, 관련 모수, 훈련 데이터를 포함하지 않는 간소화된 모델로 과적합되었는지 여부도 평가할 수 있습니다.

훈련된 ECOC 모델에서 서포트 벡터와 관련 모수를 삭제합니다. 그런 다음, compact를 사용하여 결과로 생성된 모델에서 훈련 데이터를 삭제합니다.

Mdl = discardSupportVectors(MdlSV);
CMdl = compact(Mdl);
info = whos('Mdl','CMdl');
[bytesCMdl,bytesMdl] = info.bytes;
memReduction = 1 - [bytesMdl bytesCMdl]/infoMdlSV.bytes

memReduction = 1×2

    0.0626    0.9996

이 경우, 서포트 벡터를 삭제하면 메모리 사용량이 약 6% 정도 줄어듭니다. 서포트 벡터를 간소화하고 삭제하면 크기가 약 99.96% 줄어듭니다.

서포트 벡터를 관리하는 다른 방법은 100과 같은 더 큰 상자 제약 조건을 지정하여 훈련 과정 중에 그 개수를 줄이는 것입니다. 더 적은 수의 서포트 벡터를 사용하는 SVM 모델이 더 바람직하고 메모리를 덜 사용하지만 상자 제약 조건의 값을 늘리면 훈련 시간이 늘어나는 경향이 있습니다.

작업 공간에서 MdlSV와 Mdl을 제거합니다.

clear Mdl MdlSV

홀드아웃 표본 성능 평가하기

홀드아웃 표본의 분류 오차를 계산합니다. 홀드아웃 표본 예측의 표본을 플로팅합니다.

oosLoss = loss(CMdl,X(oosIdx,:),Y(oosIdx))

oosLoss = 0

yHat = predict(CMdl,X(oosIdx,:));
nVec = 1:size(X,1);
oosIdx = nVec(oosIdx);

figure;
for j = 1:9
    subplot(3,3,j)
    imagesc(reshape(X(oosIdx(j),:),[d d]))
    h = gca;
    h.YDir = 'normal';
    title(sprintf('Quadrant: %d',yHat(j)))
end
text(-1.33*d,4.5*d + 1,'Predictions','FontSize',17)

이 모델은 어떠한 홀드아웃 표본 관측값도 오분류하지 않습니다.

참고 항목

fitcsvm | bayesopt | kfoldLoss

참고 문헌

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

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

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

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