OneHotEncoder

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

概要

OneHotEncoderは、あるクラスデータの特徴量をエンコードする。LabelEncoderやOrdinalEncoderが特徴量内のクラスに一連の数値を振るのに対して、OneHotEncoderはクラスの数だけ列を確保し、データごとに該当するクラスのみに1を立てる。エンコードされたデータは、該当するクラスのみに反応するインデックス引数となる。

なお、DataFrameのget_dummis()メソッドでもone-hotエンコーディングができる。

使い方

fit()～インデックス列の生成

以下の例は、2つのクラス特徴量を持つ6個のデータセットをOneHotEncoderで変換。

sklearn.prreprocessingからOneHotEncoderをインポート
エンコーダーのインスタンスを生成
- デフォルトではスパース行列になるので、オプションでsparse=Falseを指定
fit()メソッドでデータをフィッティングし、変換器を準備
この段階でcategories_プロパティーには各特徴量ごとのインデックス構成がセットされる

以下の例では、1つ目の特徴量は3つのクラス、2つ目の特徴量は2つのクラスを持つので、3要素、2要素の配列を要素に持つリストがcategories_にセットされる。

from sklearn.preprocessing import OneHotEncoder

X = [
    ["Tokyo", "Male"],
    ["Tokyo", "Female"],
    ["Osaka", "Male"],
    ["Kyoto", "Female"],
    ["Osaka", "Female"],
    ["Osaka", "Male"]
]

ohe = OneHotEncoder(sparse=False)
ohe.fit(X)

print(ohe.categories_)
print(ohe.categories_[0])
print(ohe.categories_[1])

# [array(['Kyoto', 'Osaka', 'Tokyo'], dtype=object), array(['Female', 'Male'], dtype=object)]
# ['Kyoto' 'Osaka' 'Tokyo']
# ['Female' 'Male']

from sklearn.preprocessing import OneHotEncoder

X = [

["Tokyo", "Male"],

["Tokyo", "Female"],

["Osaka", "Male"],

["Kyoto", "Female"],

["Osaka", "Female"],

["Osaka", "Male"]

]

ohe = OneHotEncoder(sparse=False)

ohe.fit(X)

print(ohe.categories_)

print(ohe.categories_[0])

print(ohe.categories_[1])

# [array(['Kyoto', 'Osaka', 'Tokyo'], dtype=object), array(['Female', 'Male'], dtype=object)]

# ['Kyoto' 'Osaka' 'Tokyo']

# ['Female' 'Male']

transform()～インデックスデータへの変換

fit()メソッドで準備された変換器によってデータを変換する。変換後のデータは特徴量のクラス数分の列を持つ2次元のndarrayで返される。なおfitとtransformを一度に行うfit_transform()メソッドも準備されている。

X_trans = ohe.transform(X)
print(X_trans)

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

X_trans = ohe.transform(X)

print(X_trans)

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

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

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

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

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

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

出力の右3列は3つの都市、それに続く2列は性別に対応していて、たとえば1行目のデータの都市はcategories_[0]の3番目'Tokyo'、性別はcategories_[1]の2番目の'Male'であることがあらわされている。

DataFrameによる操作

OneHotEncoderはpandas.DataFrameも扱える。ただしtransfrom()やfit_transform()メソッドの戻り値はndarrayなので、以下の例ではこれをDataFrameの形にしている。このときcolumns引数にエンコーダーのインスタンスのcategories_プロパティーを使うと個別のクラス名まで打ち込まずに済んで便利。

import numpy as np
from pandas import DataFrame

df_X = DataFrame(X, columns=["city", "gender"])
X_trans = ohe.fit_transform(df_X)
df_X_trans =DataFrame(X_trans,
    columns=np.append(ohe.categories_[0], ohe.categories_[1]))

print(df_X)
print()
print(df_X_trans)

#     city  gender
# 0  Tokyo    Male
# 1  Tokyo  Female
# 2  Osaka    Male
# 3  Kyoto  Female
# 4  Osaka  Female
# 5  Osaka    Male
# 
#    Kyoto  Osaka  Tokyo  Female  Male
# 0    0.0    0.0    1.0     0.0   1.0
# 1    0.0    0.0    1.0     1.0   0.0
# 2    0.0    1.0    0.0     0.0   1.0
# 3    1.0    0.0    0.0     1.0   0.0
# 4    0.0    1.0    0.0     1.0   0.0
# 5    0.0    1.0    0.0     0.0   1.0

import numpy as np

from pandas import DataFrame

df_X = DataFrame(X, columns=["city", "gender"])

X_trans = ohe.fit_transform(df_X)

df_X_trans =DataFrame(X_trans,

columns=np.append(ohe.categories_[0], ohe.categories_[1]))

print(df_X)

print()

print(df_X_trans)

# city gender

# 0 Tokyo Male

# 1 Tokyo Female

# 2 Osaka Male

# 3 Kyoto Female

# 4 Osaka Female

# 5 Osaka Male

# Kyoto Osaka Tokyo Female Male

# 0 0.0 0.0 1.0 0.0 1.0

# 1 0.0 0.0 1.0 1.0 0.0

# 2 0.0 1.0 0.0 0.0 1.0

# 3 1.0 0.0 0.0 1.0 0.0

# 4 0.0 1.0 0.0 1.0 0.0

# 5 0.0 1.0 0.0 0.0 1.0

数値データとクラスデータが混在する場合

DataFrameの準備

以下の例では、2つのクラス特徴量と2つの数値特徴量を持つデータセットをDataFrameとして扱う。

import numpy as np
from pandas import DataFrame
from sklearn.preprocessing import OneHotEncoder

X = [
    ["Tokyo", 10000, "Male", 2],
    ["Tokyo", 8000, "Female", 1.5],
    ["Osaka", 9000, "Male", 1.5],
    ["Kyoto", 10000, "Female", 1],
    ["Osaka", 7000, "Female", 1],
    ["Osaka", 8000, "Male", 1.5]
]

df_X = DataFrame(X, columns=["city", "hotel_charge", "gender", "travel_time"])
print(df_X)

#     city  hotel_charge  gender  travel_time
# 0  Tokyo         10000    Male          2.0
# 1  Tokyo          8000  Female          1.5
# 2  Osaka          9000    Male          1.5
# 3  Kyoto         10000  Female          1.0
# 4  Osaka          7000  Female          1.0
# 5  Osaka          8000    Male          1.5

import numpy as np

from pandas import DataFrame

from sklearn.preprocessing import OneHotEncoder

