機械学習実践チュートリアル（11）：サポートベクターマシンSVM

SVMとは何ですか?

VM の正式な英語名は Support Vector Machines で、私たちはこれをサポート ベクター マシンと呼びます。サポート ベクター マシンは、分類に使用するアルゴリズムです。短編小説の形で SVM の旅を始めましょう。

昔のバレンタインデー、恋人を助けに行った英雄だったが、空の悪魔が主人公を相手にゲームをした。

悪魔はテーブルの上に 2 色のボールを定期的に置いているようで、「棒を使ってそれらを分離しますか? 要件: さらにボールを置いた後もそれを適用するようにしてください。」 そこで、主人公はボールをこのように置きました。よくやった

?

それから悪魔はさらに多くのボールをテーブルの上に置きましたが、1 つのボールが間違った側にあるように見えました。明らかに、主人公はスティックを調整する必要があります。

SVM は、スティックの両側にできるだけ多くのスペースができるように、スティックを最適な位置に配置しようとします。このギャップがボールからスティックまでの距離です。

さて、たとえデビルズがより多くのボールを置いたとしても、スティックは依然として良い境界線です。

さて、主人公は 2 種類のボールを分けるのに役立つ棒を持っていません。どうすればよいでしょうか? もちろん、他の格闘技映画と同様に、主人公がテーブルを叩き、ボールが空中に飛びます。そして、主人公の軽さを頼りに、主人公は一枚の紙を掴み、二種類のボールの間に差し込みました。

さて、空中の悪魔の視点からこれらのボールを見ると、これらのボールは曲線で区切られているように見えます。

その後、退屈な大人たちはこれらのボールをデータと呼び、スティック分類器、最適化と呼ばれる最大のギャップを見つけるトリック、カーネリングと呼ばれるテーブルを叩く、そして超平面と呼ばれる紙切れと呼びました。

概要を説明すると、次のようになります。

分類問題であり、データが線形分離可能な場合、つまり 2 種類のボールをスティックで分離できる場合、ボールとスティックの間の距離が最大になる位置にスティックを配置するだけで済みます。この最大間隔を見つけるプロセスは、最適化と呼ばれます。しかし、現実は非常に残酷な場合が多く、一般にデータは線形分離不可能、つまり 2 種類のボールを適切に分類できる棒は存在しません。このとき、私たちはヒーローのようにボールを拾い、棒の代わりに紙を使ってボールを分類する必要があります。データを飛ばすために必要なのはカーネル関数 (カーネル)であり、ボールを切るために使用される紙は超平面です。

数学的モデリング

サポート ベクター マシン (SVM) は教師あり学習に基づくデータの一般化線形分類の一種であり、その決定境界は学習サンプルを解く最大マージン超平面です。SVM はカーネル関数を通じて非線形分類を実行でき、一般的なカーネル学習方法の 1 つです。

サポート ベクター マシン (サポート ベクター マシン) は、サンプルをセグメント化するための超平面を見つけます。セグメント化の原理は、間隔を最大化し、最終的に凸二次計画問題に変換して解決することです。線形分離可能性と線形不可能性の両方を解決でき、分類問題と回帰問題の両方を解決できます。

間隔を最大化する

トレーニング サンプルが線形分離可能な場合はハード マージン最大化 (ハード マージン SVM) を使用し、ほぼ線形分離可能な場合はソフトウェア最大化 (ソフト マージン SVM) を使用します。カーネル関数とソフト マージンの最大化は、トレーニング サンプルが線形分離できない場合に使用されます。

