【Python】「scikit-learn」簡単速習‼【識別編/総まとめ】

lr = LogisticRegression(penalty='none')

モデルを学習させます。

lr.fit(X, y)

モデルから確率を予測します。predict_probaメソッドを使って、各データ点がクラス1に属する確率を予測します。

xx1, xx2 = np.meshgrid(np.linspace(-4, 4, 100), np.linspace(-4, 4, 100))
X_grid = np.column_stack([xx1.ravel(), xx2.ravel()])
y_prob = lr.predict_proba(X_grid)[:, 1].reshape(xx1.shape)

可視化します。

plt.contourf(xx1, xx2, y_prob, cmap=plt.cm.RdBu_r, alpha=0.8)
plt.colorbar()
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdBu_r)
plt.xlim(-4, 4)
plt.ylim(-4, 4)
plt.show()

これにより、2次元データでロジスティック回帰によって確率を予測する具体例が完成しました。

サポートベクタマシーン（SVM）

サポートベクタマシン（Support Vector Machine, SVM）は、教師あり学習アルゴリズムの一つで、主に2クラスの分類問題に使用されますが、多クラス分類や回帰問題にも応用することができます。

SVMは、マージン最大化という考え方を用いて、クラスの境界線（超平面）を決定します。具体的には、データを分割する境界線の両側に、最も近いデータ点（サポートベクタ）との距離（マージン）を最大化するように境界線を引きます。

SVMでは、線形カーネルを用いた線形SVMや、非線形カーネルを用いた非線形SVMがあります。非線形SVMは、カーネルトリックと呼ばれるテクニックを用いて、非線形な境界線を引くことができます。

SVMは、高次元のデータにも対応できるため、画像処理や自然言語処理など、さまざまな分野で広く利用されています。

Pythonのscikit-learnライブラリを用いた線形SVMの例を示します。

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import LinearSVC
from sklearn.metrics import accuracy_score

# データの読み込み
iris = datasets.load_iris()
X = iris.data[:, [2, 3]]
y = iris.target

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# SVMのモデルを作成
svm = LinearSVC(C=1.0, random_state=0)
svm.fit(X_train, y_train)

# テストデータに対する予測
y_pred = svm.predict(X_test)

# 正解率の算出
acc = accuracy_score(y_test, y_pred)
print('Accuracy:', acc)

上記の例では、アヤメのデータセットを用いて線形SVMのモデルを作成し、テストデータに対する予測精度を算出しています。scikit-learnのLinearSVCクラスを使用しています。また、accuracy_score関数を用いて正解率を算出しています。

SVM：マージン、サポートベクトル、確率

SVMには、マージン、サポートベクトル、確率などの概念があります。

マージンは、分離超平面とそれに最も近いデータ点の距離です。SVMでは、マージンを最大化するように分離超平面を選択します。マージンが大きいほど、分離超平面はより一般化されたモデルになります。

サポートベクトルは、分離超平面に最も近いデータ点のうち、マージンに寄与している点を指します。SVMは、サポートベクトルを用いて分離超平面を決定するため、モデルの汎化性能が高いとされています。

確率については、SVM自体は確率的なモデルではありませんが、一部の実装では確率推定を行うことができます。具体的には、SVMを用いて分類する際に、分類器の出力をSigmoid関数などで変換して確率推定を行う方法があります。ただし、この方法は正確な確率を得るためには十分ではなく、一部のデータに対して不安定な結果を出すことがあるため、注意が必要です。

Pythonを用いたSVMの具体例を示します。

scikit-learnのSVMライブラリを用いて、アヤメの花の分類を行う例を示します。

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# データのロード
iris = datasets.load_iris()
X = iris.data[:, [2, 3]]
y = iris.target

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# SVMモデルの構築
svm = SVC(kernel='linear', C=1.0, random_state=0)

# モデルの学習
svm.fit(X_train, y_train)

# テストデータに対する予測
y_pred = svm.predict(X_test)

# 正解率の計算
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: {:.2f}'.format(accuracy))

