Python – How to do what I want to do

2020-07-06 / tau / コメントする

リスト関係

2次元リストを展開して1次元リストにしたい

itertools.chain.from_iterableを使う。

from itertools import chain

lst = [[1, 2, 3], [4, 5, 6]]
print(list(chain.from_iterable(lst)))

# [1, 2, 3, 4, 5, 6]

from itertools import chain

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

print(list(chain.from_iterable(lst)))

# [1, 2, 3, 4, 5, 6]

2次元リストを転置したい

2次元のリストを転置する方法を、順を追って確認する。

まず2次元リストの要素、すなわち各行を取り出す。リストの要素を分解するにはリストの先頭に'*'をつける。

list_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

print(*list_2d)

# [1, 2, 3] [4, 5, 6] [7, 8, 9]

list_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

print(*list_2d)

# [1, 2, 3] [4, 5, 6] [7, 8, 9]

結果はリストやタプルではなく、独立した3つの子リストが取り出されている。

これらの結果は、zip関数の任意個数の引数として与えることができる。ただしその結果はタプルとして得られる。

for row in zip(*list_2d):
    print(row)

# (1, 4, 7)
# (2, 5, 8)
# (3, 6, 9)

for row in zip(*list_2d):

print(row)

# (1, 4, 7)

# (2, 5, 8)

# (3, 6, 9)

この結果を内包表記を使って1つのリストにまとめると、3つのタプル行を含むリストになる。

list_2d_t = [row for row in zip(*list_2d)]
print(list_2d_t)

# [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

list_2d_t = [row for row in zip(*list_2d)]

print(list_2d_t)

# [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

各行をタプルではなくリストとしたいので、list関数でタプルをリストに変換する。

list_2d_t = [list(row) for row in zip(*list_2d)]
print(list_2d_t)

# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

list_2d_t = [list(row) for row in zip(*list_2d)]

print(list_2d_t)

# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

これで元の2次元リストが転置された。

ndarray関係

1次元配列の2次元化

1次元配列を単に2次元化

1次元配列を2次元一要素の行ベクトルにする方法。

np.array([a])と2次元で構築する
reshape(1, -1)で2次元1行の配列として変形

a = np.array([0, 1, 2, 3])
print(np.array([a]))
print(a.reshape(1, -1))

# [[0 1 2 3]]

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

print(np.array([a]))

print(a.reshape(1, -1))

# [[0 1 2 3]]

1次元配列の列ベクトル化

1次元配列を2次元の列ベクトルにする方法。hstack()などで列ベクトルを横に結合していくときに必要。

reshape(-1, 1)でn行1列の配列として変形

a = np.array([0, 1, 2, 3])
print(a.reshape(-1, 1))

# [[0]
#  [1]
#  [2]
#  [3]]

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

print(a.reshape(-1, 1))

# [[0]

# [1]

# [2]

# [3]]

2つの1次元配列の結合

縦に積み重ねる

素直に実行するならvstack()を使うのがおすすめ。

vstack()は1次元配列のままで積み重ねられる
append()は1次元配列を2次元化する必要がある

a = np.array([0, 1, 2])
b = np.array([3, 4, 5])
print(np.vstack((a, b)))
print(np.append(a.reshape(1, -1), b.reshape(1, -1), axis=0))

# [[0 1 2]
#  [3 4 5]]

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

b = np.array([3, 4, 5])

print(np.vstack((a, b)))

print(np.append(a.reshape(1, -1), b.reshape(1, -1), axis=0))

# [[0 1 2]

# [3 4 5]]

列ベクトルとして横につなげていく

この場合はhstack()が意外にややこしく、c_が手軽。ただし列ベクトルを意識するならhstack()もアリ。

1次元配列をreshape()で列ベクトル化し、hstack()を使う（1次元配列のままだと横1列に伸びるだけ）
c_を使う（1次元配列でも列ベクトル化されて結合される）

a = np.array([0, 1, 2])
b = np.array([3, 4, 5])
print(np.hstack((a.reshape(-1, 1), b.reshape(-1, 1))))
print(np.c_[a, b])

# [[0 3]
#  [1 4]
#  [2 5]]

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

b = np.array([3, 4, 5])

print(np.hstack((a.reshape(-1, 1), b.reshape(-1, 1))))

print(np.c_[a, b])

# [[0 3]

# [1 4]

# [2 5]]

空のベクトルへの追加

1次元配列の縦方向への追加

縦方向に追加するならvstack()が全般によさそう。

empty((0, n), dtype=type)で空の配列を準備し、これにvstack()で1次元配列をそのまま追加していく。

a = np.empty((0, 3), dtype=int)

b = np.array([0, 1, 2])
a = np.vstack((a, b))
print(a)
# [[0 1 2]]

b = np.array([3, 4, 5])
a = np.vstack((a, b))
print(a)
# [[0 1 2]
#  [3 4 5]]

a = np.empty((0, 3), dtype=int)

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

a = np.vstack((a, b))

print(a)

# [[0 1 2]]

b = np.array([3, 4, 5])

a = np.vstack((a, b))

print(a)

# [[0 1 2]

# [3 4 5]]

1次元配列を列ベクトルとして横方向に追加

empty((n, 0), dtype=type)で空の配列を準備し、1次元配列をreshape()で列ベクトルに変形してhstack()で追加していく。

a = np.empty((3, 0), dtype=int)

b = np.array([0, 1, 2])
a = np.hstack((a, b.reshape(-1, 1)))
print(a)
# [[0]
#  [1]
#  [2]]

b = np.array([3, 4, 5])
a = np.hstack((a, b.reshape(-1, 1)))
print(a)
# [[0 3]
#  [1 4]
#  [2 5]]

a = np.empty((3, 0), dtype=int)

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

a = np.hstack((a, b.reshape(-1, 1)))

print(a)

# [[0]

# [1]

# [2]]

b = np.array([3, 4, 5])

a = np.hstack((a, b.reshape(-1, 1)))

print(a)

# [[0 3]

# [1 4]

# [2 5]]

または、c_を使うとreshape()を使わなくてもそのまま列ベクトルとして追加してくれる。

a = np.empty((3, 0), dtype=int)

b = np.array([0, 1, 2])
a = np.c_[a, b]
print(a)

b = np.array([3, 4, 5])
a = np.c_[a, b]
print(a)

a = np.empty((3, 0), dtype=int)

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

a = np.c_[a, b]

print(a)

