特徴抽出

Scikit-learnを使用して特徴抽出を行い、結果をグラフ化するためのサンプルコードを示します。

以下の例では、Breast Cancerデータセットから特徴抽出を行い、主成分分析（PCA）を使用してデータの次元削減を行います。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

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

# 特徴抽出: PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# グラフ化
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('Breast Cancer Dataset - PCA')
plt.colorbar(label='Target')
plt.show()

上記のコードでは、Breast Cancerデータセットを使用して特徴抽出を行っています。

データセットから特徴量Xとラベルyを取得し、PCAを使用してデータの次元削減を行っています。

PCAのn_componentsパラメータを2に設定しているため、データは2次元に削減されます。

削減後のデータをX_pcaに格納します。

最後に、削減されたデータを散布図として表示しています。

散布図の点の色はyの値に基づいて変化し、カラーバーが対応するクラスラベルを表示します。

[実行結果]

これにより、元のデータを2次元の空間にプロットし、データの分布やクラスの分離状況を視覚化することができます。

注意: 上記のコードでは、Breast Cancerデータセットを使用していますが、他のデータセットに適用する場合は、データセットの読み込み方法や特徴量の選択を変更してください。

また、必要に応じて他の特徴抽出手法を使用することもできます。

アノマリ検知

アノマリ検知の一つの例として、Isolation Forestを使ったアノマリ検知を紹介します。

Isolation Forestは、異常値を見つけるための効果的な方法で、特に高次元のデータセットに対して有効です。

以下にPythonとScikit-learnを使ったサンプルコードを示します。

このコードでは、2次元のデータセットを生成し、Isolation Forestを使ってアノマリを検出し、結果をグラフ化します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

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

# データの生成
rng = np.random.RandomState(42)

# 正常なデータポイント
X_train = 0.3 * rng.randn(100, 2)
X_train = np.r_[X_train + 2, X_train - 2]

# 新しい正常なデータポイント
X_test = 0.3 * rng.randn(20, 2)
X_test = np.r_[X_test + 2, X_test - 2]

# 異常なデータポイント
X_outliers = rng.uniform(low=-4, high=4, size=(20, 2))

# Isolation Forestの適用
clf = IsolationForest(max_samples=100, random_state=rng)
clf.fit(X_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)

# プロット
xx, yy = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.title("IsolationForest")
plt.contourf(xx, yy, Z, cmap=plt.cm.Blues_r)

b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c='white',
                 s=20, edgecolor='k')
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c='green',
                 s=20, edgecolor='k')
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c='red',
                s=20, edgecolor='k')

plt.axis('tight')
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend([b1, b2, c],
           ["training observations",
            "new regular observations", "new abnormal observations"],
           loc="upper left")
plt.show()

このコードを実行すると、正常なデータポイント（白と緑の点）と異常なデータポイント（赤い点）がプロットされます。

Isolation Forestは、異常なデータポイントを効果的に検出します。

[実行結果]

ソースコード解説

このソースコードは、Isolation Forest（孤立性森）アルゴリズムを使用してアノマリ検知を行う例です。

以下にソースコードの各部分を詳しく説明します。

1. ライブラリのインポート:

1
2
3

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

必要なライブラリをインポートします。NumPyは数値計算を行うために使用し、Matplotlibはグラフの描画に使用します。
IsolationForestはScikit-learnのアノマリ検知アルゴリズムです。

2. データの生成:

1
2
3
4
5
6
7
8
9
10
11
12

rng = np.random.RandomState(42)

# 正常なデータポイント
X_train = 0.3 * rng.randn(100, 2)
X_train = np.r_[X_train + 2, X_train - 2]

# 新しい正常なデータポイント
X_test = 0.3 * rng.randn(20, 2)
X_test = np.r_[X_test + 2, X_test - 2]

# 異常なデータポイント
X_outliers = rng.uniform(low=-4, high=4, size=(20, 2))

正常なデータポイント（X_train）と新しい正常なデータポイント（X_test）を生成します。
また、異常なデータポイント（X_outliers）も生成します。

3. Isolation Forestの適用:

1
2
3
4
5

clf = IsolationForest(max_samples=100, random_state=rng)
clf.fit(X_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)

IsolationForestクラスのインスタンスを作成し、X_trainを使用してモデルをトレーニングします。
そして、トレーニングデータとテストデータ、異常データそれぞれのアノマリスコアを予測します。