上記のコードでは、アヤメの花のガクの長さと花びらの長さの2つの特徴量から、3種類のアヤメの花を分類するSVMモデルを構築しています。SVC関数を用いて、線形カーネルを使用するSVMモデルを定義しています。また、train_test_split関数を用いて、データをトレーニングデータとテストデータに分割しています。fit関数でモデルを学習し、predict関数でテストデータに対する予測を行っています。最後に、accuracy_score関数を用いて正解率を計算し、結果を出力しています。

※SVMで出力される数字を確率として処理する際は注意してください

SVM：非線形カーネル

SVMには、非線形の決定境界を学習するためのカーネルトリックがあります。具体的には、SVMの最適化問題で内積の代わりにカーネル関数を使用することで、非線形の決定境界を実現します。

以下は、非線形カーネルを使用してIrisデータセットの2クラス分類を行うPythonの例です。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

# Irisデータの読み込み
iris = load_iris()
X = iris.data[:, :2]
y = iris.target

# データの前処理
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# SVMのインスタンスを生成し、非線形カーネルを指定
svm = SVC(kernel='rbf', random_state=42)

# SVMの学習
svm.fit(X_train, y_train)

# 決定境界の可視化
x1_min, x1_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
x2_min, x2_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.01),
np.arange(x2_min, x2_max, 0.01))
Z = svm.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
Z = Z.reshape(xx1.shape)
plt.contourf(xx1, xx2, Z, alpha=0.3, cmap='coolwarm')
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())

# データ点のプロット
for i, target in enumerate(iris.target_names):
plt.scatter(X[y==i, 0], X[y==i, 1], label=target)
plt.legend(loc='best')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.show()

この例では、SVMのカーネル関数としてrbf（径状基底関数）を使用しています。最適なカーネル関数やハイパーパラメータの値を見つけるためには、交差検証などを使用することが推奨されます。

SVMのリニアカーネル

SVMにおいて、カーネル関数を線形カーネルに設定することで、線形分離可能なデータを分類することができます。線形カーネルは、内積による類似度を用いて計算されるため、計算が比較的簡単で高速に処理できます。

以下は、Pythonのscikit-learnライブラリを使って、がんデータを線形カーネルを用いたSVMで分類する例です。

# 必要なライブラリをインポートする
import pandas as pd
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# がんデータを読み込む
cancer = load_breast_cancer()

# 特徴量と正解データを取得する
X = cancer.data
y = cancer.target

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

# SVMのインスタンスを生成する
svc = SVC(kernel='linear', random_state=42)

# SVMのモデルを訓練する
svc.fit(X_train, y_train)

# テストデータを用いて予測する
y_pred = svc.predict(X_test)

# 正解率を計算する
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

上記の例では、SVCのkernel引数にlinearを設定することで、線形カーネルを用いたSVMを使用しています。訓練データで訓練されたモデルを用いて、テストデータを予測し、正解率を計算しています。

SVMのポリカーネル

SVMのポリカーネルとは、非線形分類問題を扱うためのカーネルの一種であり、多項式関数を用いて特徴空間を高次元化することで、非線形分類を可能にします。

ポリカーネルは、次式で表されます。

$$ K(x_i, x_j) = (\gamma x_i^T x_j + r)^d $$

ここで、$\gamma$はカーネル関数のバンド幅を制御するパラメータ、$r$は定数項を表し、$d$は多項式の次数を表します。

ポリカーネルは、SVMを用いた多項式回帰にも使用されます。多項式回帰では、入力データの変数間の相互作用を捉えるために、特徴量を高次元化します。

Pythonでの例を示します。

from sklearn.datasets import make_classification
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np

# データセットの生成
X, y = make_classification(n_features=2, n_redundant=0, n_informative=1,
n_clusters_per_class=1, random_state=4)

# ポリカーネルSVMモデルの学習
clf = SVC(kernel='poly', degree=3, gamma=1, coef0=0)
clf.fit(X, y)

# 境界線のプロット
xx, yy = np.meshgrid(np.linspace(-4, 4, 200), np.linspace(-4, 4, 200))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired)
plt.xlim(-4, 4)
plt.ylim(-4, 4)
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

この例では、make_classification関数を用いて2次元の合成データセットを生成し、SVCクラスのkernelパラメータを'poly'に設定して、ポリカーネルSVMモデルを学習しています。degreeパラメータで多項式の次数を設定し、gammaパラメータでカーネル関数のバンド幅を制御しています。また、coef0パラメータで定数項を設定しています。

