【Python実践】サポートベクターマシンを使いこなす！分類・回帰・異常検知の実践法（コピペで使えるサンプルコード付き）

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from matplotlib import rcParams
rcParams['font.family'] = 'Meiryo'

# サンプルデータの生成(4種類に分類可能な2次元のデータを100個生成)
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, n_classes=4, random_state=42)

# データを訓練用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 線形SVMモデルの作成
linear_svm = SVC(kernel='linear', C=1)

# モデルの訓練
linear_svm.fit(X_train, y_train)

# テストデータで予測
y_pred = linear_svm.predict(X_test)

# 精度の評価
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100:.2f}%")

# グラフの描画
def plot_decision_boundary(X, y, model):
    h = .02  # メッシュステップサイズ
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.3)
    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolor='k', s=20)
    plt.title("SVM 決定境界")
    plt.xlabel("特徴 1")
    plt.ylabel("特徴 2")
    plt.show()

# 訓練データと決定境界の描画
plot_decision_boundary(X_train, y_train, linear_svm)

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from matplotlib import rcParams
rcParams['font.family'] = 'Meiryo'

# サンプルデータの生成 (3種類に分類可能な3次元データを100個生成)
X, y = make_classification(n_samples=100, n_features=3, n_informative=3, n_redundant=0, n_repeated=0, n_classes=3, random_state=42)

# データを訓練用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 非線形SVM（RBFカーネル）の使用
rbf_svm = SVC(kernel='rbf', C=1, gamma=0.5)

# モデルの訓練
rbf_svm.fit(X_train, y_train)

# テストデータで予測
y_pred_rbf = rbf_svm.predict(X_test)

# 精度の評価
accuracy_rbf = accuracy_score(y_test, y_pred_rbf)
print(f"Accuracy (RBF Kernel): {accuracy_rbf * 100:.2f}%")

# 3Dプロットの描画
def plot_decision_boundary_3d(X, y, model):
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    z_min, z_max = X[:, 2].min() - 1, X[:, 2].max() + 1
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 50), np.linspace(y_min, y_max, 50))
    zz = np.zeros(xx.shape)
    for i in range(xx.shape[0]):
        for j in range(xx.shape[1]):
            zz[i, j] = model.predict(np.array([[xx[i, j], yy[i, j], 0]]))[0]
    
    ax.plot_surface(xx, yy, zz, alpha=0.3, rstride=100, cstride=100)
    scatter = ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y, edgecolor='k', s=20)
    ax.set_title("SVM 決定境界 (RBF カーネル)")
    ax.set_xlabel("特徴 1")
    ax.set_ylabel("特徴 2")
    ax.set_zlabel("特徴 3")
    plt.show()

# 3次元データと決定境界の描画
plot_decision_boundary_3d(X_train, y_train, rbf_svm)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.decomposition import PCA
from matplotlib import rcParams
rcParams['font.family'] = 'Meiryo'

# サンプルデータの生成（4種類に分類可能な100次元のデータを200個生成）
X, y = make_classification(n_samples=200, n_features=100, n_informative=4, n_redundant=0, n_clusters_per_class=1, n_classes=4, random_state=42)

# データを訓練用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# PCAによる次元削減（100次元を2次元に削減）
pca = PCA(n_components=2)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

# 非線形SVM（RBFカーネル）の使用
rbf_svm_pca = SVC(kernel='rbf', C=1, gamma=0.5)

# 次元削減後のデータを使ってモデルの訓練
rbf_svm_pca.fit(X_train_pca, y_train)

# テストデータで予測
y_pred_rbf_pca = rbf_svm_pca.predict(X_test_pca)

# 精度の評価
accuracy_rbf_pca = accuracy_score(y_test, y_pred_rbf_pca)
print(f"Accuracy (RBF Kernel, PCA): {accuracy_rbf_pca * 100:.2f}%")

# グラフの描画
def plot_decision_boundary(X, y, model):
    h = .02  # メッシュステップサイズ
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.3)
    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolor='k', s=20)
    plt.title("SVM 決定境界 (PCA)")
    plt.xlabel("特徴 1")
    plt.ylabel("特徴 2")
    plt.show()

# PCAで次元削減したデータで決定境界の描画
plot_decision_boundary(X_train_pca, y_train, rbf_svm_pca)

