Ruby – 基本的なリテラル

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

数値

整数

puts 123, -123

# 123
# -123

puts 123, -123

# 123

# -123

基数を指定する場合。

puts 0d255
puts 0b11111111
puts 0o377, 0377

# 255
# 255
# 255
# 255

puts 0d255

puts 0b11111111

puts 0o377, 0377

# 255

先頭がゼロの場合は8進数と解釈される点に注意。8進数と解釈できない場合はエラーになる。

puts 010
puts 08 -> Invalid octal digit

# 8

puts 010

puts 08 -> Invalid octal digit

# 8

実数

puts 123.456   # 固定小数点
puts 1.23456e2 # 浮動小数点

# 123.456
# 123.456

puts 123.456 # 固定小数点

puts 1.23456e2 # 浮動小数点

# 123.456

小数点以下をゼロとすると実数のリテラルになるが、小数点のみを付けるとエラーになる。

puts 123.0
puts 123. -> NoMethodError

# 123.0

puts 123.0

puts 123. -> NoMethodError

# 123.0

0～1の小数点では、先頭のゼロは省略できない。

puts 0.123
puts .123  -> syntax error

# 0.123

puts 0.123

puts .123 -> syntax error

# 0.123

有理数

末尾に'r'を付けると有理数となり、分数形式で保持される。

puts 1.25r
puts 1.414r

# 5/4
# 707/500

puts 1.25r

puts 1.414r

# 5/4

# 707/500

複素数

'i'の直前に数値を並べると虚数となり、複素数形式で保存される。

puts 1 + 2.1i
puts 1i * 1i

# 1+2.1i
# -1+0i

puts 1 + 2.1i

puts 1i * 1i

# 1+2.1i

# -1+0i

文字列

ダブルクォートかシングルクォートで囲む。

puts "Ruby string"
puts 'Ruby string'

# Ruby string
# Ruby string

puts "Ruby string"

puts 'Ruby string'

# Ruby string

ダブルクォートで囲むとバックスラッシュ記法は特殊文字として解釈されるが、シングルクォートで囲むとバックスラッシュが単なる文字として扱われる。

puts "Ruby\nstring"
puts 'Ruby\nstring'

# Ruby
# string
# Ruby\nstring

puts "Ruby\nstring"

puts 'Ruby\nstring'

# Ruby

# string

# Ruby\nstring

空白をはさんで並んだ文字列は結合される。

puts "Ruby" "String"

# RubyString

puts "Ruby" "String"

# RubyString

文字リテラル

'?'に続く一文字は文字列として扱われる。

puts ?字
puts ?\u5b57

# 字
# 字

puts ?字

puts ?\u5b57

# 字

ヒアドキュメント

'<<[識別子]'の次の行から'[識別子]'の直前の行までが複数行にわたる文字列として解釈される。

puts <<EOS
1行目
2行目
EOS

# 1行目
# 2行目

puts <<EOS

1行目

2行目

EOS

# 1行目

# 2行目

論理値

論理値のリテラルとしてtrue、falseが定義されている。

puts true ? "True" : "False"
puts false ? "True" : "False"

# True
# False

puts true ? "True" : "False"

puts false ? "True" : "False"

# True

# False

scikit-learn – predict_proba

2020-09-09 / tau / コメントする

概要

decision_function()は各データが推測したクラスに属する確信度(confidence)を表すが、超平面のパラメータに依存し、そのレンジや値の大きさと確信度の関係が明確ではない。

これに対してpredict_probaは、それぞれのターゲットが予測されたクラスに属する確率を0～1の実数で表す。2クラス分類では、結果の配列の形状は(n_sumples, 2)となる。

`predict_proba()`の挙動

以下はmake_circles()で生成した2クラスのデータをGradient Boostingによって分類したときの確信度。各データに対応した2要素の配列の1つ目がクラス0(blue)、2つ目がクラス1(orange)に属する確率を表し、2つの和は1となる。なお16行目でsuppress=Trueとすることで、ndarrayの表示を常に固定小数点としている。

import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)
y_named = np.array(["blue", "orange"])[y]

X_train, X_test, y_train, y_test, y_train_named, y_test_named = \
    train_test_split(X, y, y_named, random_state=0)

gbc = GradientBoostingClassifier(random_state=0)
gbc.fit(X_train, y_train_named)

pred_prob = gbc.predict_proba(X_test)
np.set_printoptions(suppress=True)
print(pred_prob)

# [[0.01573626 0.98426374]
#  [0.84575653 0.15424347]
#  [0.98112869 0.01887131]
#  .....
#  [0.06307595 0.93692405]
#  [0.93442475 0.06557525]
#  [0.86619957 0.13380043]]

import numpy as np

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.datasets import make_circles

from sklearn.model_selection import train_test_split

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)

y_named = np.array(["blue", "orange"])[y]

X_train, X_test, y_train, y_test, y_train_named, y_test_named = \

train_test_split(X, y, y_named, random_state=0)

gbc = GradientBoostingClassifier(random_state=0)

gbc.fit(X_train, y_train_named)

pred_prob = gbc.predict_proba(X_test)

np.set_printoptions(suppress=True)

print(pred_prob)

# [[0.01573626 0.98426374]

# [0.84575653 0.15424347]

# [0.98112869 0.01887131]