結果として得られた境界線は、非線形な決定境界になっていることがわかります。

SVM：がんデータの認識

linearカーネル

Linearカーネルを使ったSVMによるがんデータの認識の例を示します。

まず、必要なライブラリをインポートします。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, confusion_matrix

次に、UCI Machine Learning Repositoryから取得した乳がんデータセットを読み込みます。データセットには30個の特徴量があり、2つのクラス（悪性腫瘍と良性腫瘍）があります。

# データの読み込み
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data', header=None)

# 特徴量とクラスラベルの抽出
X = df.loc[:, 2:].values
y = df.loc[:, 1].values

# クラスラベルをM（悪性）とB（良性）から1と0に変換
y = np.where(y == 'M', 1, 0)

データセットをトレーニングセットとテストセットに分割します。

# データセットをトレーニングセットとテストセットに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

SVMモデルを構築します。ここではLinearカーネルを使用しています。

# SVMモデルの構築
svm = SVC(kernel='linear', random_state=0, C=1.0)
svm.fit(X_train, y_train)

モデルを使用してテストセットで予測を行い、精度と混同行列を計算します。

# テストセットで予測を行い、精度と混同行列を計算
y_pred = svm.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
confmat = confusion_matrix(y_true=y_test, y_pred=y_pred)

print('Accuracy:', accuracy)
print('Confusion matrix:\n', confmat)

RBFカーネル

がんデータの認識にSVMを適用する具体例を示します。

まず、必要なライブラリをimportします。scikit-learnのdatasetsからがんデータを取得し、train_test_splitを使ってデータをトレーニングセットとテストセットに分割します。また、StandardScalerを使ってデータをスケーリングします。

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Load cancer dataset
cancer = datasets.load_breast_cancer()

# Split dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

# Scale data
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

次に、SVMを用いてモデルをトレーニングします。ここでは、RBFカーネルを使用します。Cパラメータの値は、過剰適合を避けるために小さい値を選択します。

from sklearn.svm import SVC

# Train SVM with RBF kernel
svm = SVC(kernel='rbf', C=0.1, random_state=0)
svm.fit(X_train_scaled, y_train)

最後に、テストデータを用いてモデルの精度を評価します。

from sklearn.metrics import accuracy_score

# Predict test set labels
y_pred = svm.predict(X_test_scaled)

# Calculate accuracy score
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: {:.2f}'.format(accuracy))

このコードでは、テストセット上の正解率が約97％であることが示されます。

linearカーネルとポリカーネルのどちらを使う方がよいのか

linearカーネルとpolynomialカーネルは、異なる特徴を持ちます。linearカーネルは、データが線形に分離できる場合に最適であり、polynomialカーネルは、線形に分離できないデータを扱う際に有用です。

つまり、データが線形的に分離できる場合には、linearカーネルを使用することが適切であり、線形的に分離できない場合には、polynomialカーネルを使用することが適切です。

ただし、どちらを使用するかは、データの特徴に依存するため、適切なカーネルを選択するためには、データの分布や性質を理解することが必要です。そのため、様々なカーネルを試して比較検討することが重要です。

多層パーセプトロン (Multilayer Perceptron)

MLPは、多層パーセプトロン (Multilayer Perceptron) の略で、ニューラルネットワークの一種です。複数の層から構成され、それぞれの層には複数のニューロンが含まれます。MLPは、非線形関数を用いて複雑な問題に対応することができ、広範な分野で利用されています。

MLPは、入力層、中間層、出力層の3つの層から構成されます。入力層は、データセットの特徴量を受け取ります。中間層は、複数の隠れ層で構成され、各層には複数のニューロンがあります。中間層は、入力層からの信号を受け取り、内部的な特徴表現を学習します。最後に、出力層があり、モデルの出力を生成します。

MLPは、各層の間に結合された重みとバイアスを学習します。モデルは、損失関数を最小化するように重みとバイアスを調整し、最適な予測を行います。学習アルゴリズムには、誤差逆伝播法 (Backpropagation) が一般的に用いられます。

