Pyplot – グラフの標準色

2020-03-22 / tau / コメントする

Pyplotのグラフを描くときに標準で使われる色を直接指定する方法。色名に"tab:blue"のように指定する。

import matplotlib.pyplot as plt

color_names = [
    "tab:blue",
    "tab:orange",
    "tab:green",
    "tab:red",
    "tab:purple",
    "tab:brown",
    "tab:pink",
    "tab:gray",
    "tab:olive",
    "tab:cyan",
]

rev_colors = [c for c in color_names[::-1]]

values = [1] * 10

fig, ax = plt.subplots()
fig.subplots_adjust(left=0.2)

ax.barh(rev_colors, values, color=rev_colors)
ax.tick_params(bottom=False, labelbottom=False)

plt.show()

import matplotlib.pyplot as plt

color_names = [

"tab:blue",

"tab:orange",

"tab:green",

"tab:red",

"tab:purple",

"tab:brown",

"tab:pink",

"tab:gray",

"tab:olive",

"tab:cyan",

]

rev_colors = [c for c in color_names[::-1]]

values = [1] * 10

fig, ax = plt.subplots()

fig.subplots_adjust(left=0.2)

ax.barh(rev_colors, values, color=rev_colors)

ax.tick_params(bottom=False, labelbottom=False)

plt.show()

waveデータセット – knn

2020-03-22 / tau / コメントする

概要

k-最近傍回帰の例として、scikit-learnのwaveデータにKNeighborsRegressorを適用してみた結果。

近傍点数とクラス分類の挙動

訓練データとして10個のwaveデータを訓練データとして与え、2つのテストデータの予測するのに、近傍点数を1, 2, 3と変えた場合の様子を見てみる。

近傍点数=1の場合

2つのテストデータの特徴量の値に最も近い特徴量を持つ訓練データが選ばれ、その属性値がそのままテストデータの属性値となっている。

近傍点数=2の場合

テストデータの特徴量に最も近い方から1番目、2番目の特徴量を持つ訓練データが選ばれ、それらの属性値の平均がテストデータの属性値となっている。

近傍点数=3の場合

同様に、テストデータの特徴量に最も近い3つの訓練データの属性の平均がテストデータの属性値となっている。

実行コード

上記の計算のコードは以下の通り。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsRegressor
from mglearn.datasets import make_wave

X_train, y_train = make_wave(n_samples=10)

reg = KNeighborsRegressor(n_neighbors=3)
reg.fit(X_train, y_train)

X_test = np.array([[-1], [1]])
y_pred = reg.predict(X_test)

neigh_dist, neigh_ind = reg.kneighbors(X=X_test)
print(neigh_ind)

fig, ax = plt.subplots(figsize=(8.0, 4.8))

xmin, xmax = -3, 3
ymin, ymax = -3, 3

ax.scatter(X_train, y_train, marker='o', s=20)
ax.scatter(X_test, y_pred, marker='*', s=120)

for test, pred, ind in zip(X_test, y_pred, neigh_ind):
    for neigh in ind:
        ax.plot([test, test], [ymin, ymax], c='gray', linestyle='dashed')
        ax.plot(
            [test[0], X_train[neigh, 0]], [pred, y_train[neigh]],
            color='k', linestyle='dotted')

for x, y in zip(X_train, y_train):
    ax.annotate("{:6.3f}".format(y), xy=(x[0] - 0.1, y + 0.08))
for x, y in zip(X_test, y_pred):
    ax.annotate("{:6.3f}".format(y), xy=(x[0] - 0.2, y - 0.3))

ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)

ax.set_xlabel("feature")
ax.set_ylabel("prediction")

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.neighbors import KNeighborsRegressor

from mglearn.datasets import make_wave

X_train, y_train = make_wave(n_samples=10)

reg = KNeighborsRegressor(n_neighbors=3)

reg.fit(X_train, y_train)

X_test = np.array([[-1], [1]])

y_pred = reg.predict(X_test)

neigh_dist, neigh_ind = reg.kneighbors(X=X_test)

print(neigh_ind)

fig, ax = plt.subplots(figsize=(8.0, 4.8))

xmin, xmax = -3, 3

ymin, ymax = -3, 3

ax.scatter(X_train, y_train, marker='o', s=20)

ax.scatter(X_test, y_pred, marker='*', s=120)

for test, pred, ind in zip(X_test, y_pred, neigh_ind):

for neigh in ind:

ax.plot([test, test], [ymin, ymax], c='gray', linestyle='dashed')

ax.plot(

[test[0], X_train[neigh, 0]], [pred, y_train[neigh]],

color='k', linestyle='dotted')

for x, y in zip(X_train, y_train):

ax.annotate("{:6.3f}".format(y), xy=(x[0] - 0.1, y + 0.08))

for x, y in zip(X_test, y_pred):

ax.annotate("{:6.3f}".format(y), xy=(x[0] - 0.2, y - 0.3))

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

ax.set_xlabel("feature")

ax.set_ylabel("prediction")

plt.show()

knnの精度

O’Reillyの”Pythonではじめる機械学習”中、KNeighborsRegressorのwaveデータに対する精度が計算されている。40サンプルのwaveデータを発生させ訓練データとテストデータに分け、テストデータに対するR²スコアが0.83となることが示されている。実際に計算してみると、確かに同じ値となる。

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split
from mglearn.datasets import make_wave

X_source, y_source = make_wave(n_samples=40)

X_train, X_test, y_train, y_test =\
    train_test_split(X_source, y_source, random_state=0)

reg = KNeighborsRegressor(n_neighbors=3)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)

print("R^2 score:{:6.3f}".format(reg.score(X_test, y_test)))

# R^2 score: 0.834

import numpy as np

from sklearn.neighbors import KNeighborsRegressor

from sklearn.model_selection import train_test_split

from mglearn.datasets import make_wave

X_source, y_source = make_wave(n_samples=40)

X_train, X_test, y_train, y_test =\

train_test_split(X_source, y_source, random_state=0)

reg = KNeighborsRegressor(n_neighbors=3)

reg.fit(X_train, y_train)

y_pred = reg.predict(X_test)

print("R^2 score:{:6.3f}".format(reg.score(X_test, y_test)))

# R^2 score: 0.834

これを見ると比較的高い精度のように見えるが、train_test_split()の引数random_stateを変化させてみると以下のように精度はばらつく。乱数系列が異なると精度が0.3未満の場合もあるが、全体としてみると0.6～0.7あたりとなりそうである。

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split
from mglearn.datasets import make_wave

X_source, y_source = make_wave(n_samples=40)

reg = KNeighborsRegressor(n_neighbors=3)

print("random_state -> R^2")

for random_state in range(0, 10):
    X_train, X_test, y_train, y_test =\
        train_test_split(X_source, y_source, random_state=random_state)
    reg.fit(X_train, y_train)
    y_pred = reg.predict(X_test)

    print("{} -> {:6.3f}".format(random_state, reg.score(X_test, y_test)))

# random_state -> R^2
# 0 ->  0.834
# 1 ->  0.581
# 2 ->  0.798
# 3 ->  0.281
# 4 ->  0.773
# 5 ->  0.738
# 6 ->  0.554
# 7 ->  0.494
# 8 ->  0.678
# 9 ->  0.801

import numpy as np

from sklearn.neighbors import KNeighborsRegressor

from sklearn.model_selection import train_test_split

from mglearn.datasets import make_wave

X_source, y_source = make_wave(n_samples=40)

reg = KNeighborsRegressor(n_neighbors=3)

print("random_state -> R^2")

for random_state in range(0, 10):

X_train, X_test, y_train, y_test =\

train_test_split(X_source, y_source, random_state=random_state)

reg.fit(X_train, y_train)

y_pred = reg.predict(X_test)

print("{} -> {:6.3f}".format(random_state, reg.score(X_test, y_test)))

# random_state -> R^2

# 0 -> 0.834

# 1 -> 0.581

# 2 -> 0.798

# 3 -> 0.281

# 4 -> 0.773

# 5 -> 0.738

# 6 -> 0.554

# 7 -> 0.494

# 8 -> 0.678

# 9 -> 0.801

ためしにmake_wave(n_samples=1000)としてみると、結果は以下の通りとなり、精度は0.67程度（平均は0.677）と一定してくる。

random_state -> R^2
0 ->  0.679
1 ->  0.662
2 ->  0.682
3 ->  0.672
4 ->  0.680
5 ->  0.697
6 ->  0.712
7 ->  0.682
8 ->  0.661
9 ->  0.641

random_state -> R^2

0 -> 0.679

1 -> 0.662

2 -> 0.682

3 -> 0.672

4 -> 0.680

5 -> 0.697

6 -> 0.712

7 -> 0.682

8 -> 0.661

9 -> 0.641

予測カーブ

訓練データが少ない場合

40個のwaveデータに対して、n_neighborsを変化させたときの予測カーブを見てみる。