# .....

# [0.06307595 0.93692405]

# [0.93442475 0.06557525]

# [0.86619957 0.13380043]]

`decision_function()`との比較

先のコードに以下を続けて、predict_proba()による確率、予測されたクラス、decsion_function()の値と、各データの正解クラスを並べて表示する。予測されたクラスの方の確率が大きいこと、その予測結果とdecision_function()の符号が一致していることが確認できる。

prob0 = pred_prob[:, 0]
prob1 = pred_prob[:, 1]

data = DataFrame()
data["prob0"] = prob0
data["prob1"] = prob1
data["pred"] = gbc.predict(X_test)
data["dec_func"] = gbc.decision_function(X_test)
data["correct"] = y_test_named
print(data)

#        prob0     prob1    pred  dec_func correct
# 0   0.015736  0.984264  orange  4.135926  orange
# 1   0.845757  0.154243    blue -1.701699    blue
# 2   0.981129  0.018871    blue -3.951061    blue
# .....
# 22  0.063076  0.936924  orange  2.698263  orange
# 23  0.934425  0.065575    blue -2.656733    blue
# 24  0.866200  0.133800    blue -1.867766    blue

prob0 = pred_prob[:, 0]

prob1 = pred_prob[:, 1]

data = DataFrame()

data["prob0"] = prob0

data["prob1"] = prob1

data["pred"] = gbc.predict(X_test)

data["dec_func"] = gbc.decision_function(X_test)

data["correct"] = y_test_named

print(data)

# prob0 prob1 pred dec_func correct

# 0 0.015736 0.984264 orange 4.135926 orange

# 1 0.845757 0.154243 blue -1.701699 blue

# 2 0.981129 0.018871 blue -3.951061 blue

# .....

# 22 0.063076 0.936924 orange 2.698263 orange

# 23 0.934425 0.065575 blue -2.656733 blue

# 24 0.866200 0.133800 blue -1.867766 blue

このデータをクラス0(blue)に対する確率(prob0)でソートし、decision_function()との関係を見てみると、以下のことがわかる。

blueクラスの確率が高いとdecision_functionの確信度はマイナスで絶対値が大きくなり、orangeクラスの確率が高いと確信度はプラスで絶対値が大きくなる
blueクラスの確率とorangeクラスの確率が同程度の時、確信度の絶対値が同程度になり、符号が逆になる
確率に対して確信度は線形ではない

print(data.sort_values(by="prob0", ascending=False))

#        prob0     prob1    pred  dec_func correct
# 6   0.999543  0.000457    blue -7.690972    blue
# 10  0.998442  0.001558    blue -6.462560    blue
# 15  0.984817  0.015183    blue -4.172312  orange
# .....
# 0   0.015736  0.984264  orange  4.135926  orange
# 11  0.013521  0.986479  orange  4.289866  orange
# 4   0.013521  0.986479  orange  4.289866  orange

print(data.sort_values(by="prob0", ascending=False))

# prob0 prob1 pred dec_func correct

# 6 0.999543 0.000457 blue -7.690972 blue

# 10 0.998442 0.001558 blue -6.462560 blue

# 15 0.984817 0.015183 blue -4.172312 orange

# .....

# 0 0.015736 0.984264 orange 4.135926 orange

# 11 0.013521 0.986479 orange 4.289866 orange

# 4 0.013521 0.986479 orange 4.289866 orange

クラス0(blue)に対する確率とdecision_function()の確信度の関係を図示すると以下のようになり、確率に対して確信度が必ずしも線形になっていないことがわかる。

コードはmatplotlib.pyplotをインポートした上で、以下を追加。

prob = np.array(sorted_data["prob0"])
conf = np.array(sorted_data["dec_func"])
fig = plt.figure()
ax = fig.add_subplot()
ax.plot(prob, conf)
ax.grid()
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_position('zero')
ax.spines['left'].set_position(('data', 0.5))
ax.set_xlabel("class-0 probaility", loc='left')
ax.set_ylabel("confidence", loc='bottom')
plt.show()

prob = np.array(sorted_data["prob0"])

conf = np.array(sorted_data["dec_func"])

fig = plt.figure()

ax = fig.add_subplot()

ax.plot(prob, conf)

ax.grid()

ax.spines['top'].set_visible(False)

ax.spines['right'].set_visible(False)

ax.spines['bottom'].set_position('zero')

ax.spines['left'].set_position(('data', 0.5))

ax.set_xlabel("class-0 probaility", loc='left')

ax.set_ylabel("confidence", loc='bottom')

plt.show()

決定境界

以下は、predict_proba()で計算された確率を可視化したもので、decision_function()の場合に比べて、直感的にも分かりやすい分布となっている。

コンターに表す値として、30行目でpredict_proba()の結果の0列目、すなわちClass0の確率を取り出している。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

f0min, f0max = -1.5, 1.5
f1min, f1max = -1.75, 1.5

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)

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

gb = GradientBoostingClassifier(random_state=0)
gb.fit(X_train, y_train)

fig, axs = plt.subplots(1, 2, figsize=(10, 4.8))
color0, color1 = 'tab:blue', 'tab:orange'

f0 = np.linspace(f0min, f0max, 200)
f1 = np.linspace(f1min, f1max, 200)
f0, f1 = np.meshgrid(f0, f1)
F = np.hstack((f0.reshape(-1, 1), f1.reshape(-1, 1)))