b = np.array([3, 4, 5])

a = np.c_[a, b]

print(a)

多次元配列の1次元化

2次元以上の配列を1次元としたいときは、reshape(-1)、flatten()、ravel()メソッド／関数を使う（詳しくはこちら）。

たとえばpyplotのsubplotで2次元の配列として得られたAxesオブジェクト（への参照）に対して全て同じ処理を施したいときに、以下のようにする。

import numpy as np
import matplotlib.pyplot as plt

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

for ax in axs.reshape(-1):
    ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

for ax in axs.reshape(-1):

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

plt.show()

条件による抽出

条件に合う要素を取り出す

a = np.arange(10)
print(a[a>=5])

# [5 6 7 8 9]

a = np.arange(10)

print(a[a>=5])

# [5 6 7 8 9]

条件式による要素の取り出しを参照。

条件に合う要素のインデックスを取り出す

a = np.arange(10, 20)
print(a[np.where(a%2==0)])

# (array([0, 2, 4, 6, 8], dtype=int32),)
# [10 12 14 16 18]

a = np.arange(10, 20)

print(a[np.where(a%2==0)])

# (array([0, 2, 4, 6, 8], dtype=int32),)

# [10 12 14 16 18]

1次元配列の条件に合う行を2次元配列から切り出す

特徴量データの配列のうち、特定のクラスに属するデータだけを取り出したいときなど。

X = np.array([
    [11, 12, 13],
    [21, 22, 23],
    [31, 32, 33],
    [41, 42, 43],
])
y = np.array([0, 1, 2, 3])
print(X[y%2==0])

# [[11 12 13]
#  [31 32 33]]

X = np.array([

[11, 12, 13],

[21, 22, 23],

[31, 32, 33],

[41, 42, 43],

])

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

print(X[y%2==0])

# [[11 12 13]

# [31 32 33]]

インデックス配列の置き換え

例えばclass_name = np.array(["Class-0", "Class-1", "Class-2"])と定義されているとき、配列np.array([0 1, 2, 0])の各要素をインデックスとしてclass_nameの要素で置き換えたい（numpy.ndarray(['Class-0', 'Class-1', 'Class-2', 'Class-0'])を得たい）。

class_name = np.array(["Class-0", "Class-1", "Class-2"])
indexes = np.array([0, 1, 2, 0])
print(class_name[indexes])

# ['Class-0' 'Class-1' 'Class-2' 'Class-0']

class_name = np.array(["Class-0", "Class-1", "Class-2"])

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

print(class_name[indexes])

# ['Class-0' 'Class-1' 'Class-2' 'Class-0']

インデックス配列の置き換えを参照。

統計値の計算

`min`, `max`, `argmin`, `argmax`

1次元配列のmin()メソッド／max()メソッドを使うと、要素の中の最小値／最大値が得られる。また、argmin()メソッド／argmax()メソッドを使うと、最小の要素／最大の要素のインデックスが得られる。

a = np.array([10, 11, 12, 13])
print(a.min(), a.max())
# 10 13

print(a.argmin(), a.argmax())
# 0 3

a = np.array([10, 11, 12, 13])

print(a.min(), a.max())

# 10 13

print(a.argmin(), a.argmax())

# 0 3

2次元配列の場合は、a.reshape(-1).min()やa.reshape(-1).argmin()などと同じ結果となる。

a = np.array([
    [11, 12, 13],
    [21, 22, 23],
    [31, 32, 33],
])

print(a.min(), a.max())
# 0 8

print(a.argmin(), a.argmax())
# 11 33

a = np.array([

[11, 12, 13],

[21, 22, 23],

[31, 32, 33],

])

print(a.min(), a.max())

# 0 8

print(a.argmin(), a.argmax())

# 11 33

メソッドの引数でaxis=0を指定すると、各列ごとの最小値／最大値を要素とする1次元配列を得る。

print(a.min(axis=0))
# [11 12 13]

print(a.max(axis=0))
# [31 32 33]

print(a.min(axis=0))

# [11 12 13]

print(a.max(axis=0))

# [31 32 33]

axis=1を指定すると、各行ごとの最小値／最大値を要素とする1次元配列を得る。この場合、この配列を列ベクトルとして考えると対比がわかりやすい。

print(a.min(axis=1))
# [11 21 31]

print(a.max(axis=1))
# [13 23 33]

print(a.min(axis=1))

# [11 21 31]

print(a.max(axis=1))

# [13 23 33]

`sum`,`mean`

要素の和や平均を計算するsum()メソッド／mean()メソッドもmin()／max()と同じように機能する。

1次元配列の場合。

a = np.array([1, 2, 3, 4, 5])
print(a.sum())
# 15

print(a.mean())
# 3.0

a = np.array([1, 2, 3, 4, 5])

print(a.sum())

# 15

print(a.mean())

# 3.0

2次元配列の場合は全要素で計算したスカラーを返す。

a = np.array([
    [0, 1, 2],
    [3, 4, 5],
    [6, 7, 8],
])

print(a.sum())
# 36

print(a.mean())
# 4.0

a = np.array([

[0, 1, 2],

[3, 4, 5],

[6, 7, 8],

])

print(a.sum())

# 36

print(a.mean())

# 4.0

axis=0で列ごとに計算した結果を1次元配列で返す。

print(a.sum(axis=0))
# [ 9 12 15]

print(a.mean(axis=0))
# [3. 4. 5.]

print(a.sum(axis=0))

# [ 9 12 15]

print(a.mean(axis=0))

# [3. 4. 5.]

axis=1で行ごとに計算した結果を1次元配列で返す。この配列が列ベクトルだと解釈すると分かりやすい。

print(a.sum(axis=1))
# [ 3 12 21]

print(a.mean(axis=1))
# [1. 4. 7.]

print(a.sum(axis=1))

# [ 3 12 21]

print(a.mean(axis=1))

# [1. 4. 7.]

順列や組み合わせを得たい

概要

順列や組み合わせの結果としての要素のコレクションを得たいときは、itertoolsパッケージを使い、結果のイテレーターをforループなどで利用。

要素数（選び出す個数）指定のパラメーター名や省略時の挙動がそれぞれで異なっているので注意。

直積

itertools.product()で直積のイテレーターを得る。

import itertools
import numpy as np

a = [1, 2, 3]

for prod in itertools.product(a, repeat=2):
    print(prod, end=" ")