n_neighbors=1の時は、全ての訓練データを通るような線となる
n_neighborsが多くなるほど滑らかになる
n_neighborsがかなり大きくなると水平に近くなる
n_neighborsが訓練データ数と同じになると、予測線は水平になる（任意の特徴量に対して、全ての点の平均を計算しているため）

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsRegressor
from mglearn.datasets import make_wave

X_train, y_train = make_wave(n_samples=40)
xmin = np.min(X_train[:, 0])
xmax = np.max(X_train[:, 0])
X_test = np.linspace(xmin, xmax, 200).reshape(-1, 1)

fig, axs = plt.subplots(2, 3, figsize=(11, 6.4))
plt.subplots_adjust(hspace=0.4, wspace=0.4)

n_neighbors_list=[1, 2, 8, 16, 32, 40]
axs_1d = axs.reshape(1, -1)[0]

for ax, n_neighbors in zip(axs_1d, n_neighbors_list):
    reg = KNeighborsRegressor(n_neighbors=n_neighbors)
    reg.fit(X_train, y_train)
    y_pred = reg.predict(X_test)

    ax.scatter(X_train[:, 0], y_train, zorder=2, s=20, color='tab:blue')
    ax.plot(X_test, y_pred, zorder=1, color='tab:orange')

    ax.set_title("n_neighbors={}".format(n_neighbors))
    ax.set_xlabel("feature")
    ax.set_ylabel("target")

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.neighbors import KNeighborsRegressor

from mglearn.datasets import make_wave

X_train, y_train = make_wave(n_samples=40)

xmin = np.min(X_train[:, 0])

xmax = np.max(X_train[:, 0])

X_test = np.linspace(xmin, xmax, 200).reshape(-1, 1)

fig, axs = plt.subplots(2, 3, figsize=(11, 6.4))

plt.subplots_adjust(hspace=0.4, wspace=0.4)

n_neighbors_list=[1, 2, 8, 16, 32, 40]

axs_1d = axs.reshape(1, -1)[0]

for ax, n_neighbors in zip(axs_1d, n_neighbors_list):

reg = KNeighborsRegressor(n_neighbors=n_neighbors)

reg.fit(X_train, y_train)

y_pred = reg.predict(X_test)

ax.scatter(X_train[:, 0], y_train, zorder=2, s=20, color='tab:blue')

ax.plot(X_test, y_pred, zorder=1, color='tab:orange')

ax.set_title("n_neighbors={}".format(n_neighbors))

ax.set_xlabel("feature")

ax.set_ylabel("target")

plt.show()

訓練データが多い場合

今度はwaveデータでn_samples=200と数を多くしてみる。データ数を多くするとその名の通り、上下に波打ちながら増加している様子が見られる。これに対してn_neighborsを変化させたのが以下の図。

n_neighbors=10～20あたりで滑らかに、かつ波打つ状況が曲線で再現されている。

n_samples=300として訓練データに200を振り分け、n_neighborsを変化させたときのスコアは以下の通り。n_neighbors=20あたりで精度が最もよさそうである。

あるデータが得られたとき、その科学的なメカニズムは置いておいて、とりあえずデータから予測値を再現したいときにはそれなりに使えるかもしれない。

n_neighbors -> R^2
5 ->  0.754
10 ->  0.788
15 ->  0.789
20 ->  0.792
25 ->  0.777
50 ->  0.737
100 ->  0.613
200 -> -0.022

n_neighbors -> R^2

5 -> 0.754

10 -> 0.788

15 -> 0.789

20 -> 0.792

25 -> 0.777

50 -> 0.737

100 -> 0.613

200 -> -0.022

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from sklearn.model_selection import train_test_split
from mglearn.datasets import make_wave

X_source, y_source = make_wave(n_samples=300)

X_train, X_test, y_train, y_test =\
    train_test_split(X_source, y_source, train_size=200, random_state=0)

n_neighbors_list = [5, 10, 15, 20, 25, 50, 100, 200]

print("n_neighbors -> R^2")

for n_neighbors in n_neighbors_list:
    reg = KNeighborsRegressor(n_neighbors=n_neighbors)
    reg.fit(X_train, y_train)
    y_pred = reg.predict(X_test)

    print("{} -> {:6.3f}".format(n_neighbors, reg.score(X_test, y_test)))

import numpy as np

from sklearn.neighbors import KNeighborsRegressor

from sklearn.model_selection import train_test_split

from mglearn.datasets import make_wave

X_source, y_source = make_wave(n_samples=300)

X_train, X_test, y_train, y_test =\

train_test_split(X_source, y_source, train_size=200, random_state=0)

n_neighbors_list = [5, 10, 15, 20, 25, 50, 100, 200]

print("n_neighbors -> R^2")

for n_neighbors in n_neighbors_list:

reg = KNeighborsRegressor(n_neighbors=n_neighbors)

reg.fit(X_train, y_train)

y_pred = reg.predict(X_test)

print("{} -> {:6.3f}".format(n_neighbors, reg.score(X_test, y_test)))

pyplot – zorder～グラフの描画順

2020-03-22 / tau / コメントする

pyplotでグラフを描画する際、点よりも線の方が上になって見栄えが悪い・・・といった場合に、どのグラフから上にするかという指定が必要になる。

グラフ描画の優先性はplot()やscatter()などのグラフメソッドの引数にzorderを指定して実現できる。zorderに指定した値がより大きいグラフの方が上のレイヤーになる。指定できる値は正負の実数。

import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots(1, 2, figsize=(9.6, 3.6))

x = np.linspace(-np.pi, np.pi, 40)
y = np.sin(x)

ax[0].plot(x, y, color='tab:orange')
ax[0].scatter(x, y, color='tab:blue')

ax[1].plot(x, y, zorder=-0.1, color='tab:orange')
ax[1].scatter(x, y, zorder=1, color='tab:blue')

plt.show()

import numpy as np

import matplotlib.pyplot as plt

fig, ax = plt.subplots(1, 2, figsize=(9.6, 3.6))

x = np.linspace(-np.pi, np.pi, 40)

y = np.sin(x)

ax[0].plot(x, y, color='tab:orange')

ax[0].scatter(x, y, color='tab:blue')

ax[1].plot(x, y, zorder=-0.1, color='tab:orange')

ax[1].scatter(x, y, zorder=1, color='tab:blue')

plt.show()

左のグラフは後から実行しているscatterがplotの下に表示されている。

右のグラフではzorderを指定しており、scatterの方が値が大きいため上のレイヤーに表示されている。

forgeデータセット – knn

2020-03-22 / tau / コメントする

概要

ここでは、Pythonのscikit-learnパッケージのKNeighborsClassifierクラスにmglearnパッケージのforgeデータを適用してknnの挙動を確認する。

近傍点数を変化させたときのクラス分類の挙動や学習率曲線についてみていく。

近傍点数によるクラス分類の挙動

近傍点数=1の場合

データセットとしてmglearnで提供されているforgeデータを用いて、近傍点数=1とした場合の、3つのテストデータのクラス判定を以下に示す。各テストデータに対して最も距離(この場合はユークリッド距離)が近い点1つが定まり、その点のクラステストデータのクラスとして決定している。

なお、いろいろなところで見かけるforgeデータセットの散布図は当該データセットの特徴量0(横軸)と特徴量1(縦軸)の最小値と最大値に合わせて表示しており、軸目盛の比率が等しくない。ここでは、距離計算に視覚上の齟齬が生じないように、縦軸と横軸の比率を同じとしている。

後の計算のために、このグラフ描画のコードを以下に示す。

import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
from mglearn.datasets import make_forge

X, y = make_forge()

clfr = KNeighborsClassifier(n_neighbors=1)
clfr.fit(X, y)

col = ['blue', 'red']

test_points = [[9., 4.], [10., 3.], [11., 2.]]
nb_dist, nb_idx = clfr.kneighbors(test_points)
test_pred = clfr.predict(test_points)

fig, ax = plt.subplots()

ax.scatter(X[:, 0][y==0], X[:, 1][y==0], marker='o', c=col[0], label="class-0")
ax.scatter(X[:, 0][y==1], X[:, 1][y==1], marker='^', c=col[1], label="class-1")

ax.legend(loc="lower left")

for pts, cls, ids, dists in zip(test_points, test_pred, nb_idx, nb_dist):
    print(pts)
    ax.scatter(pts[0], pts[1], marker='*', s=150, c=col[cls])
    for id, dst in zip(ids, dists):
        ax.plot([pts[0], X[id, 0]], [pts[1], X[id, 1]], c='gray')
        print(" [{:7.4f}, {:7.4f}] - {:7.4f}".format(X[id, 0], X[id, 1], dst))

plt.show()

import matplotlib.pyplot as plt

from sklearn.neighbors import KNeighborsClassifier

from mglearn.datasets import make_forge

X, y = make_forge()

clfr = KNeighborsClassifier(n_neighbors=1)

clfr.fit(X, y)

col = ['blue', 'red']