pred = gb.predict(F).reshape(f0.shape)
axs[0].contour(f0, f1, pred, levels=[0.5])
axs[0].contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

proba = gb.predict_proba(F)[:, 0].reshape(f0.shape)
print(proba.shape)
axs[1].contourf(f0, f1, proba, alpha=0.5, cmap='RdBu')

for ax in axs:
    ax.scatter(X_train[y_train==0][:, 0], X_train[y_train==0][:, 1], marker='o', fc=color0, ec='k', label="Train class 0")
    ax.scatter(X_test[y_test==0][:, 0], X_test[y_test==0][:, 1], marker='^', fc=color0, ec='k', label="Test Class 0")
    ax.scatter(X_train[y_train==1][:, 0], X_train[y_train==1][:, 1], marker='o', fc=color1, ec='k', label="Train class 1")
    ax.scatter(X_test[y_test==1][:, 0], X_test[y_test==1][:, 1], marker='^', fc=color1, ec='k', label="Test class 1")

    ax.set_xlim(f0min, f0max)
    ax.set_ylim(f1min, f1max)
    ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)

handles, labels = axs[0].get_legend_handles_labels()

fig.legend(handles, labels, ncol=4, loc='upper center')
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.datasets import make_circles

from sklearn.model_selection import train_test_split

f0min, f0max = -1.5, 1.5

f1min, f1max = -1.75, 1.5

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)

X_train, X_test, y_train, y_test =\

train_test_split(X, y, random_state=0)

gb = GradientBoostingClassifier(random_state=0)

gb.fit(X_train, y_train)

fig, axs = plt.subplots(1, 2, figsize=(10, 4.8))

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

f0 = np.linspace(f0min, f0max, 200)

f1 = np.linspace(f1min, f1max, 200)

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

F = np.hstack((f0.reshape(-1, 1), f1.reshape(-1, 1)))

pred = gb.predict(F).reshape(f0.shape)

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

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

proba = gb.predict_proba(F)[:, 0].reshape(f0.shape)

print(proba.shape)

axs[1].contourf(f0, f1, proba, alpha=0.5, cmap='RdBu')

for ax in axs:

ax.scatter(X_train[y_train==0][:, 0], X_train[y_train==0][:, 1], marker='o', fc=color0, ec='k', label="Train class 0")

ax.scatter(X_test[y_test==0][:, 0], X_test[y_test==0][:, 1], marker='^', fc=color0, ec='k', label="Test Class 0")

ax.scatter(X_train[y_train==1][:, 0], X_train[y_train==1][:, 1], marker='o', fc=color1, ec='k', label="Train class 1")

ax.scatter(X_test[y_test==1][:, 0], X_test[y_test==1][:, 1], marker='^', fc=color1, ec='k', label="Test class 1")

ax.set_xlim(f0min, f0max)

ax.set_ylim(f1min, f1max)

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

handles, labels = axs[0].get_legend_handles_labels()

fig.legend(handles, labels, ncol=4, loc='upper center')

plt.show()

3クラス以上の場合

3クラスのirisデータセットにGradientBoostingClassifierを適用し、predict_proba()の出力を見てみる。

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from pandas import DataFrame

iris = load_iris()

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

gbc = GradientBoostingClassifier(learning_rate=0.01, random_state=0)
gbc.fit(X_train, y_train)

pred_proba = gbc.predict_proba(X_test)
df = DataFrame(pred_proba, columns=iris.target_names)
df["decision"] = np.argmax(pred_proba, axis=1)
df["prediction"] = gbc.predict(X_test)
print(df)

import numpy as np

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.ensemble import GradientBoostingClassifier

from pandas import DataFrame

iris = load_iris()

X_train, X_test, y_train, y_test = train_test_split(

iris.data, iris.target, random_state=42)

gbc = GradientBoostingClassifier(learning_rate=0.01, random_state=0)

gbc.fit(X_train, y_train)

pred_proba = gbc.predict_proba(X_test)

df = DataFrame(pred_proba, columns=iris.target_names)

df["decision"] = np.argmax(pred_proba, axis=1)

df["prediction"] = gbc.predict(X_test)

print(df)

このコードの出力結果は以下の通り。3つのクラスに対する確率が得られ、合計は1になる。こちらはdecision_function()が2クラスの時だけ配列が1次元となるのと違って、どのような場合でも行数×列数＝データ数×クラス数の配列になる。

なお17行目で、argmaxを使って各データで確率が最大となるクラスを探している。

      setosa  versicolor  virginica  decision  prediction
0   0.102177    0.788400   0.109422         1           1
1   0.783471    0.109367   0.107161         0           0
2   0.098181    0.110059   0.791761         2           2
3   0.102177    0.788400   0.109422         1           1
4   0.103600    0.667239   0.229161         1           1
.....
33  0.783471    0.109367   0.107161         0           0
34  0.783471    0.109367   0.107161         0           0
35  0.101941    0.115024   0.783035         2           2
36  0.102177    0.788400   0.109422         1           1
37  0.783471    0.109367   0.107161         0           0

setosa versicolor virginica decision prediction

0 0.102177 0.788400 0.109422 1 1

1 0.783471 0.109367 0.107161 0 0