X = [

["Tokyo", 10000, "Male", 2],

["Tokyo", 8000, "Female", 1.5],

["Osaka", 9000, "Male", 1.5],

["Kyoto", 10000, "Female", 1],

["Osaka", 7000, "Female", 1],

["Osaka", 8000, "Male", 1.5]

]

df_X = DataFrame(X, columns=["city", "hotel_charge", "gender", "travel_time"])

print(df_X)

# city hotel_charge gender travel_time

# 0 Tokyo 10000 Male 2.0

# 1 Tokyo 8000 Female 1.5

# 2 Osaka 9000 Male 1.5

# 3 Kyoto 10000 Female 1.0

# 4 Osaka 7000 Female 1.0

# 5 Osaka 8000 Male 1.5

クラスデータのヘッダーの準備

クラスデータを複数のインデックスデータの列にするための準備。

特徴量のうち、クラスデータのものと数値データのもののヘッダーを分けておく
クラスデータ用のDataFrameを準備して、元データからクラスデータの列だけを切り出し
エンコーダーを生成してfit_trans()を実行
実行後にエンコーダーのcategories_に保持されているクラスリストを取得

このクラスリストが変換後のデータのヘッダーになる。

col_class = ["city", "gender"]
col_num = ["hotel_charge", "travel_time"]

df_X_class = df_X[col_class]
ohe = OneHotEncoder(sparse=False)
X_trans = ohe.fit_transform(df_X_class)

col_class = [cls for ary in ohe.categories_ for cls in ary]
print(col_class)

# ['Kyoto', 'Osaka', 'Tokyo', 'Female', 'Male']

col_class = ["city", "gender"]

col_num = ["hotel_charge", "travel_time"]

df_X_class = df_X[col_class]

ohe = OneHotEncoder(sparse=False)

X_trans = ohe.fit_transform(df_X_class)

col_class = [cls for ary in ohe.categories_ for cls in ary]

print(col_class)

# ['Kyoto', 'Osaka', 'Tokyo', 'Female', 'Male']

クラスデータと数値データの合体

以下の処理では、変換されたクラスデータ列と元の数値データ列を合わせて最終的なデータセットとしている

クラスリストをヘッダーとして、変換後のクラスデータ(ndarray)をDataFrameとして読み込み
上記DataFrameに元データの数値データを追加

この処理によって元データセットから特徴量の順番が変わるが、学習過程で特徴量の順番は影響しない。

df_X_class_trans = DataFrame(X_trans, columns=col_class_trans)
print(df_X_class_trans)

#    Kyoto  Osaka  Tokyo  Female  Male
# 0    0.0    0.0    1.0     0.0   1.0
# 1    0.0    0.0    1.0     1.0   0.0
# 2    0.0    1.0    0.0     0.0   1.0
# 3    1.0    0.0    0.0     1.0   0.0
# 4    0.0    1.0    0.0     1.0   0.0
# 5    0.0    1.0    0.0     0.0   1.0

df_X_trans = df_X_class_trans.copy()
df_X_trans[col_num] = df_X[col_num]
print(df_X_trans)

#    Kyoto  Osaka  Tokyo  Female  Male  hotel_charge  travel_time
# 0    0.0    0.0    1.0     0.0   1.0         10000          2.0
# 1    0.0    0.0    1.0     1.0   0.0          8000          1.5
# 2    0.0    1.0    0.0     0.0   1.0          9000          1.5
# 3    1.0    0.0    0.0     1.0   0.0         10000          1.0
# 4    0.0    1.0    0.0     1.0   0.0          7000          1.0
# 5    0.0    1.0    0.0     0.0   1.0          8000          1.5

df_X_class_trans = DataFrame(X_trans, columns=col_class_trans)

print(df_X_class_trans)

# Kyoto Osaka Tokyo Female Male

# 0 0.0 0.0 1.0 0.0 1.0

# 1 0.0 0.0 1.0 1.0 0.0

# 2 0.0 1.0 0.0 0.0 1.0

# 3 1.0 0.0 0.0 1.0 0.0

# 4 0.0 1.0 0.0 1.0 0.0

# 5 0.0 1.0 0.0 0.0 1.0

df_X_trans = df_X_class_trans.copy()

df_X_trans[col_num] = df_X[col_num]

print(df_X_trans)

# Kyoto Osaka Tokyo Female Male hotel_charge travel_time

# 0 0.0 0.0 1.0 0.0 1.0 10000 2.0

# 1 0.0 0.0 1.0 1.0 0.0 8000 1.5

# 2 0.0 1.0 0.0 0.0 1.0 9000 1.5

# 3 1.0 0.0 0.0 1.0 0.0 10000 1.0

# 4 0.0 1.0 0.0 1.0 0.0 7000 1.0

# 5 0.0 1.0 0.0 0.0 1.0 8000 1.5

inverse_transform()

上でdf_X_trans = df_X_class_trans.copy()としたので、df_X_class_transは保存されている。このデータをエンコーダーのinverse_transform()に与えると、複数列で表現されていたクラスが元の表現で得られる。

print(ohe.inverse_transform(df_X_class_trans))

# [['Tokyo' 'Male']
#  ['Tokyo' 'Female']
#  ['Osaka' 'Male']
#  ['Kyoto' 'Female']
#  ['Osaka' 'Female']
#  ['Osaka' 'Male']]

print(ohe.inverse_transform(df_X_class_trans))

# [['Tokyo' 'Male']

# ['Tokyo' 'Female']

# ['Osaka' 'Male']

# ['Kyoto' 'Female']

# ['Osaka' 'Female']

# ['Osaka' 'Male']]

新しいデータの変換

訓練済みモデルにデータを与えて予測する場合、前処理のエンコーディングでは、フィッティング済みのエンコーダーに新しいデータを与えて変換する。

x = [["Kyoto", 7000, "Male", 0.5]]
df_X = DataFrame(x, columns=col_original)
print(df_X)

#     city  hotel_charge gender  travel_time
# 0  Kyoto          7000   Male          0.5

df_X_class = df_X[col_class]
X_trans = ohe.transform(df_X_class)

df_X_trans = DataFrame(X_trans, columns=col_class_trans)
df_X_trans[col_num] = df_X[col_num]
print(df_X_trans)

#    Kyoto  Osaka  Tokyo  Female  Male  hotel_charge  travel_time
# 0    1.0    0.0    0.0     0.0   1.0          7000          0.5

x = [["Kyoto", 7000, "Male", 0.5]]

df_X = DataFrame(x, columns=col_original)

print(df_X)

# city hotel_charge gender travel_time

# 0 Kyoto 7000 Male 0.5

df_X_class = df_X[col_class]

X_trans = ohe.transform(df_X_class)

df_X_trans = DataFrame(X_trans, columns=col_class_trans)