# (1, 1) (1, 2) (1, 3) (2, 1) (2, 2) (2, 3) (3, 1) (3, 2) (3, 3)

import itertools

import numpy as np

a = [1, 2, 3]

for prod in itertools.product(a, repeat=2):

print(prod, end=" ")

# (1, 1) (1, 2) (1, 3) (2, 1) (2, 2) (2, 3) (3, 1) (3, 2) (3, 3)

順列

itertools.permutations()で順列のイテレーターを得る。

for perm in itertools.permutations(a, r=2):
    print(perm, end=" ")
# (1, 2) (1, 3) (2, 1) (2, 3) (3, 1) (3, 2)

for perm in itertools.permutations(a, r=2):

print(perm, end=" ")

# (1, 2) (1, 3) (2, 1) (2, 3) (3, 1) (3, 2)

組み合わせ

itertools.combinations()で組み合わせのイテレーターを得る。

for comb in itertools.combinations(a, r=2):
    print(comb, end="")

# (1, 2)(1, 3)(2, 3)

for comb in itertools.combinations(a, r=2):

print(comb, end="")

# (1, 2)(1, 3)(2, 3)

重複組み合わせ

combinations_with_replacement()で重複ありの組み合わせのイテレーターを得る。

for comb_repl in itertools.combinations_with_replacement(a, r=2):
    print(comb_repl, end="")

# (1, 1)(1, 2)(1, 3)(2, 2)(2, 3)(3, 3)

for comb_repl in itertools.combinations_with_replacement(a, r=2):

print(comb_repl, end="")

# (1, 1)(1, 2)(1, 3)(2, 2)(2, 3)(3, 3)

インデックス配列の置き換え

2020-07-05 / tau / コメントする

表題だけではよくわからないが、以下のような場合に使う。

たとえばクラス分類のためのターゲットのデータセットが以下のように与えられているとする。

import numpy as np

y = np.array([2, 1, 1, 0, 2, 2, 0, 0, 0, 1, 0, 2])
print(y)

# [2 1 1 0 2 2 0 0 0 1 0 2]

import numpy as np

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

print(y)

# [2 1 1 0 2 2 0 0 0 1 0 2]

このとき、クラス0～2に対応する以下のような名前で表現したターゲット配列を得ることができるというもの。

names = np.array(["one", "two", "three"])
print(names[y])

# ['three' 'two' 'two' 'one' 'three' 'three' 'one' 'one' 'one' 'two' 'one' 'three']

names = np.array(["one", "two", "three"])

print(names[y])

# ['three' 'two' 'two' 'one' 'three' 'three' 'one' 'one' 'one' 'two' 'one' 'three']

順を追って考えてみるのに、まずnames配列から一つの要素を取り出す。

names = np.array(["zero", "one", "two"])
print(names[0], names[1], names[2])

# zero one two

names = np.array(["zero", "one", "two"])

print(names[0], names[1], names[2])

# zero one two

配列の要素をリストとすると、そのリストの要素をインデックスとみなして、インデックスに対応する元の配列の要素を並べた配列を返す。結果はリストではなくndarray。

print(names[[0, 1, 2, 0]])

# ['zero' 'one' 'two' 'zero']

print(names[[0, 1, 2, 0]])

# ['zero' 'one' 'two' 'zero']

配列の要素を配列としても同じように動作する。

print(names[np.array([2, 1, 0, 2])])

# ['two' 'one' 'zero' 'two']

print(names[np.array([2, 1, 0, 2])])

# ['two' 'one' 'zero' 'two']

これより、クラス分類のターゲット配列などが与えられたときに、これを番号ではなくクラス名などの配列に変換することができる。

y = np.array([1, 1, 0, 1, 0, 0])
print(names[y])

# ['one' 'one' 'zero' 'one' 'zero' 'zero']

y = np.array([1, 1, 0, 1, 0, 0])

print(names[y])

# ['one' 'one' 'zero' 'one' 'zero' 'zero']

なお、インデックス配列が2次元の場合は結果の配列も2次元となる。

z = np.array([
    [0, 1, 2],
    [1, 2, 0]
])
print(names[z])

# [['zero' 'one' 'two']
#  ['one' 'two' 'zero']]

z = np.array([

[0, 1, 2],

[1, 2, 0]

])

print(names[z])

# [['zero' 'one' 'two']

# ['one' 'two' 'zero']]

MLP – 多層パーセプトロン

2020-07-04 / tau / コメントする

線形モデルの多層化

“Pythonではじめる機械学習”の写経。多層パーセプトロン(Multilayer perceptron : MLP)はフィードフォワード・ニューラルネットワークとも呼ばれる。

まず、線形モデルを以下の式で表す。

(1) $\begin{equation*} b + w_0 x_0 + \cdots + w_n x_n \end{equation*}$

n = 3の場合について図示すると、以下のように表せる。左側のノードの特徴量x_iに対して、w_iによる重み付き和を計算している。

MLPは、この構造に中間層を導入し、中間層に隠れユニット(hidden units)を配置する。特徴量入力はまず隠れユニットに対して重み付き線形和を計算し、その後に隠れユニットの出力の重み付き線形和を出力とする。

特徴量x_i (i = 0～n)の隠れユニットh_j (j = 0～m)に対する重みをw_ij、切片をb_jとすると、h_jへの入力となる重み付き線形和は以下のようになる。

(2) $\begin{equation*} h_j = \sum_{i=0}^n (b_j + w_{ij} x_i) \end{equation*}$

また、隠れユニットh_jの出力 $\hat{y}$ に対する重みをv_j、切片をcとすると、出力への重み付き線形和は以下のようになる。

(3) $\begin{equation*} \hat{y} = c + \sum_{j=0}^m v_j h_j = c + \sum_{j=0}^m v_j \sum_{i=0}^n (b_{ij} + w_{0ij} x_i) \end{equation*}$

これは結局、xiに対する重み付き線形和となる。たとえば特徴量0～3、隠れユニット0～2の場合は以下のとおり。

(4) $\begin{align*} \hat{y} &= c + v_0 h_0 + v_1 h_1 + v_2 h_2 \\ &= c + v_0 (b_0 + w_{00} x_0 + w_{10} x_1 + w_{20} x_2) \\ &\phantom{=c+}v_1 (b_1 + w_{01} x_0 + w_{11} x_1 + w_{21} x_2) \\ &\phantom{=c+}v_2 (b_2 + w_{02} x_0 + w_{12} x_1 + w_{22} x_2) \\ &= c + v_0 b_0 + v_1 b_1 + v_2 b_2 \\ &\phantom{=}+ (v_0 w_{00} + v_1 w_{01} + v_2 w_{02}) x_0 \\ &\phantom{=}+ (v_0 w_{10} + v_1 w_{11} + v_2 w_{12}) x_1 \\ &\phantom{=}+ (v_0 w_{20} + v_1 w_{21} + v_2 w_{22}) x_2 \end{align*}$