2 0.098181 0.110059 0.791761 2 2

3 0.102177 0.788400 0.109422 1 1

4 0.103600 0.667239 0.229161 1 1

.....

33 0.783471 0.109367 0.107161 0 0

34 0.783471 0.109367 0.107161 0 0

35 0.101941 0.115024 0.783035 2 2

36 0.102177 0.788400 0.109422 1 1

37 0.783471 0.109367 0.107161 0 0

Axes.set_xlabel/ylabel～軸のラベル

2020-09-08 / tau / コメントする

概要

Axesに描いたグラフの軸にラベルを付けるには、set_xlabel()やset_ylabel()を使う。

import numpy as np
import matplotlib.pyplot as plt

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

fig = plt.figure()
ax = fig.add_subplot()
ax.plot(x, y)
ax.set_xlabel("theta")
ax.set_ylabel("sine")
plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

y = np.sin(x * 2)

fig = plt.figure()

ax = fig.add_subplot()

ax.plot(x, y)

ax.set_xlabel("theta")

ax.set_ylabel("sine")

plt.show()

位置等の調整

ラベルの位置はlocパラメーターで調整する。x軸とy軸では設定値が異なる（matplotlibのバージョンが3.1.1ではエラーになるので、3.3.1にアップグレード）。

set_xlabel("labelname", loc='left'/'center'/'right')
set_ylabel("labelname", loc='bottom'/'center'/'top')

以下の例では、set_ylabel()のパラメーターにTextのプロパティーとしてrotationを指定している（そのままだと横にしたラベルがエリア外に切れてしまうので、8行目でsubplots_adjustを指定している）。

import numpy as np
import matplotlib.pyplot as plt

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

fig, ax = plt.subplots()
fig.subplots_adjust(left=0.2)
ax.plot(x, y)
ax.set_xlabel("theta", loc='right')
ax.set_ylabel("sine", loc='top', rotation='horizontal')
plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

y = np.sin(x * 2)

fig, ax = plt.subplots()

fig.subplots_adjust(left=0.2)

ax.plot(x, y)

ax.set_xlabel("theta", loc='right')

ax.set_ylabel("sine", loc='top', rotation='horizontal')

plt.show()

scikit-learn – decision_function

2020-08-25 / tau / コメントする

概要

decision_function()は、超平面によってクラス分類をするモデルにおける、各予測データの確信度を表す。

2クラス分類の場合は(n_samples, )の1次元配列、マルチクラスの場合は(n_samples, n_classes)の2次元配列になる。2クラス分類の場合、符号の正負がそれぞれのクラスに対応する。

decision_function()を持つモデルは、LogisticRegression、SVC、GladientBoostClassifierなどで、RandomForestはこのメソッドを持っていない。

`decision_function()`の挙動

decision_function()の挙動をGradientBoostingClassifierで確認する。

まずmake_circles()で2クラスのデータを生成し、外側のクラス0をblue、内側のクラス1をorangeとして再定義する。

import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)
y_named = np.array(["blue", "orange"])[y]

import numpy as np

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.datasets import make_circles

from sklearn.model_selection import train_test_split

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)

y_named = np.array(["blue", "orange"])[y]

次に、データを訓練データとテストデータに分割し、訓練データによって学習する。データ分割にあたって、Xとyに加えて文字列に置き換えたy_namedを分割している。学習の際にはXとy_namedの訓練データとテストデータのみを用いるのでyについては特に含める必要ないが、ここではtrain_test_split()が3つ以上のデータでも分割可能なことを示している。

X_train, X_test, y_train, y_test, y_train_named, y_test_named = \
    train_test_split(X, y, y_named, random_state=0)

gbc = GradientBoostingClassifier(random_state=0)
gbc.fit(X_train, y_train_named)

X_train, X_test, y_train, y_test, y_train_named, y_test_named = \

train_test_split(X, y, y_named, random_state=0)

gbc = GradientBoostingClassifier(random_state=0)

gbc.fit(X_train, y_train_named)

学習後の分類器のclasses_プロパティーを参照すると、クラスがどのように表現されるかを確認できる。上のfit()メソッドでy_train_namedを与えたのでクラスの表現が文字列になっているが、代わりにy_trainを用いると[0, 1]のように元のyに対応したクラス表現が返される。

print(gbc.classes_)

# ['blue' 'orange']

print(gbc.classes_)

# ['blue' 'orange']

次に、学習済みモデルにテストデータを与えて、decision_function()の結果とpredict()の結果を並べてみる。decision_function()はfit()で与えたテストデータ数の1次元配列を返し、各要素の負の値に対してクラス0のblueが、正の値に対してはクラス1のorangeがpredict()で予測されていることがわかる。

data = DataFrame()
data["decision_value"] = gbc.decision_function(X_test)
data["prediction"] = gbc.predict(X_test)
print(data)

#     decision_value prediction
# 0         4.135926     orange
# 1        -1.701699       blue
# 2        -3.951061       blue
# 3        -3.626096       blue
# 4         4.289866     orange
# 5         3.661661     orange
# 6        -7.690972       blue
# 7         4.110017     orange
# 8         1.107539     orange
# 9         3.407822     orange
# 10       -6.462560       blue
# 11        4.289866     orange
# 12        3.901563     orange
# 13       -1.200312       blue
# 14        3.661661     orange
# 15       -4.172312       blue
# 16       -1.230101       blue
# 17       -3.915762       blue
# 18        4.036028     orange
# 19        4.110017     orange
# 20        4.110017     orange
# 21        0.657090     orange
# 22        2.698263     orange
# 23       -2.656733       blue
# 24       -1.867766       blue