MLPは、複雑な問題に対して非常に強力なモデルですが、多くのパラメータを持っており、過学習が起こりやすいという欠点があります。過学習を回避するためには、適切な正則化やドロップアウトなどの手法が必要になります。また、ハイパーパラメータの調整も重要な課題となります。

MLP：多層パーセプトロンの例

scikit-learnを使用して多層パーセプトロン（MLP）を実装し、分類問題を解決する例です。具体的には、ワインデータセットを使用して、ワインの品質を予測する2クラス分類問題を解決します。

# 必要なライブラリのインポート
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

# データセットの読み込み
wine = load_wine()

# 説明変数と目的変数の分割
X = wine.data
y = wine.target

# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)

# MLPモデルの構築
mlp = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=500, random_state=1)

# モデルの学習
mlp.fit(X_train, y_train)

# 予測値の算出
y_pred = mlp.predict(X_test)

# 正解率の算出
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

この例では、MLPClassifierクラスを使用して、100ノードの第1隠れ層と50ノードの第2隠れ層を持つ多層パーセプトロンを構築しています。max_iterパラメータは、モデルの学習の反復回数を設定します。また、random_stateパラメータは、乱数のシードを設定します。fitメソッドを使用して、モデルを学習し、predictメソッドを使用して、テストデータの目的変数の予測値を算出しています。最後に、accuracy_score関数を使用して、予測値の正解率を算出しています。

MLP：層を変えてみる

MLPにおいて、層を変更することでどのように精度が変化するかを見てみましょう。以下は、scikit-learnライブラリを使って、Irisデータセットを用いて多層パーセプトロンを学習する例です。層を1層から3層に変更し、それぞれの場合で精度を評価します。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

# データセットの読み込み
iris = load_iris()
X, y = iris.data, iris.target

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

# 1層のMLP
mlp1 = MLPClassifier(hidden_layer_sizes=(10,), max_iter=1000, random_state=42)
mlp1.fit(X_train, y_train)
y_pred1 = mlp1.predict(X_test)
print("1層のMLPの精度:", accuracy_score(y_test, y_pred1))

# 2層のMLP
mlp2 = MLPClassifier(hidden_layer_sizes=(10, 10), max_iter=1000, random_state=42)
mlp2.fit(X_train, y_train)
y_pred2 = mlp2.predict(X_test)
print("2層のMLPの精度:", accuracy_score(y_test, y_pred2))

# 3層のMLP
mlp3 = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000, random_state=42)
mlp3.fit(X_train, y_train)
y_pred3 = mlp3.predict(X_test)
print("3層のMLPの精度:", accuracy_score(y_test, y_pred3))

出力結果：

1層のMLPの精度: 1.0
2層のMLPの精度: 1.0
3層のMLPの精度: 1.0

この例では、Irisデータセットを用いて1層から3層のMLPを学習しました。いずれの場合でも、精度は1.0となり、3層にすることで精度が向上することはありませんでした。ただし、データセットによっては、層を追加することで精度が向上することがあります。

MLP：がんデータの認識

MLPを使ったがんデータの認識の具体例を示します。scikit-learnライブラリのload_breast_cancer関数を使ってがんデータを読み込み、MLP分類器を訓練して、テストデータで性能評価を行います。

from sklearn.datasets import load_breast_cancer
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# データの読み込み
cancer = load_breast_cancer()
X = cancer.data
y = cancer.target

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

# MLP分類器の訓練
mlp = MLPClassifier(hidden_layer_sizes=(30, 30), max_iter=1000, random_state=42)
mlp.fit(X_train, y_train)

# テストデータで性能評価
y_pred = mlp.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.3f}")

この例では、MLPClassifierクラスを使って、2つの隠れ層を持つMLPを訓練しています。hidden_layer_sizes引数には、各隠れ層のニューロンの数をタプルで指定します。また、max_iter引数には、訓練の最大イテレーション回数を指定します。性能評価には、accuracy_score関数を使って正解率を計算しています。

ランダムフォレスト

ランダムフォレスト(Random Forest)は、決定木を複数組み合わせたアンサンブル学習手法の一つであり、非常に高い汎化性能を持っています。ランダムフォレストは、個々の決定木が過学習しやすいという問題を、複数の決定木を組み合わせることで解決することができます。