非線形活性化関数

単純な線形和をいくら多層化しても、結果は特徴量の線形和にしかならない。そこで、隠れユニットの入力に対して非線形関数を適用して出力とし、複雑・柔軟な動作を可能とする。

このような関数を活性化関数(activation function)あるいは伝達関数(transfer function)と呼び、様々な種類がある。書籍では、このうちReLU (Rectified linear unit)とtanh (hyperbolic tangent)が紹介されている。ReLUは以下の式で表され、負の値が採用しえない（計算過程での）ノイズであるような場合に好都合らしい。tanhは(−∞, +∞)の入力に対して(−1, +1)の出力を返す。

(5) $\begin{equation*} h(x) = \max (0, x) = \left\{ \begin{align} x \quad (x \ge 0) \\ 0 \quad(x < 0) \end{aling} \right. \end{equation*}$

import numpy as np
import matplotlib.pyplot as plt

xmin, xmax = -5, 5
ymin, ymax = -1, 3
x = np.linspace(xmin, xmax, 100)
tanh = np.tanh(x)
relu = np.maximum(x, 0)

fig, ax = plt.subplots()
ax.plot(x, tanh, label="tanh", linewidth=2,)
ax.plot(x, relu, label="relu", linewidth=2, linestyle='dashed')
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
ax.set_xlabel("x")
ax.set_ylabel("tanh, relu")
ax.grid(True)
ax.legend()
plt.show()

import numpy as np

import matplotlib.pyplot as plt

xmin, xmax = -5, 5

ymin, ymax = -1, 3

x = np.linspace(xmin, xmax, 100)

tanh = np.tanh(x)

relu = np.maximum(x, 0)

fig, ax = plt.subplots()

ax.plot(x, tanh, label="tanh", linewidth=2,)

ax.plot(x, relu, label="relu", linewidth=2, linestyle='dashed')

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

ax.set_xlabel("x")

ax.set_ylabel("tanh, relu")

ax.grid(True)

ax.legend()

plt.show()

ニューラルネットワークのチューニング

two moonsデータでの確認

two moonsデータセットに対してMLPを適用する。隠れユニットの数はデフォルトの100としている。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier

xmin, xmax = -1.5, 2.5
ymin, ymax = -0.75, 1.75

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = \
    train_test_split(X, y, stratify=y, random_state=42)

mlp = MLPClassifier(solver='lbfgs', random_state=0).fit(X_train, y_train)

f0 = np.linspace(xmin, xmax, 400)
f1 = np.linspace(ymin, ymax, 400)
f0, f1 = np.meshgrid(f0, f1)
pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)

fig, ax = plt.subplots()
color0, color1 = 'tab:blue', 'tab:orange'
Xtr0 = X_train[y_train==0]
Xtr1 = X_train[y_train==1]
ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=80, color=color0)
ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=80, color=color1)
ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)
ax.contour(f0, f1, pred, levels=[0.5])
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
ax.set_xlabel("Feature 0")
ax.set_ylabel("Feature 1")
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_moons

from sklearn.model_selection import train_test_split

from sklearn.neural_network import MLPClassifier

xmin, xmax = -1.5, 2.5

ymin, ymax = -0.75, 1.75

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)

X_train, X_test, y_train, y_test = \

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

mlp = MLPClassifier(solver='lbfgs', random_state=0).fit(X_train, y_train)

f0 = np.linspace(xmin, xmax, 400)

f1 = np.linspace(ymin, ymax, 400)

f0, f1 = np.meshgrid(f0, f1)

pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)

fig, ax = plt.subplots()

color0, color1 = 'tab:blue', 'tab:orange'

Xtr0 = X_train[y_train==0]

Xtr1 = X_train[y_train==1]

ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=80, color=color0)

ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=80, color=color1)

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.contour(f0, f1, pred, levels=[0.5])

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

ax.set_xlabel("Feature 0")

ax.set_ylabel("Feature 1")

plt.show()

隠れユニット数と決定境界

隠れユニット数を10とした場合の結果は数の通り。先のユニット数100の場合に比べて、決定境界が折れ線になっている。

隠れユニット数の指定はhidden_layer_sizes=[10]のように指定する。複数の隠れ層を表現するためにリストとなっていて、1層の場合でも1要素のリストとする。また、収束計算回数の最大値がデフォルトのmax_iter=200では収束しきれないという警告が出るため、この値を1000に引き上げている。

結果は書籍のものと少し異なっていて、上方の▲の点より上に鋭く境界が突き抜けている。いくつかパラメーターを変えてみたが、書籍のような境界の形状は再現できなかった。

mlp = MLPClassifier(solver='lbfgs', random_state=0,
    hidden_layer_sizes=[10], max_iter=1000).fit(X_train, y_train)

1 2	mlp = MLPClassifier(solver='lbfgs', random_state=0, hidden_layer_sizes=[10], max_iter=1000).fit(X_train, y_train)

隠れユニットの数を[1]～[4]と変化させたときの決定境界の様子は以下の通りで、ユニット数が増えるにしたがって決定境界を構成する線分の数が増えている。

for i, ax in enumerate(axs.reshape(-1)):
    ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=40, color=color0)
    ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=40, color=color1)

    mlp = MLPClassifier(solver='lbfgs', random_state=0,
        hidden_layer_sizes=[i+1]).fit(X_train, y_train)
    pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)
    ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)
    ax.contour(f0, f1, pred, levels=[0.5])

    ax.set_xlim(xmin, xmax)
    ax.set_ylim(ymin, ymax)
    ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)
    ax.set_title("hidden_units={}".format(i + 1))
plt.show()

for i, ax in enumerate(axs.reshape(-1)):

ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=40, color=color0)

ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=40, color=color1)

mlp = MLPClassifier(solver='lbfgs', random_state=0,

hidden_layer_sizes=[i+1]).fit(X_train, y_train)

pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.contour(f0, f1, pred, levels=[0.5])

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

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

ax.set_title("hidden_units={}".format(i + 1))

plt.show()

隠れ層の数