data = DataFrame()

data["decision_value"] = gbc.decision_function(X_test)

data["prediction"] = gbc.predict(X_test)

print(data)

# decision_value prediction

# 0 4.135926 orange

# 1 -1.701699 blue

# 2 -3.951061 blue

# 3 -3.626096 blue

# 4 4.289866 orange

# 5 3.661661 orange

# 6 -7.690972 blue

# 7 4.110017 orange

# 8 1.107539 orange

# 9 3.407822 orange

# 10 -6.462560 blue

# 11 4.289866 orange

# 12 3.901563 orange

# 13 -1.200312 blue

# 14 3.661661 orange

# 15 -4.172312 blue

# 16 -1.230101 blue

# 17 -3.915762 blue

# 18 4.036028 orange

# 19 4.110017 orange

# 20 4.110017 orange

# 21 0.657090 orange

# 22 2.698263 orange

# 23 -2.656733 blue

# 24 -1.867766 blue

decision_function()の各要素の符号に応じてpredict()と同じ結果を得たいなら、次のように処理していくとよい。

print(gbc.decision_function(X_test) > 0)
# [ True False False False  True  True False  True  True  True False  True
#   True False  True False False False  True  True  True  True  True False
#  False]

print((gbc.decision_function(X_test) > 0).astype(int))
# [1 0 0 0 1 1 0 1 1 1 0 1 1 0 1 0 0 0 1 1 1 1 1 0 0]

print(gbc.classes_[(gbc.decision_function(X_test) > 0).astype(int)])
# ['orange' 'blue' 'blue' 'blue' 'orange' 'orange' 'blue' 'orange' 'orange'
#  'orange' 'blue' 'orange' 'orange' 'blue' 'orange' 'blue' 'blue' 'blue'
#  'orange' 'orange' 'orange' 'orange' 'orange' 'blue' 'blue']

print(gbc.decision_function(X_test) > 0)

# [ True False False False True True False True True True False True

# True False True False False False True True True True True False

# False]

print((gbc.decision_function(X_test) > 0).astype(int))

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

print(gbc.classes_[(gbc.decision_function(X_test) > 0).astype(int)])

# ['orange' 'blue' 'blue' 'blue' 'orange' 'orange' 'blue' 'orange' 'orange'

# 'orange' 'blue' 'orange' 'orange' 'blue' 'orange' 'blue' 'blue' 'blue'

# 'orange' 'orange' 'orange' 'orange' 'orange' 'blue' 'blue']

最後に、上記のデータと正解であるy_test_namedのデータを先ほどのデータフレームに追加して全体を確認する。predit()メソッドの結果とdecision_function()の符号による判定結果は等しく、y_testと異なるデータがあることがわかる。

data["decision"] = \
    gbc.classes_[(gbc.decision_function(X_test) > 0).astype(int)]
data["y_test"] = y_test_named

print(data)

#     decision_value prediction decision  y_test
# 0         4.135926     orange   orange  orange
# 1        -1.701699       blue     blue    blue
# 2        -3.951061       blue     blue    blue
# 3        -3.626096       blue     blue    blue
# 4         4.289866     orange   orange  orange
# 5         3.661661     orange   orange  orange
# 6        -7.690972       blue     blue    blue
# 7         4.110017     orange   orange  orange
# 8         1.107539     orange   orange  orange
# 9         3.407822     orange   orange  orange
# 10       -6.462560       blue     blue    blue
# 11        4.289866     orange   orange  orange
# 12        3.901563     orange   orange  orange
# 13       -1.200312       blue     blue  orange
# 14        3.661661     orange   orange  orange
# 15       -4.172312       blue     blue  orange
# 16       -1.230101       blue     blue  orange
# 17       -3.915762       blue     blue    blue
# 18        4.036028     orange   orange  orange
# 19        4.110017     orange   orange  orange
# 20        4.110017     orange   orange    blue
# 21        0.657090     orange   orange  orange
# 22        2.698263     orange   orange  orange
# 23       -2.656733       blue     blue    blue
# 24       -1.867766       blue     blue    blue

data["decision"] = \

gbc.classes_[(gbc.decision_function(X_test) > 0).astype(int)]

data["y_test"] = y_test_named

print(data)

# decision_value prediction decision y_test

# 0 4.135926 orange orange orange

# 1 -1.701699 blue blue blue

# 2 -3.951061 blue blue blue

# 3 -3.626096 blue blue blue

# 4 4.289866 orange orange orange

# 5 3.661661 orange orange orange

# 6 -7.690972 blue blue blue

# 7 4.110017 orange orange orange

# 8 1.107539 orange orange orange

# 9 3.407822 orange orange orange

# 10 -6.462560 blue blue blue

# 11 4.289866 orange orange orange

# 12 3.901563 orange orange orange

# 13 -1.200312 blue blue orange

# 14 3.661661 orange orange orange

# 15 -4.172312 blue blue orange