df_X_trans[col_num] = df_X[col_num]

print(df_X_trans)

# Kyoto Osaka Tokyo Female Male hotel_charge travel_time

# 0 1.0 0.0 0.0 0.0 1.0 7000 0.5

未知のクラスへの対処

フィッティング時になかったクラスに遭遇した場合の動作は、エンコーダーのインスタンス生成時に指定する。

OneHotEncoder(handle_unknown='error'/'ignore')

デフォルトは'error'で、未知のクラスに遭遇するとエラーを投げる。'ignore'を指定すると未知のクラスの場合はその特徴量のすべてのクラスラベルが0になる。

以下の例では、2行目のデータにフィッティングでは含まれていなかった”Nagoya”があるため、変換後のデータの2行目の1～3列が0となっている。

df_X = DataFrame(X, columns=col_original)
df_X_class = df_X[col_class]

ohe = OneHotEncoder(sparse=False, handle_unknown='ignore')
ohe.fit(df_X_class)

x = [
    ["Kyoto", 9000, "Female", 1],
    ["Nagoya", 7000, "Male", 0.5]
]
df_X = DataFrame(x, columns=col_original)
df_X_class = df_X[col_class]
print(df_X_class)

#      city  gender
# 0   Kyoto  Female
# 1  Nagoya    Male

X_class_trans = ohe.transform(df_X_class)
print(X_class_trans)

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

df_X_trans = DataFrame(X_class_trans, columns=col_class_trans)
df_X_trans[col_num] = df_X[col_num]
print(df_X_trans)

#    Kyoto  Osaka  Tokyo  Female  Male  hotel_charge  travel_time
# 0    1.0    0.0    0.0     1.0   0.0          9000          1.0
# 1    0.0    0.0    0.0     0.0   1.0          7000          0.5

df_X = DataFrame(X, columns=col_original)

df_X_class = df_X[col_class]

ohe = OneHotEncoder(sparse=False, handle_unknown='ignore')

ohe.fit(df_X_class)

x = [

["Kyoto", 9000, "Female", 1],

["Nagoya", 7000, "Male", 0.5]

]

df_X = DataFrame(x, columns=col_original)

df_X_class = df_X[col_class]

print(df_X_class)

# city gender

# 0 Kyoto Female

# 1 Nagoya Male

X_class_trans = ohe.transform(df_X_class)

print(X_class_trans)

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

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

df_X_trans = DataFrame(X_class_trans, columns=col_class_trans)

df_X_trans[col_num] = df_X[col_num]

print(df_X_trans)

# Kyoto Osaka Tokyo Female Male hotel_charge travel_time

# 0 1.0 0.0 0.0 1.0 0.0 9000 1.0

# 1 0.0 0.0 0.0 0.0 1.0 7000 0.5

この変換データをinverse_transform()で逆変換すると、未知のクラスであったところは'None'に変換される。

print(ohe.inverse_transform(X_class_trans))

# [['Kyoto' 'Female']
#  [None 'Male']]

print(ohe.inverse_transform(X_class_trans))

# [['Kyoto' 'Female']

# [None 'Male']]

LabelEncoder

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

概要

sklearn.preprocessingのLabelEncoderは、クラスデータ（カテゴリーデータ）を数値ラベルに変換する。

コンストラクターは引数をとらない
fit()メソッドに特徴量を要素とする1次元配列（特徴量数）の元データを与える
特徴量のクラス数がn_classのとき、特徴量データが0～n_class−1の整数ラベルに変換される
特徴量が定量的な数値データであっても整数ラベルに変換される

使い方

LabelEncoderを使うには、まずそのインスタンスを生成し、fit()メソッドで数値ラベルを生成する。fit()メソッドを実行すると、元データのクラスの重複を除いたクラスリストがclasses_プロパティーに保存され、transform()メソッドで任意のデータを変換する変換器が準備される。

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
le.fit(["Japan", "US", "Germany", "Japan", "US"])
print(le.classes_)

# ['Germany' 'Japan' 'US']

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()

le.fit(["Japan", "US", "Germany", "Japan", "US"])

print(le.classes_)

# ['Germany' 'Japan' 'US']

準備された変換器で、変換したいデータにtransform()メソッドを適用して、変換された数値ラベルを得る。

y = ["Germany", "US", "US", "Japan"]
y_trans = le.transform(y)
print(y_trans)

# [0 2 2 1]

y = ["Germany", "US", "US", "Japan"]

y_trans = le.transform(y)

print(y_trans)

# [0 2 2 1]

このラベルデータにinverse_transform()を適用すると、数値ラベルが元のクラスデータに逆変換される。

print(le.inverse_transform(y_trans))

# ['Germany' 'US' 'US' 'Japan']

print(le.inverse_transform(y_trans))

# ['Germany' 'US' 'US' 'Japan']

transform()の引数に元データに存在しないクラスデータが含まれていた場合、エラーとなる。

print(le.transform("Germany", "China"))

# TypeError: transform() takes 2 positional arguments but 3 were given

print(le.transform("Germany", "China"))

# TypeError: transform() takes 2 positional arguments but 3 were given

注意

LabelEncoderは、元データに定量的な数値データを与えた場合でもこれらを数値ラベルに変換する。

le.fit([-0.5, 0, 0.3, 0.7, 1.2, 1.5])
y_trans = le.transform([-0.5, 0.7, 1.2])
print(y_trans)
print(le.inverse_transform(y_trans))

# [0 3 4]
# [-0.5  0.7  1.2]

le.fit([-0.5, 0, 0.3, 0.7, 1.2, 1.5])

y_trans = le.transform([-0.5, 0.7, 1.2])

print(y_trans)

print(le.inverse_transform(y_trans))

# [0 3 4]

# [-0.5 0.7 1.2]

transform()の引数に元データに存在しない数値が含まれている場合はエラーとなる。

Normalizer

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

概要

sklearn.preprocessorsモジュールのNormalizerは、特徴量ベクトルのノルムが1になるようにする。具体的には、データごとに特徴量F_iを以下の式によってF_i^*に変換する。

(1) $\begin{equation*} {F_i}^* = \frac{\sum F_i}{\left( \sum {|F_i|}^p \right) ^\frac{1}{p}} \end{equation*}$

ノルムのタイプはコンストラクターの引数で指定する。デフォルトは'l2'で、その他に'l1'、'max'を指定可能。

Normalizer(norm='l2')

挙動

それぞれ異なる正規分布に従う2つの特徴量について、Normalizerを適用したときの挙動を以下に示す。

scalerのような相似性の変換ではないので左下の変換後のヒストグラムは変換前の形状と異なっている。