test_points = [[9., 4.], [10., 3.], [11., 2.]]

nb_dist, nb_idx = clfr.kneighbors(test_points)

test_pred = clfr.predict(test_points)

fig, ax = plt.subplots()

ax.scatter(X[:, 0][y==0], X[:, 1][y==0], marker='o', c=col[0], label="class-0")

ax.scatter(X[:, 0][y==1], X[:, 1][y==1], marker='^', c=col[1], label="class-1")

ax.legend(loc="lower left")

for pts, cls, ids, dists in zip(test_points, test_pred, nb_idx, nb_dist):

print(pts)

ax.scatter(pts[0], pts[1], marker='*', s=150, c=col[cls])

for id, dst in zip(ids, dists):

ax.plot([pts[0], X[id, 0]], [pts[1], X[id, 1]], c='gray')

print(" [{:7.4f}, {:7.4f}] - {:7.4f}".format(X[id, 0], X[id, 1], dst))

plt.show()

概要は以下の通り。

5行目でforgeデータセットを準備
7行目で近傍点数を1で指定してクラス分類器を構築
8行目で訓練データとしてforgeデータを与える
12行目で3つのテストデータを準備
13行目でテストデータに対する近傍点のインデックスとテストデータまでの距離を獲得
14行目でテストデータのクラスを決定
18-19行目で訓練データの散布図を描画
23行目で、テストデータとそのクラス決定結果、クラス決定に用いられた点群のインデックス、テストデータと各点の距離を並行してループ
- 24行目でテストデータの座標を出力
- 25行目でテストデータを描画
- 26行目のループで、テストデータごとの近傍点に関する処理を実行
  - 27行目でテストデータと近傍点の間に直線を描画
  - 28行目で近傍点とテストデータからの距離を出力

出力結果は以下の通りで、各予測点に対して近傍点が1つ決定されている。

[9.0, 4.0]
 [ 8.6749,  4.4757] -  0.5762
[10.0, 3.0]
 [10.2403,  2.4554] -  0.5952
[11.0, 2.0]
 [11.5640,  1.3389] -  0.8689

[9.0, 4.0]

[ 8.6749, 4.4757] - 0.5762

[10.0, 3.0]

[10.2403, 2.4554] - 0.5952

[11.0, 2.0]

[11.5640, 1.3389] - 0.8689

近傍点数=3の場合

先の例で、コードの7行目で近傍点=3で指定してクラス分類器を構築する。

clfr = KNeighborsClassifier(n_neighbors=3)

1	clfr = KNeighborsClassifier(n_neighbors=3)

一般にknnでは、テストデータに対して複数の近傍点を指定する場合、各近傍点のクラスのうち最も多いものをテストデータのクラスとする(多数決)。

[9.0, 4.0]
 [ 8.6749,  4.4757] -  0.5762
 [ 9.4912,  4.3322] -  0.5930
 [ 8.1062,  4.2870] -  0.9387
[10.0, 3.0]
 [10.2403,  2.4554] -  0.5952
 [ 9.5017,  1.9382] -  1.1729
 [ 8.7337,  2.4916] -  1.3645
[11.0, 2.0]
 [11.5640,  1.3389] -  0.8689
 [10.2403,  2.4554] -  0.8858
 [10.0639,  0.9908] -  1.3765

[9.0, 4.0]

[ 8.6749, 4.4757] - 0.5762

[ 9.4912, 4.3322] - 0.5930

[ 8.1062, 4.2870] - 0.9387

[10.0, 3.0]

[10.2403, 2.4554] - 0.5952

[ 9.5017, 1.9382] - 1.1729

[ 8.7337, 2.4916] - 1.3645

[11.0, 2.0]

[11.5640, 1.3389] - 0.8689

[10.2403, 2.4554] - 0.8858

[10.0639, 0.9908] - 1.3765

近傍点数=2の場合

テストデータのクラスを近傍点のクラスの多数決で求めるとすると、近傍点数が偶数の時の処理が問題になる。KNeighborsClassifierの場合、偶数でクラス分類が拮抗する場合は、クラス番号が最も小さいものに割り当てられるらしい。実際、n_neighbors=2としたときの3つのテストデータのうち中央の点(10.0, 3.0)については、赤い点(10.24, 2.45)～class-1～距離0.5952の方が青い点(9.5017, 1.9382)～class-0～距離1.1729よりも距離は近いがクラス番号が0である青い点のクラスで判定されている。

[9.0, 4.0]
 [ 8.6749,  4.4757] -  0.5762
 [ 9.4912,  4.3322] -  0.5930
[10.0, 3.0]
 [10.2403,  2.4554] -  0.5952
 [ 9.5017,  1.9382] -  1.1729
[11.0, 2.0]
 [11.5640,  1.3389] -  0.8689
 [10.2403,  2.4554] -  0.8858

[9.0, 4.0]

[ 8.6749, 4.4757] - 0.5762

[ 9.4912, 4.3322] - 0.5930

[10.0, 3.0]

[10.2403, 2.4554] - 0.5952

[ 9.5017, 1.9382] - 1.1729

[11.0, 2.0]

[11.5640, 1.3389] - 0.8689

[10.2403, 2.4554] - 0.8858

偶数の点で多数決で拮抗した場合には、最も近い点のクラスで決定する、平均距離が近い方のクラスで決定するといった方法が考えられるが、この場合は必ず番号が小さなクラスが選ばれるため、若干結果に偏りがでやすいのでは、と考える。

決定境界

近傍点の数を変えた時の決定境界の変化を確認する。k近傍法はscikit-learnのKNeighborsClassifierクラスを利用する。

近傍点の数を1, 2, 3, …と変化させたときの決定境界の変化は以下の通り。

近傍点数が少ないときは訓練データにフィットするよう決定境界が複雑になるが、近傍点数が多いと決定境界は滑らかになる。特に近傍点数が訓練データの点数に等しいとき、全訓練データの多数決でクラス決定され、全領域で判定結果が同じとなる(この場合は近傍点数26が偶数なので、クラス番号の小さいclass-0で決定されている)。

この図を描画したコードを以下に示す。

7行目、引数で与えたAxesに対して決定境界を描く関数を定義
- 18行目、決定境界をcontourf()を利用して描いている
21行目、引数で与えたAxesに対してクラスごとに色分けした散布図を描く関数を定義
54行目、2次元配列のAxesを1次元配列として扱っている

import numpy as np
import matplotlib.pyplot as plt
from mglearn.datasets import make_forge
from sklearn.neighbors import KNeighborsClassifier


def draw_decision_boundary(ax, n_neighbors, X, y, X0_field, X1_field):
    clsfr = KNeighborsClassifier(n_neighbors=n_neighbors)

    clsfr.fit(X, y)

    y_predicted = np.empty((len(X1_field), len(X0_field)))

    for row, x1 in enumerate(X1_field):
        for col, x0 in enumerate(X0_field):
            y_predicted[row, col] = clsfr.predict(np.array([[x0, x1]]))

    ax.contourf(X0_field, X1_field, y_predicted, levels=1, alpha=0.5)


def draw_scatter(ax, X0, X1, xlim, ylim):
    ax.scatter(X0[y==0], X1[y==0], marker='o', s=40, label="class-0")
    ax.scatter(X0[y==1], X1[y==1], marker='^', s=40, label="class-1")

    ax.set_xlim(xlim[0], xlim[1])
    ax.set_ylim(ylim[0], ylim[1])

    ax.set_xlabel("feature 0")
    ax.set_ylabel("feature 1")

    ax.tick_params(labelbottom=False, labelleft=False)
    ax.tick_params(bottom=False, left=False)

    ax.legend(loc='lower right')


X, y = make_forge()

X0_scatter = X[:, 0]
X1_scatter = X[:, 1]

n_X0_field, n_X1_field = 20, 20
y_predicted = np.empty((n_X1_field, n_X0_field))

xlim = (7.5, 12.5)
ylim = (-1.5, 6.5)
X0_field = np.linspace(xlim[0], xlim[1], n_X0_field)
X1_field = np.linspace(ylim[0], ylim[1], n_X1_field)

fig, axs = plt.subplots(2, 3, figsize=(9.6, 6.4))
fig.subplots_adjust(hspace= 0.4)

n_neighbors_list = [1, 2, 3, 24, 25, 26]
axs_1d = axs.reshape(1, -1)[0]

for n_neighbors, ax in zip(n_neighbors_list, axs_1d):
    ax.set_title("neighbors={}".format(n_neighbors))
    draw_decision_boundary(ax, n_neighbors, X, y, X0_field, X1_field)
    draw_scatter(ax, X0_scatter, X1_scatter, xlim, ylim)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from mglearn.datasets import make_forge

from sklearn.neighbors import KNeighborsClassifier

def draw_decision_boundary(ax, n_neighbors, X, y, X0_field, X1_field):

clsfr = KNeighborsClassifier(n_neighbors=n_neighbors)