隠れユニット数が10程度でも、隠れ層の数を増やすと決定境界は滑らかになる。

mlp = MLPClassifier(solver='lbfgs', random_state=0,
    hidden_layer_sizes=[10, 10]).fit(X_train, y_train)

1 2	mlp = MLPClassifier(solver='lbfgs', random_state=0, hidden_layer_sizes=[10, 10]).fit(X_train, y_train)

隠れ層が2層の場合に、各層のユニット数を変化させたときの決定境界の変化を見てみる。1層目のユニット数が大まかな形に影響し、2層目のユニットは決定境界の滑らかさに影響していると言えそうだ。

units0_list = [1, 5, 10]
units1_list = [1, 5, 10]
for row, units0 in enumerate(units0_list):
    for col, units1 in enumerate(units1_list):
        ax = axs[row, col]
        ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=20, color=color0)
        ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=20, color=color1)

        mlp = MLPClassifier(solver='lbfgs', random_state=0,
            hidden_layer_sizes=[units0, units1]).fit(X_train, y_train)
        pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)
        ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)
        ax.contour(f0, f1, pred, levels=[0.5])

        ax.set_xlim(xmin, xmax)
        ax.set_ylim(ymin, ymax)
        ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)
        ax.set_title("hidden_units=[{},{}]".format(units0, units1))
plt.show()

units0_list = [1, 5, 10]

units1_list = [1, 5, 10]

for row, units0 in enumerate(units0_list):

for col, units1 in enumerate(units1_list):

ax = axs[row, col]

ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=20, color=color0)

ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=20, color=color1)

mlp = MLPClassifier(solver='lbfgs', random_state=0,

hidden_layer_sizes=[units0, units1]).fit(X_train, y_train)

pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.contour(f0, f1, pred, levels=[0.5])

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

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

ax.set_title("hidden_units=[{},{}]".format(units0, units1))

plt.show()

活性化関数tanh

デフォルトでは非線形活性化関数にReLUが用いられるが、これをtanhとすることで下図のように決定境界が滑らかになる。デフォルトのまま（右）だと書籍のような形にならないが、最大計算回数max_iter=115と制限すると大体似たような形になる。

max_iter_list = [115, 200]
for max_iter, ax in zip(max_iter_list, axs_1d):
    ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=80, color=color0)
    ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=80, color=color1)

    mlp = MLPClassifier(solver='lbfgs', activation='tanh', random_state=0,
        hidden_layer_sizes=[10, 10], max_iter=max_iter).fit(X_train, y_train)
    pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)
    ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)
    ax.contour(f0, f1, pred, levels=[0.5])

    ax.set_xlim(xmin, xmax)
    ax.set_ylim(ymin, ymax)
    ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)
    ax.set_title("max_iter={}".format(max_iter))
plt.show()

max_iter_list = [115, 200]

for max_iter, ax in zip(max_iter_list, axs_1d):

ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=80, color=color0)

ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=80, color=color1)

mlp = MLPClassifier(solver='lbfgs', activation='tanh', random_state=0,

hidden_layer_sizes=[10, 10], max_iter=max_iter).fit(X_train, y_train)

pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.contour(f0, f1, pred, levels=[0.5])

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

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

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

plt.show()

ここでも2つの隠れ層のユニット数を変化させてみると、第1層が大まかな形、第2層が細部の表現に影響していると言えそうだ。

正則化

MLPClassifierはL2正則化が可能で、パラメーターalphaに大きな値を設定すると正則化を強くできる。デフォルトはalpha=0.0001で正則化が効いていない状態。

以下に、2層のユニット数[10, 10]と[100, 100]に対してalphaをデフォルトの0.0001から1.0まで変化させたときの様子を示す。ただしmax_iter=500として未収束の警告が出ないようにしている。alphaを大きくするにしたがって正則化が強くなり、決定境界がシンプルなものになっていく様子が見られる。

units = [10, 100]
alphas = [0.0001, 0.01, 0.1, 1]
for axr, unit in zip(axs, units):
    for ax, alpha in zip(axr, alphas):
        ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=20, color=color0)
        ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=20, color=color1)

        mlp = MLPClassifier(solver='lbfgs', random_state=0,
            hidden_layer_sizes=[unit, unit], alpha=alpha,
            max_iter=500).fit(X_train, y_train)
        pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)
        ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)
        ax.contour(f0, f1, pred, levels=[0.5])

        ax.set_title("units={}, alpha={}".format(unit, alpha), fontsize=8)
        ax.set_xlim(xmin, xmax)
        ax.set_ylim(ymin, ymax)
        ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)
plt.show()

units = [10, 100]

alphas = [0.0001, 0.01, 0.1, 1]

for axr, unit in zip(axs, units):

for ax, alpha in zip(axr, alphas):

ax.scatter(Xtr0[:, 0], Xtr0[:, 1], marker='o', s=20, color=color0)

ax.scatter(Xtr1[:, 0], Xtr1[:, 1], marker='^', s=20, color=color1)

mlp = MLPClassifier(solver='lbfgs', random_state=0,

hidden_layer_sizes=[unit, unit], alpha=alpha,

max_iter=500).fit(X_train, y_train)

pred = mlp.predict(np.vstack([f0.ravel(), f1.ravel()]).T).reshape(f0.shape)

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.contour(f0, f1, pred, levels=[0.5])

ax.set_title("units={}, alpha={}".format(unit, alpha), fontsize=8)

ax.set_xlim(xmin, xmax)

ax.set_ylim(ymin, ymax)

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

plt.show()

ランダムな重みづけの影響

ニューラルネットワークでは、学習開始前に各重み係数がランダムに割り当てられるため、その初期値がモデルに影響を与える。以下は同じパラメーター設定に対してrandom_stateのみを変化させたもので、決定境界の形が異なっている。

データの前処理等

MLPのBreast cancerデータセットへの適用例で、データの標準化や重み係数の分布の確認等を行っている。

今後の課題

総数・ユニット数と計算量の関係
パラメーター調整のパターン
scikit-learn以外のライブラリー(keras, lasagna, tensor-flow)
GPUのサポート
収束計算のアルゴリズム(lbfgs, adam, sgd)

Breast cancerデータセット – MLP

2020-07-04 / tau / コメントする

精度不足

書籍”Pythonではじめる機械学習”の”2.3.8.2 ニューラルネットワークのチューニング”で、scikit-learnのMLPをBreast Cancerデータセットに適用した例が示されている。