データの空間的な分布は、デフォルトのL2ノルムの指定によって全データが半径1の円周上に位置するよう変換される。

変換後のデータを拡大してみると以下の通りで、原点を中心とした半径1の円周上に各点が並んでいる。

他の2つ、L1ノルムと最大値ノルムを指定して実行した結果が下記の通りで、それぞれのノルムに応じた線上に各点が並んでいる。

コードは以下の通りで、データに対してfit()メソッドでスケールパラメーターを決定し、transform()メソッドで変換を行うところを、これらを連続して実行するfit_transform()メソッドを使っている。

import numpy as np
import numpy.random as rnd
import matplotlib.pyplot as plt
import matplotlib.patches as patch
from sklearn.preprocessing import Normalizer

rnd.seed(0)
x1 = rnd.normal(loc=1, scale=2, size=100)
x2 = rnd.normal(loc=5, scale=1, size=100)
X = np.hstack((x1.reshape(-1, 1), x2.reshape(-1, 1)))

X_trans = Normalizer().fit_transform(X)

fig1 = plt.figure(figsize=(9.6, 4.8))

ax1 = fig1.add_subplot(2, 2, 1)
ax2 = fig1.add_subplot(2, 2, 3)
ax3 = fig1.add_subplot(1, 2, 2)

ax1.hist(X[:, 0], ec='k', range=(-5, 10), bins=40, alpha=0.5)
ax1.hist(X[:, 1], ec='k', range=(-5, 10), bins=40, alpha=0.5)

ax2.hist(X_trans[:, 0], range=(-1.2, 1.2), bins=40, ec='k', alpha=0.5)
ax2.hist(X_trans[:, 1], range=(-1.2, 1.2), bins=40, ec='k', alpha=0.5)

ax3.scatter(X[:, 0], X[:, 1], ec='k', fc='w')
ax3.scatter(X_trans[:, 0], X_trans[:, 1], ec='k', fc='gray')
ax3.set_aspect('equal')
ax3.set_xlim(-5, 8)
ax3.set_ylim(-5, 8)

fig2, ax4 = plt.subplots()

ax4.scatter(X_trans[:, 0], X_trans[:, 1], ec='k', fc='gray')
ax4.set_aspect('equal')
ax4.set_xlim(-1.5, 1.5)
ax4.set_ylim(-1.5, 1.5)
ax4.grid()
ax4.spines['top'].set_visible(False)
ax4.spines['right'].set_visible(False)
ax4.spines['bottom'].set_position('zero')
ax4.spines['left'].set_position('zero')
circ = patch.Circle(xy=(0, 0), radius=1, ec='k', fill=False)
ax4.add_patch(circ)

X_trans_l1 = Normalizer('l1').fit_transform(X)
X_trans_max = Normalizer('max').fit_transform(X)

fig3, axes = plt.subplots(1, 2, figsize=(9.6, 4.8))

axes[0].scatter(X_trans_l1[:, 0],X_trans_l1[:, 1], ec='k', fc='gray')
axes[0].plot([0, 1, 0, -1, 0], [1, 0, -1, 0, 1], c='k')
axes[1].scatter(X_trans_max[:, 0],X_trans_max[:, 1], ec='k', fc='gray')
axes[1].plot([1, 1, -1, -1, 1], [1, -1, -1, 1, 1], c='k')

for ax in axes.reshape(-1):
    ax.set_aspect('equal')
    ax.set_xlim(-1.5, 1.5)
    ax.set_ylim(-1.5, 1.5)
    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('zero')

plt.show()

import numpy as np

import numpy.random as rnd

import matplotlib.pyplot as plt

import matplotlib.patches as patch

from sklearn.preprocessing import Normalizer

rnd.seed(0)

x1 = rnd.normal(loc=1, scale=2, size=100)

x2 = rnd.normal(loc=5, scale=1, size=100)

X = np.hstack((x1.reshape(-1, 1), x2.reshape(-1, 1)))

X_trans = Normalizer().fit_transform(X)

fig1 = plt.figure(figsize=(9.6, 4.8))

ax1 = fig1.add_subplot(2, 2, 1)

ax2 = fig1.add_subplot(2, 2, 3)

ax3 = fig1.add_subplot(1, 2, 2)

ax1.hist(X[:, 0], ec='k', range=(-5, 10), bins=40, alpha=0.5)

ax1.hist(X[:, 1], ec='k', range=(-5, 10), bins=40, alpha=0.5)

ax2.hist(X_trans[:, 0], range=(-1.2, 1.2), bins=40, ec='k', alpha=0.5)

ax2.hist(X_trans[:, 1], range=(-1.2, 1.2), bins=40, ec='k', alpha=0.5)

ax3.scatter(X[:, 0], X[:, 1], ec='k', fc='w')

ax3.scatter(X_trans[:, 0], X_trans[:, 1], ec='k', fc='gray')

ax3.set_aspect('equal')

ax3.set_xlim(-5, 8)

ax3.set_ylim(-5, 8)

fig2, ax4 = plt.subplots()

ax4.scatter(X_trans[:, 0], X_trans[:, 1], ec='k', fc='gray')

ax4.set_aspect('equal')

ax4.set_xlim(-1.5, 1.5)

ax4.set_ylim(-1.5, 1.5)

ax4.grid()

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

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

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

ax4.spines['left'].set_position('zero')

circ = patch.Circle(xy=(0, 0), radius=1, ec='k', fill=False)

ax4.add_patch(circ)

X_trans_l1 = Normalizer('l1').fit_transform(X)

X_trans_max = Normalizer('max').fit_transform(X)

fig3, axes = plt.subplots(1, 2, figsize=(9.6, 4.8))

axes[0].scatter(X_trans_l1[:, 0],X_trans_l1[:, 1], ec='k', fc='gray')

axes[0].plot([0, 1, 0, -1, 0], [1, 0, -1, 0, 1], c='k')

axes[1].scatter(X_trans_max[:, 0],X_trans_max[:, 1], ec='k', fc='gray')

axes[1].plot([1, 1, -1, -1, 1], [1, -1, -1, 1, 1], c='k')

for ax in axes.reshape(-1):

ax.set_aspect('equal')

ax.set_xlim(-1.5, 1.5)

ax.set_ylim(-1.5, 1.5)

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

plt.show()

特徴

Normalizerは特徴量ベクトルの方向だけが重要な場合に用いる。たとえば空間内の特定の方向範囲にあるクラスターの分離などかと思うが、抽象的なものになると想像がつかない。実際、サイト上で見ても、Normalizerの意義とデータの性質に基づいて適用しているケースは、検索上位には出てこない。