clsfr.fit(X, y)

y_predicted = np.empty((len(X1_field), len(X0_field)))

for row, x1 in enumerate(X1_field):

for col, x0 in enumerate(X0_field):

y_predicted[row, col] = clsfr.predict(np.array([[x0, x1]]))

ax.contourf(X0_field, X1_field, y_predicted, levels=1, alpha=0.5)

def draw_scatter(ax, X0, X1, xlim, ylim):

ax.scatter(X0[y==0], X1[y==0], marker='o', s=40, label="class-0")

ax.scatter(X0[y==1], X1[y==1], marker='^', s=40, label="class-1")

ax.set_xlim(xlim[0], xlim[1])

ax.set_ylim(ylim[0], ylim[1])

ax.set_xlabel("feature 0")

ax.set_ylabel("feature 1")

ax.tick_params(labelbottom=False, labelleft=False)

ax.tick_params(bottom=False, left=False)

ax.legend(loc='lower right')

X, y = make_forge()

X0_scatter = X[:, 0]

X1_scatter = X[:, 1]

n_X0_field, n_X1_field = 20, 20

y_predicted = np.empty((n_X1_field, n_X0_field))

xlim = (7.5, 12.5)

ylim = (-1.5, 6.5)

X0_field = np.linspace(xlim[0], xlim[1], n_X0_field)

X1_field = np.linspace(ylim[0], ylim[1], n_X1_field)

fig, axs = plt.subplots(2, 3, figsize=(9.6, 6.4))

fig.subplots_adjust(hspace= 0.4)

n_neighbors_list = [1, 2, 3, 24, 25, 26]

axs_1d = axs.reshape(1, -1)[0]

for n_neighbors, ax in zip(n_neighbors_list, axs_1d):

ax.set_title("neighbors={}".format(n_neighbors))

draw_decision_boundary(ax, n_neighbors, X, y, X0_field, X1_field)

draw_scatter(ax, X0_scatter, X1_scatter, xlim, ylim)

plt.show()

k-最近傍法 – 回帰

2020-03-22 / tau / コメントする

概要

k-最近傍法(k nearest neighbors: knn)による回帰は、テストデータの近傍の訓練データからテストデータの属性値を決定する。その手法は単純で、特段の学習処理はせず、訓練データセットの特徴量と属性値を記憶するのみで、テストデータが与えられたときに近傍点から属性値を決定する。手順は以下の通り。

パッケージをインポートする
特徴量と属性値のデータセットを記憶する
テストデータが与えられたら、特徴量空間の中で近傍点を選ぶ
近傍点の属性値からテストデータの属性値を決定する

パラメーターは近傍点の数で、1以上訓練データの数まで任意に増やすことができる。

利用方法

手順

scikit-learnのKNeighborsRegressorクラスの利用方法は以下の通り。

sklearn.neighborsからKNeighborsRegressorをインポート
コンストラクターの引数に近傍点数n_neighborsを指定して、KNeighborsRegressorのインスタンスを生成
fit()メソッドに訓練データの特徴量と属性値を与えて学習
predict()メソッドにテストデータの特徴量を指定して、属性値を予測
必要に応じて、kneighbors()メソッドでテストデータの近傍点情報を取得

パッケージのインポート

k-最近傍回帰のパッケージは以下でインポートする。

from sklearn.neighbors import KNeighborsRegressor

1	from sklearn.neighbors import KNeighborsRegressor

コンストラクター

KNeighborsClassifier(n_neighbors=n): nは近傍点の数でデフォルトは5。この他の引数に、近傍点を発見するアルゴリズムなどが指定できるようだ。

訓練

fit()メソッドに与える訓練データは、特徴量セットと属性値の2つ。

fit(X, y): Xは訓練データセットの特徴量データで、データ数×特徴量数の2次元配列。yは訓練データセットの属性値データで要素数はデータ数に等しい

予測

テストデータの属性値の予測は、predict()メソッドにテストデータの特徴量を与える。

y = predict(X): Xはテストデータの特徴量データで、データ数×特徴量数の2次元配列。戻り値yは予測された属性値データで要素数はデータ数に等しい。

近傍点の情報

テストデータに対する近傍点の情報を、kneighbors()メソッドで得ることができる。

neigh_dist, neigh_ind = kneighbors(X): テストデータの特徴量Xを引数に与え、近傍点に関する情報を得る。neigh_distは各テストデータから各近傍点までの距離、neigh_indは各テストデータに対する各近傍点のインデックス。いずれも2次元の配列で、テストデータ数×近傍点数の2次元配列となっている。

実行例

以下の例では、n_neighbors=2としてKNeighborsRegressorのインスタンスを準備している。

これに対してfit()メソッドで、2つの特徴量とそれに対する属性値を持つ訓練データを5個与えている。特徴量データX_trainは行数がデータ数、列数が特徴量の数となる2次元配列を想定している。また属性値y_trainは訓練データ数と同じ要素数の1次元配列。

特徴量1	特徴量2	属性値
-2	-3	-1
-1	-1	0
0	1	1
1	2	2
3	3	3

これらの訓練データに対して、テストデータの特徴量X_testとして(-0.5, -2)、(1, 0)の2つを与えた時の出力を見てみる。

import numpy as np
from sklearn.neighbors import KNeighborsRegressor

X_train = np.array(
    [[-2, -3],
     [-1, -1],
     [0, 1],
     [1, 2]])
y_train = np.array([-1, 0, 1, 2])

reg = KNeighborsRegressor(n_neighbors=2)
reg.fit(X_train, y_train)

X_test = np.array([[-0.5, -2], [1, 0]])
y_pred = reg.predict(X_test)

neigh_dist, neigh_ind = reg.kneighbors(X=X_test)

print("X_train=\n{}".format(X_train))
print("y_train={}".format(y_train))
print("X_test=\n{}".format(X_test))
print("y_pred={}".format(y_pred))
print("neighbors' distance=\n{}".format(neigh_dist))
print("neighbors' indicies=\n{}".format(neigh_ind))

import numpy as np

from sklearn.neighbors import KNeighborsRegressor

X_train = np.array(

[[-2, -3],

[-1, -1],

[0, 1],

[1, 2]])

y_train = np.array([-1, 0, 1, 2])

reg = KNeighborsRegressor(n_neighbors=2)

reg.fit(X_train, y_train)

X_test = np.array([[-0.5, -2], [1, 0]])

y_pred = reg.predict(X_test)

neigh_dist, neigh_ind = reg.kneighbors(X=X_test)

print("X_train=\n{}".format(X_train))

print("y_train={}".format(y_train))

print("X_test=\n{}".format(X_test))

print("y_pred={}".format(y_pred))

print("neighbors' distance=\n{}".format(neigh_dist))

print("neighbors' indicies=\n{}".format(neigh_ind))

このコードの実行結果は以下の通り。

X_train=
[[-2 -3]
 [-1 -1]
 [ 0  1]
 [ 1  2]]
y_train=[-1  0  1  2]
[[-0.5 -2. ]
 [ 1.   0. ]]
y_pred=[-0.5  1.5]
neighbors' distance=
[[1.11803399 1.80277564]
 [1.41421356 2.        ]]
neighbors' indicies=
[[1 0]
 [2 3]]

X_train=

[[-2 -3]

[-1 -1]

[ 0 1]

[ 1 2]]

y_train=[-1 0 1 2]

[[-0.5 -2. ]

[ 1. 0. ]]

y_pred=[-0.5 1.5]

neighbors' distance=

[[1.11803399 1.80277564]

[1.41421356 2. ]]

neighbors' indicies=

[[1 0]

[2 3]]

属性値の予測結果については、2つのテストデータに対して2つの属性値0.5と1.5が返されている。

kneighbors()メソッドの戻り値から、1つ目のテストデータにはインデックスが1と0の2つの点とそれぞれへの距離1.118と1.802が、2つ目のテストデータにはインデックスが2と3の点とそれぞれへの距離1.414と2.0が得られる。

1つ目のテストデータ(-0.5, -2)からの距離
- X_train[1]=(-1, -1)→ $\sqrt{(-0.5)^2+1^2}\approx 1.118$
- X_train[0]=(-2, -3)→ $\sqrt{(-1.5)^2+(-1)^2}\approx 1.802$
2つ目のテストデータ(1, 0)からの距離
- X_train[2]=(0, 1)→ $\sqrt{(-1)^2+1^2}\approx 1.414$
- X_train[3]=(1, 2)→ $\sqrt{0^2+2^2}=2$

y_predは、テストデータごとに2つの近傍点の属性値の平均をとっている。

1つ目のテストデータの属性値
- y_train[1]=-1とy_train[0]=0の平均→-0.5
2つ目のテストデータの属性値
- y_train[2]=1とy_train[3]=2の平均→1.5

この様子を特徴量平面上に描いたのが以下の図である。各点の数値は、各データの属性値を示している。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsRegressor

