選挙結果予測

選挙に関するデータ分析の一例として、選挙結果を予測するモデルを作成してみましょう。

ここでは、選挙の候補者の年齢、教育レベル、キャンペーンの予算などを特徴として使用します。

これらの特徴を基に、候補者が選挙に勝つかどうかを予測します。

まず、サンプルデータを作成します。

ここでは、pandasとnumpyを使用します。

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

import pandas as pd
import numpy as np

# データの作成
np.random.seed(0)
data = {
    '年齢': np.random.randint(30, 70, 100),
    '教育レベル': np.random.randint(1, 4, 100),
    'キャンペーン予算': np.random.randint(1, 10, 100) * 10000,
    '選挙結果': np.random.randint(0, 2, 100)
}
df = pd.DataFrame(data)

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

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

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

# 特徴とラベルを分割
X = df[['年齢', '教育レベル', 'キャンペーン予算']]
y = df['選挙結果']

# データを訓練セットとテストセットに分割
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)

最後に、matplotlibを使用して結果をグラフ化します。

ここでは、テストデータの予測結果と実際の結果を比較する混同行列を作成します。

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

import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

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

# 混同行列の作成
cm = confusion_matrix(y_test, y_pred)

# 混同行列のグラフ化
plt.imshow(cm, cmap=plt.cm.Blues)
plt.xlabel("Predicted labels")
plt.ylabel("True labels")
plt.xticks([], [])
plt.yticks([], [])
plt.title('Confusion matrix ')
plt.colorbar()
plt.show()

[実行結果]

このコードはあくまで一例であり、実際の選挙データ分析では、より多くの特徴を考慮に入れ、より複雑なモデルを使用することが一般的です。

また、データの前処理や特徴選択、モデルの評価など、ここでは触れていない重要なステップもあります。

ソースコード解説

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

1行目と2行目では、pandasとnumpyをインポートしています。

pandasはデータ解析や操作を行うためのライブラリであり、numpyは数値計算を行うためのライブラリです。

5行目から11行目では、データセットを作成しています。

np.random.seed(0)は乱数のシードを設定し、再現性を確保しています。

dataには4つの特徴（年齢、教育レベル、キャンペーン予算、選挙結果）を持つ100行のデータが生成されます。

12行目では、作成したデータを使ってpandasのDataFrameを作成しています。

22行目では、scikit-learnのtrain_test_splitを使用してデータを訓練セットとテストセットに分割しています。

Xには特徴量のカラム（’年齢’、’教育レベル’、’キャンペーン予算’）が代入され、yにはラベルのカラム（’選挙結果’）が代入されます。

test_size=0.2はテストセットの割合を指定しており、random_state=0は乱数のシードを設定して再現性を確保しています。

25行目では、scikit-learnのLogisticRegressionを使用してロジスティック回帰モデルを作成しています。

28行目と29行目では、matplotlibのpyplotモジュールとscikit-learnのconfusion_matrixをインポートしています。

32行目では、作成したモデルを使用してテストデータの予測を行っています。

35行目では、予測結果と真のラベルを用いて混同行列を作成しています。

38行目から45行目では、混同行列をグラフ化しています。

plt.imshow()で混同行列を表示し、plt.xlabel()、plt.ylabel()で軸ラベルを設定しています。

plt.xticks([], [])とplt.yticks([], [])は軸の目盛りを非表示にしています。

plt.title()でグラフのタイトルを設定し、plt.colorbar()でカラーバーを表示しています。

最後のplt.show()でグラフを表示します。

このソースコードは、訓練セットとテストセットの分割、ロジスティック回帰モデルの訓練、テストデータの予測、混同行列の作成とグラフ化を順番に行っています。

アルツハイマー病の診断

アルツハイマー病の診断には、様々な特徴量が関与しますが、ここではシンプルな例として、年齢と一部の生化学的指標（例えば、血液中の特定のタンパク質レベル）を特徴量として使用するとします。

以下に、scikit-learnを使用した分類問題の解き方を示します。

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

1
2
3
4
5
6

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix, accuracy_score
import seaborn as sns

次に、仮想的なデータセットを作成します。

ここでは、年齢とタンパク質レベルの2つの特徴量を持つ1000人の患者データを生成します。

また、各患者がアルツハイマー病であるかどうかをランダムに決定します。

1
2
3

np.random.seed(0)
X = np.random.randint(60, 100, (1000, 2))  # Age and Protein level
y = np.random.choice([0, 1], 1000)  # 0: Healthy, 1: Alzheimer's

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

1

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

ランダムフォレスト分類器を訓練します。

1
2

clf = RandomForestClassifier(n_estimators=100, random_state=0)
clf.fit(X_train, y_train)

テストセットでの予測と評価を行います。

1
2

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

最後に、混同行列をグラフ化します。

1
2
3
4
5
6

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d")
plt.title("Confusion Matrix")
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.show()

このコードは、ランダムに生成したデータに対してランダムフォレスト分類器を訓練し、テストデータでの予測精度を計算し、混同行列を表示します。

[実行結果]

実際の問題では、適切な特徴量の選択と前処理、モデルの選択とチューニングが重要となります。

特徴抽出

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()

[実行結果]

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

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

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