デフォルトのパラメーターのままで実行した例は以下の通りだが、訓練スコアとテストスコアは、書籍ではそれぞれ0.92と0.90となっていて、下の結果とは異なる。

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

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

print("for raw data")
mlp = MLPClassifier(random_state=42).fit(X_train, y_train)
print("Training score: {:.3f}".format(mlp.score(X_train, y_train)))
print("Test score    : {:.3f}".format(mlp.score(X_test, y_test)))

# for raw data
# Training score: 0.939
# Test score    : 0.916

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.neural_network import MLPClassifier

ds = load_breast_cancer()

X_train, X_test, y_train, y_test = \

train_test_split(ds.data, ds.target, random_state=0)

print("for raw data")

mlp = MLPClassifier(random_state=42).fit(X_train, y_train)

print("Training score: {:.3f}".format(mlp.score(X_train, y_train)))

print("Test score : {:.3f}".format(mlp.score(X_test, y_test)))

# for raw data

# Training score: 0.939

# Test score : 0.916

データの標準化

これに対して書籍では、特徴量データを標準化(standardize)する例を示している。同じコードで計算したのが以下の結果で、この場合は書籍と同じ値となっている。

mean_train = X_train.mean(axis=0)
std_train = X_train.std(axis=0)
X_train_scaled = (X_train - mean_train) / std_train
X_test_scaled = (X_test - mean_train) / std_train

print("for scaled data")
mlp = MLPClassifier(random_state=0).fit(X_train_scaled, y_train)
print("Training score: {:.3f}".format(mlp.score(X_train_scaled, y_train)))
print("Test score    : {:.3f}".format(mlp.score(X_test_scaled, y_test)))

# for scaled data
# Training score: 0.991
# Test score    : 0.965

mean_train = X_train.mean(axis=0)

std_train = X_train.std(axis=0)

X_train_scaled = (X_train - mean_train) / std_train

X_test_scaled = (X_test - mean_train) / std_train

print("for scaled data")

mlp = MLPClassifier(random_state=0).fit(X_train_scaled, y_train)

print("Training score: {:.3f}".format(mlp.score(X_train_scaled, y_train)))

print("Test score : {:.3f}".format(mlp.score(X_test_scaled, y_test)))

# for scaled data

# Training score: 0.991

# Test score : 0.965

ここで未収束の警告が出て、これも書籍と同じ。

ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.
  % self.max_iter, ConvergenceWarning)

1 2	ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet. % self.max_iter, ConvergenceWarning)

書籍に倣ってmax_iter=1000とすると正常終了するが、今度は書籍の結果(0.995/0.965)と異なる結果となってしまう。

mlp = MLPClassifier(max_iter=1000, random_state=0).fit(X_train_scaled, y_train)
print("Training score: {:.3f}".format(mlp.score(X_train_scaled, y_train)))
print("Test score    : {:.3f}".format(mlp.score(X_test_scaled, y_test)))

# Training score: 1.000
# Test score    : 0.972

mlp = MLPClassifier(max_iter=1000, random_state=0).fit(X_train_scaled, y_train)

print("Training score: {:.3f}".format(mlp.score(X_train_scaled, y_train)))

print("Test score : {:.3f}".format(mlp.score(X_test_scaled, y_test)))

# Training score: 1.000

# Test score : 0.972

random_stateが違う？

よく見ると、最初のコードではMPLClassifierのパラメーターでrandom_state=42とそれ以前と同じ値を使っているが、その後の2つの計算ではrandom_state=0と異なる値を使っている。MLPの解説で重みの初期値に影響するrandom_stateの値によってモデルが異なることを注意しているにもかかわらず、このパラメーターを変更している理由がよくわからない（値を42に揃えてみたところ、ドラスティックな変化はなかったが）。

重み係数の分布

最後に、書籍に掲載されているimshowを使った重み係数の分布を再現してみる。imshowは画像ファイルを表示するほかに、配列を与えてその内容に応じたイメージを表示できる。colorbarは扱いがややこしそうで、Axesに対して適当なメソッドが見当たらなかったので、ここではpyplotに直接描画している。

import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier

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

mlp = MLPClassifier(random_state=42, hidden_layer_sizes=[100]).fit(X_train, y_train)

plt.figure(figsize=(20, 5))
plt.imshow(mlp.coefs_[0], interpolation='none', cmap='viridis')
plt.yticks(range(30), ds.feature_names)
plt.xlabel("weights for features in hidden layer")
plt.ylabel("Feature names")
plt.colorbar()
plt.show()

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.neural_network import MLPClassifier

ds = load_breast_cancer()

X_train, X_test, y_train, y_test = \

train_test_split(ds.data, ds.target, random_state=0)

mlp = MLPClassifier(random_state=42, hidden_layer_sizes=[100]).fit(X_train, y_train)

plt.figure(figsize=(20, 5))

plt.imshow(mlp.coefs_[0], interpolation='none', cmap='viridis')

plt.yticks(range(30), ds.feature_names)

plt.xlabel("weights for features in hidden layer")

plt.ylabel("Feature names")

plt.colorbar()

plt.show()

ndarray – ブロードキャスト

2020-07-04 / tau / コメントする

1次元の場合

以下の配列を元の配列とする。

a = np.arange(4)
print(a)

# [0 1 2 3]

a = np.arange(4)

print(a)

# [0 1 2 3]

数値は1次元配列に拡張されて、要素ごとに演算される。

b = 2
print(a + b)
print(a * b)

# 2 -> [2, 2, 2, 2]

# [2 3 4 5]
# [0 2 4 6]

b = 2

print(a + b)

print(a * b)

# 2 -> [2, 2, 2, 2]

# [2 3 4 5]

# [0 2 4 6]

要素が1つの配列（リスト）は同じサイズの配列に拡張されて、要素ごとに演算される。

b = np.array([2])
print(a + b)
print(a * b)

# [2] -> [2, 2, 2, 2]

# [2 3 4 5]
# [0 2 4 6]

b = np.array([2])

print(a + b)

print(a * b)

# [2] -> [2, 2, 2, 2]

# [2 3 4 5]

# [0 2 4 6]

2次元の場合

以下の配列を元の配列とする。

a = np.arange(9).reshape(3, 3)
print(a)

# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

a = np.arange(9).reshape(3, 3)

print(a)

# [[0 1 2]

# [3 4 5]

# [6 7 8]]

数値は2次元配列に拡張されて、要素ごとに計算される。