X_train = np.array(
    [[-2, -3],
     [-1, -1],
     [0, 1],
     [1, 2],
     [3, 3]])
y_train = np.array([-1, 0, 1, 2, 3])

reg = KNeighborsRegressor(n_neighbors=2)
reg.fit(X_train, y_train)

X_test = np.array([[-0.5, -2], [1, 0]])
y_pred = reg.predict(X_test)

neigh_dist, neigh_ind = reg.kneighbors(X=X_test)

fig, ax = plt.subplots()

ax.scatter(X_train[:, 0], X_train[:, 1], label="X_train")
ax.scatter(X_test[:, 0], X_test[:, 1], marker='*', s=120, label="X_test")

for tests, ind in zip(X_test, neigh_ind):
    for neigh in ind:
        ax.plot(
            [tests[0], X_train[neigh][0]], [tests[1], X_train[neigh][1]],
            color='k', linestyle='dotted')

for x, y in zip(X_train, y_train):
    ax.annotate("{}".format(y), xy=(x[0], x[1]), xytext=(x[0]+0.1, x[1]+0.1))
for x, y in zip(X_test, y_pred):
    ax.annotate("{}".format(y), xy=(x[0], x[1]), xytext=(x[0]+0.1, x[1]+0.1))

ax.set_xlabel("feature 1")
ax.set_ylabel("feature 2")
ax.legend()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.neighbors import KNeighborsRegressor

X_train = np.array(

[[-2, -3],

[-1, -1],

[0, 1],

[1, 2],

[3, 3]])

y_train = np.array([-1, 0, 1, 2, 3])

reg = KNeighborsRegressor(n_neighbors=2)

reg.fit(X_train, y_train)

X_test = np.array([[-0.5, -2], [1, 0]])

y_pred = reg.predict(X_test)

neigh_dist, neigh_ind = reg.kneighbors(X=X_test)

fig, ax = plt.subplots()

ax.scatter(X_train[:, 0], X_train[:, 1], label="X_train")

ax.scatter(X_test[:, 0], X_test[:, 1], marker='*', s=120, label="X_test")

for tests, ind in zip(X_test, neigh_ind):

for neigh in ind:

ax.plot(

[tests[0], X_train[neigh][0]], [tests[1], X_train[neigh][1]],

color='k', linestyle='dotted')

for x, y in zip(X_train, y_train):

ax.annotate("{}".format(y), xy=(x[0], x[1]), xytext=(x[0]+0.1, x[1]+0.1))

for x, y in zip(X_test, y_pred):

ax.annotate("{}".format(y), xy=(x[0], x[1]), xytext=(x[0]+0.1, x[1]+0.1))

ax.set_xlabel("feature 1")

ax.set_ylabel("feature 2")

ax.legend()

plt.show()

各種データに対する適用例

waveデータ

waveデータセット

2020-03-21 / tau / コメントする

概要

waveデータセットは、”Pythonではじめる機械学習”(O’REILLY)中で用いられる架空のデータセットである。

その内容は、引数n_samplesで指定した個数の点について1つの特徴量とターゲットの値を持ち、回帰を扱うのに適している。

利用方法

mglearnパッケージから、たとえば以下のように利用する。

from mglearn.datasets import make_wave

X, y = make_wave(n_samples=40)

from mglearn.datasets import make_wave

X, y = make_wave(n_samples=40)

実行するとdeprecatedの警告が出るが、放置してもよいらしい。

内容

waveデータの特徴は以下の通り。

引数のn_samplesには任意の整数を指定できる
特徴量（x座標の値）は決まっている
- n_samplesが増えてもx₀, x₁, …の値は変わらない
- x₀, x₁, …は実行のたびに同じパターン
ターゲットの値（y座標の値）は変化するが実行ごとに同じ
- n_samplesが変わると同じx₀, x₁, …の値に対するy₀, y₁, …の値は変化する
- y₀, y₁, …は実行のたびに同じパターン

このことを、n_samplesの値を変化させたときのX, yの内容で確認してみる。

import matplotlib.pyplot as plt
from mglearn.datasets import make_wave

n_samples_list = [1, 2, 3, 4, 5, 6]

for n_samples in n_samples_list:
    X, y = make_wave(n_samples=n_samples)
    print("\nn_samples={}".format(n_samples))
    for u, v in zip(X, y):
        print("({:6.3f}, {:6.3f})".format(u[0], v))

# n_samples=1
# (-0.7528, -0.9974)
# 
# n_samples=2
# (-0.7528, -0.1176)
# ( 2.7043,  1.6216)
# 
# n_samples=3
# (-0.7528, -0.9974)
# ( 2.7043,  1.0195)
# ( 1.3920,  0.5076)
# 
# n_samples=4
# (-0.7528, -0.5585)
# ( 2.7043,  0.7430)
# ( 1.3920,  1.1577)
# ( 0.5920,  1.0291)
# 
# n_samples=5
# (-0.7528, -0.3020)
# ( 2.7043,  1.3653)
# ( 1.3920,  0.0776)
# ( 0.5920,  0.3828)
# (-2.0639, -1.7779)
# 
# n_samples=6
# (-0.7528,  0.3481)
# ( 2.7043,  1.2438)
# ( 1.3920,  0.1333)
# ( 0.5920,  0.9167)
# (-2.0639, -1.7239)
# (-2.0640, -1.7250)

import matplotlib.pyplot as plt

from mglearn.datasets import make_wave

n_samples_list = [1, 2, 3, 4, 5, 6]

for n_samples in n_samples_list:

X, y = make_wave(n_samples=n_samples)

print("\nn_samples={}".format(n_samples))

for u, v in zip(X, y):

print("({:6.3f}, {:6.3f})".format(u[0], v))

# n_samples=1

# (-0.7528, -0.9974)

# n_samples=2

# (-0.7528, -0.1176)

# ( 2.7043, 1.6216)

# n_samples=3

# (-0.7528, -0.9974)

# ( 2.7043, 1.0195)

# ( 1.3920, 0.5076)

# n_samples=4

# (-0.7528, -0.5585)

# ( 2.7043, 0.7430)

# ( 1.3920, 1.1577)

# ( 0.5920, 1.0291)

# n_samples=5

# (-0.7528, -0.3020)

# ( 2.7043, 1.3653)

# ( 1.3920, 0.0776)

# ( 0.5920, 0.3828)

# (-2.0639, -1.7779)

# n_samples=6

# (-0.7528, 0.3481)

# ( 2.7043, 1.2438)

# ( 1.3920, 0.1333)

# ( 0.5920, 0.9167)

# (-2.0639, -1.7239)

# (-2.0640, -1.7250)

このコードは何度実行しても同じ値を返す。x座標のパターンが変わっていないこと、y座標のパターンは実行のたびに変化していることがわかる。ただし異なるn_sampleに対して、同じxに対するyの値は大きくは変化していない。

なお、n_samplesが6の時のxの最後の値とその1つ前の値がかなり近く、対応するyの値も近い。n_samplesが1の時と3の時に、先頭のXとyの値が殆ど等しい。

以上のことから、waveデータセットはXについては毎回同じ系列でランダムな値を返し、yはXに対して一定の計算値に毎回同じ系列の乱数で擾乱を加えていると想像される。

最後に、n_samplesを多くしたときの結果を見てみると明らかに線形で上昇しつつ波打っているのがわかる。おそらく $y=a \sin b x + c$ のような式に擾乱を与えていると思われる。

手法の適用

最近傍回帰(knn)

Breast cancer データセット – k-近傍法

2020-03-20 / tau / コメントする

概要

breast_cancerデータセットにscikit-learnのKNeighborsClassifierクラスでk-最近傍法を適用した結果。

学習率曲線

breast_cancerデータセットにk-最近傍法を適用し、近傍点数を変化させて学習率の変化をチェック。データセットを学習データとテストデータに分けるときのrandom_stateを変え、近傍点数に伴う変化を見てみた。

irisデータセットの場合に比べると、学習データとテストデータの傾向は落ち着いていて、近傍点数=8で制度が0.92～0.95程度。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier


def train_and_test(X, y, n_neighbors_list, random_state):

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

    training_scores = []
    test_scores = []

    for n_neighbors in n_neighbors_list:
        classifier = KNeighborsClassifier(n_neighbors=n_neighbors)

        classifier.fit(X_train, y_train)

        training_scores.append(classifier.score(X_train, y_train))
        test_scores.append(classifier.score(X_test, y_test))

    return training_scores, test_scores


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

n_neighbors_list = np.arange(1, 16, dtype=int)
random_state_list = np.array([0, 1, 2, 3])

fig, axs = plt.subplots(2, 2, figsize=(9.6, 7.2))
plt.subplots_adjust(hspace=0.4)

axs_1d = axs.reshape(1, -1)[0]