# 16 -1.230101 blue blue orange

# 17 -3.915762 blue blue blue

# 18 4.036028 orange orange orange

# 19 4.110017 orange orange orange

# 20 4.110017 orange orange blue

# 21 0.657090 orange orange orange

# 22 2.698263 orange orange orange

# 23 -2.656733 blue blue blue

# 24 -1.867766 blue blue blue

`decision_function()`の意味

decusuib_function()のレベルは超平面上の高さになるが、これはデータ、モデルパラメーターにより変化し、このスケールの解釈は難しい。それはpredict_proba()で得られる予測確率とdecision_function()で計算される確信度の非線形性からも予想される。

circlesデータに対するGradientBoostingClassifierの決定境界とdecision_function()の値の分布を表示したのが以下の図。コンターが交錯していてわかりにくく、直感的にはpredict_proba()の方がわかりやすい。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier

f0min, f0max = -1.5, 1.5
f1min, f1max = -1.75, 1.5

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)

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

gb = GradientBoostingClassifier(random_state=0)

gb.fit(X_train, y_train)

print("X_test.shape           : {}".format(X_test.shape))
print("Decision function shape: {}".format(
    gb.decision_function(X_test).shape))

fig, axs = plt.subplots(1, 2, figsize=(10, 4.8))
color0, color1 = 'tab:blue', 'tab:orange'

f0 = np.linspace(f0min, f0max, 200)
f1 = np.linspace(f1min, f1max, 200)
f0, f1 = np.meshgrid(f0, f1)
F = np.c_[f0.reshape(-1, 1), f1.reshape(-1, 1)]

pred = gb.predict(F).reshape(f0.shape)
axs[0].contour(f0, f1, pred, levels=[0.5])
axs[0].contourf(f0, f1, pred, levels=1, colors=[color0, color1], alpha=0.25)

decision = gb.decision_function(F).reshape(f0.shape)
axs[1].contourf(f0, f1, decision, alpha=0.5, cmap='bwr')

for ax in axs:
    ax.scatter(X_train[y_train==0][:, 0], X_train[y_train==0][:, 1], marker='o', fc=color0, ec='k', label="Train class 0")
    ax.scatter(X_test[y_test==0][:, 0], X_test[y_test==0][:, 1], marker='^', fc=color0, ec='k', label="Test Class 0")
    ax.scatter(X_train[y_train==1][:, 0], X_train[y_train==1][:, 1], marker='o', fc=color1, ec='k', label="Train class 1")
    ax.scatter(X_test[y_test==1][:, 0], X_test[y_test==1][:, 1], marker='^', fc=color1, ec='k', label="Test class 1")

    ax.set_xlim(f0min, f0max)
    ax.set_ylim(f1min, f1max)
    ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)

handles, labels = axs[0].get_legend_handles_labels()

fig.legend(handles, labels, ncol=4, loc='upper center')
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_circles

from sklearn.model_selection import train_test_split

from sklearn.ensemble import GradientBoostingClassifier

f0min, f0max = -1.5, 1.5

f1min, f1max = -1.75, 1.5

X, y = make_circles(noise=0.25, factor=0.5, random_state=1)

X_train, X_test, y_train, y_test =\

train_test_split(X, y, random_state=0)

gb = GradientBoostingClassifier(random_state=0)

gb.fit(X_train, y_train)

print("X_test.shape : {}".format(X_test.shape))

print("Decision function shape: {}".format(

gb.decision_function(X_test).shape))

fig, axs = plt.subplots(1, 2, figsize=(10, 4.8))

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

f0 = np.linspace(f0min, f0max, 200)

f1 = np.linspace(f1min, f1max, 200)

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

F = np.c_[f0.reshape(-1, 1), f1.reshape(-1, 1)]

pred = gb.predict(F).reshape(f0.shape)

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

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

decision = gb.decision_function(F).reshape(f0.shape)

axs[1].contourf(f0, f1, decision, alpha=0.5, cmap='bwr')

for ax in axs:

ax.scatter(X_train[y_train==0][:, 0], X_train[y_train==0][:, 1], marker='o', fc=color0, ec='k', label="Train class 0")

ax.scatter(X_test[y_test==0][:, 0], X_test[y_test==0][:, 1], marker='^', fc=color0, ec='k', label="Test Class 0")

ax.scatter(X_train[y_train==1][:, 0], X_train[y_train==1][:, 1], marker='o', fc=color1, ec='k', label="Train class 1")

ax.scatter(X_test[y_test==1][:, 0], X_test[y_test==1][:, 1], marker='^', fc=color1, ec='k', label="Test class 1")

ax.set_xlim(f0min, f0max)

ax.set_ylim(f1min, f1max)

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

handles, labels = axs[0].get_legend_handles_labels()

fig.legend(handles, labels, ncol=4, loc='upper center')

plt.show()

3クラス以上の場合

3クラスのirisデータセットにGradientBoostingClassifierを適用して、decision_function()の出力を見てみる。

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from pandas import DataFrame

iris = load_iris()

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

gbc = GradientBoostingClassifier(learning_rate=0.01, random_state=0)
gbc.fit(X_train, y_train)

dec_func = gbc.decision_function(X_test)
print(dec_func.shape)
df = DataFrame(dec_func, columns=iris.target_names)