b = 2
print(a + b)

# 2 -> [[2 2 2]
#       [2 2 2]
#       [2 2 2]]

# [[ 2  3  4]
#  [ 5  6  7]
# [ 8  9 10]]

b = 2

print(a + b)

# 2 -> [[2 2 2]

# [2 2 2]

# [2 2 2]]

# [[ 2 3 4]

# [ 5 6 7]

# [ 8 9 10]]

要素が一つの配列は2次元に拡張されて、要素ごとに計算される。

b = [2]
print(a + b)

# [2] -> [[2 2 2]
#         [2 2 2]
#         [2 2 2]]

# [[ 2  3  4]
#  [ 5  6  7]
#  [ 8  9 10]]

b = [2]

print(a + b)

# [2] -> [[2 2 2]

# [2 2 2]

# [2 2 2]]

# [[ 2 3 4]

# [ 5 6 7]

# [ 8 9 10]]

列数と同じ要素数の1次元配列（リスト）は、同じ列数の2次元配列に拡張されて計算される。

b = [1, 2, 3]
print(a + b)

# [1 2 3] -> [[1 2 3]
#             [1 2 3]
#             [1 2 3]]

# [[ 1  3  5]
#  [ 4  6  8]
#  [ 7  9 11]]

b = [1, 2, 3]

print(a + b)

# [1 2 3] -> [[1 2 3]

# [1 2 3]

# [1 2 3]]

# [[ 1 3 5]

# [ 4 6 8]

# [ 7 9 11]]

行数と同じ要素数の列ベクトルは、同じ行数の2次元配列に拡張されて計算される。

b = np.array([1, 2, 3]).reshape(-1, 1)
print(a + b)

# [[1]      [[1 1 1]
#  [2]  ->   [2 2 2]
#  [3]]      [3 3 3]]

# [[ 1  2  3]
#  [ 5  6  7]
#  [ 9 10 11]]

b = np.array([1, 2, 3]).reshape(-1, 1)

print(a + b)

# [[1] [[1 1 1]

# [2] -> [2 2 2]

# [3]] [3 3 3]]

# [[ 1 2 3]

# [ 5 6 7]

# [ 9 10 11]]

Python/pyplot – 決定境界の描き方

2020-07-02 / tau / コメントする

決定境界の描き方として以前ループを使った泥臭い方法を考えたが、meshgridを使って数行で書けることを知ったのでまとめ。

結論としては以下の19～25行目の8行で、以下の手順で決定境界を書いている。

2つの特徴量の全領域をカバーする値をnumpy.linspace()で生成
numpy.meshgrid()で2次元のグリッドに変換
各特徴量のメッシュグリッドを1次元に変形し、縦2列の配列化
prediction()メソッドでその配列の各座標に対応する予測値を計算（結果は1次元配列）
結果の配列をmeshgridと同じ形状の2次元配列に変形
contour/contourf()で決定境界を描画

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

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)

x0_min, x0_max = -2.0, 2.5
x1_min, x1_max = -1.0, 1.5

knn = KNeighborsClassifier(n_neighbors=3).fit(X, y)

fig, ax = plt.subplots()

color0, color1 = 'tab:blue', 'tab:orange'
ax.scatter(X[y==0][:, 0], X[y==0][:, 1], marker='o')
ax.scatter(X[y==1][:, 0], X[y==1][:, 1], marker='^')

f0 = np.linspace(x0_min, x0_max, 200)
f1 = np.linspace(x1_min, x1_max, 200)
f0, f1 = np.meshgrid(f0, f1)
pred = knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])) \
        .reshape(f0.shape)
ax.contour(f0, f1, pred, levels=[0.5])
ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.set_xlim(x0_min, x0_max)
ax.set_ylim(x1_min, x1_max)
ax.set_xlabel("Feature-0")
ax.set_ylabel("Feature-1")

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_moons

from sklearn.neighbors import KNeighborsClassifier

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)

x0_min, x0_max = -2.0, 2.5

x1_min, x1_max = -1.0, 1.5

knn = KNeighborsClassifier(n_neighbors=3).fit(X, y)

fig, ax = plt.subplots()

color0, color1 = 'tab:blue', 'tab:orange'

ax.scatter(X[y==0][:, 0], X[y==0][:, 1], marker='o')

ax.scatter(X[y==1][:, 0], X[y==1][:, 1], marker='^')

f0 = np.linspace(x0_min, x0_max, 200)

f1 = np.linspace(x1_min, x1_max, 200)

f0, f1 = np.meshgrid(f0, f1)

pred = knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])) \

.reshape(f0.shape)

ax.contour(f0, f1, pred, levels=[0.5])

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ax.set_xlim(x0_min, x0_max)

ax.set_ylim(x1_min, x1_max)

ax.set_xlabel("Feature-0")

ax.set_ylabel("Feature-1")

plt.show()

具体的な変数の変形状況を要素数4の少ない例で示すと以下の通り。

まず、2つの特徴量の範囲の数列を生成する。

f0 = np.linspace(x0_min, x0_max, 4)
f1 = np.linspace(x1_min, x1_max, 4)
print(f0)
print(f1)

# [-2.  -0.5  1.   2.5]
# [-1.         -0.16666667  0.66666667  1.5       ]

f0 = np.linspace(x0_min, x0_max, 4)

f1 = np.linspace(x1_min, x1_max, 4)

print(f0)

print(f1)

# [-2. -0.5 1. 2.5]

# [-1. -0.16666667 0.66666667 1.5 ]

それらの数列を、meshgridで2次元配列に変形する。

f0, f1 = np.meshgrid(f0, f1)
print(f0)
print(f1)

# [[-2.  -0.5  1.   2.5]
#  [-2.  -0.5  1.   2.5]
#  [-2.  -0.5  1.   2.5]
#  [-2.  -0.5  1.   2.5]]
# [[-1.         -1.         -1.         -1.        ]
#  [-0.16666667 -0.16666667 -0.16666667 -0.16666667]
#  [ 0.66666667  0.66666667  0.66666667  0.66666667]
#  [ 1.5         1.5         1.5         1.5       ]]

f0, f1 = np.meshgrid(f0, f1)

print(f0)

print(f1)

# [[-2. -0.5 1. 2.5]

# [-2. -0.5 1. 2.5]

# [-2. -0.5 1. 2.5]]

# [[-1. -1. -1. -1. ]

# [-0.16666667 -0.16666667 -0.16666667 -0.16666667]