# ～　省略 ～

evaluate_classification_metrics(y_test, y_pred_rbf_pca)

# ～　省略 ～

# 非線形SVM（RBFカーネル）の使用（ probability=Trueを指定）
rbf_svm_pca = SVC(kernel='rbf', C=1, gamma=0.5, probability=True)

# ～　省略 ～

# 陽性クラスの予測確率を取得（0列目：クラス0の確率、1列目：クラス1の確率が格納されている）
y_prob = rbf_svm_pca.predict_proba(X_test_pca)[:, 1]

# ROC曲線のプロット（2値)
plot_roc_curve(y_test, y_prob)

# ～　省略 ～

# 非線形SVM（RBFカーネル）の使用（ probability=Trueを指定）
rbf_svm_pca = SVC(kernel='rbf', C=1, gamma=0.5, probability=True)

# ～　省略 ～

# 陽性クラスの予測確率を取得
y_prob = rbf_svm_pca.predict_proba(X_test_pca)

# ROC曲線のプロット（多値）
plot_roc_curve_multi(y_test, y_prob)

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

# サンプルデータの生成（多クラス分類、特徴量50）
X, y = make_classification(n_samples=1000, n_features=50, n_informative=30, n_redundant=10, n_classes=3, random_state=42)

# SVMモデルの設定
svm = SVC()

# パラメータグリッドの設定
param_grid = {
    'C': [0.1, 1, 10, 100, 1000],
    'gamma': [1, 0.1, 0.01, 0.001, 0.0001],
    'kernel': ['rbf']
}

# グリッドサーチの設定
grid = GridSearchCV(svm, param_grid, refit=True, verbose=3)
grid.fit(X, y)

# 最適なパラメータの表示
print("Best Parameters:", grid.best_params_)

# グリッドサーチ後の最適モデルを取得
best_model = grid.best_estimator_
print("Best Model:", best_model)

import matplotlib.pyplot as plt
from sklearn.svm import SVR
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
from matplotlib import rcParams

# 日本語フォントの設定
rcParams['font.family'] = 'Meiryo'

# サンプルデータの生成（回帰問題、特徴量50）
X, y = make_regression(n_samples=200, n_features=50, noise=0.1, random_state=42)

# データを訓練用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 最適なパラメータを使用してSVRモデルを再訓練
svr = SVR(kernel='rbf', C=100, gamma=0.01)
svr.fit(X_train, y_train)

# テストデータで予測
y_pred = svr.predict(X_test)

# 精度の評価
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"Mean Squared Error: {mse:.2f}")
print(f"R^2 Score: {r2:.2f}")

# 結果のプロット
plt.figure(figsize=(8, 6))
plt.scatter(y_test, y_pred, color='blue', label='予測値 vs 実測値')
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=2, label='理想的な直線')
plt.xlabel('実測値')
plt.ylabel('予測値')
plt.title('SVRによる回帰')
plt.legend()
plt.grid()
plt.show()

# ～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
# ここにSVMUtilとグラフ描画関数のコードを張り付けるか、インポートしてください
# ～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～

import numpy as np
import pandas as pd

# ------------------------------------------------------------------
# 訓練データを生成し、DataFrameに変換
# ------------------------------------------------------------------
# シードを固定
np.random.seed(42)

# ダミーデータの生成
data = {
    'feature1': np.random.rand(100),
    'feature2': np.random.rand(100),
    'target': np.random.choice([0, 1], size=100)
}
df = pd.DataFrame(data)

# ------------------------------------------------------------------
# 生成した訓練データでSVMを学習し、モデルを保存
# ------------------------------------------------------------------
# SVMUtilクラスのインスタンスを作成
svm_util = SVMUtil(df)

# モデルを学習する
svm_util.fit(column=['feature1', 'feature2'], target='target', C=1.0, gamma='scale', kernel='rbf')

# 予測を行う
predictions = svm_util.predict(column=['feature1', 'feature2'])
print(predictions)

# 訓練データの分類結果をグラフ化
plot_svm_results_2d(svm_util,X_train=df[['feature1','feature2']].values,y_train=df['target'].values)

# モデルを保存する
svm_util.save_model('svm_model.pkl')