# random_stateを変化させて学習率の違いを見る
for ax, random_state in zip(axs_1d, random_state_list):
    training_scores, test_scores =\
        train_and_test(X, y, n_neighbors_list, random_state)

    ax.plot(n_neighbors_list, training_scores)
    ax.plot(n_neighbors_list, test_scores)

    ax.set_title("random_state={}".format(random_state))
    ax.set_xlabel("number of neighbors")
    ax.set_ylim(0.9, 1.01)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.neighbors import KNeighborsClassifier

def train_and_test(X, y, n_neighbors_list, random_state):

X_train, X_test, y_train, y_test =\

train_test_split(X, y, stratify=y, random_state=random_state)

training_scores = []

test_scores = []

for n_neighbors in n_neighbors_list:

classifier = KNeighborsClassifier(n_neighbors=n_neighbors)

classifier.fit(X_train, y_train)

training_scores.append(classifier.score(X_train, y_train))

test_scores.append(classifier.score(X_test, y_test))

return training_scores, test_scores

cancer_ds = load_breast_cancer()

X = cancer_ds.data

y = cancer_ds.target

n_neighbors_list = np.arange(1, 16, dtype=int)

random_state_list = np.array([0, 1, 2, 3])

fig, axs = plt.subplots(2, 2, figsize=(9.6, 7.2))

plt.subplots_adjust(hspace=0.4)

axs_1d = axs.reshape(1, -1)[0]

# random_stateを変化させて学習率の違いを見る

for ax, random_state in zip(axs_1d, random_state_list):

training_scores, test_scores =\

train_and_test(X, y, n_neighbors_list, random_state)

ax.plot(n_neighbors_list, training_scores)

ax.plot(n_neighbors_list, test_scores)

ax.set_title("random_state={}".format(random_state))

ax.set_xlabel("number of neighbors")

ax.set_ylim(0.9, 1.01)

plt.show()

irisデータセット – knn

2020-03-20 / tau / コメントする

概要

irisデータセットにscikit-learnのKNeighborsClassifierクラスでk-最近傍法を適用した結果。

学習率曲線

irisデータセットにk-最近傍法を適用し、近傍点数を変化させて学習率の変化をチェック。データセットを学習データとテストデータに分けるときのrandom_stateを変え、近傍点数に伴う変化を見てみた。

レコード数が150と少ないこともあって、random_stateを変えるごとにかなり推移が異なるが、概ね95%の精度が保たれている。

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.neighbors import KNeighborsClassifier


def train_and_test(X, y, n_neighbors_list, random_state):

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

    training_scores = []
    test_scores = []

    for n_neighbors in n_neighbors_list:
        classifier = KNeighborsClassifier(n_neighbors=n_neighbors)

        classifier.fit(X_train, y_train)

        training_scores.append(classifier.score(X_train, y_train))
        test_scores.append(classifier.score(X_test, y_test))

    return training_scores, test_scores


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

n_neighbors_list = np.arange(1, 16, dtype=int)
random_state_list = np.array([0, 1, 2, 3])

fig, axs = plt.subplots(2, 2, figsize=(9.6, 7.2))
plt.subplots_adjust(hspace=0.4)

axs_1d = axs.reshape(1, -1)[0]

# random_stateを変化させて学習率の違いを見る
for ax, random_state in zip(axs_1d, random_state_list):
    training_scores, test_scores =\
        train_and_test(X, y, n_neighbors_list, random_state)

    ax.plot(n_neighbors_list, training_scores)
    ax.plot(n_neighbors_list, test_scores)

    ax.set_title("random_state={}".format(random_state))
    ax.set_xlabel("number of neighbors")
    ax.set_ylim(0.9, 1.01)

plt.show()

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.neighbors import KNeighborsClassifier

def train_and_test(X, y, n_neighbors_list, random_state):

X_train, X_test, y_train, y_test =\

train_test_split(X, y, stratify=y, random_state=random_state)

training_scores = []

test_scores = []

for n_neighbors in n_neighbors_list:

classifier = KNeighborsClassifier(n_neighbors=n_neighbors)

classifier.fit(X_train, y_train)

training_scores.append(classifier.score(X_train, y_train))

test_scores.append(classifier.score(X_test, y_test))

return training_scores, test_scores

iris_ds = load_iris()

X = iris_ds.data

y = iris_ds.target

n_neighbors_list = np.arange(1, 16, dtype=int)

random_state_list = np.array([0, 1, 2, 3])

fig, axs = plt.subplots(2, 2, figsize=(9.6, 7.2))

plt.subplots_adjust(hspace=0.4)

axs_1d = axs.reshape(1, -1)[0]

# random_stateを変化させて学習率の違いを見る

for ax, random_state in zip(axs_1d, random_state_list):

training_scores, test_scores =\

train_and_test(X, y, n_neighbors_list, random_state)

ax.plot(n_neighbors_list, training_scores)

ax.plot(n_neighbors_list, test_scores)

ax.set_title("random_state={}".format(random_state))

ax.set_xlabel("number of neighbors")

ax.set_ylim(0.9, 1.01)

plt.show()

Breast cancer wisconsinデータセットの俯瞰

2020-03-20 / tau / コメントする

概要

breast_cancerデータは、複数の乳癌患者に関する細胞診の結果と診断結果に関するデータセットで、569人について腫瘤の細胞診に関する30の特徴量と診断結果（悪性／良性）が格納されている。このデータセットについて、irisデータセットと同じ流れで、一般的なグラフによる可視化によって俯瞰してみる。

各特徴量と診断結果

30個の特徴量について悪性と良性に色分けしてヒストグラムを描いてみると、特徴量によって悪性と良性がある程度分かれているものと、重なりが大きいものがあることがわかる。

特徴量の数は多いが、低い次元で見る限りは明確に悪性／良性を分離できる特徴量はあまり多くなさそうである。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer

cancer_ds = load_breast_cancer()

X = cancer_ds.data
y = cancer_ds.target
feature_names = cancer_ds.feature_names
target_names = cancer_ds.target_names

fig, axs = plt.subplots(6, 5, figsize=(10.0, 8))

plt.rcParams['font.size'] = 8
fig.subplots_adjust(hspace=0.4, wspace=0.4)
axs_1d = axs.reshape(1, -1)[0]

for ax, feature in zip(axs_1d, range(len(feature_names))):

    xf = X[:, feature]
    range_min = np.min(xf)
    range_max = np.max(xf)

    ax.set_title("{}({})".format(feature_names[feature], feature))
    ax.hist(xf[y==0], range=(range_min, range_max), bins=20,
        color='b', ec='k', alpha=0.5, label="b")
    ax.hist(xf[y==1], range=(range_min, range_max), bins=20,
        color='r', ec='k', alpha=0.5, label="m")
    ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)

handler, label = axs_1d[0].get_legend_handles_labels()
fig.legend(handler, label, ncol=2, loc='lower center')

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer

cancer_ds = load_breast_cancer()

X = cancer_ds.data

y = cancer_ds.target

feature_names = cancer_ds.feature_names

target_names = cancer_ds.target_names

fig, axs = plt.subplots(6, 5, figsize=(10.0, 8))

plt.rcParams['font.size'] = 8

fig.subplots_adjust(hspace=0.4, wspace=0.4)

axs_1d = axs.reshape(1, -1)[0]

for ax, feature in zip(axs_1d, range(len(feature_names))):

xf = X[:, feature]

range_min = np.min(xf)

range_max = np.max(xf)

ax.set_title("{}({})".format(feature_names[feature], feature))

ax.hist(xf[y==0], range=(range_min, range_max), bins=20,

color='b', ec='k', alpha=0.5, label="b")

ax.hist(xf[y==1], range=(range_min, range_max), bins=20,

color='r', ec='k', alpha=0.5, label="m")

ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)

handler, label = axs_1d[0].get_legend_handles_labels()

fig.legend(handler, label, ncol=2, loc='lower center')

plt.show()

2つの特徴量同士の関係

特徴量が30個あるので、scatter_matrixやpairplotで全ての特徴量の関係を見るのはあまり得策ではない。そこで、30個の特徴量の中から、悪性／良性が分かれているものを選んで相互の関係を見てみる。

ここでは、双方の分布の山ができるだけ離れており、重なっている部分が少ないものとして、平均凹度、最大半径、最大周囲長、最大凹点数を選んだ。

最大半径と最大周囲長はかなり相関が高く、双方を組み合わせてもあまり効果はなさそうだ。もともと半径と周囲長は円形なら比例関係にあるので当然の結果だろう。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_breast_cancer
from mpl_toolkits.mplot3d import Axes3D

cancer_ds = load_breast_cancer()
X = cancer_ds.data
y = cancer_ds.target
feature_names = cancer_ds.feature_names
target_names = cancer_ds.target_names

X06 = X[:, 6].reshape(-1, 1)
X20 = X[:, 20].reshape(-1, 1)
X22 = X[:, 22].reshape(-1, 1)
X27 = X[:, 27].reshape(-1, 1)
X_new = np.hstack((X06, X20, X22, X27))
fname_new = np.array(
    [feature_names[6], feature_names[20], feature_names[22], feature_names[27]])