4. プロット:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

xx, yy = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.title("IsolationForest")
plt.contourf(xx, yy, Z, cmap=plt.cm.Blues_r)

b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c='white',
                 s=20, edgecolor='k')
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c='green',
                 s=20, edgecolor='k')
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c='red',
                s=20, edgecolor='k')

plt.axis('tight')
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend([b1, b2, c],
           ["training observations",
            "new regular observations", "new abnormal observations"],
           loc="upper left")
plt.show()

アノマリスコアをグラフ化し、データポイントをプロットします。等高線プロットはアノマリスコアのレベルを示し、青い色が正常である領域を表します。
また、正常データポイントは白色で、新しい正常データポイントは緑色、異常データポイントは赤色でプロットされます。

これにより、Isolation Forestアルゴリズムによるアノマリ検知の結果が可視化されます。

グラフを通じて、異常データポイントが正常データから分離される様子を確認できます。

クレジットスコアリング

クレジットスコアリングの一例として、ロジスティック回帰を用いた二項分類問題を考えてみましょう。

この例では、顧客がローンを返済する（1）かしない（0）かを予測します。

特徴量としては、年齢と収入を考えてみます。

まず、必要なライブラリをインポートし、仮想のデータセットを作成します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
import seaborn as sns

# 仮想データセットの作成
np.random.seed(0)
age = np.random.randint(20, 70, 1000)
income = np.random.randint(20000, 100000, 1000)
will_pay_back = np.random.randint(0, 2, 1000)

df = pd.DataFrame({
    'age': age,
    'income': income,
    'will_pay_back': will_pay_back
})

次に、データを訓練セットとテストセットに分割し、ロジスティック回帰モデルを訓練します。

1
2
3
4
5
6
7
8
9
10

# 特徴量とターゲットに分割
X = df[['age', 'income']]
y = df['will_pay_back']

# 訓練セットとテストセットに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# ロジスティック回帰モデルの訓練
model = LogisticRegression()
model.fit(X_train, y_train)

最後に、訓練したモデルを用いてテストセットのデータを予測し、結果をグラフ化します。

1
2
3
4
5
6
7

# テストセットのデータを予測
y_pred = model.predict(X_test)

# 結果のグラフ化
cm = pd.crosstab(y_test, y_pred, rownames=['Actual'], colnames=['Predicted'])
sns.heatmap(cm, annot=True, fmt='d')
plt.show()

このヒートマップは混同行列を表しており、モデルがどの程度正確に予測できているかを視覚的に理解するのに役立ちます。

[実行結果]

ソースコード解説

コードの詳細な説明は下記の通りです。

1. import ステートメント:

必要なライブラリやモジュールをインポートします。
numpy、pandas、sklearn、matplotlib.pyplot、seabornが使用されています。

2. 仮想データセットの作成:

numpy.randomを使って、age（年齢）、income（収入）、will_pay_back（返済するかどうか）の3つの特徴量を持つ仮想的なデータセットを作成します。
これらの特徴量はランダムな値で生成されます。

3. データフレームの作成:

pandas.DataFrameを使って、上記で生成した特徴量を含むデータフレーム df を作成します。

4. 特徴量とターゲットの分割:

df から特徴量 X（’age’と’income’）とターゲット変数 y（’will_pay_back’）を分割します。

5. 訓練セットとテストセットの分割:

sklearn.model_selection.train_test_split を使って、データを訓練セットとテストセットに分割します。
ここでは、テストセットのサイズを設定し、乱数のシードを固定して再現性を確保しています。

6. ロジスティック回帰モデルの訓練:

sklearn.linear_model.LogisticRegression を使って、ロジスティック回帰モデルを作成し、訓練セットを用いてモデルを訓練します。

7. テストセットのデータを予測:

訓練されたモデルを使って、テストセットの特徴量 X_test を予測します。

8. 結果のグラフ化:

予測結果と実際のターゲット変数 y_test をもとに、混同行列（confusion matrix）を作成し、seaborn.heatmap を使って可視化します。
混同行列は、予測されたクラスと実際のクラスの組み合わせごとにカウントされます。

9. plt.show():

グラフを表示します。

このコードを実行すると、ロジスティック回帰モデルを使って返済するかどうかを予測し、混同行列をグラフ化することができます。