なおNormalizerによる変換は不可逆であり、scalerのようなinverse_transform()を持たない。

preprocessor – 異常値に対する頑健性

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

機械学習モデルにデータを適用するための前処理としていくつかのアルゴリズムによっては、異常値の影響を受けやすいことがある。

たとえば下図の左のような分布のデータがあるとする（平均が1、分散が1の正規分布に従う500個のランダムデータ）。そしてこのデータに値20の異常値が10個発生したとすると、全体の分布は右のようになる。

このデータに対して、MinMaxScaler、StandardScaler、RobustScalerで変換した結果を以下に示す。ただしStandardScalerとRobustScalerについては、異常値は表示させず元の正規分布に係る範囲のみを表示している。

まず左側のMinMaxScalerについては、異常値を含めてレンジが0～1となるので、本体の正規分布のデータが0付近の小さな値に集中する。このため、本来学習の精度に効いてくるべき本体部分のデータの分離が十分でない可能性が出てくる。

真ん中のStandardScalerと右側のRobustScalerについては、本体部分の形は元の正規分布の形と大きく変わらず、頑健であることがわかる。

ここで異常値の個数を10個から20個に増やして、同じく3種類の変換を施してみる。

左側のMinMaxScalerについては、異常値の個数とは関係なくその値のみでレンジが決まり、元の分布が0付近に押し込められている状況は同じ。

真ん中のStandardScalerについては、10個の時に比べて少し分布の形が変わっていて、レンジが狭くなっている。

右側のRobustScalerについては、元の分布の形は大きくは変わっていない。

以上のことから、少なくとも3つの変換器について以下のような特徴があることがわかる。

MinMaxScalerは異常値によって本来分析したいデータのレンジが狭くなる可能性がある
StandardScalerは異常値の影響を受けにくいが、その大きさや頻度によって若干本体部分の分布が影響を受ける
RobustScalerは異常値の個数が極端に多くなければ、本来のデータの特性を頑健に保持する

なお、上記の作図のコードは以下の通り。

import numpy as np
import numpy.random as rnd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import RobustScaler

rnd.seed(0)
x = rnd.normal(loc=1, scale=1, size=500)
x1 = np.append(x, [20] * 10)
x2 = np.append(x, [20] * 20)

scaler = MinMaxScaler()
x1_scaled_by_minmax = scaler.fit_transform(x1.reshape(-1, 1))
x2_scaled_by_minmax = scaler.fit_transform(x2.reshape(-1, 1))

scaler = StandardScaler()
x1_scaled_by_standard = scaler.fit_transform(x1.reshape(-1, 1))
x2_scaled_by_standard = scaler.fit_transform(x2.reshape(-1, 1))

scaler = RobustScaler()
x1_scaled_by_robust = scaler.fit_transform(x1.reshape(-1, 1))
x2_scaled_by_robust = scaler.fit_transform(x2.reshape(-1, 1))

fig0, axes = plt.subplots(1, 2, figsize=(12.8, 4.8))
axes[0].hist(x1, ec='k', bins=10, range=(-2, 4))
axes[1].hist(x1, ec='k', bins=40)

fig1, axes = plt.subplots(1, 3, figsize=(18.6, 4.8))

ax = axes[0]
ax.hist(x1_scaled_by_minmax, ec='k', bins=40)
ax.set_title("MinMaxScaler")

ax = axes[1]
ax.hist(x1_scaled_by_standard, ec='k', bins=10, range=(-1.5, 1))
ax.set_title("StandardScaler")

ax = axes[2]
ax.hist(x1_scaled_by_robust, ec='k', bins=10, range=(-2.5, 2.5))
ax.set_title("RobustScaler")

fig2, axes = plt.subplots(1, 3, figsize=(18.6, 4.8))

ax = axes[0]
ax.hist(x2_scaled_by_minmax, ec='k', bins=40)
ax.set_title("MinMaxScaler")

ax = axes[1]
ax.hist(x2_scaled_by_standard, ec='k', bins=10, range=(-1.5, 1))
ax.set_title("StandardScaler")

ax = axes[2]
ax.hist(x2_scaled_by_robust, ec='k', bins=10, range=(-2.5, 2.5))
ax.set_title("RobustScaler")

plt.show()

import numpy as np

import numpy.random as rnd

import matplotlib.pyplot as plt

from sklearn.preprocessing import MinMaxScaler

from sklearn.preprocessing import StandardScaler

from sklearn.preprocessing import RobustScaler

rnd.seed(0)

x = rnd.normal(loc=1, scale=1, size=500)

x1 = np.append(x, [20] * 10)

x2 = np.append(x, [20] * 20)

scaler = MinMaxScaler()

x1_scaled_by_minmax = scaler.fit_transform(x1.reshape(-1, 1))

x2_scaled_by_minmax = scaler.fit_transform(x2.reshape(-1, 1))

scaler = StandardScaler()

x1_scaled_by_standard = scaler.fit_transform(x1.reshape(-1, 1))

x2_scaled_by_standard = scaler.fit_transform(x2.reshape(-1, 1))

scaler = RobustScaler()

x1_scaled_by_robust = scaler.fit_transform(x1.reshape(-1, 1))

x2_scaled_by_robust = scaler.fit_transform(x2.reshape(-1, 1))

fig0, axes = plt.subplots(1, 2, figsize=(12.8, 4.8))

axes[0].hist(x1, ec='k', bins=10, range=(-2, 4))

axes[1].hist(x1, ec='k', bins=40)

fig1, axes = plt.subplots(1, 3, figsize=(18.6, 4.8))

ax = axes[0]

ax.hist(x1_scaled_by_minmax, ec='k', bins=40)

ax.set_title("MinMaxScaler")

ax = axes[1]

ax.hist(x1_scaled_by_standard, ec='k', bins=10, range=(-1.5, 1))

ax.set_title("StandardScaler")

ax = axes[2]

ax.hist(x1_scaled_by_robust, ec='k', bins=10, range=(-2.5, 2.5))

ax.set_title("RobustScaler")

fig2, axes = plt.subplots(1, 3, figsize=(18.6, 4.8))

ax = axes[0]

ax.hist(x2_scaled_by_minmax, ec='k', bins=40)

ax.set_title("MinMaxScaler")

ax = axes[1]

ax.hist(x2_scaled_by_standard, ec='k', bins=10, range=(-1.5, 1))

ax.set_title("StandardScaler")

ax = axes[2]

ax.hist(x2_scaled_by_robust, ec='k', bins=10, range=(-2.5, 2.5))

ax.set_title("RobustScaler")

plt.show()

RobustScaler

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

概要