ランダムフォレストでは、学習データからランダムにサンプリングして複数の決定木を構築し、それらを組み合わせて予測を行います。また、各決定木の分岐条件もランダムに選択するため、決定木の多様性を高め、より汎化性能を向上させることができます。

ランダムフォレストは、分類問題や回帰問題に応用することができ、特に大規模なデータセットに対して有効です。また、ランダムフォレストは、特徴量の重要度を評価することができるため、特徴量選択の手段としても利用されます。

Pythonでのランダムフォレストの具体例は以下の通りです。ここでは、UCI Machine Learning Repositoryにあるワインの品質データセットを用いて、ランダムフォレストによるワインの品質予測を行っています。

from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# ワインの品質データセットをロードする
data = load_wine()

# 特徴量とターゲットを取得する
X = data.data
y = data.target

# 訓練データとテストデータに分割する
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# ランダムフォレストによる学習を行う
clf = RandomForestClassifier(n_estimators=100, random_state=0)
clf.fit(X_train, y_train)

# テストデータを予測する
y_pred = clf.predict(X_test)

# 正解率を出力する
print("Accuracy:", accuracy_score(y_test, y_pred))

この例では、ランダムフォレストのモデルをRandomForestClassifierで構築し、n_estimatorsで決定木の数を指定しています。また、train_test_splitでデータを訓練データとテストデータに分割し、accuracy_scoreで正解率を計算しています。

ランダムフォレスト：2次元データの認識

ランダムフォレストを用いた2次元データの認識の具体例を示します。

まずは必要なライブラリをインポートします。ランダムフォレストを用いるために、sklearn.ensembleモジュールからRandomForestClassifierをインポートします。また、データを生成するために、make_blobsをインポートします。そして、グラフを描画するために、matplotlib.pyplotをインポートします。

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

次に、2次元データを生成します。make_blobsを用いて、2つのクラスのデータを生成します。n_samplesはサンプル数、centersはクラスの数、random_stateは乱数のシードを指定します。

X, y = make_blobs(n_samples=100, centers=2, random_state=0)

生成したデータを可視化して確認します。以下のコードは、生成したデータを散布図にして表示します。

plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm')
plt.show()

次に、ランダムフォレストを用いてデータを分類します。RandomForestClassifierのn_estimators引数には、ランダムフォレストの決定木の数を指定します。

clf = RandomForestClassifier(n_estimators=100, random_state=0)
clf.fit(X, y)

分類器を用いて、グリッド状に作られたデータの分類結果を予測し、可視化して確認します。以下のコードは、分類器によって予測された各データ点のクラスを、グリッド状に作られた座標上に表示します。

xx, yy = np.meshgrid(np.arange(-5, 5, 0.1),
np.arange(-5, 5, 0.1))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm')
plt.show()

これで、ランダムフォレストを用いた2次元データの認識の例が完成しました。

ランダムフォレスト：別の2次元データの認識と過学習

ランダムフォレストを用いた2次元データの認識と過学習についてのPythonの具体例です。例として、scikit-learnのmake_moons関数を使用して、2つの半月状のクラスを持つデータセットを生成し、ランダムフォレストで分類を行います。

from sklearn.datasets import make_moons
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
import numpy as np

# データセットの生成
X, y = make_moons(n_samples=1000, noise=0.3, random_state=42)

# データセットの可視化
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()

# データセットの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ランダムフォレストの学習と予測
rfc = RandomForestClassifier(n_estimators=10, random_state=42)
rfc.fit(X_train, y_train)
y_pred = rfc.predict(X_test)

# 正解率の計算
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy:', accuracy)

上記の例では、make_moons関数によってデータセットを生成し、ランダムフォレストを用いて学習と予測を行っています。ランダムフォレストの分類器数は10個(n_estimators=10)、ランダムフォレストの種を指定しています(random_state=42)。生成したデータセットは、matplotlibを使用して可視化されています。最後に、正解率を計算しています。

上記の例では、ランダムフォレストがデータをうまく分類できていることがわかります。しかし、ランダムフォレストには過学習のリスクがあるため、過学習を確認するために、同じデータセットに対して学習データとテストデータの正解率をプロットしてみます。