混同行列は、予測の正確性や誤分類の種類を評価するのに役立ちます。

詐欺検出

金融取引の詐欺検出の例題として、以下のデータセットを考えます。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

# サンプルデータの生成
rng = np.random.RandomState(42)
X = 0.3 * rng.randn(100, 2)
X_outliers = rng.uniform(low=-4, high=4, size=(20, 2))
X = np.vstack([X, X_outliers])

# Isolation Forestモデルの構築と詐欺検出の実行
clf = IsolationForest(contamination=0.1, random_state=rng)
clf.fit(X)
y_pred = clf.predict(X)

# 結果の可視化
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis')
plt.title("Fraud Detection with Isolation Forest")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.show()

この例では、Isolation Forestと呼ばれるアルゴリズムを使用して詐欺検出を行っています。

Isolation Forestは、データの異常度を評価し、異常なデータポイントを検出するために使用されます。

結果をグラフ化すると、データポイントが異常かどうかに応じて色分けされた散布図が表示されます。

異常なデータポイントは通常、他のデータポイントからは明らかに分離していることが視覚的に確認できます。

異常なデータポイントは、詐欺の可能性が高いと考えられます。

上記のコードを実行すると、詐欺検出の結果をグラフで確認することができます。

[実行結果]

コード解説

このコードは、Isolation Forestを使用して金融取引の詐欺検出を行い、結果をグラフ化するためのものです。

以下に各部分の説明をします。

1行目から3行目:

必要なライブラリをインポートします。
numpyは数値計算のために使用され、matplotlib.pyplotはグラフの描画に使用されます。
sklearn.ensembleからはIsolation Forestモデルをインポートします。

6行目から9行目:

サンプルデータの生成を行います。
numpy.random.RandomStateを使用して乱数のシードを設定し、乱数を用いて2次元のデータセットXを生成します。
X_outliersは異常値を表すデータセットです。最後にnp.vstackを使用してXとX_outliersを結合します。

12行目:

IsolationForestクラスのインスタンスを作成します。
contaminationパラメータは異常値の割合を指定し、random_stateパラメータは乱数のシードを指定します。

13行目:

fitメソッドを使用してIsolation Forestモデルをデータに適合させます。

13行目:

predictメソッドを使用してデータポイントの異常度を予測します。
異常であれば-1、正常であれば1のラベルが返されます。

17行目から21行目:

結果を可視化します。
plt.scatterを使用してデータポイントを散布図として表示します。
cパラメータをy_predとし、異常度に応じて色を付けます。
plt.title、plt.xlabel、plt.ylabelを使用してグラフにタイトルや軸ラベルを追加します。
最後の行で、グラフを表示します。

このコードを実行すると、生成されたデータセット上での詐欺検出結果を可視化したグラフが表示されます。

異常なデータポイントは異なる色で表示され、詐欺の可能性が高いと予測されます。

交差検証

ythonとscikit-learnを使用して交差検証を行う基本的なコードを以下に示します。

この例では、K-Fold交差検証を使用します。

また、結果をグラフ化するためにmatplotlibを使用します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
import numpy as np

# データセットのロード
iris = load_iris()
X, y = iris.data, iris.target

# 分類器のインスタンス化
clf = DecisionTreeClassifier(random_state=1234)

# 交差検証のスコアを計算
scores = cross_val_score(clf, X, y, cv=5)

# スコアの平均と標準偏差を計算
mean_score = np.mean(scores)
std_dev = np.std(scores)
print(f"Average score: {mean_score}")
print(f"Standard deviation: {std_dev}")

# 結果のグラフ化
plt.bar(range(1, len(scores) + 1), scores)
plt.ylim([0.0, 1.0])
plt.xlabel('Fold')
plt.ylabel('Accuracy')
plt.title('Cross-validation scores')
plt.show()

このコードは、Irisデータセットを使用して決定木分類器の交差検証を行います。

cross_val_score関数は、分類器、特徴量、ターゲット、および分割数（この場合は5）を引数に取り、各分割に対するスコアの配列を返します。

最後に、各分割のスコアを棒グラフで表示します。

これにより、モデルのパフォーマンスがどの程度一貫しているか（つまり、分割によって大きく変動しないか）を視覚的に確認できます。

[実行結果]

コード解説

このコードは、scikit-learnを使用して決定木分類器を交差検証するためのサンプルコードです。

