メインコンテンツへスキップ
見出し画像

scikit-learn機械学習㉖SVM実践編

    前回までの4つの記事でSVMの理論的な側面を紹介しました。

    1. マージンの最大化

    2. ソフト・マージンの導入

    3. カーネル・トリック

    4. 多クラス分類

    今回は、これまで積み上げてきたSVMの理論を利用して、実際にscikit-learnを使ってコーディングをして、実験を行います。

    画像
    こんなデータを自分で作る

    このような非線形のデータをさまざまなカーネルで実験します。また、ハイパーパラメータの調節をランダム・サーチを使って行います。

    最後は、いくつかの非線形データセットの生成方法を紹介します。

    Python環境を準備する

    Pythonの仮想環境を作ってscikit-learnとJupyterなど必要なライブラリをインストールします。

    # 作業フォルダを作って、そこへ移動する
    mkdir svm_test
    cd svm_test
    
    # 仮想環境を作り、アクティベートする
    python3 -m venv venv
    source venv/bin/activate
    
    # pip をアップグレードしておく
    pip install --upgrade pip
    
    # 必要なライブラリをインストール
    pip install numpy scikit-learn jupyter matplotlib 

    Jupyterノートブックを立ち上げてPython3のノートブックを作成してください。Jupyterノートブックに関しては、こちらを参照してください。

    なお、ノートブックの閲覧編集にはVSCode(Visual Studio Code)も使えます。私は、どちらかというとVSCodeをよく使います。これについてもこちらで簡単に解説しています。

    データを準備する

    make_moonsでデータを作成

    今回は、make_moonsを使ってデータセットを作成します。

    from sklearn.datasets import make_moons
    
    # データセットを作成
    X, y = make_moons(n_samples=100, noise=0.1, random_state=0)

    再現性の確保のため、乱数シードを固定(random_state=0)にしています。

    このデータセットは、交互に重なった2つの半円になります。プロットして画像で確認します。

    import matplotlib.pyplot as plt
    
    # データポイントをプロット
    plt.figure()
    plt.scatter(X[y==0, 0], X[y==0, 1], color='red', marker='o', label='class 0')
    plt.scatter(X[y==1, 0], X[y==1, 1], color='blue', marker='s', label='class 1')
    plt.xlabel('x1')
    plt.ylabel('x2')
    plt.legend()
    plt.title('Moons dataset')
    plt.show()
    画像

    このように2つの半円が重なり、非線形のデータ配置になっています。

    訓練とテストデータに分割

    データセットの3割をテスト用にして、残りを訓練用にします。

    from sklearn.model_selection import train_test_split
    
    # トレーニングデータとテストデータに分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, 
                             test_size=0.3, random_state=42)

    全体のデータ数が100なので、テストデータは30個、訓練データは70個になります。

    なお、ここでも乱数シードを固定しています。random_stateに設定する値は何でもOKですが、同じであることが重要で、毎回このコマンドが呼ばれるたびに同じ乱数のシーケンスが使われるようになります。

    データの正規化

    特徴量の正規化を行います。

    from sklearn.preprocessing import StandardScaler
    
    # 特徴量を正規化
    scaler = StandardScaler()
    X_train = scaler.fit_transform(X_train)
    X_test = scaler.transform(X_test)

    ここでは、StandardScalarを使っているので、訓練データの平均を0、標準偏差を1にスケーリングします。これにより、各特徴量が正規化されます。

    また、訓練データのもともとの平均と標準偏差を使って、テストデータもスケーリングします。テストデータは必ずしも平均を0、標準偏差を1にはなりませんが、訓練データとテストデータが同じスケールで処理されるので、訓練データで学習したモデルがテストデータで同様の予測ができるようになります。

    決定境界を可視化する関数

    決定境界とサポートベクトルを2次元で可視化

    SVMの分類器による決定境界を可視化するための関数として plot_decision_boundary を定義します。

    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.colors import ListedColormap
    
    # 決定境界を可視化する関数
    def plot_decision_boundary(X, y, classifier, test_data=False):
        X_set, y_set = X, y
        X1, X2 = np.meshgrid(
                     np.arange(X_set[:, 0].min() - 1, X_set[:, 0].max() + 1, 0.01),
                     np.arange(X_set[:, 1].min() - 1, X_set[:, 1].max() + 1, 0.01))
        
        # 各座標点を1次元配列に変換して分類器に入力
        Z = classifier.predict(np.array([X1.ravel(), X2.ravel()]).T)
    
        # 予測結果をグリッドの行列形式に変換
        plt.contourf(X1, X2, Z.reshape(X1.shape),
                     alpha=0.75, cmap=ListedColormap(('red', 'blue')))
    
        # x軸とy軸の範囲を設定
        plt.xlim(X1.min(), X1.max())
        plt.ylim(X2.min(), X2.max())
    
        # データポイントをプロット
        for i, j in enumerate(np.unique(y_set)):
            plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                        c=ListedColormap(('red', 'blue'))(i), label=j)
        
        # グラフのタイトル設定
        if test_data:
            plt.title('Decision boundary (Test data)')
        else:
            plt.title('Decision boundary (Training data)')
        
        plt.xlabel('Feature 1')
        plt.ylabel('Feature 2')
        plt.legend()
        plt.show()
    • X: 特徴量の行列。2次元のデータセットが渡されます。

    • y: 対応するラベルのベクトル。各データポイントのクラスを表します。

    • classifier: 学習済みの分類器。この分類器を使用して決定境界を計算します。

    • test_data: テストデータであるかを指定するフラグ。Trueの場合、テストデータに対するプロットとしてタイトルを変更します。

    このコードを理解する必要はありませんが、興味がある方のために少し解説します。

    2次元平面上のメッシュグリッドを作成

    まず、2次元平面上のメッシュグリッド(meshgrid)を生成しています。

        X1, X2 = np.meshgrid(
                     np.arange(X_set[:, 0].min() - 1, X_set[:, 0].max() + 1, 0.01),
                     np.arange(X_set[:, 1].min() - 1, X_set[:, 1].max() + 1, 0.01))

    ここの部分は、複雑なので以下のように分解して解説します。

        # 特徴量は2次元(平面)データ
        X1_set, X2_set = X_set[:, 0], X_set[:, 1]
    
        # 各軸の最小値と最大値を基準にしてグリッドの範囲定める
        X1_min, X1_max = X1_set.min() - 1, X1_set.max() + 1
        X2_min, X2_max = X2_set.min() - 1, X2_set.max() + 1
    
        # グリッドの範囲を0.01刻みで分割したのが軸値
        X1_points = np.arange(X1_min, X1_max, 0.01)
        X2_points = np.arange(X2_min, X2_max, 0.01)
    
        # すべての組み合わせが座標点のセット
        X1, X2 = np.meshgrid(X1_points, X2_points)

    やりたいのは、今回の特徴量は2次元(平面)データなので、2次元のグリッドを使って各座標の値を指定することです。

        # 特徴量は2次元(平面)データ
        X1_set, X2_set = X_set[:, 0], X_set[:, 1]

    まず、各軸の最小値と最大値を基準にしてグリッドの範囲を定めます。

        # 各軸の最小値と最大値を基準にしてグリッドの範囲定める
        X1_min, X1_max = X1_set.min() - 1, X1_set.max() + 1
        X2_min, X2_max = X2_set.min() - 1, X2_set.max() + 1

    描画する範囲は、実際の範囲から±1と広げてすべてのデータがはっきりと表示されるようにしています。

    次に、軸の値を決めます。

        # グリッドの範囲を0.01刻みで分割したのが軸値
        X1_points = np.arange(X1_min, X1_max, 0.01)
        X2_points = np.arange(X2_min, X2_max, 0.01)

    ここでは、グリッドの範囲を0.01刻みで分割しています。

    分割点の数は、データの範囲と刻みの細かさによって変わってきます。

    この2つの軸の値のすべての組み合わせが座標点のセットとなります。

        # すべての組み合わせが座標点のセット
        X1, X2 = np.meshgrid(X1_points, X2_points)

    ここで meshgrid を使っています。「mesh」(メッシュ)は網目の意味です。

    meshgrid の目的は、N個の軸の値のすべての組み合わせをN次元のグリッドのインデックスでアクセスできるようにすることです。

    簡単な例で説明します。

    x = np.array([1, 2])
    y = np.array([3, 4, 5])
    
    X, Y = np.meshgrid(x, y)

    ここでは、x と y の2つのリストがあり、x は2つの値、y は3つの値があります。この2つの軸の組み合わせでは、横軸2と縦軸3なので6個の座標ができます。

    よって、XとYは横2x縦3(行3列2)のグリッドに配置されます。

    print("X:", X.shape)
    print("Y:", Y.shape)

    これは、次のように表示されます。

    X: (3, 2)
    Y: (3, 2)

    つまり、XもYも行3列2の2次元データになっています。これらのデータは3x2の行列に収まっていることになります。

    実際にXとYの値を表示してみます。

    print("X:")
    print(X)
    
    print("Y:")
    print(Y)
    X:
    [[1 2]
     [1 2]
     [1 2]]
    Y:
    [[3 3]
     [4 4]
     [5 5]]

    こうしてみると、Xの値である1と2に対して、すべてのYの値3、4、5を組み合わせた形になっています。これですべての座標の値を行列のインデックスでアクセスできるようになりました。

    たとえば、例えば一番左上の座標は 行列のインデックスが[0, 0] なので、X[0, 0] と Y[0, 0] の値から (1, 3) となります。

    グリッドのインデックスと座標の値を対応させて表示してみます。

    for i in range(3):
        for j in range(2):
            print(f'[{i}][{j}] => ({X[i][j]}, {Y[i][j]})')
    [0][0] => (1, 3)
    [0][1] => (2, 3)
    [1][0] => (1, 4)
    [1][1] => (2, 4)
    [2][0] => (1, 5)
    [2][1] => (2, 5)

    なお、meshgridは、3次元以上の多次元でも使用可能です。

    例えば、3次元ならば、インデックスも座標の値も3次元になります。

    分類器による予測

    メッシュグリッド上の各点に対して、分類器 classifier がどのクラスに分類するかを予測します。

        # 各座標点を1次元配列に変換して分類器に入力
        Z = classifier.predict(np.array([X1.ravel(), X2.ravel()]).T)

    X1とX2は2次元配列ですが、分類器で1次元の入力を期待しているので、ravel() を使って、X1とX2を1次元化しています。

    このままだと、入力が(特徴量の数 x データ数)なので、.T で転置することで、(データ数 x 特徴量の数)とし、行が一つのデータポイント(2つの特徴量の値)としています。

    決定境界の描画

    予測結果をグリッドの行列形式にリシェイプして、決定境界を描画します。

        # 予測結果をグリッドの行列形式に変換
        plt.contourf(X1, X2, Z.reshape(X1.shape),
                     alpha=0.75, cmap=ListedColormap(('red', 'blue')))

    contourfを使って、予測結果をもとに決定境界を塗りつぶしています。

    また、ListedColormap(('red', 'blue'))を使って、2つのクラスに対応する領域を赤と青で表示しています。

    alpha=0.75は透明度を指定しています。

    あとは、 scatter を使ってデータポイントを表示します。また、タイトルやラベルなども追加します。

    線形カーネルでの実験

    線形カーネルを指定して、SVM分類器(SVC)を訓練します。

    from sklearn.svm import SVC
    
    # 線形カーネルを使用してSVMをトレーニング
    svm_linear = SVC(kernel='linear', random_state=0, C=1.0)
    svm_linear.fit(X_train, y_train)

    まずは、訓練データに対して、決定境界線を可視化します。

    # 線形カーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, svm_linear)
    画像
    線形カーネルによる境界線(訓練データ)

    まあ、かなりのデータの分類はできていますが、やっぱり本質を捉えていないのが訓練データでもわかります。

    テストデータでも同様に決定境界線を可視化してみます。

    # 線形カーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, svm_linear, test_data=True)
    画像
    線形カーネルによる境界線(テストデータ)

    テストデータでも結果は似ています。うまく分類できていないデータポイントがいくつか確認できます。

    多項式カーネルでの実験

    多項式カーネルで次数を変えながら境界線を比較します。

    2次の多項式カーネル

    2次の多項式カーネルで実験します。

    # 多項式カーネルを使用してSVMをトレーニング
    svm_poly = SVC(kernel='poly', degree=2, random_state=0, C=1.0)
    svm_poly.fit(X_train, y_train)

    カーネルを多項式(kernel='poly')、次数を2(degree=2)と指定しました。

    境界線を表示します。

    # 多項式カーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, svm_poly)
    
    # 多項式カーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, svm_poly, test_data=True)
    画像
    2次の多項式カーネルによる境界線(訓練データ)
    画像
    2次の多項式カーネルによる境界線(テストデータ)

    あまりうまく分割できてはいません。

    なお、2次の多項式カーネルでは、データを放物線状や円形の対称性を持った形で分割する傾向があります。

    3次の多項式カーネル

    3次の多項式カーネルで実験します。

    # 多項式カーネルを使用してSVMをトレーニング
    svm_poly = SVC(kernel='poly', degree=3, random_state=0, C=1.0)
    svm_poly.fit(X_train, y_train)
    
    # 多項式カーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, svm_poly)
    
    # 多項式カーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, svm_poly, test_data=True)
    画像
    3次の多項式カーネルによる境界線(訓練データ)
    画像
    3次の多項式カーネルによる境界線(テストデータ)

    2次の時よりは分割がうまくいっていますが、これなら線形カーネルの方がよかったようにも見えます。

    3次の多項式には、3次の式が含まれるので、S字型や非対称のカーブを持った決定境界が作られる傾向があります。

    多項式カーネルの性質

    4次、5次ともっと多項式の次数を増やすことができますが、境界線はあまりうまく分割を行えません。興味のある方はやってみてください。

    なお、偶数次と奇数次で境界線の形状に異なる傾向が見られます。これは、多項式関数の性質によるものです。

    • 偶数次の多項式は、グラフが左右対称または上下対称になりやすい性質を持っています。そのため、分類器がデータを放物線や円形のような対称的な形で分割します。

    • 一方で、奇数次の多項式は、非対称なカーブを描き、より柔軟にデータを分割できます。

    RBFカーネルでの実験

    ガンマ=0.5

    RBFカーネルでも実験してみます。

    # RBFカーネルを使用してSVMをトレーニング
    svm_rbf = SVC(kernel='rbf', random_state=0, gamma=0.5, C=1.0)
    svm_rbf.fit(X_train, y_train)

    カーネルはRBF(kernel='rbf')で、ガンマは0.5(gamma=0.5)を指定しました。

    ガンマ(gamma)は、RBFカーネルの中の指数関数で使われるハイパーパラメータです。データ点の影響範囲を調整するパラメータで、分散の逆数的な意味があります。

    • 小さいgamma: 各データ点の影響範囲が広くなり、遠くのデータ点も考慮して滑らかな決定境界を作ります。

    • 大きいgamma: 各データ点の影響範囲が狭くなり、近くのデータ点だけに焦点を当てて、より複雑で細かい決定境界を作ります。

    詳しくはこちらを参照してください。

    # RBFカーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, svm_rbf)
    
    # RBFカーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, svm_rbf, test_data=True)
    画像
    RBFカーネル(ガンマ=0.5)による境界線(訓練データ)
    画像
    RBFカーネル(ガンマ=0.5)による境界線(テストデータ)

    かなりよく分割できています。

    ガンマ=0.9

    ガンマを大きくして(gamma=0.9)、より局所的な影響を強めてみます。

    # RBFカーネルを使用してSVMをトレーニング
    svm_rbf = SVC(kernel='rbf', random_state=0, gamma=0.9, C=1.0)
    svm_rbf.fit(X_train, y_train)
    
    # RBFカーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, svm_rbf)
    
    # RBFカーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, svm_rbf, test_data=True)
    画像
    RBFカーネル(ガンマ=0.9)による境界線(訓練データ)
    画像
    RBFカーネル(ガンマ=0.9)による境界線(テストデータ)

    かなりうまく分割できています。このデータセットでは、過学習は見受けられません。

    ガンマ=0.1

    今度は、ガンマを小さくして(gamma=0.1)、広範囲のデータからの影響を考慮するようにします。

    # RBFカーネルを使用してSVMをトレーニング
    svm_rbf = SVC(kernel='rbf', random_state=0, gamma=0.1, C=1.0)
    svm_rbf.fit(X_train, y_train)
    
    # RBFカーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, svm_rbf)
    
    # RBFカーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, svm_rbf, test_data=True)
    画像
    RBFカーネル(ガンマ=0.1)による境界線(訓練データ)
    画像
    RBFカーネル(ガンマ=0.1)による境界線(テストデータ)

    こうなるともはや線形カーネルとあまり変わりません。

    以上より、RBFカーネルではガンマの調節が非常に重要なのがわかります。

    ハイパーパラメータの調節

    正則化パラメータC

    SVCには、正則化パラメータとしてCがあり、誤分類をどれだけ許容するかを制御します。

    • 大きいC: 誤分類をできるだけ許さず、境界線がデータに厳密にフィットします。これにより、過学習が起きやすくなります。

    • 小さいC: 一部の誤分類を許容し、決定境界がより滑らかになり、汎化性能が向上します。柔軟に適合することで過学習を防ぎます。しかし、Cが小さすぎると未学習になる可能性も高くなります。

    つまり、Cはモデルの複雑さと汎化性能のバランスを調整しますが、これを手作業で調節するのは簡単ではありません。

    ランダム・サーチ

    ハイパーパラメータの調節では、グリッド・サーチやランダム・サーチなどを使います。今回は、幅広い範囲でハイパーパラメータを探索したいのでランダム・サーチを使います。

    まず、検索する値を対数スケールで準備します。

    from sklearn.model_selection import RandomizedSearchCV
    
    # ランダムサーチ用のパラメータ範囲を定義
    param_dist = {
        'C': np.logspace(-3, 3, 100),     # 10^-3 から 10^3 を対数スケールの範囲
        'gamma': np.logspace(-4, 2, 100), # 10^-4 から 10^2 を対数スケールの範囲
    }

    次に、ランダムサーチを実行します。

    # ランダムサーチを実行(試行回数n_iterを設定)
    random_search = RandomizedSearchCV(SVC(), 
        param_distributions=param_dist, n_iter=50, cv=5, random_state=42)
    random_search.fit(X_train, y_train)

    最良のパラメータを表示します。

    # 最良のパラメータを表示
    best_params = random_search.best_params_
    print(best_params)
    {'gamma': np.float64(1.747528400007683), 'C': np.float64(23.10129700083158)}

    つまり、ガンマは約1.75、Cは約23.1となりました。

    境界線を表示します。

    # RBFカーネルでの決定境界を可視化(トレーニングデータ)
    plot_decision_boundary(X_train, y_train, random_search)
    
    # RBFカーネルでの決定境界を可視化(テストデータ)
    plot_decision_boundary(X_test, y_test, random_search, test_data=True)
    画像
    RBFカーネル(ランダム・サーチ)による境界線(訓練データ)
    画像
    RBFカーネル(ランダム・サーチ)による境界線(テストデータ)

    かなりよく分類できています。

    もっと非線形データを生成する

    make_moons をいじる

    今回はデータ数も100と多くはありません。また、ノイズも0.1と低めに設定してあります。

    よって、SVM(特にRBFカーネル)が過学習している可能性はあります。

    そこで、もっとノイズを増やしたり、大きなデータセットを作ってみたら結果も変わってくるので面白いでしょう。

    例えば、以下のように make_moons を使ってデータ数とノイズを増やしてみてください。

    X, y = make_moons(n_samples=500, noise=0.3, random_state=0)

    また、以下に挙げるように非線形データを作る方法は他にもあります。

    同心円のデータ作成:make_circles

    make_circlesは、円状の2つの同心円から成るデータを生成します。内側と外側の円がそれぞれ異なるクラスに属するため、非線形の分類問題に適しています。

    from sklearn.datasets import make_circles
    import matplotlib.pyplot as plt
    
    # データ生成
    X, y = make_circles(n_samples=100, noise=0.05, factor=0.5, random_state=0)
    
    # データ可視化
    plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='red', label='Class 0')
    plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='blue', label='Class 1')
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.legend()
    plt.show()
    • factor: 内側の円と外側の円の距離を調整します。

    • noise: データに対するノイズの強さを指定します。

    画像
    make_circlesで同心円のデータ生成

    ガウス分布によるデータ作成:make_blobs

    make_blobsは、複数のガウス分布からデータを生成します。デフォルトでは線形分離可能なデータが作られますが、パラメータを調整することで非線形の分布も作れます。cluster_stdでクラス間の散らばり具合を設定すると、データが線形分離できなくなる場合があります。

    from sklearn.datasets import make_blobs
    
    # データ生成
    X, y = make_blobs(n_samples=100, centers=3, cluster_std=1.0, random_state=0)
    
    # データ可視化
    plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='red', label='Class 0')
    plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='blue', label='Class 1')
    plt.scatter(X[y == 2][:, 0], X[y == 2][:, 1], color='green', label='Class 2')
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.legend()
    plt.show()
    • centers: クラス数を指定します。

    • cluster_std: クラス内のデータのばらつき具合を指定します。

    画像
    make_blobsでガウス分布によるデータ生成

    正規分布から複数クラス:make_gaussian_quantiles

    make_gaussian_quantilesは、正規分布に従うデータを複数のクラスに分割し非線形の分布を作ることができます。

    from sklearn.datasets import make_gaussian_quantiles
    
    X, y = make_gaussian_quantiles(
               n_samples=100, n_features=2, n_classes=3, random_state=0)
    
    # データ可視化
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis')
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')
    plt.show()
    画像
    make_gaussian_quantilesで正規分布から複数クラスのデータ作成

    以上、これらの関数を使うことで、さまざまな非線形データセットを生成し、モデルのテストや可視化に活用できます。

    興味のある方はトライしてみてください。

    次回予告

    SVMは非線形データの処理に非常に優れた機械学習モデルです。他の古典機械学習モデルよりも優れた結果を出すことが多々あります。

    一方で、SVMは大規模なデータセットでは計算コストが増大し、学習に時間がかかるという課題があります。

    「非線形」と聞いて、ニューラルネットワークを思い浮かべる方も多いでしょう。実際、ディープラーニング(多層ニューラルネットワーク)の成功により、大規模データセットではSVMの役割が減少してきました。

    なお、scikit-learnではニューラルネットワークもサポートされており、簡単に試すことが可能です。

    次回は、ニューラルネットワークを紹介します。

    お楽しみに!

     
     
    「わかりやすく、具体的に」AIとサイエンスの情報を発信中

    あなたへのおすすめ