# [ 0.66666667 0.66666667 0.66666667 0.66666667]

# [ 1.5 1.5 1.5 1.5 ]]

予測モデルに与える変数は各特徴量を列とする2次元配列とする必要があるので、まず上の2次元配列をそれぞれ1次元に変形。この変形では、2次元配列の各行を連ねていった1行の配列を列ベクトルにした形になる。

print(f0.reshape(-1, 1))
print(f1.reshape(-1, 1))

# [[-2. ]
#  [-0.5]
#  [ 1. ]
#  [ 2.5]
#  [-2. ]
#  [-0.5]
#  [ 1. ]
#  [ 2.5]
#  [-2. ]
#  [-0.5]
#  [ 1. ]
#  [ 2.5]
#  [-2. ]
#  [-0.5]
#  [ 1. ]
#  [ 2.5]]
# [[-1.        ]
#  [-1.        ]
#  [-1.        ]
#  [-1.        ]
#  [-0.16666667]
#  [-0.16666667]
#  [-0.16666667]
#  [-0.16666667]
#  [ 0.66666667]
#  [ 0.66666667]
#  [ 0.66666667]
#  [ 0.66666667]
#  [ 1.5       ]
#  [ 1.5       ]
#  [ 1.5       ]
#  [ 1.5       ]]

print(f0.reshape(-1, 1))

print(f1.reshape(-1, 1))

# [[-2. ]

# [-0.5]

# [ 1. ]

# [ 2.5]

# [-2. ]

# [-0.5]

# [ 1. ]

# [ 2.5]

# [-2. ]

# [-0.5]

# [ 1. ]

# [ 2.5]

# [-2. ]

# [-0.5]

# [ 1. ]

# [ 2.5]]

# [[-1. ]

# [-1. ]

# [-0.16666667]

# [ 0.66666667]

# [ 1.5 ]

# [ 1.5 ]]

次に2つの列ベクトルを横方向に並べて、総計算データ数×特徴量数(2)の2次元配列とする。

print(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)]))

# [[-2.         -1.        ]
#  [-0.5        -1.        ]
#  [ 1.         -1.        ]
#  [ 2.5        -1.        ]
#  [-2.         -0.16666667]
#  [-0.5        -0.16666667]
#  [ 1.         -0.16666667]
#  [ 2.5        -0.16666667]
#  [-2.          0.66666667]
#  [-0.5         0.66666667]
#  [ 1.          0.66666667]
#  [ 2.5         0.66666667]
#  [-2.          1.5       ]
#  [-0.5         1.5       ]
#  [ 1.          1.5       ]
#  [ 2.5         1.5       ]]

print(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)]))

# [[-2. -1. ]

# [-0.5 -1. ]

# [ 1. -1. ]

# [ 2.5 -1. ]

# [-2. -0.16666667]

# [-0.5 -0.16666667]

# [ 1. -0.16666667]

# [ 2.5 -0.16666667]

# [-2. 0.66666667]

# [-0.5 0.66666667]

# [ 1. 0.66666667]

# [ 2.5 0.66666667]

# [-2. 1.5 ]

# [-0.5 1.5 ]

# [ 1. 1.5 ]

# [ 2.5 1.5 ]]

この配列の各座標に対する予測値を、predict()メソッドで予測。この結果は、1次元化されたf0やf1と同じく、2次元のmeshgridの各行を横に連ねたものになっている。

print(knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])))

# [0 0 1 1 0 1 1 1 0 0 0 1 0 0 0 1]

print(knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])))

# [0 0 1 1 0 1 1 1 0 0 0 1 0 0 0 1]

この結果を、meshgrid化されたf0（またはf1）と同じ形に変形。これで予測結果がf0×f1平面の各座標に対応した予測値の2次元配列となっている。

print(knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])).reshape(f0.shape))

# [[0 0 1 1]
#  [0 1 1 1]
#  [0 0 0 1]
#  [0 0 0 1]]

print(knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])).reshape(f0.shape))

# [[0 0 1 1]

# [0 1 1 1]

# [0 0 0 1]

# [0 0 0 1]]

この結果を使い、contour()/contourf()で決定境界あるいは決定領域を描画。

pred = knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])) \
        .reshape(f0.shape)
ax.contour(f0, f1, pred, levels=[0.5])
ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

pred = knn.predict(np.hstack([f0.reshape(-1, 1), f1.reshape(-1, 1)])) \

.reshape(f0.shape)

ax.contour(f0, f1, pred, levels=[0.5])

ax.contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

ここでlevelsの指定は以下のようにしている。

まずcontour()の場合、ドキュメンテーションには“If an int n, use n data intervals; i.e. draw n+1 contour lines. The level heights are automatically chosen.”と書かれているので、levels=0と指定すると0＋1本の線が描かれると考えたが以下のような警告が出て線の位置がずれた。

serWarning: No contour levels were found within the data range.
  ax.contour(f0, f1, pred, levels=0)

1 2	serWarning: No contour levels were found within the data range. ax.contour(f0, f1, pred, levels=0)

そこでlevels=[0.5]と2つのクラス値0と1の間をとると適切に表示される。

なおcontourf()のときは、levels=1として2つの領域が描かれる。

リスト関係

2次元リストを展開して1次元リストにしたい

2次元リストを転置したい

ndarray関係

1次元配列の2次元化

1次元配列を単に2次元化

1次元配列の列ベクトル化

2つの1次元配列の結合

縦に積み重ねる

列ベクトルとして横につなげていく

空のベクトルへの追加

1次元配列の縦方向への追加

1次元配列を列ベクトルとして横方向に追加

多次元配列の1次元化

条件による抽出

条件に合う要素を取り出す

条件に合う要素のインデックスを取り出す

1次元配列の条件に合う行を2次元配列から切り出す

インデックス配列の置き換え

統計値の計算

min, max, argmin, argmax

sum,mean

順列や組み合わせを得たい

概要

直積

順列

組み合わせ

重複組み合わせ

線形モデルの多層化

非線形活性化関数

ニューラルネットワークのチューニング

two moonsデータでの確認

隠れユニット数と決定境界

隠れ層の数

活性化関数tanh

正則化

ランダムな重みづけの影響

データの前処理等

今後の課題

精度不足

データの標準化

random_stateが違う？

重み係数の分布

1次元の場合

2次元の場合

`min`, `max`, `argmin`, `argmax`

`sum`,`mean`