# 学習曲線のプロット
train_accs = []
test_accs = []
for i in range(1, 100):
rfc = RandomForestClassifier(n_estimators=i, random_state=42)
rfc.fit(X_train, y_train)
y_train_pred = rfc.predict(X_train)
y_test_pred = rfc.predict(X_test)
train_acc = accuracy_score(y_train, y_train_pred)
test_acc = accuracy_score(y_test, y_test_pred)
train_accs.append(train_acc)
test_accs.append(test_acc)

plt.plot(range(1, 100), train_accs, label='train')
plt.plot(range(1, 100), test_accs, label='test')

ここでは、ランダムフォレストが過学習を起こす様子を見てみましょう。以下のコードは、ランダムフォレストを用いて、特徴量が2つのデータを学習し、過学習が起こる様子を可視化します。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier

# ランダムフォレストによる学習
n_estimators = 1000
max_depth = 50
X_train = np.random.uniform(size=(1000, 2))
y_train = (X_train[:, 0] > 0.5) & (X_train[:, 1] > 0.5)
X_test = np.random.uniform(size=(1000, 2))
y_test = (X_test[:, 0] > 0.5) & (X_test[:, 1] > 0.5)
rf = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth)
rf.fit(X_train, y_train)

# 学習データとテストデータの正解率を算出
train_score = rf.score(X_train, y_train)
test_score = rf.score(X_test, y_test)
print(f"train score: {train_score:.2f}, test score: {test_score:.2f}")

# 学習結果の可視化
xx, yy = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100))
X_grid = np.c_[xx.ravel(), yy.ravel()]
Z = rf.predict_proba(X_grid)[:, 1]
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.RdBu, alpha=.8)

# 学習データとテストデータのプロット
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.RdBu, edgecolor='white', alpha=.6)
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.RdBu, edgecolor='black', alpha=.6)
plt.xlim(0, 1)
plt.ylim(0, 1)
plt.title("Random Forest")
plt.show()

このコードを実行すると、グラフが表示されます。

このグラフでは、学習データとテストデータの境界を分ける境界線が非常に複雑になっていることがわかります。つまり、ランダムフォレストは、学習データに対して過学習を起こしてしまったため、テストデータに対してはうまく汎化できていないことがわかります。

ランダムフォレスト：がんデータの認識

ランダムフォレストを使ったがんデータの認識の具体例を示します。

まず、必要なライブラリをimportします。

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

次に、がんデータを読み込み、特徴量と目的変数に分割します。

cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = pd.Series(cancer.target)

データを訓練用とテスト用に分割します。

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

ランダムフォレストを使ってモデルを構築します。ここでは、決定木の数を100に設定します。

rfc = RandomForestClassifier(n_estimators=100, random_state=42)
rfc.fit(X_train, y_train)

train_pred = rfc.predict(X_train)
test_pred = rfc.predict(X_test)
train_acc = accuracy_score(y_train, train_pred)
test_acc = accuracy_score(y_test, test_pred)
print(f"Train accuracy: {train_acc:.3f}")
print(f"Test accuracy: {test_acc:.3f}")

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV

param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}

model = LogisticRegression()
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5)

grid_search.fit(X, y)

print(grid_search.best_params_)

from sklearn.datasets import load_iris
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, train_test_split

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=0)

param_grid = {'C': [0.1, 1, 10, 100],
'gamma': [0.1, 1, 10, 100]}

svc = SVC()
grid = GridSearchCV(svc, param_grid=param_grid, cv=5)

grid.fit(X_train, y_train)

print("Best parameters: {}".format(grid.best_params_))
print("Best cross-validation score: {:.2f}".format(grid.best_score_))

print("Test set score: {:.2f}".format(grid.score(X_test, y_test)))

from sklearn.datasets import load_iris
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC

iris = load_iris()
X = iris.data
y = iris.target

param_grid = {'C': [0.1, 1, 10, 100],
'gamma': [0.1, 1, 10, 100],
'kernel': ['rbf', 'sigmoid', 'linear']}

svc = SVC()

grid_search = GridSearchCV(svc, param_grid, cv=5)