# ------------------------------------------------------------------
# 新しいデータを作成し、保存したモデルを読み込んで分類を実行
# ------------------------------------------------------------------
# 新しいデータフレームを作成して予測を行う
new_data = {
    'feature1': np.random.rand(10),
    'feature2': np.random.rand(10)
}
new_df = pd.DataFrame(new_data)

# モデルを読み込む
svm_util.load_model('svm_model.pkl')

# 読み込んだモデルで予測する
new_predictions = svm_util.predict(column=['feature1', 'feature2'], df=new_df)
print(new_predictions)

# テストデータの分類結果をグラフ化
plot_svm_results_2d(svm_util,X_test=new_df[['feature1','feature2']].values,y_test=new_predictions)

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import rcParams
rcParams['font.family'] = 'Meiryo'

def plot_svm_results_2d(model, X_train=None, y_train=None, X_test=None, y_test=None):
    """
    2次元データのSVMの結果をプロットする。

    学習データとテストデータを表示し、クラスを色分けしてプロットする。
    また、決定境界を描画する。

    Parameters:
    model : SVMモデル
        学習済みのSVMモデル。
    X_train : array-like, shape (n_samples, 2), optional
        学習データの特徴量。2次元データを想定。
    y_train : array-like, shape (n_samples,), optional
        学習データのクラスラベル。
    X_test : array-like, shape (n_samples, 2), optional
        テストデータの特徴量。2次元データを想定。
    y_test : array-like, shape (n_samples,), optional
        テストデータのクラスラベル。
    """
    plt.figure(figsize=(8, 6))

    # 学習データのプロット（2次元データのみ）
    if X_train is not None and y_train is not None:
        plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='coolwarm', edgecolors='k', s=70, label="学習データ")

    # テストデータのプロット（2次元データのみ）
    if X_test is not None and y_test is not None:
        plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap='coolwarm', edgecolors='none', s=70, label="テストデータ")

    # 境界の等高線を描画するための範囲を設定
    if X_train is not None:
        xx, yy = np.meshgrid(np.linspace(X_train[:, 0].min() - 1, X_train[:, 0].max() + 1, 500),
                             np.linspace(X_train[:, 1].min() - 1, X_train[:, 1].max() + 1, 500))
    elif X_test is not None:
        xx, yy = np.meshgrid(np.linspace(X_test[:, 0].min() - 1, X_test[:, 0].max() + 1, 500),
                             np.linspace(X_test[:, 1].min() - 1, X_test[:, 1].max() + 1, 500))
    else:
        # 両方のデータがない場合は範囲を固定（適宜調整）
        xx, yy = np.meshgrid(np.linspace(-5, 5, 500), np.linspace(-5, 5, 500))

    x_range = np.c_[xx.ravel(), yy.ravel()]
    Z = model.model.decision_function(x_range).reshape(xx.shape)

    # 境界の等高線を描画
    plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors='black')
    plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.Blues_r, alpha=0.3)

    # グラフの設定
    plt.legend()
    plt.title("SVM 分類結果と決定境界", fontsize=16)
    plt.xlabel("特徴量 1", fontsize=12)
    plt.ylabel("特徴量 2", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.7)

    # 結果を表示
    plt.show()


def plot_svm_results_1d(model, X_train=None, y_train=None, X_test=None, y_test=None):
    """
    1次元データのSVMの結果をプロットする。

    学習データとテストデータを表示し、クラスを色分けしてプロットする。
    また、決定境界を描画する。

    Parameters:
    model : SVMモデル
        学習済みのSVMモデル。
    X_train : array-like, shape (n_samples,), optional
        学習データの特徴量。1次元データを想定。
    y_train : array-like, shape (n_samples,), optional
        学習データのクラスラベル。
    X_test : array-like, shape (n_samples,), optional
        テストデータの特徴量。1次元データを想定。
    y_test : array-like, shape (n_samples,), optional
        テストデータのクラスラベル。
    """
    plt.figure(figsize=(8, 6))

    # 学習データのプロット
    if X_train is not None and y_train is not None:
        plt.scatter(X_train, y_train, c='lightblue', edgecolors='k', s=70, label="学習データ")

    # テストデータのプロット
    if X_test is not None and y_test is not None:
        plt.scatter(X_test, y_test, c='green', edgecolors='none', s=70, label="テストデータ")

    # 決定境界の描画
    if X_train is not None:
        x_range = np.linspace(X_train.min() - 1, X_train.max() + 1, 500).reshape(-1, 1)
    elif X_test is not None:
        x_range = np.linspace(X_test.min() - 1, X_test.max() + 1, 500).reshape(-1, 1)
    else:
        # 両方のデータがない場合は固定範囲を使用（適宜調整）
        x_range = np.linspace(-5, 5, 500).reshape(-1, 1)

    y_range = model.model.decision_function(x_range)
    plt.plot(x_range, y_range, color='black', linewidth=2, label='決定境界')

    # グラフの設定
    plt.axhline(0, color='black', linewidth=2)
    plt.legend()
    plt.title("SVM 分類結果（1次元）", fontsize=16)
    plt.xlabel("特徴量", fontsize=12)
    plt.ylabel("クラスラベル", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.7)

    # 結果を表示
    plt.show()