df["decision"] = np.argmax(dec_func, axis=1)
df["prediction"] = gbc.predict(X_test)
print(df)

import numpy as np

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.ensemble import GradientBoostingClassifier

from pandas import DataFrame

iris = load_iris()

X_train, X_test, y_train, y_test = train_test_split(

iris.data, iris.target, random_state=42)

gbc = GradientBoostingClassifier(learning_rate=0.01, random_state=0)

gbc.fit(X_train, y_train)

dec_func = gbc.decision_function(X_test)

print(dec_func.shape)

df = DataFrame(dec_func, columns=iris.target_names)

df["decision"] = np.argmax(dec_func, axis=1)

df["prediction"] = gbc.predict(X_test)

print(df)

このコードの出力結果は以下の通り。2クラスの場合は1次元配列だったが、3クラスになると行数×列数がデータ数×クラス数の配列になる。predict_proba()は2クラスでも2列の配列になるので、decision_function()の2クラスの場合だけ特に1次元配列になると言える。

なお、19行目で各データごとに最大の値をとる列をargmaxで探して、そのサフィックスを”decision”のクラス番号として表示している。

(38, 3)
      setosa  versicolor  virginica  decision  prediction
0  -1.995715    0.047583  -1.927207         1           1
1   0.061464   -1.907557  -1.927938         0           0
2  -1.990582   -1.876379   0.096867         2           2
3  -1.995715    0.047583  -1.927207         1           1
4  -1.997302   -0.134691  -1.203415         1           1
.....
33  0.061464   -1.907557  -1.927938         0           0
34  0.061464   -1.907557  -1.927938         0           0
35 -1.997122   -1.876379   0.041660         2           2
36 -1.995715    0.047583  -1.927207         1           1
37  0.061464   -1.907557  -1.927938         0           0

(38, 3)

setosa versicolor virginica decision prediction

0 -1.995715 0.047583 -1.927207 1 1

1 0.061464 -1.907557 -1.927938 0 0

2 -1.990582 -1.876379 0.096867 2 2

3 -1.995715 0.047583 -1.927207 1 1

4 -1.997302 -0.134691 -1.203415 1 1

.....

33 0.061464 -1.907557 -1.927938 0 0

34 0.061464 -1.907557 -1.927938 0 0

35 -1.997122 -1.876379 0.041660 2 2

36 -1.995715 0.047583 -1.927207 1 1

37 0.061464 -1.907557 -1.927938 0 0

scikit-learn – make_circles

2020-08-23 / tau / コメントする

概要

sklearn.datasets.make_circles()はクラス分類のためのデータを生成する。2つのクラスのデータが同心円状に分布し、各クラスの半径の差異、データのばらつきを指定できる。

得られるデータの形式

2つの配列X, yが返され、配列Xは列が特徴量、行がレコードの2次元配列。ターゲットyはレコード数分のクラス属性値の整数で0か1の値をとる。

from sklearn.datasets import make_circles

X, y = make_circles(n_samples=10, random_state=0)

print("X:\n{}".format(X))
print("y:{}".format(y))

# X:
# [[-0.80901699  0.58778525]
#  [-0.6472136  -0.4702282 ]
#  [ 0.30901699 -0.95105652]
#  [ 0.2472136  -0.76084521]
#  [ 0.30901699  0.95105652]
#  [ 0.2472136   0.76084521]
#  [-0.6472136   0.4702282 ]
#  [-0.80901699 -0.58778525]
#  [ 1.          0.        ]
#  [ 0.8         0.        ]]
# y:[0 1 0 1 0 1 1 0 0 1]

from sklearn.datasets import make_circles

X, y = make_circles(n_samples=10, random_state=0)

print("X:\n{}".format(X))

print("y:{}".format(y))

# X:

# [[-0.80901699 0.58778525]

# [-0.6472136 -0.4702282 ]

# [ 0.30901699 -0.95105652]

# [ 0.2472136 -0.76084521]

# [ 0.30901699 0.95105652]

# [ 0.2472136 0.76084521]

# [-0.6472136 0.4702282 ]

# [-0.80901699 -0.58778525]

# [ 1. 0. ]

# [ 0.8 0. ]]

# y:[0 1 0 1 0 1 1 0 0 1]

パラメーターの指定

sklearn.datasets.make_circles(n_samples=100, *, shuffle=True, noise=None, random_state=None, factor=0.8)

1	sklearn.datasets.make_circles(n_samples=100, *, shuffle=True, noise=None, random_state=None, factor=0.8)

n_samples: 総データ数で、奇数の場合は内側のデータが1つ多くなる。2要素のタプルで指定した場合、1つ目が外側、2つ目が内側のデータ数となる。デフォルトは100
shuffle: データをシャッフルするかどうかを指定。Falseにすると、前半がクラス0、後半がクラス1となるように並ぶ。デフォルトはTrue。
noise: ガウス分布のノイズを標準偏差で指定。デフォルトはNoneでノイズなし。
random_state: データを生成する乱数系列を指定。デフォルトはNone
factor: 外側に対する内側のデータのスケールファクター。デフォルトは0.8。

利用例

以下はスケールファクターを0.5、ノイズを0.15としてデフォルトの100個のデータを生成した例。

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

X, y = make_circles(factor=0.5, noise=0.15)