grid_search.fit(X, y)

print(grid_search.best_params_)
print(grid_search.best_score_)

from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

# パラメータの範囲を指定
param_dist = {
'hidden_layer_sizes': randint(10, 200),
'alpha': uniform(0.0001, 0.1),
'learning_rate_init': uniform(0.0001, 0.1),
}

# MLPモデルを定義
mlp = MLPClassifier(random_state=0)

# ランダムサーチを定義
random_search = RandomizedSearchCV(
mlp, param_distributions=param_dist, n_iter=100, cv=5, random_state=0, n_jobs=-1)

# ランダムサーチを実行
random_search.fit(X_train, y_train)

# 最適なパラメータを取得
print('Best parameters: {}'.format(random_search.best_params_))

# 最適なモデルで予測
y_pred = random_search.predict(X_test)

from sklearn.datasets import load_breast_cancer
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

data = load_breast_cancer()
X, y = data.data, data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

pipe = make_pipeline(
PCA(n_components=2),
LogisticRegression(random_state=42)
)

pipe.fit(X_train, y_train)

y_pred = pipe.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

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

# スケーリングとSVMをパイプラインにまとめる
svm_pipeline = Pipeline([
('scaler', StandardScaler()),
('svm', SVC())
])

# ハイパーパラメータのグリッドサーチ
param_grid = {
'svm__C': [0.1, 1, 10],
'svm__kernel': ['linear', 'rbf', 'poly']
}

# グリッドサーチを行う
from sklearn.model_selection import GridSearchCV
grid_search = GridSearchCV(svm_pipeline, param_grid=param_grid, cv=5)
grid_search.fit(X, y)

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, random_state=0)

pipe = Pipeline([
('scaler', StandardScaler()),
('svm', SVC())
])

param_grid = {
'svm__C': [0.1, 1, 10],
'svm__gamma': [0.1, 1, 10]
}

grid = GridSearchCV(pipe, param_grid=param_grid, cv=5)

grid.fit(X_train, y_train)

print("Best parameters: ", grid.best_params_)
print("Best cross-validation score: {:.2f}".format(grid.best_score_))
print("Test set score: {:.2f}".format(grid.score(X_test, y_test)))

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.svm import SVC

# データの読み込み
data = load_breast_cancer()

# 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, random_state=0)

# ハイパーパラメータの候補を定義
param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}

# グリッドサーチで最適なパラメータを探索
grid_search = GridSearchCV(SVC(kernel='linear'), param_grid, cv=5)
grid_search.fit(X_train, y_train)

# 最適なパラメータでモデルをトレーニング
best_svc = grid_search.best_estimator_
best_svc.fit(X_train, y_train)

# テストデータで評価
accuracy = best_svc.score(X_test, y_test)
print('Accuracy:', accuracy)

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

data = load_breast_cancer()
X = data.data
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

import matplotlib.pyplot as plt

train_scores = []
test_scores = []
Cs = [0.001, 0.01, 0.1, 1, 10, 100, 1000]

for C in Cs:
svm = SVC(kernel='linear', C=C)
svm.fit(X_train, y_train)
train_score = accuracy_score(y_train, svm.predict(X_train))
test_score = accuracy_score(y_test, svm.predict(X_test))
train_scores.append(train_score)
test_scores.append(test_score)

plt.plot(Cs, train_scores, label='Train')
plt.plot(Cs, test_scores, label='Test')
plt.xscale('log')
plt.xlabel('C')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

from sklearn.model_selection import GridSearchCV
from sklearn import svm, datasets

# データの読み込み
iris = datasets.load_iris()
X = iris.data
y = iris.target

# モデルの定義
svc = svm.SVC(kernel='linear')

# パラメータグリッドの定義
parameters = {'C': [0.1, 1, 10, 100]}

# グリッドサーチの定義
clf = GridSearchCV(svc, parameters, cv=5)

# モデルの学習
clf.fit(X, y)

# 最適なパラメータの表示
print(clf.best_params_)

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import LinearSVC
from sklearn.metrics import accuracy_score

iris = datasets.load_iris()
X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

svm = LinearSVC()
svm.fit(X_train, y_train)