import numpy as np
import pandas as pd
from sklearn.svm import SVC
import pickle

class SVMUtil:
    def __init__(self, df=None, model_path=None):
        """
        SVMUtilクラスの初期化メソッド
        :param df: 初期データフレーム (pd.DataFrame)
        :param model_path: モデルファイルのパス (str)
        """
        self.df = None if df is None else df.copy()  # データフレームのコピーを保持
        self.model = None if model_path is None else self.load_model(model_path)  # SVMモデル
        self.pred = []  # 予測結果のリスト

    def fit(self, column, target, C=1.0, gamma="auto", kernel="rbf"):
        """
        SVMモデルの作成と学習
        :param column: 学習に使用するカラム名 (str または list)
        :param target: 目的変数（ターゲット変数）のカラム名 (str)
        :param C: SVMのCパラメータ (float)
        :param gamma: SVMのgammaパラメータ (str または float)
        :param kernel: 使用するカーネルの種類 (str)
            - 'linear': 線形カーネル
            - 'poly': 多項式カーネル
            - 'rbf': RBFカーネル（ガウシアンカーネル⇒デフォルト）
            - 'sigmoid': シグモイドカーネル
        :return: 学習したモデル
        """
        # 指定されたカラムのデータを抽出
        if isinstance(column, list) and len(column) > 1:
            X = self.df[column].values
        else:
            X = self.df[column].values.reshape(-1, 1)  # 複数カラムのデータを2次元配列に変換

        y = self.df[target].values

        # SVMモデルの作成
        self.model = SVC(C=C, gamma=gamma, kernel=kernel, probability=True).fit(X, y)
        return self.model

    def predict(self, column, df=None):
        """
        学習したモデルを使用して予測を行う
        :param column: 学習に使用するカラム名 (str または list)
        :param df: 予測に使用するデータフレーム (pd.DataFrame)
        :return: 予測結果の配列
        """
        if df is not None:
            self.df = df

        # 指定されたカラムのデータを抽出
        if isinstance(column, list) and len(column) > 1:
            X = self.df[column].values
        else:
            X = self.df[column].values.reshape(-1, 1)  # 複数カラムのデータを2次元配列に変換

        self.pred = self.model.predict(X)
        return self.pred

    def read_csv(self, file_name, encoding="shift-jis"):
        """
        CSVファイルからデータを読み込むメソッド
        :param file_name: 読み込むファイルのパス (str)
        :param encoding: ファイルのエンコーディング (str)
        """
        self.df = pd.read_csv(file_name, encoding=encoding)  # データフレームに読み込み

    def save_model(self, model_path):
        """
        学習したモデルをファイルに保存するメソッド
        :param model_path: 保存するファイルのパス (str)
        """
        self.model_path = model_path
        with open(model_path, 'wb') as f:
            pickle.dump(self.model, f)  # モデルをバイナリ形式で保存

    def load_model(self, model_path=None):
        """
        モデルをファイルから読み込むメソッド
        :param model_path: 読み込むファイルのパス (str)
        :return: 読み込んだモデル
        """
        if model_path is None:
            model_path = self.model_path

        with open(model_path, 'rb') as f:
            self.model = pickle.load(f)  # モデルをバイナリ形式で読み込み
        return self.model