以下にコードの詳細を説明します。

1行目から5行目:

必要なモジュールと関数をインポートします。
load_iris関数は、Irisデータセットをロードするために使用されます。
cross_val_score関数は、指定した分類器とデータセットで交差検証を行い、スコアを計算します。DecisionTreeClassifierは、決定木分類器のクラスです。
matplotlib.pyplotモジュールは、グラフの可視化のために使用されます。
numpyモジュールは、数値計算をサポートするために使用されます。

8行目から9行目:

load_iris関数を使用してIrisデータセットをロードし、Xとyに特徴量とラベルを格納します。

12行目:

DecisionTreeClassifierをインスタンス化します。
random_stateパラメータは、再現性のために乱数生成器のシードを設定します。

15行目:

cross_val_score関数を使用して交差検証のスコアを計算します。
cross_val_score関数は、指定された分類器とデータセットを使用して、指定された分割数（この場合は5）で交差検証を実行し、各分割のスコアを返します。
これらのスコアはscoresに格納されます。

18行目から21行目:

scoresの平均値と標準偏差を計算します。
np.mean関数はスコアの平均を計算し、np.std関数はスコアの標準偏差を計算します。
print関数では、平均スコアと標準偏差をコンソールに出力します。

24行目から29行目:

結果を棒グラフで可視化します。
plt.bar関数を使用して棒グラフを作成し、plt.ylimでy軸の範囲を設定します。
plt.xlabelとplt.ylabelでx軸とy軸のラベルを指定し、plt.titleでグラフのタイトルを設定します。
最後に、plt.showでグラフを表示します。

このコードは、Irisデータセットを使用して決定木分類器の交差検証を行い、結果を可視化する例です。

分類器やデータセットを変更することで、他の問題に対しても同様の手順を実行できます。

次元削減

次元削減の例題として、手書き数字の画像データセットであるMNISTを使用して、PCAを用いた次元削減を行う例を示します。

まず、Scikit-learnのデータセットモジュールからMNISTデータセットを読み込みます。

1
2
3
4
5
6

from sklearn.datasets import fetch_openml

# MNISTデータセットの読み込み
mnist = fetch_openml('mnist_784', version=1)
X = mnist.data
y = mnist.target

次に、読み込んだデータを正規化します。

1
2
3
4
5

from sklearn.preprocessing import MinMaxScaler

# 特徴量の正規化
scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X)

データを正規化した後、PCAを使用して次元削減を行います。

1
2
3
4
5

from sklearn.decomposition import PCA

# PCAのインスタンスを作成し、次元削減を実行
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X_normalized)

最後に、次元削減されたデータを可視化します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import matplotlib.pyplot as plt

# 可視化のためにデータを分割
x = X_reduced[:, 0]
y = X_reduced[:, 1]

# グラフのプロット
plt.scatter(x, y, c=y, cmap='viridis', alpha=0.5)
plt.colorbar(label='Digit')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('MNIST Dataset - PCA')

plt.show()

このコードを実行すると、次元削減されたデータを2次元平面上にプロットした散布図が表示されます。

各データポイントは手書き数字を表し、色によって異なる数字が示されます。

[実行結果]

この例では、MNISTデータセットを使用してPCAを適用し、高次元の手書き数字のデータを2次元に削減しました。

削減されたデータを散布図としてプロットすることで、異なる数字のパターンやクラスタを視覚化することができます。

ボストンの住宅価格予測

回帰問題の例として、ボストンの住宅価格データセットを使用して、部屋の数（RM）から住宅価格（MEDV）を予測する問題を考えてみましょう。

このデータセットは、scikit-learnライブラリに含まれています。

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

1
2
3
4

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

次に、データセットをロードします。

1

boston = datasets.load_boston()

部屋の数（RM）を特徴量として、住宅価格（MEDV）をターゲットとします。

1
2

X = boston.data[:, np.newaxis, 5]  # RM
y = boston.target  # MEDV

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

1
2
3
4

X_train = X[:-20]
X_test = X[-20:]
y_train = y[:-20]
y_test = y[-20:]

線形回帰モデルを作成し、訓練データで訓練します。

1
2

regr = linear_model.LinearRegression()
regr.fit(X_train, y_train)

テストデータを使って予測を行います。

1

y_pred = regr.predict(X_test)