from sklearn.datasets import load_iris
from sklearn.svm import SVC, LinearSVC
from sklearn.model_selection import train_test_split
import time

iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

C = [10**i for i in range(-3, 5)]

for c in C:
svc_start = time.time()
svc = SVC(kernel='linear', C=c)
svc.fit(X_train, y_train)
svc_end = time.time()

lin_svc_start = time.time()
lin_svc = LinearSVC(C=c)
lin_svc.fit(X_train, y_train)
lin_svc_end = time.time()

print(f"C = {c}")
print(f"SVC: {svc_end - svc_start}")
print(f"LinearSVC: {lin_svc_end - lin_svc_start}")

C = 0.001
SVC: 0.00599980354309082
LinearSVC: 0.002000570297241211
C = 0.01
SVC: 0.0070002079010009766
LinearSVC: 0.002000570297241211
C = 0.1
SVC: 0.006999969482421875
LinearSVC: 0.0019996166229248047
C = 1
SVC: 0.0070002079010009766
LinearSVC: 0.0020008087158203125
C = 10
SVC: 0.009999990463256836
LinearSVC: 0.003000497817993164
C = 100
SVC: 0.02400040626525879
LinearSVC: 0.003000497817993164
C = 1

from sklearn.datasets import make_classification
from sklearn.svm import LinearSVC
from sklearn.model_selection import train_test_split
import time

# ダミーデータの生成
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=0, random_state=42)

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

# LinearSVCのインスタンス化（primalソルバを使用）
clf = LinearSVC(dual=False, random_state=42)

# Cの値を変えながら学習時間を計測
for C in [0.001, 0.01, 0.1, 1, 10]:
clf.set_params(C=C)
start = time.time()
clf.fit(X_train, y_train)
end = time.time()
print("C = {}: {:.9f}".format(C, end - start))

from sklearn.datasets import make_classification
from sklearn.svm import LinearSVC
import time

# ランダムに2値分類のためのサンプルデータを生成
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10, n_classes=2, random_state=1)

# C=0.01でPrimalソルバを使用した場合の処理時間を計測
start = time.time()
clf = LinearSVC(C=0.01, dual=False, random_state=1)
clf.fit(X, y)
end = time.time()
print('Primal solver, C=0.01: {}'.format(end - start))

# C=10でPrimalソルバを使用した場合の処理時間を計測
start = time.time()
clf = LinearSVC(C=10, dual=False, random_state=1)
clf.fit(X, y)
end = time.time()
print('Primal solver, C=10: {}'.format(end - start))

from sklearn import datasets
from sklearn.model_selection import GridSearchCV
from sklearn.svm import LinearSVC

# データセットの読み込み
iris = datasets.load_iris()
X = iris.data
y = iris.target

# グリッドサーチのパラメータ範囲の設定
param_grid = {'C': [0.1, 1, 10, 100]}

# LinearSVCのインスタンスを生成
svm = LinearSVC(max_iter=10000, dual=False)

# グリッドサーチの実行
grid_search = GridSearchCV(svm, param_grid, cv=5)
grid_search.fit(X, y)

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

from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X, y = make_classification(n_samples=1000, n_features=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

sgd = SGDClassifier(loss='log', random_state=42)
sgd.fit(X_train, y_train)

y_pred = sgd.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print("Accuracy:", acc)

from sklearn.datasets import load_digits
digits = load_digits()
X, y = digits.data, digits.target

from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import GridSearchCV

param_grid = {
'alpha': [0.0001, 0.001, 0.01],
'penalty': ['l2'],
'loss': ['log'],
'learning_rate': ['constant'],
}

clf = SGDClassifier(random_state=42)
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=3, n_jobs=-1)
grid_search.fit(X, y)

print(grid_search.best_params_)
print(grid_search.best_score_)

from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=0, random_state=42)

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)


from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import GridSearchCV

clf = SGDClassifier(random_state=42)

param_grid = {'penalty': ['l1', 'l2'], 'learning_rate': ['constant', 'invscaling', 'adaptive']}

grid = GridSearchCV(clf, param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)

print("Best parameters: ", grid.best_params_)
print("Training accuracy: ", grid.best_score_)
print("Test accuracy: ", grid.score(X_test, y_test))