df = pd.DataFrame(X_new, columns=fname_new)

df['target'] = cancer_ds.target
df.loc[df['target']==0, 'target'] = "malignant"
df.loc[df['target']==1, 'target'] = "benign"

g = sns.pairplot(df, hue='target', plot_kws={'alpha':0.5})

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X06[y==0], X20[y==0], X27[y==0], alpha=0.5, label="malignant")
ax.scatter(X06[y==1], X20[y==1], X27[y==1], alpha=0.5, label="benign")
ax.legend()

plt.show()

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.datasets import load_breast_cancer

from mpl_toolkits.mplot3d import Axes3D

cancer_ds = load_breast_cancer()

X = cancer_ds.data

y = cancer_ds.target

feature_names = cancer_ds.feature_names

target_names = cancer_ds.target_names

X06 = X[:, 6].reshape(-1, 1)

X20 = X[:, 20].reshape(-1, 1)

X22 = X[:, 22].reshape(-1, 1)

X27 = X[:, 27].reshape(-1, 1)

X_new = np.hstack((X06, X20, X22, X27))

fname_new = np.array(

[feature_names[6], feature_names[20], feature_names[22], feature_names[27]])

df = pd.DataFrame(X_new, columns=fname_new)

df['target'] = cancer_ds.target

df.loc[df['target']==0, 'target'] = "malignant"

df.loc[df['target']==1, 'target'] = "benign"

g = sns.pairplot(df, hue='target', plot_kws={'alpha':0.5})

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

ax.scatter(X06[y==0], X20[y==0], X27[y==0], alpha=0.5, label="malignant")

ax.scatter(X06[y==1], X20[y==1], X27[y==1], alpha=0.5, label="benign")

ax.legend()

plt.show()

3つの特徴量の関係

最後に、平均凹度、最大半径、最大凹点数の3つの特徴量の関係を3次元化してみた。結果の図を回転させて、できるだけ境界面に沿うような角度から見たのが以下の図である。個々の特徴量だけで見るよりはかなり分離の精度は高くなっている。

上記の3d可視化とその前のpairplotのコードは下記の通り。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_breast_cancer
from mpl_toolkits.mplot3d import Axes3D

cancer_ds = load_breast_cancer()
X = cancer_ds.data
y = cancer_ds.target
feature_names = cancer_ds.feature_names
target_names = cancer_ds.target_names

X06 = X[:, 6].reshape(-1, 1)
X20 = X[:, 20].reshape(-1, 1)
X22 = X[:, 22].reshape(-1, 1)
X27 = X[:, 27].reshape(-1, 1)
X_new = np.hstack((X06, X20, X22, X27))
fname_new = np.array(
    [feature_names[6], feature_names[20], feature_names[22], feature_names[27]])

df = pd.DataFrame(X_new, columns=fname_new)

df['target'] = cancer_ds.target
df.loc[df['target']==0, 'target'] = "malignant"
df.loc[df['target']==1, 'target'] = "benign"

g = sns.pairplot(df, hue='target', plot_kws={'alpha':0.5})

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X06[y==0], X20[y==0], X27[y==0], alpha=0.5, label="malignant")
ax.scatter(X06[y==1], X20[y==1], X27[y==1], alpha=0.5, label="benign")
ax.legend()

plt.show()

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.datasets import load_breast_cancer

from mpl_toolkits.mplot3d import Axes3D

cancer_ds = load_breast_cancer()

X = cancer_ds.data

y = cancer_ds.target

feature_names = cancer_ds.feature_names

target_names = cancer_ds.target_names

X06 = X[:, 6].reshape(-1, 1)

X20 = X[:, 20].reshape(-1, 1)

X22 = X[:, 22].reshape(-1, 1)

X27 = X[:, 27].reshape(-1, 1)

X_new = np.hstack((X06, X20, X22, X27))

fname_new = np.array(

[feature_names[6], feature_names[20], feature_names[22], feature_names[27]])

df = pd.DataFrame(X_new, columns=fname_new)

df['target'] = cancer_ds.target

df.loc[df['target']==0, 'target'] = "malignant"

df.loc[df['target']==1, 'target'] = "benign"

g = sns.pairplot(df, hue='target', plot_kws={'alpha':0.5})

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

ax.scatter(X06[y==0], X20[y==0], X27[y==0], alpha=0.5, label="malignant")

ax.scatter(X06[y==1], X20[y==1], X27[y==1], alpha=0.5, label="benign")

ax.legend()

plt.show()

pyplot – legend～凡例

2020-03-20 / tau / コメントする

概要

pyplotの各グラフに凡例を入れるには、legend()メソッドを使う。基本の使い方は以下の通り。

plotやscatterなどでグラフを描く時の引数にlabel=”…”でラベルを定義する。ここで設定した文字列が凡例に使われる。
グラフフィールドのオブジェクトのlegend()メソッドを実行する。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
s = np.sin(x)
c = np.cos(x)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s, label="sin")
ax.plot(x, c, label="cos")

ax.legend()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

s = np.sin(x)

c = np.cos(x)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s, label="sin")

ax.plot(x, c, label="cos")

ax.legend()

plt.show()

凡例の位置

標準的な位置指定

凡例の位置はloc引数に対して定義された文字列で指定する。

legend(loc='...')

1	legend(loc='...')

位置しての文字列は’[縦位置] [横位置]’で指定。

縦位置はupper, center, lowerの何れか、横位置はleft, center, rightの何れかで、縦位置と横位置の間には半角スペースを入れる（たとえば'upper right'）。ただし縦横中心の場合は'center'。

デフォルトは'best'で最も適切な位置が自動で設定される。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
s = np.sin(x)
c = np.cos(x)

fig, axs = plt.subplots(3, 3, figsize=(12.8, 9.6))

plt.subplots_adjust(hspace=0.4)

legends = np.empty((3, 3), dtype=object)
legends[0, 0] = 'upper left'
legends[0, 1] = 'upper center'
legends[0, 2] = 'upper right'
legends[1, 0] = 'center left'
legends[1, 1] = 'center'
legends[1, 2] = 'center right'
legends[2, 0] = 'lower left'
legends[2, 1] = 'lower center'
legends[2, 2] = 'lower right'

for row in range(3):
    for col in range(3):
        axs[row, col].set_title(legends[row, col])
        axs[row, col].plot(x, s, label="sin")
        axs[row, col].plot(x, c, label="cos")
        axs[row, col].legend(loc=legends[row, col])

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

s = np.sin(x)

c = np.cos(x)

fig, axs = plt.subplots(3, 3, figsize=(12.8, 9.6))

plt.subplots_adjust(hspace=0.4)

legends = np.empty((3, 3), dtype=object)

legends[0, 0] = 'upper left'

legends[0, 1] = 'upper center'

legends[0, 2] = 'upper right'

legends[1, 0] = 'center left'

legends[1, 1] = 'center'

legends[1, 2] = 'center right'

legends[2, 0] = 'lower left'

legends[2, 1] = 'lower center'

legends[2, 2] = 'lower right'

for row in range(3):

for col in range(3):

axs[row, col].set_title(legends[row, col])

axs[row, col].plot(x, s, label="sin")

axs[row, col].plot(x, c, label="cos")

axs[row, col].legend(loc=legends[row, col])

plt.show()

bboxによる位置指定～凡例の外側への設置

Axes.legend()の位置指定で引数としてbbox_to_anchorを指定することで、グラフの描画領域の相対位置を細かく指定することもできる。

Axes.legend(bbox_to_anchor=(x, y), loc=location_str)

1	Axes.legend(bbox_to_anchor=(x, y), loc=location_str)

bbox_to_anchor=(x, y)

x, yはグラフ描画行きの左下を(0, 0)、右上を(1, 1)としたときの相対位置。ここで指定した位置とlocで指定した凡例の基準点を一致させる。

以下のコードは、全てbbox_to_anchor=(1, 1)として凡例を描画域の右上に合わせている。その上でlocで指定した凡例の位置がこの点と一致させられる。

たとえばloc="lower right"とすると凡例の左下の位置が描画域の右上と同じになるように配置される。また、標準では凡例の枠の周りに少しパディングが行われるが、borderaxespad引数で数値を指定することでその間隔を調整できる。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
ys = np.sin(x)
yc = np.cos(x)

fig, axes = plt.subplots(2, 2)
ax_1d = axes.reshape(axes.size)

for ax in ax_1d:
    ax.plot(x, ys, label="sin x")
    ax.plot(x, yc, label="cos x")

ax_1d[0].legend(bbox_to_anchor=(1, 1), loc='lower right', borderaxespad=0)
ax_1d[1].legend(bbox_to_anchor=(1, 1), loc='lower left')
ax_1d[2].legend(bbox_to_anchor=(1, 1), loc='upper right')
ax_1d[3].legend(bbox_to_anchor=(1, 1), loc='upper left', borderaxespad=0)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