結果を表示します。

1
2
3
4
5

print('Coefficients: \n', regr.coef_)
print('Mean squared error: %.2f'
      % mean_squared_error(y_test, y_pred))
print('Coefficient of determination: %.2f'
      % r2_score(y_test, y_pred))

最後に、結果をグラフ化します。

1
2
3
4
5
6

plt.scatter(X_test, y_test,  color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xlabel('Number of Rooms (RM)')
plt.ylabel('Median value of owner-occupied homes in $1000s (MEDV)')
plt.title('Linear Regression on Boston Housing Data')
plt.show()

このコードは、部屋の数から住宅価格を予測する線形回帰モデルを訓練し、その性能を評価し、結果をグラフ化します。

[実行結果]

ボストンの住宅価格の回帰の結果を評価するために、いくつかの指標が表示されました。

以下にそれぞれの指標の説明をします。

1. Coefficients: [9.126359]
これは、回帰モデルにおける説明変数（住宅価格を予測するための特徴量）の係数です。
単回帰の場合、この値は単一の特徴量の重みを示します。この場合、係数が9.126359と表示されています。

2. Mean squared error: 18.73
平均二乗誤差（Mean Squared Error, MSE）は、予測値と実際の値の間の差の二乗の平均です。
この値が小さいほど、モデルの予測が正確であることを示します。
この場合、MSEは18.73と表示されています。

3. Coefficient of determination: 0.20
決定係数（Coefficient of Determination）は、回帰モデルの予測の精度を示す指標です。
予測の精度は、実際の値の変動のうち、モデルがどれだけ説明できるかを表します。
決定係数の値は0から1の範囲であり、1に近いほど予測が正確です。
この場合、決定係数は0.20と表示されています。

この結果を解釈すると、係数は9.126359となっており、これは住宅価格の予測において重要な特徴量が1単位増加するごとに価格が約9.126359単位上昇することを示しています。

しかし、MSEが18.73となっているため、予測の誤差が比較的大きいことが分かります。

また、決定係数が0.20となっているため、このモデルは住宅価格の変動の約20％を説明できることを示しています。

ただし、この決定係数は予測の精度が低いことを意味しており、他の要素や特徴量がモデルに追加される必要があるかもしれません。

アンサンブル学習

アンサンブル学習の一つであるランダムフォレストを例に取り、scikit-learnを使って解説します。

ランダムフォレストは、複数の決定木を組み合わせて予測精度を向上させる手法です。

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

1
2
3
4
5
6

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

次に、データセットを訓練データとテストデータに分割します。

make_classification関数を使用して、仮想的な分類データセットを生成します。

ここでは、n_samples=1000でサンプル数を指定し、n_features=4で特徴量の数を指定しています。

n_informative=2は、実際に予測に寄与する特徴量の数を指定し、n_redundant=0で冗長な特徴量の数を指定しています。

random_state=0でデータの乱数シードを固定し、shuffle=Falseでデータをシャッフルしないようにします。

1

X, y = make_classification(n_samples=1000, n_features=4, n_informative=2, n_redundant=0, random_state=0, shuffle=False)

ランダムフォレストのモデルを作成し、訓練データで学習させます。

train_test_split関数を使用してデータセットを訓練データとテストデータに分割します。

ここでは、訓練データが80%、テストデータが20%になるように分割しています。

1

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

ランダムフォレスト分類器（RandomForestClassifier）を作成し、訓練データで学習させます。

max_depth=2でツリーの深さを2に制限しています。

1
2

clf = RandomForestClassifier(max_depth=2, random_state=0)
clf.fit(X_train, y_train)

テストデータを使用して予測を行い、予測の正確さを評価します。

accuracy_score関数を使用して、実際のラベル（y_test）と予測されたラベル（y_pred）の一致率を計算し、表示します。

1
2

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

最後に、特徴量の重要度をグラフ化します。

ランダムフォレストモデルによって計算された特徴量の重要度を取得し、グラフ化して表示します。

importancesには各特徴量の重要度が格納され、indicesは重要度の降順で特徴量のインデックスが格納されます。

グラフはバー（縦棒）で表示され、各バーの高さは特徴量の重要度を表しています。

X軸は特徴量のインデックス、Y軸は重要度を表しています。

1
2
3
4
5
6
7
8
9

importances = clf.feature_importances_
indices = np.argsort(importances)[::-1]

plt.figure()
plt.title("Feature importances")
plt.bar(range(X.shape[1]), importances[indices], color="r", align="center")
plt.xticks(range(X.shape[1]), indices)
plt.xlim([-1, X.shape[1]])
plt.show()

[実行結果]

このグラフは、各特徴量がモデルの予測にどれだけ影響を与えているかを示しています。

高いバーは、その特徴量がモデルの予測に大きな影響を与えていることを示しています。

このグラフを通じて、モデルがどの特徴量を重要視しているかを理解することができます。

強化学習

強化学習の簡単な例題として、探索と利益のトレードオフを考慮したマルチアームバンディット問題を考えてみましょう。

以下に、サンプルデータを作成し、そのデータを元に最適化問題を解く方法を示します。

サンプルデータ:

• アーム1: 平均報酬1.5
• アーム2: 平均報酬2.0
• アーム3: 平均報酬1.8
• アーム4: 平均報酬1.2
• アーム5: 平均報酬1.7

また、最大の試行回数は100回とします。

以下が、CVXPYを使用してこの最適化問題を解くコード例です。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import cvxpy as cp
import numpy as np
import matplotlib.pyplot as plt

# アームの平均報酬
arm_means = [1.5, 2.0, 1.8, 1.2, 1.7]

# 最大の試行回数
max_trials = 100

# 変数の定義
x = cp.Variable(len(arm_means), boolean=True)

# 制約条件
constraints = [
    cp.sum(x) == 1,  # 1つのアームを選択する
    x >= 0          # 非負制約
]

# 目的関数
objective = cp.Maximize(cp.sum(cp.multiply(arm_means, x)))

# 最適化問題の定義
problem = cp.Problem(objective, constraints)

# 最適化の実行
optimal_value = problem.solve()

# 最適なアームの選択を取得
arm_selection = [i for i in range(len(arm_means)) if x.value[i] == 1][0]

# グラフ化
arms = range(len(arm_means))
rewards = [arm_means[i] for i in arms]
plt.bar(arms, rewards)
plt.xticks(arms)
plt.xlabel('Arm')
plt.ylabel('Average Reward')
plt.title('Average Reward of Arms')plt.show()

上記のコードでは、cvxpyライブラリを使用して最適化問題を定義しています。

目的関数は、選択したアームの平均報酬の総和を最大化するように設定されています。

制約条件として、1つのアームを選択することや非負制約を指定しています。

最適化問題を解くと、最適なアームの選択が得られます。

これをグラフ化することで、各アームの平均報酬を視覚的に理解することができます。

棒グラフでアームの番号に対応する平均報酬が表示されます。

[実行結果]

ソースコード解説

コードの各部分の説明をします。

1. import文:

• cvxpyモジュールをcpという別名でインポートしています。
  CVXPYは凸最適化問題を解くためのPythonライブラリです。
• numpyモジュールをnpという別名でインポートしています。
  NumPyは数値計算のためのPythonライブラリです。
• matplotlib.pyplotモジュールをpltという別名でインポートしています。
  Matplotlibはデータの可視化のためのPythonライブラリです。

2. データの定義:

• arm_meansは各アームの平均報酬を格納するリストです。
  例えば、[1.5, 2.0, 1.8, 1.2, 1.7]というリストは、5つのアームの平均報酬がそれぞれ1.5, 2.0, 1.8, 1.2, 1.7であることを示しています。
• max_trialsは最大の試行回数を表しています。

3. 変数の定義:

• xはアームの選択を表すバイナリ変数です。
  各要素が0または1の値を持ちます。
  この変数を使ってアームの選択を最適化します。

4. 制約条件の定義:

• constraintsは最適化問題の制約条件を表すリストです。
  ここでは、1つのアームを選択する制約(cp.sum(x) == 1)と非負制約(x >= 0)を設定しています。

5. 目的関数の定義:

• objectiveは最適化問題の目的関数を表すオブジェクトです。
  この場合、アームの平均報酬とアームの選択を乗算し、その総和を最大化するように設定しています。

6. 最適化問題の定義:

• problemは最適化問題を表すオブジェクトです。
  目的関数と制約条件を指定しています。

7. 最適化の実行:

• optimal_value = problem.solve()で最適化問題を解いています。
  最適化の結果、最適なアームの選択と最適な報酬の総和が得られます。

8. 最適なアームの選択を取得:

• arm_selectionは最適なアームの選択を示す変数です。
  アームの選択が1の要素のインデックスを取得しています。

9. グラフ化:

• armsはアームの番号を表すリストです。
• rewardsは各アームの平均報酬を格納したリストです。
• plt.bar()関数を使用してアームの番号に対応する平均報酬を棒グラフで表示しています。
• plt.xlabel()、plt.ylabel()、plt.title()で軸ラベルやタイトルを設定しています。
• plt.show()でグラフを表示します。

このコードの結果は、アームの平均報酬を棒グラフとして表示します。

最適なアームの選択結果と平均報酬が視覚化されます。

作物の収量予測

scikit-learnを使って、作物の収量予測を行ってみます。

作物の栽培に関するいくつかの特徴量（例：土壌のpH値、日照時間、降水量）と作物の収量の関係を持つサンプルデータセットを作成し、予測を行います。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# サンプルデータの作成
np.random.seed(0)
n_samples = 100
X = np.random.rand(n_samples, 3)  # 特徴量：土壌のpH値、日照時間、降水量
y = 50 + 30 * X[:, 0] + 20 * X[:, 1] + 10 * X[:, 2] + 10 * np.random.randn(n_samples)  # 収量

# 線形回帰モデルの学習と予測
model = LinearRegression()
model.fit(X, y)
y_pred = model.predict(X)

# 結果の可視化
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], y, color='b', label='Actual')
plt.scatter(X[:, 0], y_pred, color='r', label='Predicted')
plt.xlabel('soil pH value')
plt.ylabel('crop yield')
plt.title('Crop yield prediction')
plt.legend()
plt.show()