実際の問題では、決定境界が一意ではない状況がよくありますが、これは不適切な問題です。トレーニング サンプル セット
$D=\{(x_{}、y_{}）、({\times }_{}、y_{}）、\dots 、({\times }_{}、y_{})\}、y_{}\in \{-1、1\}$分類アルゴリズムの基本的な考え方は、トレーニング セットに基づいてサンプル空間内で分割超平面を見つけることですが、トレーニング サンプルを分離できる分割超平面は多数存在する可能性があります。見つけるには？

svm によって検出される直線は、モデルの汎化能力を確保するために、決定境界から最も近い赤い点と青い点からできるだけ遠くにあることが望まれます。SVM は、2 つのカテゴリの最も近いサンプルから最も遠い最適な決定境界を見つけようとします。図内の 3 つの点は、決定境界から同じ距離にあります。これら 3 つの点はサポート ベクターと呼ばれます。判定境界に平行な2直線間の距離がマージンであり、SVMではマージンを最大化するため、この問題を最適化問題に変換します。

最適化問題

分類区間の式

Svm はマージンを最大化します (マージン = 2d)。これは d を最大化することに対応します。つまり、点から直線までの距離が最大になります。解析幾何学で 2 次元空間内の点$(x,y)$を直線$あ\times +によって\_+C=0$の距離の公式$\frac{|Ax+By+C}{\sqrt{{あ}^2+B^2}}$
これを n 次元${私}^T\cdot {バツ}_{}=0$
其中$\theta \; に$は切片と係数${バツ}_{}$ちょうど$定数\; 1\; の行をx$サンプルに追加します。これは前の線形回帰と同じです。

切片を取ると$w^T\times +b=その中のw$
は、サンプル内の各データに重みを割り当てることです。これらは、直線の方程式を表現する 2 つの異なる方法です。次に、新しい点から線までの距離方程式を取得できます:
$\frac{|w^{T}x+b}{\Vert \Vert \_}$，その中$\Vert w\Vert =\sqrt{w_1^{}+w_2^{}+\cdots +w_n^{}}$

制限

目的関数の数学的形式を取得することに成功したようです。ただし、w の最大値を見つけるには。私たちは次のような問題に直面しなければなりません。

1. 超平面がサンプル点を正しく分類しているかどうかをどのように判断すればよいでしょうか?
2. 距離 d の最大値が必要であることはわかっています。まずサポート ベクトル上の点を見つける必要があります。多数の点の中からサポート ベクトル上の点を選択するにはどうすればよいでしょうか?
   上記で直面する必要がある問題は制約条件です。これは、最適化する変数 d の値の範囲が制限され、制約されていることを意味します。実際、最適化問題において常に制約が最も厄介なものでした。
   しかし、これらの制約が存在することがわかったので、それらを説明するには数学的言語を使用する必要があります。ここに図の説明を挿入してください。ただし、SVM アルゴリズムはいくつかの巧妙なトリックを使用して、これらの制約を不等式に統合します。

この 2 次元平面上には 2 種類の点があり、それぞれにマークを付けます。

赤い点は 1 としてマークされ、これを陽性サンプルとして人為的に指定し、
青い五芒星は -1 としてマークされ、これを人為的に陰性サンプルとして指定します。
カテゴリ ラベル yi を各サンプル ポイント xi に追加します。

中央の直線は決定境界です$w^T\times +b=0$であり、上と下の直線は距離が d より大きくなければならないことを意味するため、
$\{\begin{array}{l}\frac{w^T{\times }^{\left(i\right)}+}{\Vert \Vert \_}\ge d\forall y{\_}^{\left(私\right)}=1\\ \frac{w^T{\times }^{\left(i\right)}+}{\Vert \Vert \_}\le -d\forall y{\_}^{\left(私\right)}=-\end{array}$
このとき、２種類のサンプルがそれぞれ１と－１であるとする。次に、上記の式の左辺と右辺を同時に d で割って、
$\{\begin{array}{l}\frac{w^T{\times }^{\left(i\right)}+}{\Vert w\Vert d}\ge 1\forall y{\_}^{\left(私\right)}=1\\ \frac{w^T{\times }^{\left(i\right)}+}{\Vert w\Vert d}\le -1\forall y{\_}^{\left(私\right)}=-\end{array}$

ここで、 |w| と d は両方ともスカラーです (制限値の計算には影響しません) このとき、分母は削除され、 {
$\{\begin{array}{l}{w}^T{\times }^{\left(私\right)}+b\ge 1\forall y{\_}^{\left(私\right)}=1\\ w^T{\times }^{\left(私\right)}+b\le -1\forall y{\_}^{\left(私\right)}=-\end{array}$
この時点で 2 つの方程式が得られますが、ちょっとしたトリックを使用して 2 つの方程式を 1 つにマージします。
$\boxed{y_{}(w^T{\times }^{\left(私\right)}+b)\ge 1}$

目的関数の最大化

ここで私たちの考えをまとめると、目的関数が得られます:
$マ\times \frac{|w^{T}x+b}{\Vert \Vert \_}$
私たちの最適化目標は、d を最大化することです。d の最大化問題を解くためにサポート ベクター上のサンプル ポイントを使用することはすでに述べました。では、サポート ベクター上のサンプル ポイントの特徴は何でしょうか?
$|w^T\times +b|=1したがって、$
これは$マ\times \frac{}{\Vert \Vert \_}$つまり、$分\Vert w\Vert しかし、$
多くの場合、導出の便宜上、$\boxed{分\frac{}{2}\Vert w{\Vert }^2}$
ただし、これは制約付きの最適化問題であり、$s。と。y_{}(w^T{\times }^{\left(私\right)}+b)\ge 1、私=1、2、\dots 、ここで、m$
はサンプル ポイントの総数であり、略語 st は「Subject to」を意味し、「特定の条件に従う」ことを意味します。上の式は、不等式制約の下での典型的な 2 次関数の最適化問題を記述しており、サポート ベクター マシンの基本的な数学モデルでもあります。
制約のある最適化問題を解くには、ラグランジュ乗数法を使用して双対問題を取得する必要があります。次に問題の関数:
$$\boxed{L(w,b、）\_=\frac{}{2}\Vert w{\Vert }^2+\sum _{i=1}{ある}_{}(1-y_{}(w^T{\times }_{}+b))}$$

ここで、${ある}_{}$それはラグランジュ乗数です。これはハード マージン SVM です。

ソフトマージンとSVM正則化

実際の適用中に青い点が赤い点の近くに現れる場合、つまり 2 つのカテゴリは比較的近いが、青い点との全体的な違いが明らかな場合、それは特別な点または間違った特異点と見なすことができます。は誤解を招き、最終的なハード マージン分類境界が直線 1 になります。現時点では、モデルの汎化能力には疑問があります。通常、非常に特殊な青い点は、直線 2 のように無視して、ほとんどのデータが直線から最も遠ざかるようにする必要がありますが、おそらくこれが最良の分類境界であり、一般化能力が高いことを意味します。これは、モデルの精度が高すぎる場合、モデルの過剰適合につながる可能性があることを間接的に説明することもできます。

より一般的な例としては、青い点が赤い点に混合されると、データ セットが線形分離不可能になります。2 つのカテゴリを分離できる直線はありません。この場合、ハード マージンもはや汎化能力が強いかどうかの問題ではなく、両者を分ける直線はないということです。

したがって、上記の 2 つの状況をどの角度から始めるにしても、svm モデルに部分的なフォールト トレランスを与えることを検討する必要があります。これはソフトマージン SVM につながります。
$$\begin{gathered} 分\frac{}{2}\Vert w{\Vert }^2、s。と。y_{}(w^T{\times }^{\left(私\right)}+b)\ge 1-g_{}、 \\ {g}_{}>0、私=1、2、\dots 、Hard\; Margin\; SVM\; と比較してm\; は \end{gathered}$$
条件を緩和することに相当し、グラフから直感的に理解すると上記の直線を点線に緩和することに相当します。さらに、より重要な点は$g_{}$固定値ではなく、各サンプル${バツ}_{}$ξ i \zeta_{i}を持っています$g_{}$ただし、この$g_{}$一定の制限も必要ですが、この条件が無期限に緩和されるわけではありません。つまり、このフォールト トレランス スペースは大きすぎてはいけないため、制限する必要があります。

L1 通常
$$\begin{gathered} \boxed{分（\frac{}{2}\Vert w{\Vert }^2+C\sum _{i=1}{g}_{}）、s。と。y_{}(w^T{\times }^{\left(私\right)}+b)\ge 1-g_{}、 \\ {g}_{}\ge 0、私=1、2、\dots 、メートル} \end{gathered}$$
フォールトトレランスと目的関数を重み付けるために新しいハイパーパラメータ C を導入しました。実際、これは、モデルが極端な方向に発展するのを防ぐために、それに L1 正規項を追加したという事実としても理解できます。極端なデータセットや未知のデータに敏感であり、データの一般化能力が優れています。このいわゆる L1 正規は、絶対値を持たないという点で以前の L1 正規とは異なります。これは、単に$g_{}\ge 0$なので、絶対値を加算しないのが妥当です。C が大きいほどハード マージン SVM に近づき、C が小さいほどフォールト トレランスの余地が大きいことを意味します。svm の正則化と線形回帰の正則化の違いは、C の位置が異なることです。具体的な理由をより深く理解した後、更新します。
次に、次のように L1 規則性があり、それに対応して L2 規則性があります。
$$\begin{gathered} \boxed{分（\frac{}{2}\Vert w{\Vert }^2+C\sum _{i=1}{g}_{私}^{}）、s。と。y_{}(w^T{\times }^{\left(私\right)}+b)\ge 1-g_{}、 \\ {g}_{}>0、私=1、2、\dots 、メートル} \end{gathered}$$

Sklearnのsvm

実際にSVMを使用する場合は、どちらも距離が関係するため、KNNと同様にデータを標準化する必要があります。なぜなら、データのスケールが違いすぎる場合、たとえば下図の横軸が0～1、縦軸が0～10000の場合です。したがって、まず標準化が必要です。

最初のステップは、単純な二値分類データ セットを準備することです。

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
"""
load_iris是一个经典的机器学习数据集，它包含了150个样本
这个数据集中的四个特征分别是花萼长度（sepal length）、花萼宽度（sepal width）、花瓣长度（petal length）和花瓣宽度（petal width），
它们都是以厘米（cm）为单位测量的。目标变量是鸢尾花的种类，
有三种不同的种类：Setosa、Versicolour和Virginica。
它们的中文名分别是山鸢尾、杂色鸢尾和维吉尼亚鸢尾。
"""
iris = datasets.load_iris()

x = iris.data
y = iris.target
# 只做一个简单的二分类,获取分类是山鸢尾、杂色鸢尾的数据，同时取2维的特征就行了
x = x[y<2, :2]
y = y[y<2]
#分别绘制出分类是0和1的点，不同的scatter颜色不一样
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

svm を実装するには、まず比較的大きな C を使用します。

# 标准化数据
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
#数据归一化
standardscaler = StandardScaler()
standardscaler.fit(x)
x_standard = standardscaler.transform(x)
svc = LinearSVC(C=1e9)
svc.fit(x_standard, y)

def plot_decision_boundary(model, axis):
    x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),
                         np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
    x_new = np.c_[x0.ravel(), x1.ravel()]
    y_predict = model.predict(x_new)
    zz = y_predict.reshape(x0.shape)

    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)
    w = model.coef_[0]
    b = model.intercept_[0]
    # w0*x0 + w1*x1 + b = 0
    # x1 = -w0/w1 * x0 - b/w1
    plot_x = np.linspace(axis[0], axis[1], 200)
    up_y = -w[0]/w[1] * plot_x - b/w[1] + 1/w[1]
    down_y = -w[0]/w[1] * plot_x - b/w[1] - 1/w[1]
    
    up_index = (up_y >= axis[2]) & (up_y <= axis[3])
    down_index = (down_y >= axis[2]) & (down_y <= axis[3])
    
    plt.plot(plot_x[up_index], up_y[up_index], color='black')
    plt.plot(plot_x[down_index], down_y[down_index], color='black')
plot_decision_boundary(svc, axis=[-3, 3, -3, 3])
plt.scatter(x_standard[y==0, 0], x_standard[y==0, 1], color='red')
plt.scatter(x_standard[y==1, 0], x_standard[y==1, 1], color='blue')
plt.show()

より小さい C を使用し、C のさまざまな値の効果を比較します。

svc2 = LinearSVC(C=0.01)
svc2.fit(x_standard, y)

plot_decision_boundary(svc2, axis=[-3, 3, -3, 3])
plt.scatter(x_standard[y==0, 0], x_standard[y==0, 1], color='red')
plt.scatter(x_standard[y==1, 0], x_standard[y==1, 1], color='blue')
plt.show()

2 つの写真を比較すると、C が小さい場合、赤い点が誤って青に分割されていることがわかり、C が小さいほど誤差の余地が大きいことがわかります。

SVM での多項式機能の使用

これまで話してきたのは線形 svm です。svm では非線形問題も解決できます。線形回帰から非線形回帰の考え方と類推して、多項式特徴が最初に使用されます。

まずデータセットを生成します。

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets

x, y = datasets.make_moons()
x.shape
# (100, 2)
y.shape
# (100,)
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

次に、データにランダム ノイズを追加します。

x, y = datasets.make_moons(noise=0.15, random_state=666)
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

多項式、正規化、線形 SVM を使用する

from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline

def PolynomiaSVC(degree, C=1.0):
    return Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('std_scale', StandardScaler()),
        ('linear_svc', LinearSVC(C=C))
    ])

poly_svc = PolynomiaSVC(degree=3)
poly_svc.fit(x, y)

def plot_decision_boundary(model, axis):
    x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),
                         np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
    x_new = np.c_[x0.ravel(), x1.ravel()]
    y_predict = model.predict(x_new)
    zz = y_predict.reshape(x0.shape)

    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)

plot_decision_boundary(poly_svc, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x1[y1==0, 0], x1[y1==0, 1])
plt.scatter(x1[y1==1, 0], x1[y1==1, 1])
plt.show()

この方法を使用して多項式特徴を追加し、それらを線形 SVC に入力することに加えて、同様の機能を実現する別の方法もあります。

from sklearn.svm import SVC

# 这种方法训练的过程并不完全是先将数据进行标准化，再使用linearSVC这么一个过程
# SVC中默认的C=0
def PolynomiaKernelSVC(degree, C=1.0):
    return Pipeline([
        ('std_scale', StandardScaler()),
        ('kernel_svc', SVC(kernel='poly', degree=degree, C=C))
    ])

poly_kernel_svc = PolynomiaKernelSVC(degree=3)
poly_kernel_svc.fit(x1, y1)
# Pipeline(memory=None,
#     steps=[('std_scale', StandardScaler(copy=True, with_mean=True, with_std=True)),
#  ('kernel_svc', SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
#   decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
#   kernel='poly', max_iter=-1, probability=False, random_state=None,
#   shrinking=True, tol=0.001, verbose=False))])

plot_decision_boundary(poly_kernel_svc, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x1[y1==0, 0], x1[y1==0, 1])
plt.scatter(x1[y1==1, 0], x1[y1==1, 1])
plt.show()

このメソッドは svm のカーネル関数です。次に、カーネル機能について詳しく説明する。

カーネル関数とは

実際のタスクでは、元のサンプル空間に 2 つのカテゴリを正しく分割できる超平面が存在しない場合があります。このような問題に対しては、サンプルを元の空間から高次元の特徴空間にマッピングして、サンプルがこの空間に収まるようにすることができます。特徴空間内部的に線形分離可能。したがって、カーネル関数の役割は、本来線形分離不可能なデータを線形分離可能にすることです。以下は、多項式カーネル マッピングを使用する手順です。

以下の関数に変換するとデータは線形分離可能になります。

一般的に使用されるカーネル関数:
1. 線形カーネル: $k(x_{}、{バツ}_{})={バツ}_{私}^{}{バツ}_{}+c$
2. 多項式カーネル:$k(x_{}、{バツ}_{})=({\times }_{私}^{}{バツ}_{}+c{)}^d$、 d=1 の場合、線形カーネルに縮退します。
3. ガウス カーネル RBF:$k(x_{}、{バツ}_{})=exp(-\frac{\Vert {\times }_{}-{\times }_{}{\Vert }^{}}{2P{\_}^2}）、p>0$はガウス カーネルの帯域幅 RBF カーネルです: 放射基底関数カーネル
4. ラプラシアン カーネル:$k(x_{}、{バツ}_{})=exp(-\frac{\Vert {\times }_{}-{\times }_{}}{p})、p>0$
5、シグモイド核：$k(x_{}、{バツ}_{})=(\beta x\_\_{}_{私}^{}{バツ}_{}+私）$

ガウスカーネル関数

ガウス カーネル関数は、一般的に使用されるカーネル関数であり、通常はサポート ベクター マシン (SVM) などの機械学習アルゴリズムで使用されます。元の空間から高次元の空間にデータをマッピングできるため、本来分離できなかったサンプルを新しい空間で分離できます。

平たく言えば、ガウス カーネル関数は 2 つのサンプル間の類似性を計算できる「類似性測定」のようなものです。ガウス カーネル関数を使用する場合、最初に中心点を選択し、次に各サンプル点と中心点の間の距離を計算し、その距離を類似性の尺度として使用します。この距離は通常、ガウス分布関数によって重み付けされます。これがガウス カーネル関数の名前の由来です。
より具体的には、ガウス カーネル関数は 2 つのサンプル点${バツ}_{}$そして${バツ}_{}$高次元空間にマッピングし、新しい空間で内積を計算し、次の式を取得します。
$K({\times }_{}、{バツ}_{})=\exp (-\gamma ||x_{}-{バツ}_{}|{|}^2)$

その中で、$\gamma \; は$ガウス分布の幅を制御するパラメータです。$||{\times }_{}-{バツ}_{}|{|}^2$はサンプル点${バツ}_{}$そして${バツ}_{}$間のユークリッド距離の二乗 γ \ガンマのとき$\gamma$の値が大きい場合、ガウス分布のピーク値は狭くなり、類似性測定では 2 つのサンプル点間の距離により注意が払われます$\gamma$の値が小さい場合、ガウス分布のピーク値は広くなり、2 つのサンプル点間の全体的な類似性に焦点を当てた類似性測定がより滑らかになります。

全体として、ガウス カーネル関数は、特に非線形分類問題に関しては、多くの機械学習アルゴリズムで使用できる、非常に柔軟で強力な類似性尺度です。

次に、ガウス カーネル関数マッピングを通じてマッピング プロセス全体をより直感的に理解できます。

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-4, 5, 1)
# array([-4, -3, -2, -1,  0,  1,  2,  3,  4])
y = np.array((x >= -2) & (x <= 2), dtype='int')
# array([0, 0, 1, 1, 1, 1, 1, 0, 0])
plt.scatter(x[y==0], [0] * len(x[y==0]))
plt.scatter(x[y==1], [0] * len(x[y==1]))
plt.show()

ガウスカーネル以降

def gaussian(x, l):
    gamma = 1.0
    return np.exp(-gamma *(x-l)**2)

l1, l2 = -1, 1

x_new = np.empty((len(x), 2))
for i,data in enumerate(x):
    x_new[i, 0] = gaussian(data, l1)
    x_new[i, 1] = gaussian(data, l2)

plt.scatter(x_new[y==0, 0], x_new[y==0, 1])
plt.scatter(x_new[y==1, 0], x_new[y==1, 1])
plt.show()

実際、実ガウス カーネル関数を実現するプロセスは固定されていません$\gamma$ですが、各データ点では$\gamma$、半径 gamma = 1.0 を決定すると、

次のようになります:$g\left(x\right)=\frac{}{p\sqrt{午後2時}}{e}^{-\frac{}{2}\left(\frac{x-}{p}\right)}$
ここで、$\mu \; は$関数$\sigma \; は$グラフ全体の近さの度合いを決定します、$\sigma$が小さいほど画像が高くなり、画像が相対的に集中していることを示します。反対の$\sigma$が大きいほど、グラフはより分散します。
$K({\times }_{}、{バツ}_{})=e^{-\gamma \Vert x_{}-{\times }_{}{\Vert }^2}$
$\gamma$が大きいほど、ガウス分布は広くなります。

$\gamma \; が$小さいほど、ガウス分布は狭くなります。

次に、sklearn でカプセル化されたガウス カーネル関数を使用します。

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets

x, y = datasets.make_moons(noise=0.15, random_state=666)

from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline

def RBFKernelSVC(gamma=1.0):
    return Pipeline([
        ('std_scale', StandardScaler()),
        ('svc', SVC(kernel='rbf', gamma=gamma))
    ])

svc = RBFKernelSVC(gamma=1.0)
svc.fit(x, y)

def plot_decision_boundary(model, axis):
    x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),
                         np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
    x_new = np.c_[x0.ravel(), x1.ravel()]
    y_predict = model.predict(x_new)
    zz = y_predict.reshape(x0.shape)

    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)

plot_decision_boundary(svc, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

svc_gamma100 = RBFKernelSVC(gamma=100)
svc_gamma100.fit(x, y)

plot_decision_boundary(svc_gamma100, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

svc_gamma10 = RBFKernelSVC(gamma=10)
svc_gamma10.fit(x, y)

plot_decision_boundary(svc_gamma10, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

svc_gamma01 = RBFKernelSVC(gamma=0.1)
svc_gamma01.fit(x, y)

plot_decision_boundary(svc_gamma01, axis=[-1.5, 2.5, -1.0, 1.5])
plt.scatter(x[y==0, 0], x[y==0, 1])
plt.scatter(x[y==1, 0], x[y==1, 1])
plt.show()

ガンマはモデルの複雑さを調整することに相当し、ガンマが小さいほどモデルの複雑さは低くなり、ガンマが大きいほどモデルの複雑さは高くなります。したがって、ハイパーパラメータ ガンマを調整して、過学習と過小学習のバランスを取る必要があります。

この記事のテキストと例の出典:

1. https://cuijiahua.com/blog/2017/11/ml_8_svm_1.html
2. https://zhuanlan.zhihu.com/p/79679104