X0 = X[y==0]
X1 = X[y==1]

fig, ax = plt.subplots()
ax.scatter(X0[:, 0], X0[:, 1])
ax.scatter(X1[:, 0], X1[:, 1])

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_circles

X, y = make_circles(factor=0.5, noise=0.15)

X0 = X[y==0]

X1 = X[y==1]

fig, ax = plt.subplots()

ax.scatter(X0[:, 0], X0[:, 1])

ax.scatter(X1[:, 0], X1[:, 1])

plt.show()

以下はノイズの程度を変化させた例。

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

scale_factors = [0, 0.4, 0.6, 0.8]

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

for ax, factor in zip(axs.reshape(axs.size), scale_factors):
    X, y = make_circles(noise=0.1, factor=factor, random_state=0)

    ax.scatter(X[y==0][:, 0], X[y==0][:, 1])
    ax.scatter(X[y==1][:, 0], X[y==1][:, 1])
    ax.set_title("factor={:3.1f}".format(factor))

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

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_circles

scale_factors = [0, 0.4, 0.6, 0.8]

fig = plt.figure(figsize=(9.6,7.2))

axs = fig.subplots(2, 2)

for ax, factor in zip(axs.reshape(axs.size), scale_factors):

X, y = make_circles(noise=0.1, factor=factor, random_state=0)

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

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

ax.set_title("factor={:3.1f}".format(factor))

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

plt.show()

以下はスケールファクターを変化させた例。

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

scale_factors = [0, 0.4, 0.6, 0.8]

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

for ax, factor in zip(axs.reshape(axs.size), scale_factors):
    X, y = make_circles(noise=0.1, factor=factor, random_state=0)

    ax.scatter(X[y==0][:, 0], X[y==0][:, 1])
    ax.scatter(X[y==1][:, 0], X[y==1][:, 1])
    ax.set_title("factor={:3.1f}".format(factor))

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

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_circles

scale_factors = [0, 0.4, 0.6, 0.8]

fig = plt.figure(figsize=(9.6,7.2))

axs = fig.subplots(2, 2)

for ax, factor in zip(axs.reshape(axs.size), scale_factors):

X, y = make_circles(noise=0.1, factor=factor, random_state=0)

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

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

ax.set_title("factor={:3.1f}".format(factor))

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

plt.show()

pyplot – subplotの位置調整

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

subplot間の間隔調整

Figure内のSubplotの位置や相互の間隔を調整するには、subplots_adjust()メソッドを用いる。pyplot.subplots_adjust()でもよいが、figureのメソッドとしてもよい。

pyplot.subplots_adjust(left, bottom, right, top, wspace, hspace): left, bottom, right, topはsubplots全体の左端、下端、右端、上端の位置。wspace, hspaceはそれぞれ各subplot間の幅方向と高さ方向の間隔。

引数の意味はドキュメントで以下のように説明されている。

left = 0.125  # the left side of the subplots of the figure
right = 0.9   # the right side of the subplots of the figure
bottom = 0.1  # the bottom of the subplots of the figure
top = 0.9     # the top of the subplots of the figure
wspace = 0.2  # the amount of width reserved for space between subplots,
              # expressed as a fraction of the average axis width
hspace = 0.2  # the amount of height reserved for space between subplots,
              # expressed as a fraction of the average axis height

left = 0.125 # the left side of the subplots of the figure

right = 0.9 # the right side of the subplots of the figure

bottom = 0.1 # the bottom of the subplots of the figure

top = 0.9 # the top of the subplots of the figure

wspace = 0.2 # the amount of width reserved for space between subplots,

# expressed as a fraction of the average axis width

hspace = 0.2 # the amount of height reserved for space between subplots,

# expressed as a fraction of the average axis height

left～topはキャンバスの左上を(0, 0)、右下を(1, 1)としたときの比率。

たとえばデフォルトで4つのsubpotsを描く。

import numpy as np
import matplotlib.pyplot as plt

fig, axs = plt.subplots(2, 2)
x = np.linspace(-np.pi, np.pi)

for n, ax in enumerate(axs.reshape(axs.size)):
    ax.plot(x, np.sin(x * (n + 1)))

fig.subplots_adjust()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

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

for n, ax in enumerate(axs.reshape(axs.size)):

ax.plot(x, np.sin(x * (n + 1)))

fig.subplots_adjust()

plt.show()

これに対してsubplots全体の左端をキャンバス内の左から0.3の位置に、下端を下から0.5の位置に設定すると以下のようになる。

fig.subplots_adjust(left=0.3, bottom=0.5)

1	fig.subplots_adjust(left=0.3, bottom=0.5)

また、wspace、hspaceを1とすると以下のようになる。

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

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

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

数値

整数

実数

有理数

複素数

文字列

文字リテラル

ヒアドキュメント

論理値

概要

predict_proba()の挙動

decision_function()との比較

決定境界

3クラス以上の場合

概要

位置等の調整

概要

decision_function()の挙動

decision_function()の意味

3クラス以上の場合

概要

得られるデータの形式

パラメーターの指定

利用例

subplot間の間隔調整

リスト関係

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が違う？

重み係数の分布

`predict_proba()`の挙動

`decision_function()`との比較

`decision_function()`の挙動

`decision_function()`の意味

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

`sum`,`mean`