この例では、土壌のpH値が作物の収量に与える影響を考慮しています。

他の特徴量（日照時間、降水量）も同様に考慮できます。

グラフでは、実際の収量（青色の点）と予測された収量（赤色の点）が表示されます。

線形回帰モデルがデータに最適化され、実際の収量に近い予測を行うことが期待されます。

[実行結果]

ソースコード解説

このソースコードは、作物の収量予測を行うためにscikit-learnとmatplotlibを使用しています。

以下にソースコードの詳細を説明します。

1. ライブラリのインポート:

• numpyは数値計算を行うためのライブラリです。
• matplotlib.pyplotはデータの可視化を行うためのライブラリです。
• sklearn.linear_modelモジュールからLinearRegressionクラスをインポートしています。

2. サンプルデータの作成:

• np.random.seed(0)は乱数のシードを設定しています。
  これにより、再現可能な結果が得られます。
• n_samples = 100はサンプルの数を指定しています。
• X = np.random.rand(n_samples, 3)は、3つの特徴量（土壌のpH値、日照時間、降水量）を持つサンプルデータを作成しています。
• y = 50 + 30 * X[:, 0] + 20 * X[:, 1] + 10 * X[:, 2] + 10 * np.random.randn(n_samples)は、作物の収量を計算しています。特徴量と係数の線形結合に、ノイズとして正規分布からサンプリングした乱数を加えています。

3. 線形回帰モデルの学習と予測:

• model = LinearRegression()はLinearRegressionクラスのインスタンスを作成しています。
• model.fit(X, y)は作成したモデルにデータをフィットさせて学習を行います。
• y_pred = model.predict(X)は学習済みモデルを使用して入力データ X の収量を予測します。

4. 結果の可視化:

• plt.figure(figsize=(10, 6))はグラフの図のサイズを指定しています。
• plt.scatter(X[:, 0], y, color='b', label='Actual')は実際の収量を散布図で表示しています。
  X軸は土壌のpH値、Y軸は作物の収量です。
• plt.scatter(X[:, 0], y_pred, color='r', label='Predicted')は予測された収量を散布図で表示しています。
• plt.xlabel('soil pH value')はX軸のラベルを設定しています。
• plt.ylabel('crop yield')はY軸のラベルを設定しています。
• plt.title('Crop yield prediction')はグラフのタイトルを設定しています。
• plt.legend()は凡例を表示します。
• plt.show()はグラフを表示します。

このコードは、線形回帰モデルを使用して特徴量と作物の収量の関係を学習し、予測結果を可視化する例です。

特徴量には土壌のpH値だけでなく、他の特徴量も含めることができます。