ys = np.sin(x)

yc = np.cos(x)

fig, axes = plt.subplots(2, 2)

ax_1d = axes.reshape(axes.size)

for ax in ax_1d:

ax.plot(x, ys, label="sin x")

ax.plot(x, yc, label="cos x")

ax_1d[0].legend(bbox_to_anchor=(1, 1), loc='lower right', borderaxespad=0)

ax_1d[1].legend(bbox_to_anchor=(1, 1), loc='lower left')

ax_1d[2].legend(bbox_to_anchor=(1, 1), loc='upper right')

ax_1d[3].legend(bbox_to_anchor=(1, 1), loc='upper left', borderaxespad=0)

plt.show()

ただし、この例では凡例が画面の右側ではみ出て切れてしまっている。このようなときは、tightlayout()をFigureに対して実行することで描画領域に全体を収めることができる。

ax_1d[0].legend(bbox_to_anchor=(1, 1), loc='lower right', borderaxespad=0)
ax_1d[1].legend(bbox_to_anchor=(1, 1), loc='lower left')
ax_1d[2].legend(bbox_to_anchor=(1, 1), loc='upper right')
ax_1d[3].legend(bbox_to_anchor=(1, 1), loc='upper left', borderaxespad=0)
fig.tight_layout()

ax_1d[0].legend(bbox_to_anchor=(1, 1), loc='lower right', borderaxespad=0)

ax_1d[1].legend(bbox_to_anchor=(1, 1), loc='lower left')

ax_1d[2].legend(bbox_to_anchor=(1, 1), loc='upper right')

ax_1d[3].legend(bbox_to_anchor=(1, 1), loc='upper left', borderaxespad=0)

fig.tight_layout()

凡例の並べ方

凡例はデフォルトでは縦に並べられるが、ncolに整数を指定して凡例の列数を指定できる。

legend(ncol=<em>n</em>)

1	legend(ncol=<em>n</em>)

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
s1 = np.sin(x)
c1 = np.cos(x)
s2 = np.sin(x * 2)
c2 = np.cos(x * 2)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s1, label="sin x")
ax.plot(x, c1, label="cos x")
ax.plot(x, s2, label="sin 2x")
ax.plot(x, c2, label="cos 2x")

ax.legend(ncol=2, loc='lower center')

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

s1 = np.sin(x)

c1 = np.cos(x)

s2 = np.sin(x * 2)

c2 = np.cos(x * 2)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s1, label="sin x")

ax.plot(x, c1, label="cos x")

ax.plot(x, s2, label="sin 2x")

ax.plot(x, c2, label="cos 2x")

ax.legend(ncol=2, loc='lower center')

plt.show()

デザイン等

このほか、デザイン関連で以下のような引数がある

title=[文字列]: 凡例内にタイトルを設定。
fancybox=False/True: Trueを指定すると凡例の枠の角が丸くなる。
shadow=False/True: Trueを指定すると凡例に影がつけられる。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
s = np.sin(x)
c = np.cos(x)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s, label="sin")
ax.plot(x, c, label="cos")

ax.legend(title="legend title", fancybox=True, shadow=True)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

s = np.sin(x)

c = np.cos(x)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s, label="sin")

ax.plot(x, c, label="cos")

ax.legend(title="legend title", fancybox=True, shadow=True)

plt.show()

凡例の文字サイズ

凡例本体の文字サイズは、legend()の引数fontsizeで指定する。

凡例のタイトルの文字サイズは、凡例オブジェクトからget_title()でタイトルオブジェクトを取得し、set_fontsize()で設定する。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
y_sin = np.sin(x)
y_cos = np.cos(x)

fig, ax = plt.subplots()

ax.plot(x, y_sin, label="sin")
ax.plot(x, y_cos, label="cos")

lg = ax.legend(title="sin/cos", fontsize=12)
lg.get_title().set_fontsize(15)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

y_sin = np.sin(x)

y_cos = np.cos(x)

fig, ax = plt.subplots()

ax.plot(x, y_sin, label="sin")

ax.plot(x, y_cos, label="cos")

lg = ax.legend(title="sin/cos", fontsize=12)

lg.get_title().set_fontsize(15)

plt.show()

この2行の手続きは、以下のようにチェインによって1行で書くこともできる。

ax.legend(title="sin/cos", fontsize=12).get_title().set_fontsize(15)

1	ax.legend(title="sin/cos", fontsize=12).get_title().set_fontsize(15)

引数`handles`、`labels`

legend(handles, labels)という指定方法。公式ドキュメントではこちらが先に示されている。

Axes.get_legend_handles_labels()の戻り値として、グラフ要素のhandleとそれに対するlabelのリストが得られる。

この方法は、後述のように複数のグラフの凡例をまとめて扱うときに利用する。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
s = np.sin(x)
c = np.cos(x)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s, label="sin")
ax.plot(x, c, label="cos")
handles, labels = ax.get_legend_handles_labels()

ax.legend(handles, labels)

print(handles)
print(labels)

plt.show()

# [<matplotlib.lines.Line2D object at 0x142220F0>, <matplotlib.lines.Line2D object at 0x14222370>]
# ['sin', 'cos']

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

s = np.sin(x)

c = np.cos(x)

fig, ax = plt.subplots(figsize=(4.8, 3.6))

ax.plot(x, s, label="sin")

ax.plot(x, c, label="cos")

handles, labels = ax.get_legend_handles_labels()

ax.legend(handles, labels)

print(handles)

print(labels)

plt.show()

# [<matplotlib.lines.Line2D object at 0x142220F0>, <matplotlib.lines.Line2D object at 0x14222370>]

# ['sin', 'cos']

複数グラフの場合の凡例

複数のAxesのグラフの凡例を1つにまとめて表示したい場合は、それぞれのAxesでhandleとlabelを取得しておき、それらを結合してlegend()の引数とする。

import numpy as np
import numpy.random as rnd
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
sn = np.sin(x)
cs = np.cos(x)

fig, axs = plt.subplots(1, 2, figsize=(8, 3.6))

axs[0].plot(sn, c='b', label="sin x")
handles0, labels0 = axs[0].get_legend_handles_labels()

axs[1].plot(cs, c='r', label="cos x")
handles1, labels1 = axs[1].get_legend_handles_labels()

axs[0].legend(handles0 + handles1, labels0 + labels1)

plt.show()

import numpy as np

import numpy.random as rnd

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

sn = np.sin(x)

cs = np.cos(x)

fig, axs = plt.subplots(1, 2, figsize=(8, 3.6))

axs[0].plot(sn, c='b', label="sin x")

handles0, labels0 = axs[0].get_legend_handles_labels()

axs[1].plot(cs, c='r', label="cos x")

handles1, labels1 = axs[1].get_legend_handles_labels()

axs[0].legend(handles0 + handles1, labels0 + labels1)

plt.show()

上の方法だと特定のAxesに凡例が表示されるが、これをまとめたいときには、figureに凡例を表示させる。

import numpy as np
import numpy.random as rnd
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
sn = np.sin(x)
cs = np.cos(x)

fig, axs = plt.subplots(1, 2, figsize=(8, 3.6))

axs[0].plot(sn, c='b', label="sin x")
handles0, labels0 = axs[0].get_legend_handles_labels()

axs[1].plot(cs, c='r', label="cos x")
handles1, labels1 = axs[1].get_legend_handles_labels()

fig.legend(handles0 + handles1, labels0 + labels1, ncol=2, loc='upper center')

plt.show()

import numpy as np

import numpy.random as rnd

import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)

sn = np.sin(x)

cs = np.cos(x)

fig, axs = plt.subplots(1, 2, figsize=(8, 3.6))

axs[0].plot(sn, c='b', label="sin x")

handles0, labels0 = axs[0].get_legend_handles_labels()

axs[1].plot(cs, c='r', label="cos x")

handles1, labels1 = axs[1].get_legend_handles_labels()

fig.legend(handles0 + handles1, labels0 + labels1, ncol=2, loc='upper center')

plt.show()

概要

近傍点数とクラス分類の挙動

近傍点数=1の場合

近傍点数=2の場合

近傍点数=3の場合

実行コード

knnの精度

予測カーブ

訓練データが少ない場合

訓練データが多い場合

概要

近傍点数によるクラス分類の挙動

近傍点数=1の場合

近傍点数=3の場合

近傍点数=2の場合

決定境界

概要

利用方法

手順

パッケージのインポート

コンストラクター

訓練

予測

近傍点の情報

実行例

各種データに対する適用例

概要

利用方法

内容

手法の適用

概要

学習率曲線

概要

学習率曲線

概要

各特徴量と診断結果

2つの特徴量同士の関係

3つの特徴量の関係

概要

凡例の位置

標準的な位置指定

bboxによる位置指定～凡例の外側への設置

凡例の並べ方

デザイン等

凡例の文字サイズ

引数handles、labels

複数グラフの場合の凡例

引数`handles`、`labels`