sklearn.preprocessingモジュールのRobustScalerは、各特徴量の中央値(med_i)と第1-4分位数(q_1i)、第3-4分位数(q_3i)を用いて特徴量を標準化する。

(1) $\begin{equation*} {F_i}^* = \frac{F_i - med_i}{q_{3i} - q_{1i}} \end{equation*}$

挙動

それぞれ異なる正規分布に従う2つの特徴量について、RobustScalerを適用したときの挙動を以下に示す。異なる大きさとレンジの特徴量が、変換後には原点を中心としてほぼ同じような広がりになっているのがわかる。

import numpy as np
import numpy.random as rnd
import matplotlib.pyplot as plt
from sklearn.preprocessing import RobustScaler

rnd.seed(0)
x1 = rnd.normal(loc=2, scale=3, size=100)
x2 = rnd.normal(loc=7, scale=1, size=100)
X = np.hstack((x1.reshape(-1, 1), x2.reshape(-1, 1)))

scaler = RobustScaler()
X_transformed = scaler.fit_transform(X)

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

ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 3)
ax3 = fig.add_subplot(1, 2, 2)

ax1.hist(X[:, 0], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 0")
ax1.hist(X[:, 1], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 1")
ax1.legend(loc='upper left')

ax2.hist(X_transformed[:, 0], range=(-3, 3), bins=40, ec='k', alpha=0.5,
    label="Feature 0")
ax2.hist(X_transformed[:, 1], range=(-3, 3), bins=40, ec='k', alpha=0.5,
    label="Feature 1")
ax2.legend(loc='upper left')

ax3.scatter(X[:, 0], X[:, 1], ec='k', fc='w', label="before transformation")
ax3.scatter(X_transformed[:, 0], X_transformed[:, 1], ec='k', fc='gray',
    label="after transformation")
ax3.set_aspect('equal')
ax3.set_xlim(-7, 10)
ax3.set_ylim(-7, 10)
ax3.set_xlabel("Feature 0")
ax3.set_ylabel("Feature 1")
ax3.legend()

plt.show()

import numpy as np

import numpy.random as rnd

import matplotlib.pyplot as plt

from sklearn.preprocessing import RobustScaler

rnd.seed(0)

x1 = rnd.normal(loc=2, scale=3, size=100)

x2 = rnd.normal(loc=7, scale=1, size=100)

X = np.hstack((x1.reshape(-1, 1), x2.reshape(-1, 1)))

scaler = RobustScaler()

X_transformed = scaler.fit_transform(X)

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

ax1 = fig.add_subplot(2, 2, 1)

ax2 = fig.add_subplot(2, 2, 3)

ax3 = fig.add_subplot(1, 2, 2)

ax1.hist(X[:, 0], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 0")

ax1.hist(X[:, 1], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 1")

ax1.legend(loc='upper left')

ax2.hist(X_transformed[:, 0], range=(-3, 3), bins=40, ec='k', alpha=0.5,

label="Feature 0")

ax2.hist(X_transformed[:, 1], range=(-3, 3), bins=40, ec='k', alpha=0.5,

label="Feature 1")

ax2.legend(loc='upper left')

ax3.scatter(X[:, 0], X[:, 1], ec='k', fc='w', label="before transformation")

ax3.scatter(X_transformed[:, 0], X_transformed[:, 1], ec='k', fc='gray',

label="after transformation")

ax3.set_aspect('equal')

ax3.set_xlim(-7, 10)

ax3.set_ylim(-7, 10)

ax3.set_xlabel("Feature 0")

ax3.set_ylabel("Feature 1")

ax3.legend()

plt.show()

簡単なデータでRobustScalerの計算過程を確認しておく。以下の例では5個のデータにRobustScalerを適用している。これは1つの特徴量を持つ5個のデータを模していることになる。

インスタンス内に保持されたパラメーターのうち、center_は特徴量の標本平均、scale_が第3-4分位数－第1-4分位数となっていて、これらで各特徴量が標準化されているのが確認できる。

import numpy as np
from sklearn.preprocessing import RobustScaler

x = np.array([2, 3, 4, 5, 6, 8, 10, 12])
print(np.percentile(x, q=[0, 25, 50, 75, 100]))

scaler = RobustScaler()
x_transformed = scaler.fit_transform(x.reshape(-1, 1))
print(x_transformed.reshape(-1))
print("centers:{}".format(scaler.center_))
print("scales :{}".format(scaler.scale_))

# [ 2.    3.75  5.5   8.5  12.  ]
# [-0.73684211 -0.52631579 -0.31578947 -0.10526316  0.10526316  0.52631579
#   0.94736842  1.36842105]
# centers:[5.5]
# scales :[4.75]

import numpy as np

from sklearn.preprocessing import RobustScaler

x = np.array([2, 3, 4, 5, 6, 8, 10, 12])

print(np.percentile(x, q=[0, 25, 50, 75, 100]))

scaler = RobustScaler()

x_transformed = scaler.fit_transform(x.reshape(-1, 1))

print(x_transformed.reshape(-1))

print("centers:{}".format(scaler.center_))

print("scales :{}".format(scaler.scale_))

# [ 2. 3.75 5.5 8.5 12. ]

# [-0.73684211 -0.52631579 -0.31578947 -0.10526316 0.10526316 0.52631579

# 0.94736842 1.36842105]

# centers:[5.5]

# scales :[4.75]

特徴

RobustScalerは異常値に対して頑健であり、StandardScalerより頑健性が高い。

StandardScaler

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

概要

sklearn.preprocessingモジュールのStandardScalerは、各特徴量の標本平均と標本分散を用いて特徴量を標準化する。

具体的には、特徴量F_iの標本平均(m_i)と標本分散(v_i)から以下の式により各特徴量F_iをF_i^*に変換する。

(1) $\begin{equation*} {F_i}^* = \frac{F_i -m_i}{\sqrt{v_i}} \end{equation*}$

挙動

それぞれ異なる正規分布に従う2つの特徴量について、StandardScalerを適用したときの挙動を以下に示す。異なる大きさとレンジの特徴量が、変換後には原点を中心としてほぼ同じような広がりになっているのがわかる。

import numpy as np
import numpy.random as rnd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler

rnd.seed(0)
x1 = rnd.normal(loc=2, scale=3, size=100)
x2 = rnd.normal(loc=7, scale=1, size=100)
X = np.hstack((x1.reshape(-1, 1), x2.reshape(-1, 1)))

scaler = StandardScaler()
X_transformed = scaler.fit_transform(X)

fig = plt.figure(figsize=(9.6, 4.8))
fig.subplots_adjust(wspace=0.3)

ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 3)
ax3 = fig.add_subplot(1, 2, 2)

ax1.hist(X[:, 0], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 0")
ax1.hist(X[:, 1], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 1")
ax1.legend(loc='upper left')

ax2.hist(X_transformed[:, 0], range=(-3, 3), bins=40, ec='k', alpha=0.5,
    label="Feature 0")
ax2.hist(X_transformed[:, 1], range=(-3, 3), bins=40, ec='k', alpha=0.5,
    label="Feature 0")
ax2.legend(loc='upper left')

ax3.scatter(X[:, 0], X[:, 1], ec='k', fc='w', label="before transformation")
ax3.scatter(X_transformed[:, 0], X_transformed[:, 1], ec='k', fc='gray',
    label="after transformation")
ax3.set_aspect('equal')
ax3.set_xlim(-10, 10)
ax3.set_ylim(-10, 10)
ax3.set_xlabel("Feature 0")
ax3.set_ylabel("Feature 1")
ax3.legend()

plt.show()

import numpy as np

import numpy.random as rnd

import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler

rnd.seed(0)

x1 = rnd.normal(loc=2, scale=3, size=100)

x2 = rnd.normal(loc=7, scale=1, size=100)

X = np.hstack((x1.reshape(-1, 1), x2.reshape(-1, 1)))

scaler = StandardScaler()

X_transformed = scaler.fit_transform(X)

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

fig.subplots_adjust(wspace=0.3)

ax1 = fig.add_subplot(2, 2, 1)

ax2 = fig.add_subplot(2, 2, 3)

ax3 = fig.add_subplot(1, 2, 2)

ax1.hist(X[:, 0], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 0")

ax1.hist(X[:, 1], ec='k', range=(-5, 10), bins=40, alpha=0.5, label="Feature 1")

ax1.legend(loc='upper left')

ax2.hist(X_transformed[:, 0], range=(-3, 3), bins=40, ec='k', alpha=0.5,

label="Feature 0")

ax2.hist(X_transformed[:, 1], range=(-3, 3), bins=40, ec='k', alpha=0.5,

label="Feature 0")

ax2.legend(loc='upper left')

ax3.scatter(X[:, 0], X[:, 1], ec='k', fc='w', label="before transformation")

ax3.scatter(X_transformed[:, 0], X_transformed[:, 1], ec='k', fc='gray',

label="after transformation")

ax3.set_aspect('equal')

ax3.set_xlim(-10, 10)

ax3.set_ylim(-10, 10)

ax3.set_xlabel("Feature 0")

ax3.set_ylabel("Feature 1")

ax3.legend()

plt.show()

簡単なデータでStandardScalerの計算過程を確認しておく。以下の例では5個のデータにStandardScalerを適用している。これは1つの特徴量を持つ5個のデータを模していることになる。

import numpy as np
from sklearn.preprocessing import StandardScaler

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

scaler = StandardScaler()
x_transformed = scaler.fit_transform(x.reshape(-1, 1))
print(x_transformed.reshape(-1))

print("mean_ :{}".format(scaler.mean_))
print("var_  :{}".format(scaler.var_))
print("scale_:{}".format(scaler.scale_))

# [-1.41421356 -0.70710678  0.          0.70710678  1.41421356]
# mean_ :[3.]
# var_  :[2.]
# scale_:[1.41421356]

import numpy as np

from sklearn.preprocessing import StandardScaler

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

scaler = StandardScaler()

x_transformed = scaler.fit_transform(x.reshape(-1, 1))

print(x_transformed.reshape(-1))

print("mean_ :{}".format(scaler.mean_))

print("var_ :{}".format(scaler.var_))

print("scale_:{}".format(scaler.scale_))

# [-1.41421356 -0.70710678 0. 0.70710678 1.41421356]

# mean_ :[3.]

# var_ :[2.]

# scale_:[1.41421356]

インスタンス内に保持されたパラメーターのうち、mean_は特徴量の標本平均、var_は標本分散（不偏分散ではない）となっている。scale_はvar_の平方根。

各データの特徴量は次式で標準化されているのが計算で確認できる。

(2) $\begin{equation*} {F_i}^* = \frac{F_i - \rm{mean\_}}{\rm{scale\_}} = \frac{F_i - \rm{mean\_}}{\sqrt{\rm{var\_}}} \end{equation*}$

特徴

StandardScalerは異常値の影響に対して比較的頑健である。

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

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つの領域が描かれる。

Breast Cancerデータセット – SVM

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

過学習？

書籍”Pythonではじめる機械学習”の”2.3.7.4 SVMパラメータの調整”の最後の方で、scikit-learnのSVMをBreast Cancerデータセットに適用した例が示されている（カーネル法によるSVMについてはこちらにまとめている）。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

ds = load_breast_cancer()
X, y = ds.data, ds.target

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

svc = SVC(gamma='auto').fit(X_train, y_train)

print("Training score: {:.3f}".format(svc.score(X_train, y_train)))
print("Test score    : {:.3f}".format(svc.score(X_test, y_test)))

# Training score: 1.000
# Test score    : 0.629

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.svm import SVC

ds = load_breast_cancer()

X, y = ds.data, ds.target

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

svc = SVC(gamma='auto').fit(X_train, y_train)

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

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

# Training score: 1.000

# Test score : 0.629

ここで、原典ではSVC()の引数を指定せずデフォルトのままとしているが、そのまま実行すると以下のような結果になった。

Training score: 0.904
Test score    : 0.937

1 2	Training score: 0.904 Test score : 0.937

scikit-learnのドキュメンテーションによると、

Kernel coefficient for ‘rbf’, ‘poly’ and ‘sigmoid’.

if gamma='scale' (default) is passed then it uses 1 / (n_features * X.var()) as value of gamma,
if ‘auto’, uses 1 / n_features.

Changed in version 0.22: The default value of gamma changed from ‘auto’ to ‘scale’.

とされていて、gammaのデフォルト設定が変わったようである。新しい仕様ではデフォルトでデータのスケーリングが行われるため、どちらかといえば適合不足の状態になる。先のコードでは明示的にgamma=autoを設定し、書籍と同じ結果を得ている。

特徴量データのサイズの違い

Breast Cancerデータの30の特徴量について、各々の分布状況を箱髭図で描いてみた。縦軸の対数スケールに対してでも、各特徴量がかなりばらついており、1万倍～100万倍ほどの違いがあることがわかる。

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

ds = load_breast_cancer()
X, y = ds.data, ds.target

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

fig, ax = plt.subplots(figsize=(6.4, 6))
fig.subplots_adjust(bottom=0.3)

ax.boxplot(X_train, showfliers=False)
ax.set_xticklabels(ds.feature_names, rotation=270, fontsize=8)
ax.set_yscale('log')

plt.show()

import matplotlib.pyplot as plt

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

ds = load_breast_cancer()

X, y = ds.data, ds.target

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

fig, ax = plt.subplots(figsize=(6.4, 6))

fig.subplots_adjust(bottom=0.3)

ax.boxplot(X_train, showfliers=False)

ax.set_xticklabels(ds.feature_names, rotation=270, fontsize=8)

ax.set_yscale('log')

plt.show()

データの前処理

データのスケールを揃えるために使われるMiniMaxScalorでは、各特徴量の訓練データを最小値と最大値でスケーリングし、0～1に納まるようにする。具体的には、特徴量ごとに最小値を引いて、最大値－最小値のレンジで除する。

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

ds = load_breast_cancer()
X, y = ds.data, ds.target

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

min_features = X_train.min(axis=0)
max_features = X_train.max(axis=0)
ranges = max_features - min_features

X_train_scaled = (X_train - min_features) / ranges
print("Scaled training data:")
print("Minimum for each feature\n{}".format(X_train_scaled.min(axis=0)))
print("Maximum for each feature\n{}".format(X_train_scaled.max(axis=0)))
print()
X_test_scaled = (X_test - min_features) / ranges
print("Scaled test data:")
print("Minimum for each feature\n{}".format(X_test_scaled.min(axis=0)))
print("Maximum for each feature\n{}".format(X_test_scaled.max(axis=0)))

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.svm import SVC

ds = load_breast_cancer()

X, y = ds.data, ds.target

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

min_features = X_train.min(axis=0)

max_features = X_train.max(axis=0)

ranges = max_features - min_features

X_train_scaled = (X_train - min_features) / ranges

print("Scaled training data:")

print("Minimum for each feature\n{}".format(X_train_scaled.min(axis=0)))

print("Maximum for each feature\n{}".format(X_train_scaled.max(axis=0)))

print()

X_test_scaled = (X_test - min_features) / ranges

print("Scaled test data:")

print("Minimum for each feature\n{}".format(X_test_scaled.min(axis=0)))

print("Maximum for each feature\n{}".format(X_test_scaled.max(axis=0)))

この結果、訓練データの各特徴量の最小値はすべて0となり、最大値はすべて1となる。

Scaled training data:
Minimum for each feature
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
 0. 0. 0. 0. 0. 0.]
Maximum for each feature
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.
 1. 1. 1. 1. 1. 1.]

Scaled training data:

Minimum for each feature

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.

0. 0. 0. 0. 0. 0.]

Maximum for each feature

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.

1. 1. 1. 1. 1. 1.]

テストデータに対してもスケーリングを行うが、ここで使う最小値とレンジは訓練データのものとし、訓練データとテストデータでスケーリングに歪がでないようにする。その結果、スケーリング後のテストデータには、最小値が0より小さい値や最大値が1より大きい値が出ている。

Scaled test data:
Minimum for each feature
[ 0.03540158  0.04190871  0.02895446  0.01497349  0.14260888  0.04999658
  0.          0.          0.07222222  0.00589722  0.00105015 -0.00057494
  0.00067851 -0.0007963   0.05148726  0.01434497  0.          0.
  0.04195752  0.01113138  0.03678406  0.01252665  0.03366702  0.01400904
  0.08531995  0.01833687  0.          0.          0.00749064  0.02367834]
Maximum for each feature
[0.76809125 1.22697095 0.75813696 0.64750795 1.20310633 1.11643038
 0.99906279 0.90606362 0.93232323 0.94903117 0.45573058 0.72623944
 0.48593507 0.31641282 1.36082713 1.2784499  0.36313131 0.77476795
 1.32643996 0.72672498 0.82106012 0.87553305 0.77887345 0.67803775
 0.78603975 0.87843331 0.93450479 1.0024113  0.76384782 0.58743277]

Scaled test data:

Minimum for each feature

[ 0.03540158 0.04190871 0.02895446 0.01497349 0.14260888 0.04999658

0. 0. 0.07222222 0.00589722 0.00105015 -0.00057494

0.00067851 -0.0007963 0.05148726 0.01434497 0. 0.

0.04195752 0.01113138 0.03678406 0.01252665 0.03366702 0.01400904

0.08531995 0.01833687 0. 0. 0.00749064 0.02367834]

Maximum for each feature

[0.76809125 1.22697095 0.75813696 0.64750795 1.20310633 1.11643038

0.99906279 0.90606362 0.93232323 0.94903117 0.45573058 0.72623944

0.48593507 0.31641282 1.36082713 1.2784499 0.36313131 0.77476795

1.32643996 0.72672498 0.82106012 0.87553305 0.77887345 0.67803775

0.78603975 0.87843331 0.93450479 1.0024113 0.76384782 0.58743277]

スケーリングされた訓練データとテストデータについてスコアを計算すると以下のようになり、先ほどの過学習の状態から適合不足の状態となった。尚この結果は、新しいSVCクラスにおいてデフォルトのgamma='auto'を指定したときの傾向と似ていて、若干の適合不足となっている。

svc = SVC(gamma='auto').fit(X_train_scaled, y_train)

print("Training score:{:.3f}".format(svc.score(X_train_scaled, y_train)))
print("Test score    :{:.3f}".format(svc.score(X_test_scaled, y_test)))

# Training score:0.948
# Test score    :0.951

svc = SVC(gamma='auto').fit(X_train_scaled, y_train)

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

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

# Training score:0.948

# Test score :0.951

パラメーター調整

上記の適合不足の結果に対して、パラメーターを変化させてみる。デフォルトのC=1からC=1000としてみると、訓練スコア、テストスコアとも改善された。テストスコアはランダムフォレストや決定木の勾配ブースティングの結果と同じになっている。

svc = SVC(C=1000, gamma='auto').fit(X_train_scaled, y_train)

print("Training score:{:.3f}".format(svc.score(X_train_scaled, y_train)))
print("Test score    :{:.3f}".format(svc.score(X_test_scaled, y_test)))

# Training score:0.988
# Test score    :0.972

svc = SVC(C=1000, gamma='auto').fit(X_train_scaled, y_train)

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

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

# Training score:0.988

# Test score :0.972

さらにいくつかのCとgammaで試してみると、特にスコアがいいのは以下のケースだった。なおgamma=1, 10の場合、C=100, 1000, 10000に対して訓練スコアが1.000、テストスコアが0.95程度で全て過学習となった。

C	gamma	訓練スコア	テストスコア
1000	auto	0.988	0.972
1000	0.01	0.986	0.979
100	0.1	0.986	0.972