Axesで軸を反転させる

2020-11-01 / tau / コメントする

軸の反転には、invert_xaxis()、invert_yaxis()を使う。

軸が反転されているかどうかの確認には、xaxis_inverted()、yaxis_inverted()を使う。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1)
y = x**2

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

for ax in axs.flatten():
    ax.plot(x, y)
    ax.set_aspect('equal')
    ax.set_xlim(0, 1)
    ax.set_ylim(0, 1)

axs[1, 0].invert_xaxis()
axs[1, 1].invert_xaxis()

axs[0, 1].invert_yaxis()
axs[1, 1].invert_yaxis()

axs[1, 0].set_title("x inverted")
axs[0, 1].set_title("y inverted")
axs[1, 1].set_title("x,y inverted")

for ax in axs.flatten():
    print(ax.xaxis_inverted(), ax.yaxis_inverted())

plt.show()

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(0, 1)

y = x**2

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

for ax in axs.flatten():

ax.plot(x, y)

ax.set_aspect('equal')

ax.set_xlim(0, 1)

ax.set_ylim(0, 1)

axs[1, 0].invert_xaxis()

axs[1, 1].invert_xaxis()

axs[0, 1].invert_yaxis()

axs[1, 1].invert_yaxis()

axs[1, 0].set_title("x inverted")

axs[0, 1].set_title("y inverted")

axs[1, 1].set_title("x,y inverted")

for ax in axs.flatten():

print(ax.xaxis_inverted(), ax.yaxis_inverted())

plt.show()

実行結果

False False
False True
True False
True True

False False

False True

True False

True True

sklearn – confusion_matrix

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

概要

機械学習の精度を複数の視点で確認するのに、Confusion Matrix（混同行列）を用いるが、sklearn.metricsパッケージのconfusion_matrixモジュールはこの集計を自動で行ってくれる。

使い方

引数

confusion_matrix(y_true, y_pred, labels=None, normalize=None)

y_true: ターゲットの正解の配列を与える。
y_pred: 予測されたターゲットの配列を与える。
labels: 表示される順番を変更したいときに、ターゲット値をリストで指定する。
normalize: 合計値に対する比率で表示する。正解の合計に対する場合は'true'、予測結果の合計に対する場合は'pred'、全体の合計に対する場合は'all'を指定する。

戻り値

戻り値は[n_class, n_class]の2次元配列で、各行が正解の各クラス、各列が予測された各クラスに対応する。各クラスの並びは、数値なら昇順、文字列なら辞書順で、行・列とも同じ並びになる。

実行例

データの準備とモデルによる予測

Breast Cancerデータセットで使い方を見ていく。まず、cancerデータを読み込み、訓練データとテストデータに分割する。予測モデルにはLogistic回帰を用いて、訓練データについてターゲットを予測する。以降、訓練データに関する正解ターゲットと予測ターゲットを使う。

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix

ds = load_breast_cancer()

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

logreg = LogisticRegression(solver='liblinear').fit(X_train, y_train)
y_train_pred = logreg.predict(X_train)

import numpy as np

import pandas as pd

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import confusion_matrix

ds = load_breast_cancer()

X_train, X_test, y_train, y_test = train_test_split(

ds.data, ds.target, stratify=ds.target, random_state=42)

logreg = LogisticRegression(solver='liblinear').fit(X_train, y_train)

y_train_pred = logreg.predict(X_train)

ここでデータの内容を確認しておく。正解データ、予測データとも0/1の2クラスで、0が悪性(malignant)、1が良性(begnign)と定義されている。

np.set_printoptions(threshold=1, edgeitems=3)
print("Target data")
print("Actual data    (size={}):{}".format(y_train.size, y_train))
print("Predicted data (size={}):{}".format(y_train_pred.size, y_train_pred))
print(ds.target_names)

# Actual data    (size=426):[0 1 0 ... 0 0 1]
# Predicted data (size=426):[0 1 0 ... 0 0 1]
# ['malignant' 'benign']

np.set_printoptions(threshold=1, edgeitems=3)

print("Target data")

print("Actual data (size={}):{}".format(y_train.size, y_train))

print("Predicted data (size={}):{}".format(y_train_pred.size, y_train_pred))

print(ds.target_names)

# Actual data (size=426):[0 1 0 ... 0 0 1]

# Predicted data (size=426):[0 1 0 ... 0 0 1]

# ['malignant' 'benign']

また、0/1の数値によるクラス表現を文字列表現にした配列を別に作っておく。

y_train_named = np.array([ds.target_names[x] for x in y_train])
y_train_pred_named = np.array([ds.target_names[x] for x in y_train_pred])

print("Actual data    (size={}):{}".format(y_train.size, y_train_named))
print("Predicted data (size={}):{}".format(y_train_pred.size, y_train_pred_named))

# Actual data    (size=426):['malignant' 'benign' 'malignant' ... 'malignant' 'malignant' 'benign']
# Predicted data (size=426):['malignant' 'benign' 'malignant' ... 'malignant' 'malignant' 'benign']

y_train_named = np.array([ds.target_names[x] for x in y_train])

y_train_pred_named = np.array([ds.target_names[x] for x in y_train_pred])

print("Actual data (size={}):{}".format(y_train.size, y_train_named))

print("Predicted data (size={}):{}".format(y_train_pred.size, y_train_pred_named))

# Actual data (size=426):['malignant' 'benign' 'malignant' ... 'malignant' 'malignant' 'benign']

# Predicted data (size=426):['malignant' 'benign' 'malignant' ... 'malignant' 'malignant' 'benign']

基本的な使い方

要素のみを得る

基本的な使い方は、confusion_matrix()の引数に正解データと予測データをコレクションで与える。結果は行・列とも昇順で並べられる。以下の例では、1行目が正解・悪性、2行目が正解・良性、1列目が予測・悪性、2列目が予測・良性となっている。

mat = confusion_matrix(y_train, y_train_pred)
print(mat)

# [[148  11]
#  [  9 258]]

mat = confusion_matrix(y_train, y_train_pred)

print(mat)

# [[148 11]

# [ 9 258]]

クラスが文字列で表現されている場合は、文字列の辞書順なので、行・列とも'benign'、'malignant'の順で並べられる。この結果、数値表現の場合に対して行・列とも入れ替わっている。

mat_named = confusion_matrix(y_train_named, y_train_pred_named)
print(mat_named)

# [[258   9]
#  [ 11 148]]

mat_named = confusion_matrix(y_train_named, y_train_pred_named)

print(mat_named)

# [[258 9]

# [ 11 148]]

要素の並び順を変更する

引数labelsにリストでクラスの並びを指定できる。以下の例ではデフォルトの昇順の並びを変更している。

print(confusion_matrix(y_train, y_train_pred, labels=[1, 0]))

# [[258   9]
#  [ 11 148]]

print(confusion_matrix(y_train_named, y_train_pred_named,
    labels=['malignant', 'benign']))

# [[148  11]
#  [  9 258]]

print(confusion_matrix(y_train, y_train_pred, labels=[1, 0]))

# [[258 9]

# [ 11 148]]

print(confusion_matrix(y_train_named, y_train_pred_named,

labels=['malignant', 'benign']))

# [[148 11]

# [ 9 258]]

要素を正規化する～比率で表す

引数normalizeで合計に対する比率の計算の仕方を指定できる。

normalize='true'の場合、正解の各行の合計に対する比率が計算される。以下の例では行の合計で各要素が除され、各行の合計が1となっている。

mat = confusion_matrix(y_train, y_train_pred, normalize='true')
print(mat)
print(mat.sum(axis=1))

# [[0.93081761 0.06918239]
#  [0.03370787 0.96629213]]
# [1. 1.]

mat = confusion_matrix(y_train, y_train_pred, normalize='true')

print(mat)

print(mat.sum(axis=1))

# [[0.93081761 0.06918239]

# [0.03370787 0.96629213]]

# [1. 1.]

normalize='pred'の場合、予測の各列の合計に対する比率が計算される。以下の例では列の合計で各要素が除され、各列の合計が1となっている。

mat = confusion_matrix(y_train, y_train_pred, normalize='pred')
print(mat)
print(mat.sum(axis=0))

# [[0.94267516 0.04089219]
#  [0.05732484 0.95910781]]
# [1. 1.]

mat = confusion_matrix(y_train, y_train_pred, normalize='pred')

print(mat)

print(mat.sum(axis=0))

# [[0.94267516 0.04089219]

# [0.05732484 0.95910781]]

# [1. 1.]

normalize='all'の場合、すべての要素の合計に対する比率が計算される。以下の例では、全要素の合計が1となっている。

mat = confusion_matrix(y_train, y_train_pred, normalize='all')
print(mat)
print(mat.sum())

# [[0.34741784 0.0258216 ]
#  [0.02112676 0.6056338 ]]
# 1.0

mat = confusion_matrix(y_train, y_train_pred, normalize='all')

print(mat)

print(mat.sum())

# [[0.34741784 0.0258216 ]

# [0.02112676 0.6056338 ]]

# 1.0

なお、normalize='all'を指定した場合の対角要素の和は、全要素に対する正解要素の比率になり、score()メソッドの値と等しい。

print("Accuracy      :{}".format(mat[0, 0] + mat[1, 1]))
print("Training score:{}".format(logreg.score(X_train, y_train)))

# Accuracy      :0.9530516431924883
# Training score:0.9530516431924883

print("Accuracy :{}".format(mat[0, 0] + mat[1, 1]))

print("Training score:{}".format(logreg.score(X_train, y_train)))

# Accuracy :0.9530516431924883

# Training score:0.9530516431924883

DataFrameによる扱い

ラベルの追加

pandasのDataFrameを使うと、行・列のラベルが表示されるので見やすくなる。行（正解）のラベルはindexで、列（予測）のラベルはcolumnsで指定し、同じ内容のコレクションを与える。

mat = confusion_matrix(y_train, y_train_pred)
result_label = ['malignant', 'benign']
df = pd.DataFrame(mat, columns=result_label, index=result_label)

#            malignant  benign
# malignant        148      11
# benign             9     258

mat = confusion_matrix(y_train, y_train_pred)

result_label = ['malignant', 'benign']

df = pd.DataFrame(mat, columns=result_label, index=result_label)

# malignant benign

# malignant 148 11

# benign 9 258

合計欄

DataFrameのsum()メソッドで、行・列の合計を計算して追加すると見やすい。sum()メソッドの引数を省略するとデフォルトのaxis=0となり、列ごとの合計が1次元配列で得られる。引数をaxis=1とすると行単位の合計が1次元配列で得られる。

以下の例では、まず列方向の合計（各予測クラスの合計）を最後の行に加え、その行も含めて行方向の合計（各正解クラス、予測クラス合計の合計）を最後の列に加える。

sums_in_col = df.sum()
df.loc['Total'] = sums_in_col

sums_in_row = df.sum(axis=1)
df['Total'] = sums_in_row

print(df)

#            malignant  benign  Total
# malignant        148      11    159
# benign             9     258    267
# Total            157     269    426

sums_in_col = df.sum()

df.loc['Total'] = sums_in_col

sums_in_row = df.sum(axis=1)

df['Total'] = sums_in_row

print(df)

# malignant benign Total

# malignant 148 11 159

# benign 9 258 267

# Total 157 269 426

Multiindex

DataFrameのMultiindexを使うと、正解・予測を表示できるのでより分かりやすくなる。ただし行・列・要素の指定が少し煩雑になる。

actual_label = ['Actual'] * 2
pred_label = ['Prediction'] * 2
df = pd.DataFrame(mat, columns=[pred_label, result_label], index=[actual_label, result_label])
print(df)

#                  Prediction       
#                   malignant benign
# Actual malignant        148     11
#        benign             9    258

actual_label = ['Actual'] * 2

pred_label = ['Prediction'] * 2

df = pd.DataFrame(mat, columns=[pred_label, result_label], index=[actual_label, result_label])

print(df)

# Prediction

# malignant benign

# Actual malignant 148 11

# benign 9 258

以下はMultiindexの場合に合計欄を加える例。

sums_in_col = df.sum()
df.loc[('Actual', 'Total'), :] = sums_in_col

sums_in_row = df.sum(axis=1)
df[('Prediction', 'Total')] = sums_in_row

df = df.astype('int')
print(df)

#                  Prediction             
#                   malignant benign Total
# Actual malignant        148     11   159
#        benign             9    258   267
#        Total            157    269   426

sums_in_col = df.sum()

df.loc[('Actual', 'Total'), :] = sums_in_col

sums_in_row = df.sum(axis=1)

df[('Prediction', 'Total')] = sums_in_row

df = df.astype('int')

print(df)

# Prediction

# malignant benign Total

# Actual malignant 148 11 159

# benign 9 258 267

# Total 157 269 426

バグの素～間違いやすいところ

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

リストの初期化

問題

以下の処理を意図する。

2次元リストを準備し、そのリストに1列追加する
追加の際、各行を2行ずつに繰り返し、追加した列には全行を通したカウンター値を記録

Before:
[['A', 'X'], ['B', 'Y'], ['C', 'Z']]
After:
[['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

Before:

[['A', 'X'], ['B', 'Y'], ['C', 'Z']]

After:

[['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

これを意図したコードで以下のように意図しない結果となった。

source_list = [
    ["A", "X"],
    ["B", "Y"],
    ["C", "Z"]
]

print("Before:")
print(source_list)

new_list = []

counter = 1
for i in range(len(source_list)):
    new_row = source_list[i]
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

    new_row = source_list[i]
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

print("After:")
print(new_list)

# Before:
# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]
# After:
# [['A', 'X', 1, 2], ['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6], ['C', 'Z', 5, 6]]

source_list = [

["A", "X"],

["B", "Y"],

["C", "Z"]

]

print("Before:")

print(source_list)

new_list = []

counter = 1

for i in range(len(source_list)):

new_row = source_list[i]

new_row.append(counter)

counter += 1

new_list.append(new_row)

new_row = source_list[i]

new_row.append(counter)

counter += 1

new_list.append(new_row)

print("After:")

print(new_list)

# Before:

# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]

# After:

# [['A', 'X', 1, 2], ['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6], ['C', 'Z', 5, 6]]

原因

原因は14行目、19行目で複製すべきリストnew_rowを単純に代入しているためで、変数代入時に元のリストオブジェクトは複製されず重複して参照されるだけとなり、1つの変更が元のオブジェクトを通して全体に波及してしまう。

具体的にリストのi行目の処理を追うと以下の通り。

1回目のnew_row = source_list[i]で元リストのi行目が1次元リストとして共有される
そのリストの最後尾にカウンター値が追加され、カウンターがインクリメントされる
- この時点で1次元リストの最後尾にカウンター値が追加され、new_row、source_list[i]のいずれにも参照されている
新しいリストに1次元リストが行として追加される
- この時点で、source_list[i]、new_row、new_list[2*i]が共通の1次元リストを参照している
2回目のnew_row = source_list[i]で元リストのi行目が共有される（実はこの処理は1番目の繰り返しであり意味がない）
そのリストの最後尾にカウンター値が追加され、カウンターがインクリメントされる
- この時点で、先に最後尾にカウンター値追加済みの1次元リストの最後尾に更にカウンター値が追加され、new_row、source_list[i]のいずれにも参照されている
新しいリストに1次元リストが行として追加される
- この時点で、source_list[i]、new_row、new_list[2*i+1]が共通の1次元リストを参照している

この結果、source_listも以下のように変更される。

[['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6]]

1	[['A', 'X', 1, 2], ['B', 'Y', 3, 4], ['C', 'Z', 5, 6]]

解決

この原因である重複参照を解消するため、元リスト各行の（参照を）代入するのではなく、copy()メソッドで新しいインスタンスを生成することで、想定した結果を得る。

source_list = [
    ["A", "X"],
    ["B", "Y"],
    ["C", "Z"]
]

print("Before:")
print(source_list)

new_list = []

counter = 1
for i in range(len(source_list)):
    new_row = source_list[i].copy()
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

    new_row = source_list[i].copy()
    new_row.append(counter)
    counter += 1
    new_list.append(new_row)

print("After:")
print(new_list)

# Before:
# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]
# After:
# [['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

source_list = [

["A", "X"],

["B", "Y"],

["C", "Z"]

]

print("Before:")

print(source_list)

new_list = []

counter = 1

for i in range(len(source_list)):

new_row = source_list[i].copy()

new_row.append(counter)

counter += 1

new_list.append(new_row)

new_row = source_list[i].copy()

new_row.append(counter)

counter += 1

new_list.append(new_row)

print("After:")

print(new_list)

# Before:

# [['A', 'X'], ['B', 'Y'], ['C', 'Z']]

# After:

# [['A', 'X', 1], ['A', 'X', 2], ['B', 'Y', 3], ['B', 'Y', 4], ['C', 'Z', 5], ['C', 'Z', 6]]

結論

リストを代入するときに参照・複製を意識し、基本はcopy()で複製。

DataFrameのスピード～行の追加

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

概要

pandas.DataFrameで数千行のデータの組み換えをやろうとしたときにかなり時間がかかったので、簡単な例で実行時間を確認してみた。

結論から言うと、他の様々なサイトで言及されているように、「行単位の追加はかなり時間がかかるが、列単位の追加は圧倒的に早い」ということになる。また、先にリストなどでデータを構成しておいてからDataFrameを生成する方法も高速なことが分かった。

問題設定

次のように、3つの列を持つ行データを1万個、DataFrameに追加していく例を考える。

import time
import numpy as np
import pandas as pd

col_list = ['one', 'two', 'three']
row_to_add = [1, 2, 3]

start_time = time.time()

・・・それぞれの処理・・・

end_time = time.time()
print("erapse time {} sec".format(end_time - start_time))

import time

import numpy as np

import pandas as pd

col_list = ['one', 'two', 'three']

row_to_add = [1, 2, 3]

start_time = time.time()

・・・それぞれの処理・・・

end_time = time.time()

print("erapse time {} sec".format(end_time - start_time))

appendメソッド

appendメソッドは2つのDataFrameを結合するメソッドで、行の追加方法としてもよく紹介されている。実行結果は以下の通りで約7秒（3回繰り返して同程度）。

df = pd.DataFrame(columns=col_list)
for i in range(10000):
    df_to_add = pd.DataFrame([row_to_add], columns=col_list)
    df = df.append(df_to_add)

# erapse time 6.999355792999268 sec

df = pd.DataFrame(columns=col_list)

for i in range(10000):

df_to_add = pd.DataFrame([row_to_add], columns=col_list)

df = df.append(df_to_add)

# erapse time 6.999355792999268 sec

appendでリストをDataFrameにする際、リストをそのまま渡すと列と解釈されるので、2次元化して行であることを明示している。また列名を指定しないと新たな列として4～6列目に行が加えられていくので、加えるDataFrameでも列名を指定している。

リストをそのまま渡して列として生成し、行インデックスに列名を渡してDataFrameを生成してから'.T'で転置している例なども見られた。

なお、この場合のDataFrameの各要素は整数型となる。

     one two three
0      1   2     3
1      1   2     3
2      1   2     3
3      1   2     3
4      1   2     3
...   ..  ..   ...
9995   1   2     3
9996   1   2     3
9997   1   2     3
9998   1   2     3
9999   1   2     3

one two three

0 1 2 3

1 1 2 3

2 1 2 3

3 1 2 3

4 1 2 3

... .. .. ...

9995 1 2 3

9996 1 2 3

9997 1 2 3

9998 1 2 3

9999 1 2 3

locプロパティーはインデックス指定に注意

DataFrameのlocプロパティーは、スライスによって複数行・列の要素の参照・代入ができる。これを利用して、空のDataFrameに1行ずつ追加していく。実行時間は7秒台。

この場合のDataFrameの各要素も整数になる。

df = pd.DataFrame(columns=col_list)
for i in range(10000):
    df.loc[i, :] = row_to_add

# erapse time 7.583117246627808 sec

df = pd.DataFrame(columns=col_list)

for i in range(10000):

df.loc[i, :] = row_to_add

# erapse time 7.583117246627808 sec

興味深いのことに、loc[i:, ]ではなくてloc[i]で指定すると実行時間が倍以上、20秒近くになる。

df = pd.DataFrame(columns=col_list)
for i in range(10000):
    df.loc[i] = row_to_add

# erapse time 19.00727939605713 sec

df = pd.DataFrame(columns=col_list)

for i in range(10000):

df.loc[i] = row_to_add

# erapse time 19.00727939605713 sec

なお、locの代わりにilocを使うと"IndexError: iloc cannot enlarge its target object"とエラーになる。

DataFrameの領域を確保した場合

リストで確保した場合

予めデータのサイズがわかっている場合に、ダミーデータで埋めたリストで領域を確保してみる。領域を一気に確保して値を入れていくだけなので実行速度は速い。実行時間は0.7秒程度で、appendやlocで1行ずつ追加していくのに比べて1/10。

df = pd.DataFrame([[0] * 3] * 10000, columns=col_list)
for i in range(10000):
    df.loc[i, :] = row_to_add

# erapse time 0.6972208023071289 sec

df = pd.DataFrame([[0] * 3] * 10000, columns=col_list)

for i in range(10000):

df.loc[i, :] = row_to_add

# erapse time 0.6972208023071289 sec

ここでloc[i, :]をloc[i]とすると、実行時間は0.5秒程度と少し早くなる。これは1行ずつ追加する場合と逆の傾向だが、この場合はその差は追加の場合に比べて小さい。

なお、この方法では領域が既に確保されているのでilocに変更しても同じ結果となる。

ndarrayで確保した場合

リストではなくndarrayで領域を確保してみると、実行速度はリストの場合と同程度。

df = pd.DataFrame(np.empty((10000, 3)), columns=col_list)
for i in range(10000):
    df.loc[i, :] = row_to_add

# erapse time 0.6625535488128662 sec

df = pd.DataFrame(np.empty((10000, 3)), columns=col_list)

for i in range(10000):

df.loc[i, :] = row_to_add

# erapse time 0.6625535488128662 sec

ただし、この場合各要素は実数となる。整数が必要ならndarrayのコンストラクターでdtype='int'を指定する。

      one  two  three
0     1.0  2.0    3.0
1     1.0  2.0    3.0
2     1.0  2.0    3.0
3     1.0  2.0    3.0
4     1.0  2.0    3.0
...   ...  ...    ...
9995  1.0  2.0    3.0
9996  1.0  2.0    3.0
9997  1.0  2.0    3.0
9998  1.0  2.0    3.0
9999  1.0  2.0    3.0

one two three

0 1.0 2.0 3.0

1 1.0 2.0 3.0

2 1.0 2.0 3.0

3 1.0 2.0 3.0

4 1.0 2.0 3.0

... ... ... ...

9995 1.0 2.0 3.0

9996 1.0 2.0 3.0

9997 1.0 2.0 3.0

9998 1.0 2.0 3.0

9999 1.0 2.0 3.0

ここでndarrayのdtypeを整数で指定すると実行時間が以下のような傾向となった。

int8, int16→4秒台
int32, int64→0.6秒台

ワード境界の中に値を埋め込んでいくのに時間がかかっていると考えられる。

列ごとのリストを加える方法はかなり速い

列ごとの辞書でDataFrameを生成する方法

列ごとのリストを作っておいて、それらから全体のデータを辞書として準備し、DataFrameを生成する方法。

これは更に速く、実行時間は0.015秒前後。loc[i, :]で行ごとに加えていく方法の1/1000の時間で済むことになる。

one = []
two = []
three = []
for i in range(10000):
    one += [1]
    two += [2]
    three += [3]
all = [one, two, three]
df = pd.DataFrame(
    data={'one':one, 'two':two, 'three':three}, columns=col_list)

# erapse time 0.014957666397094727 sec

one = []

two = []

three = []

for i in range(10000):

one += [1]

two += [2]

three += [3]

all = [one, two, three]

df = pd.DataFrame(

data={'one':one, 'two':two, 'three':three}, columns=col_list)

# erapse time 0.014957666397094727 sec

ただし辞書のキーで列名を指定するところがやや煩雑か。

列単位でリストを加えていく方法

列ごとのリストを、順次DataFrameに加えていく方法。

この場合もかなり速いが、上の方法では実行時間が一定しているのに対して、こちらは0.015～0.03秒と少しばらついて、ほんの僅かだが遅め。

one = []
two = []
three = []
for i in range(10000):
    one += [1]
    two += [2]
    three += [3]
df = pd.DataFrame(columns=col_list)
df['one'] = one
df['two'] = two
df['three'] = three

# erapse time 0.020946025848388672 sec

one = []

two = []

three = []

for i in range(10000):

one += [1]

two += [2]

three += [3]

df = pd.DataFrame(columns=col_list)

df['one'] = one

df['two'] = two

df['three'] = three

# erapse time 0.020946025848388672 sec

列ごとのndarrayを加える方法

空のndarrayを準備して要素を加えていき、これを列単位でDataFrameに加える方法。

実行時間は0.25秒程度でリストの時の10倍の時間がかかっている。別途ndarrayの要素追加時部分だけの時間を計測すると、この部分だけで0.2秒台で、配列の要素追加のところで時間がかかっている。

one = np.empty(0, dtype=int)
two = np.empty(0)
three = np.empty(0)
for i in range(10000):
    one = np.append(one, [1])
    two = np.append(two, [2])
    three = np.append(three, [3])
df = pd.DataFrame(columns=col_list)
df['one'] = one
df['two'] = two
df['three'] = three
end_time = time.time()

# erapse time 0.24968528747558594 sec

one = np.empty(0, dtype=int)

two = np.empty(0)

three = np.empty(0)

for i in range(10000):

one = np.append(one, [1])

two = np.append(two, [2])

three = np.append(three, [3])

df = pd.DataFrame(columns=col_list)

df['one'] = one

df['two'] = two

df['three'] = three

end_time = time.time()

# erapse time 0.24968528747558594 sec

2次元リストから生成する方法がベスト

リストなどを列ごとに加えるのではなく、2次元のリストを構成しておいて、それを使ってDataFrameを生成する方法。

実行時間は0.01～0.02秒程度で、最も早い部類に入る。順次行を追加するという発想にコードも近く、速度・可読性ともに最適のようである。

list_data = []
for i in range(10000):
    list_data.append(row_to_add)
df = pd.DataFrame(list_data, columns=col_list)

# erapse time 0.011972188949584961 sec

list_data = []

for i in range(10000):

list_data.append(row_to_add)

df = pd.DataFrame(list_data, columns=col_list)

# erapse time 0.011972188949584961 sec

既存のDataFrameに追加する場合

既にデータがあるDataFrameに新たな行を追加する場合を考える。これまでの例で、どうやらリストの形で操作するのが速そうで、DataFrameからリストへの変換がそれなりに速いのなら、その方法が最もよさそうだと予想できる。

以下のコードはこのことを確認したもの。3つのパートに分かれていて、最初がこれまでと同じDataFrameの生成、次がDataFrameからリストへの変換、最後がリストへの追加と追加後のDataFrameの生成となっている。

DataFrameからリストへの変換は、to_numpy()メソッドでndarrayが得られるので（DataFrameのvaluesでもndarrayは非推奨）、それをtolist()メソッドでリストに変換している。

import time
import pandas as pd

start_time = time.time()
# First, prepare the original dataset

col_list = ('one', 'two', 'three')
list_data = []
initial_row = [1, 2, 3]

for i in range(10000):
    list_data.append(initial_row)

df = pd.DataFrame(list_data, columns=col_list)

time_to_create = time.time()
print(df)

# Second, prepare the list to add new data
list_data = df.to_numpy().tolist()
time_to_prepare_list = time.time()

# Finally, add new data to list and generate the new DataFrame
row_to_add = [10, 20, 30]

for i in range(10000):
    list_data.append(row_to_add)

df = pd.DataFrame(list_data, columns=col_list)

time_to_append = time.time()
print(df)

print("time to create :{} sec".format(time_to_create - start_time))
print("time to prepare:{} sec".format(time_to_prepare_list - time_to_create))
print("time to append :{} sec".format(time_to_append - time_to_prepare_list))

# time to create :0.0070116519927978516 sec
# time to prepare:0.006953001022338867 sec
# time to append :0.012996912002563477 sec

import time

import pandas as pd

start_time = time.time()

# First, prepare the original dataset

col_list = ('one', 'two', 'three')

list_data = []

initial_row = [1, 2, 3]

for i in range(10000):

list_data.append(initial_row)

df = pd.DataFrame(list_data, columns=col_list)

time_to_create = time.time()

print(df)

# Second, prepare the list to add new data

list_data = df.to_numpy().tolist()

time_to_prepare_list = time.time()

# Finally, add new data to list and generate the new DataFrame

row_to_add = [10, 20, 30]

for i in range(10000):

list_data.append(row_to_add)

df = pd.DataFrame(list_data, columns=col_list)

time_to_append = time.time()

print(df)

print("time to create :{} sec".format(time_to_create - start_time))

print("time to prepare:{} sec".format(time_to_prepare_list - time_to_create))

print("time to append :{} sec".format(time_to_append - time_to_prepare_list))

# time to create :0.0070116519927978516 sec

# time to prepare:0.006953001022338867 sec

# time to append :0.012996912002563477 sec

結果はかなり高速で、DataFrameのままでlocで追加するよりもはるかに速い。

まとめ

今回のケースの場合、1万行の追加でlocを使うと7秒で1行当たり0.0007秒。100行まとめて追加すると0.07秒で、この時点でリストに変換して追加した方が速くなる。

数少ない行を低頻度で追加するのでなければ、DataFrameにまとまった行を追加したり、既にあるDataFrameの構造を変換するには、一旦リストに変換してからデータを追加し、DataFrameに変換し直した方が速いと言える。

Python3 – zip関数

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

概要

組み込み関数zip()は、引数のコレクションやイテレーターの要素を組み合わせた値を返すイテレーター。ジッパーの左右の小さな金具が交互に合わさって一つになるイメージ。

使い方

zip()の引数に、1つにしたい複数のコレクションを与える。戻り値はイテレーター。

list1 = ['Tokyo', 'Aichi', 'Osaka']
list2 = [13, 23, 27]

print(zip(list1, list2))
# <zip object at 0x0000015B8AB51640>

print(list(zip(list1, list2)))
# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

list1 = ['Tokyo', 'Aichi', 'Osaka']

list2 = [13, 23, 27]

print(zip(list1, list2))

# <zip object at 0x0000015B8AB51640>

print(list(zip(list1, list2)))

# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

イテレーターなのでforループなどに使える。

for item1, item2 in zip(list1, list2):
    print(item1, item2)

# Tokyo 13
# Aichi 23
# Osaka 27

for item1, item2 in zip(list1, list2):

print(item1, item2)

# Tokyo 13

# Aichi 23

# Osaka 27

引数はコレクションのほかイテレーターも可能。

for item1, item2 in zip(range(1, 7, 2),  range(2, 8, 2)):
    print(item1, item2)

# 1 2
# 3 4
# 5 6

for item1, item2 in zip(range(1, 7, 2), range(2, 8, 2)):

print(item1, item2)

# 1 2

# 3 4

# 5 6

引数が3つ以上でも可能。

list1 = [1, 4, 7]
list2 = [2, 5, 8]
list3 = [3, 6, 9]

for item1, item2, item3 in zip(list1, list2, list3):
    print(item1, item2, item3)

# 1 2 3
# 4 5 6
# 7 8 9

list1 = [1, 4, 7]

list2 = [2, 5, 8]

list3 = [3, 6, 9]

for item1, item2, item3 in zip(list1, list2, list3):

print(item1, item2, item3)

# 1 2 3

# 4 5 6

# 7 8 9

リスト化した時の表現

zip()をリスト化した時の結果list(zip())を確認しておく。1つにまとめられた内容が、それぞれタプルとなっている。

list1 = ['Tokyo', 'Aichi', 'Osaka']
list2 = [13, 23, 27]
print(list(zip(list1, list2)))
# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

list1 = [1, 4, 7]
list2 = [2, 5, 8]
list3 = [3, 6, 9]
print(list(zip(list1, list2, list3)))
# [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

list1 = ['Tokyo', 'Aichi', 'Osaka']

list2 = [13, 23, 27]

print(list(zip(list1, list2)))

# [('Tokyo', 13), ('Aichi', 23), ('Osaka', 27)]

list1 = [1, 4, 7]

list2 = [2, 5, 8]

list3 = [3, 6, 9]

print(list(zip(list1, list2, list3)))

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

引数の長さが違うとき

引数のコレクションやイテレーターの長さが異なるときは、短いものに合わされて、他のの残りの内容は無視される。

list1 = [1, 2, 3]
list2 = [10, 20, 30, 40, 50]

print(list(zip(list1, list2)))

# [(1, 10), (2, 20), (3, 30)]

list1 = [1, 2, 3]

list2 = [10, 20, 30, 40, 50]

print(list(zip(list1, list2)))

# [(1, 10), (2, 20), (3, 30)]

itertools.zip_longest()を使うと、最も長いものに合わされて、残りが指定された値で埋められる。

直接関係ないこと～zipper

“zipper”という言葉はAmerican Englishで、グッドリッチ社の商標登録だった言葉がいわゆるファスナーを指す名詞になったようだ。British Englishではzipが名詞としてファスナーの意味となる。

動詞のzipはzipperから「（ファスナーで）締める」という意味を持つ。そもそもzipという動詞には、素早く動く、飛んでいくといった意味があるらしい(informal to go somewhere or do something very quickly ~ LONGMAN)。が、日本語サイトの英和辞書では後者の訳が先に出ているが、LONGMAN/Camblidge/Oxfordなどのオンライン辞書では前者のファスナー関係の訳が先に来ている。日本語サイトがnativeの感覚と異っているのがわかる。

Python – リストの要素の削除

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

概要

リストの要素の削除をするのに、いくつかの方法がある。

clear()メソッド～リストの要素をすべて削除して空にする
pop()メソッド～引数で指定した位置の要素を削除し、その内容を返す
remove()メソッド～引数と一致する最初の要素を削除する
del()関数～引数でリストの要素・スライスを指定し、その範囲の要素を削除する

`clear()`メソッド

clear()メソッドはリストの全ての要素を削除して空にする。戻り値はない。

words = ['the', 'rain', 'in', 'Spain']

print(words.clear())
print(words)

# None
# []

words = ['the', 'rain', 'in', 'Spain']

print(words.clear())

print(words)

# None

# []

`pop()`メソッド

pop()メソッドは引数で指定した位置の要素を削除し、その内容を返す。

words = ['the', 'rain', 'in', 'Spain']

print(words.pop(2))
print(words)

# in
# ['the', 'rain', 'Spain']

words = ['the', 'rain', 'in', 'Spain']

print(words.pop(2))

print(words)

# in

# ['the', 'rain', 'Spain']

引数が要素位置の範囲を超えるとエラー。

words.pop(8)

# IndexError: pop index out of range

words.pop(8)

# IndexError: pop index out of range

`remove()`メソッド

remove()メソッドは引数に一致する要素を削除する。戻り値はない。

words = ['the', 'rain', 'in', 'Spain']

print(words.remove('in'))
print(words)

# None
# ['the', 'rain', 'Spain']

words = ['the', 'rain', 'in', 'Spain']

print(words.remove('in'))

print(words)

# None

# ['the', 'rain', 'Spain']

リスト中に存在しない要素を指定するとエラー。

words.remove('out')

# ValueError: list.remove(x): x not in list

words.remove('out')

# ValueError: list.remove(x): x not in list

`delete()`メソッド

delete()メソッドはリストの要素を指定して削除。戻り値はなく、結果を参照しようとするとエラー。

words = ['the', 'rain', 'in', 'Spain']

del(words[2])
print(words)

print(del(words[0])

# ['the', 'rain', 'Spain']
# SyntaxError: invalid syntax

words = ['the', 'rain', 'in', 'Spain']

del(words[2])

print(words)

print(del(words[0])

# ['the', 'rain', 'Spain']

# SyntaxError: invalid syntax

リストの要素範囲をスライスで指定して削除することも可能。

words = ['the', 'rain', 'in', 'Spain']

del(words[1:3])
print(words)

# ['the', 'Spain']

words = ['the', 'rain', 'in', 'Spain']

del(words[1:3])

print(words)

# ['the', 'Spain']

join()～リストの文字列の結合

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

文字列に対するjoin()メソッドは、その区切り文字を使って引数のリストの要素を結合する。

chars = ['A', 'B', 'C', 'D']

print(' and '.join(chars))

# A and B and C and D

chars = ['A', 'B', 'C', 'D']

print(' and '.join(chars))

# A and B and C and D

空の文字列''を使えば文字列同士をつなげて1つにできる。

print(''.join(chars))

# ABCD

print(''.join(chars))

# ABCD

もちろん文字だけでなく文字列も。

words = ['The', 'rain', 'in', 'Spain']

print(' '.join(words))

# The rain in Spain

words = ['The', 'rain', 'in', 'Spain']

print(' '.join(words))

# The rain in Spain

sklearn.preprocessing

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

使い方

機械学習のうち、ニューラルネットワークやSVMなどのモデルは、データの値の大きさやレンジが異なる場合、過学習になったり精度が悪くなることがあり、データを揃えるための前処理が必要になる（SVMの例、ニューラルネットワークの例）。

scikit-learnのpreprocessingモジュールには、データの前処理を行う各種のクラスが準備されている。一般的な使い方は以下の通り。

データを訓練データとテストデータに分ける
各preprocessorのfit()メソッドに訓練データを与えて変換用のパラメータを準備する（変換モデルを構築する）
- fit()メソッドは、各列が特徴量、各行がデータレコードである2次元配列を想定している
変換器のtransform()メソッドに訓練データを与えて前処理を施す
同じ変換器のtransform()メソッドにテストデータを与えて前処理をほどこす

なお、fit()メソッドとtransform()メソッドをそれぞれ分けて行うほか、fit().transform()とメソッドチェーンで実行してもよい。またpreprocessorにはこれらを一体化したfit_transform()というメソッドも準備されている。

実行例

preprocessingのscaler系のクラスの1つ、MinMaxScalerを例にして、その挙動を追ってみる。

まず必要なライブラリーやクラスをインポートし、Breast cancerデータを読み込み、データを訓練データとテストデータに分ける。cancerデータは30の特徴量を列とし、569のレコードを持つが、それを3:1に分け、426セットの訓練データと143セットのテストデータとしている。

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

np.set_printoptions(suppress=True, precision=2, floatmode='fixed')

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test =\
    train_test_split(cancer.data, cancer.target, random_state=1)
print("shepe of trainning data:{}".format(X_train.shape))
print("shepe of test data     :{}".format(X_test.shape))

# shepe of trainning data:(426, 30)
# shepe of test data     :(143, 30)

import numpy as np

from sklearn.datasets import load_breast_cancer

from sklearn.model_selection import train_test_split

np.set_printoptions(suppress=True, precision=2, floatmode='fixed')

cancer = load_breast_cancer()

X_train, X_test, y_train, y_test =\

train_test_split(cancer.data, cancer.target, random_state=1)

print("shepe of trainning data:{}".format(X_train.shape))

print("shepe of test data :{}".format(X_test.shape))

# shepe of trainning data:(426, 30)

# shepe of test data :(143, 30)

次にMinMaxScalerのインスタンスを生成し、fit()メソッドに訓練データX_trainを与えて、変換用のモデルを構築する。

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
scaler.fit(X_train)

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

scaler.fit(X_train)

preprocessingでいうモデルの構築とは、基準となるデータを与えて、変換用のパラメータを算出・保持するのに相当する。

今回の例のMinMaxScalerオブジェクトでは、特徴量数を要素数とする1次元配列で、データセット中の各特徴量の最小値(data_min_)、最大値(data_max_)、最大値－最小値のレンジ(data_range_)、レンジの逆数であるscales_がインスタンス内に保持されている。

これらのパラメーターは、30の特徴量について、426個のデータの最小値、最大値・・・などとなっている。たとえば1つ目の特徴量については、最大値－最小値は28.11−6.98=21.13となり、data_range_の1つ目の値と符合している。またscales_の各要素は、data_range_の各要素の逆数となっている。

print("-----traing data characteristics and parameters")
print("mins  :\n{}".format(scaler.data_min_))
print("maxs  :\n{}".format(scaler.data_max_))
print("ranges:\n{}".format(scaler.data_range_))
print("scales:\n{}".format(scaler.scale_))

# -----traing data characteristics and parameters
# mins  :
# [  6.98   9.71  43.79 143.50   0.05   0.02   0.00   0.00   0.11   0.05
#    0.12   0.36   0.76   6.80   0.00   0.00   0.00   0.00   0.01   0.00
#    7.93  12.02  50.41 185.20   0.07   0.03   0.00   0.00   0.16   0.06]
# maxs  :
# [  28.11   39.28  188.50 2501.00    0.16    0.29    0.43    0.20    0.30
#     0.10    2.87    4.88   21.98  542.20    0.03    0.14    0.40    0.05
#     0.06    0.03   36.04   49.54  251.20 4254.00    0.22    0.94    1.17
#     0.29    0.58    0.15]
# ranges:
# [  21.13   29.57  144.71 2357.50    0.11    0.27    0.43    0.20    0.20
#     0.05    2.76    4.52   21.22  535.40    0.03    0.13    0.40    0.05
#     0.05    0.03   28.11   37.52  200.79 4068.80    0.15    0.91    1.17
#     0.29    0.42    0.09]
# scales:
# [ 0.05  0.03  0.01  0.00  9.03  3.74  2.34  4.97  5.05 21.97  0.36  0.22
#   0.05  0.00 33.99  7.51  2.53 18.94 19.26 34.55  0.04  0.03  0.00  0.00
#   6.60  1.10  0.85  3.44  2.38 10.71]

print("-----traing data characteristics and parameters")

print("mins :\n{}".format(scaler.data_min_))

print("maxs :\n{}".format(scaler.data_max_))

print("ranges:\n{}".format(scaler.data_range_))

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

# -----traing data characteristics and parameters

# mins :

# [ 6.98 9.71 43.79 143.50 0.05 0.02 0.00 0.00 0.11 0.05

# 0.12 0.36 0.76 6.80 0.00 0.00 0.00 0.00 0.01 0.00

# 7.93 12.02 50.41 185.20 0.07 0.03 0.00 0.00 0.16 0.06]

# maxs :

# [ 28.11 39.28 188.50 2501.00 0.16 0.29 0.43 0.20 0.30

# 0.10 2.87 4.88 21.98 542.20 0.03 0.14 0.40 0.05

# 0.06 0.03 36.04 49.54 251.20 4254.00 0.22 0.94 1.17

# 0.29 0.58 0.15]

# ranges:

# [ 21.13 29.57 144.71 2357.50 0.11 0.27 0.43 0.20 0.20

# 0.05 2.76 4.52 21.22 535.40 0.03 0.13 0.40 0.05

# 0.05 0.03 28.11 37.52 200.79 4068.80 0.15 0.91 1.17

# 0.29 0.42 0.09]

# scales:

# [ 0.05 0.03 0.01 0.00 9.03 3.74 2.34 4.97 5.05 21.97 0.36 0.22

# 0.05 0.00 33.99 7.51 2.53 18.94 19.26 34.55 0.04 0.03 0.00 0.00

# 6.60 1.10 0.85 3.44 2.38 10.71]

構築された変換器によりX_trainを変換すると、すべての特徴量について最小値が0、最大値が1となる。

X_train_scaled = scaler.transform(X_train)
print("-----scaled training data characteristics")
print("mins  :\n{}".format(X_train_scaled.min(axis=0)))
print("maxs  :\n{}".format(X_train_scaled.max(axis=0)))
print("ranges:\n{}".format(X_train_scaled.max(axis=0) - X_train_scaled.min(axis=0)))

# mins  :
# [0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
#  0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
#  0.00 0.00]
# maxs  :
# [1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00
#  1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00
#  1.00 1.00]
# ranges:
# [1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00
#  1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00
#  1.00 1.00]

X_train_scaled = scaler.transform(X_train)

print("-----scaled training data characteristics")

print("mins :\n{}".format(X_train_scaled.min(axis=0)))

print("maxs :\n{}".format(X_train_scaled.max(axis=0)))

print("ranges:\n{}".format(X_train_scaled.max(axis=0) - X_train_scaled.min(axis=0)))

# mins :

# [0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

# 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

# 0.00 0.00]

# maxs :

# [1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00

# 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00

# 1.00 1.00]

# ranges:

# [1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00

# 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00 1.00

# 1.00 1.00]

同じ変換器でテストデータも変換すると、変換後の特徴量の最小値・最大値は0、1になっていない。これはテストデータの最大値・最小値が必ずしも訓練データのそれらと一致しないので当然である。また、テストデータの最大値が訓練データの最大値よりも大きい場合は、テストデータの最大値が1を超えることになる。

X_test_scaled = scaler.transform(X_test)
print("-----scaled test data characteristics")
print("mins  :\n{}".format(X_test_scaled.min(axis=0)))
print("maxs  :\n{}".format(X_test_scaled.max(axis=0)))
print("ranges:\n{}".format(X_test_scaled.max(axis=0) - X_test_scaled.min(axis=0)))

# mins  :
# [ 0.03  0.02  0.03  0.01  0.14  0.04  0.00  0.00  0.15 -0.01 -0.00  0.01
#   0.00  0.00  0.04  0.01  0.00  0.00 -0.03  0.01  0.03  0.06  0.02  0.01
#   0.11  0.03  0.00  0.00 -0.00 -0.00]
# maxs  :
# [0.96 0.82 0.96 0.89 0.81 1.22 0.88 0.93 0.93 1.04 0.43 0.50 0.44 0.28
#  0.49 0.74 0.77 0.63 1.34 0.39 0.90 0.79 0.85 0.74 0.92 1.13 1.07 0.92
#  1.21 1.63]
# ranges:
# [0.92 0.79 0.92 0.88 0.67 1.18 0.88 0.93 0.78 1.04 0.43 0.49 0.44 0.28
#  0.45 0.73 0.77 0.63 1.37 0.38 0.87 0.74 0.83 0.74 0.81 1.11 1.07 0.92
#  1.21 1.63]

X_test_scaled = scaler.transform(X_test)

print("-----scaled test data characteristics")

print("mins :\n{}".format(X_test_scaled.min(axis=0)))

print("maxs :\n{}".format(X_test_scaled.max(axis=0)))

print("ranges:\n{}".format(X_test_scaled.max(axis=0) - X_test_scaled.min(axis=0)))

# mins :

# [ 0.03 0.02 0.03 0.01 0.14 0.04 0.00 0.00 0.15 -0.01 -0.00 0.01

# 0.00 0.00 0.04 0.01 0.00 0.00 -0.03 0.01 0.03 0.06 0.02 0.01

# 0.11 0.03 0.00 0.00 -0.00 -0.00]

# maxs :

# [0.96 0.82 0.96 0.89 0.81 1.22 0.88 0.93 0.93 1.04 0.43 0.50 0.44 0.28

# 0.49 0.74 0.77 0.63 1.34 0.39 0.90 0.79 0.85 0.74 0.92 1.13 1.07 0.92

# 1.21 1.63]

# ranges:

# [0.92 0.79 0.92 0.88 0.67 1.18 0.88 0.93 0.78 1.04 0.43 0.49 0.44 0.28

# 0.45 0.73 0.77 0.63 1.37 0.38 0.87 0.74 0.83 0.74 0.81 1.11 1.07 0.92

# 1.21 1.63]

テストデータで改めてfit()メソッドを実行してテストデータに適用するとレンジが0～1になるが、そうすると訓練データとテストデータで異なる変換を行うことになり、結果が歪んでしまう。

preprocessingの各種モデル

sklearn.preprocessingには多様な変換器が準備されているが、それらを目的ごとのカテゴリーに分けて整理する。

scaler～スケール変換

データの大きさやレンジを変換してそろえる。

MinMaxScaler: 各特徴量が0～1の範囲になるよう正規化する（線形変換）。
StandardScaler: 各特徴量の標本平均と標本分散を使って標準化する（線形変換）。
RobustScaler: 各特徴量の中央値と4分位数を使って標準化する（線形変換）。

normalization～正則化

特徴量ベクトルのノルムをそろえる。レンジをそろえる目的のscalerに比べて、元のデータ分布の相似性はなくなる。

Normalizer: 特徴量ベクトルのノルムを1にそろえる。

binalize～2値化

特徴量データを0/1の2値に分ける。

encoder～カテゴリーデータのエンコード

カテゴリーで与えられたデータ（性別、曜日など）をモデルで扱うために数値化する。

LabelEncoder: 1次元配列で与えられた特徴量クラスデータを、数値ラベルに変換する。
OrdinalEncoder: 2次元配列で与えられた特徴量クラスデータを、数値ラベルに変換する。
OneHotEncoder: 2次元配列で与えられた特徴量クラスデータを、特徴量ごとのインジケーター列に変換する。

スケール変換の頑健性

MinMaxScalerは計算過程が簡明だが、飛び離れた異常値がわずかでもあるとそれが全体のレンジを規定し、本来適用したいデータの値が歪んでしまう。StandardScalerやRobustScalerはこのような異常値に対して頑健な変換を行う。これら3つの頑健性についてはこちらで確認している。

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']]

OrdinalEncoder

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

概要

sklearn.preprocessingのOrdinalEncoderは、2次元のデータ（行数×列数＝データ数×特徴量数）を須知ラベルデータに変換する。

コンストラクターでencoderのインスタンスを生成
fit()メソッドに2次元の元データを与える（元データは2次元のリスト、ndarray、DataFrameは可）
元データの特徴量ごと（列ごと）にデータが数値ラベル化される
特徴量のカテゴリー数がn_classのとき、特徴量データが0～n_class−1の整数ラベルに変換される
1次元のデータを変換する場合も2次元に変形する必要がある
変換は全ての列が対象となり、定量的な数値データが含まれていてもそれらが数値ラベルに変換される

使い方

fit～ラベルの設定

以下の例では、3つの特徴量を持つ6つのデータを例題としている。特徴量は3つともクラスデータで、fit()メソッドで変換器の準備をする。

エンコーダーにおけるfit()は、特徴量ごとにクラスデータのラベルを設定し、変換器を準備する
フィッティングの後、categories_プロパティーにリストがセットされる
categories_はndarrayを要素とするリストで、各配列には特徴量ごとの重複を除いたクラス名が格納される
各特徴量のクラスはcategories_各要素の配列の先頭から数値ラベル0, 1, 2, …に対応している。

from sklearn.preprocessing import OrdinalEncoder

X = [
    ["Tokyo", "Male", "by air"],
    ["Tokyo", "Male", "by rail"],
    ["Osaka", "Female", "by rail"],
    ["Kyoto", "Female", "by bus"],
    ["Osaka", "Male", "by air"],
    ["Osaka", "Female", "by bus"]
]

oe = OrdinalEncoder()
oe.fit(X)
print(oe.categories_)
print(oe.categories_[0])
print(oe.categories_[1])
print(oe.categories_[2])

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

from sklearn.preprocessing import OrdinalEncoder

X = [

["Tokyo", "Male", "by air"],

["Tokyo", "Male", "by rail"],

["Osaka", "Female", "by rail"],

["Kyoto", "Female", "by bus"],

["Osaka", "Male", "by air"],

["Osaka", "Female", "by bus"]

]

oe = OrdinalEncoder()

oe.fit(X)

print(oe.categories_)

print(oe.categories_[0])

print(oe.categories_[1])

print(oe.categories_[2])

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

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

# ['Female' 'Male']

# ['by air' 'by bus' 'by rail']

transform～ラベルへの変換

この変換器のtransform()メソッドで元データを変換すると、元データと同じ次元・次数の2次元配列が得られ、各クラスデータが数値データに変換された結果が格納されている。

なお、OrdinalEncoderにもfit_transform()メソッドが準備されている。

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

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

X_trans = oe.transform(X)

print(X_trans)

# [[2. 1. 0.]

# [2. 1. 2.]

# [1. 0. 2.]

# [0. 0. 1.]

# [1. 1. 0.]

# [1. 0. 1.]]

1次元のデータを変換する場合でも、1×1の2次元とする必要があり、結果も2次元の配列で返される。

y = [["Kyoto", "Male", "by rail"]]
y_trans = oe.transform(y)
print(y_trans)

# [[0. 1. 2.]]

y = [["Kyoto", "Male", "by rail"]]

y_trans = oe.transform(y)

print(y_trans)

# [[0. 1. 2.]]

inverse_transform()で数値ラベルをクラスデータに逆変換可能。

print(oe.inverse_transform(y_trans))

# [['Kyoto' 'Male' 'by rail']]

print(oe.inverse_transform(y_trans))

# [['Kyoto' 'Male' 'by rail']]

categories_パラメーターについて

なおコンストラクターのcategories_パラメーターを指定できるが、これはあらかじめ特徴量のクラスデータがわかっている場合に、これらを全特徴量について指定する。この際、元データに含まれないクラスを含めてもよい。

oe = OrdinalEncoder(categories=[
    ["Tokyo", "Kyoto", "Osaka", "Nagoya"],
    ["Male", "Female"],
    ["by air", "by bus", "by rail"]])
oe.fit(X)

oe = OrdinalEncoder(categories=[

["Tokyo", "Kyoto", "Osaka", "Nagoya"],

["Male", "Female"],

["by air", "by bus", "by rail"]])

oe.fit(X)

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

クラスデータと数値データが混在する場合にOrdinalEncoderで変換すると、すべてのデータがクラスデータとみなされ、数値データもラベルに変換されてしまう。

以下の例では、最後の列の実数データも、1, 1.5, …, ５に対して0, 1, …, 5のラベルに変換されている。

X = [
    ["Tokyo", "Male", "by air", 1.5],
    ["Tokyo", "Male", "by rail", 3],
    ["Osaka", "Female", "by rail", 3.5],
    ["Kyoto", "Female", "by bus", 5],
    ["Osaka", "Male", "by air", 1],
    ["Osaka", "Female", "by bus", 4]
]

oe = OrdinalEncoder()
oe.fit(X)
X_trans = oe.transform(X)
print(X_trans)

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

X = [

["Tokyo", "Male", "by air", 1.5],

["Tokyo", "Male", "by rail", 3],

["Osaka", "Female", "by rail", 3.5],

["Kyoto", "Female", "by bus", 5],

["Osaka", "Male", "by air", 1],

["Osaka", "Female", "by bus", 4]

]

oe = OrdinalEncoder()

oe.fit(X)

X_trans = oe.transform(X)

print(X_trans)

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

# [2. 1. 2. 2.]

# [1. 0. 2. 3.]

# [0. 0. 1. 5.]

# [1. 1. 0. 0.]

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

このような場合は、クラスデータのみ取り出して変換させる。OrdinalEncoderはpandas.DataFrameを扱うことができるので、列操作のために元データをDataFrameとする。

import pandas as pd
df = pd.DataFrame(X, columns=["city", "gender", "transportation", "travel_time"])
print(df)

#     city  gender transportation  travel_time
# 0  Tokyo    Male         by air          1.5
# 1  Tokyo    Male        by rail          3.0
# 2  Osaka  Female        by rail          3.5
# 3  Kyoto  Female         by bus          5.0
# 4  Osaka    Male         by air          1.0
# 5  Osaka  Female         by bus          4.0

import pandas as pd

df = pd.DataFrame(X, columns=["city", "gender", "transportation", "travel_time"])

print(df)

# city gender transportation travel_time

# 0 Tokyo Male by air 1.5

# 1 Tokyo Male by rail 3.0

# 2 Osaka Female by rail 3.5

# 3 Kyoto Female by bus 5.0

# 4 Osaka Male by air 1.0

# 5 Osaka Female by bus 4.0

今回の例では、最初の3列がクラスデータなので、一時的なDataFrameにそれらを切出してOrdinalEncoderを適用する。transform()の結果はndarrayで戻るので、それを元のDataFrameの列に入れ替えている。

df_temp = df[["city", "gender", "transportation"]]
oe.fit(df_temp)
df_trans = oe.transform(df_temp)
print(df_trans)
print()
df[["city", "gender", "transportation"]] = df_trans
print(df)

# [[2. 1. 0.]
#  [2. 1. 2.]
#  [1. 0. 2.]
#  [0. 0. 1.]
#  [1. 1. 0.]
#  [1. 0. 1.]]
#
#    city  gender  transportation  travel_time
# 0   2.0     1.0             0.0          1.5
# 1   2.0     1.0             2.0          3.0
# 2   1.0     0.0             2.0          3.5
# 3   0.0     0.0             1.0          5.0
# 4   1.0     1.0             0.0          1.0
# 5   1.0     0.0             1.0          4.0

df_temp = df[["city", "gender", "transportation"]]

oe.fit(df_temp)

df_trans = oe.transform(df_temp)

print(df_trans)

print()

df[["city", "gender", "transportation"]] = df_trans

print(df)

# [[2. 1. 0.]

# [2. 1. 2.]

# [1. 0. 2.]

# [0. 0. 1.]

# [1. 1. 0.]

# [1. 0. 1.]]

# city gender transportation travel_time

# 0 2.0 1.0 0.0 1.5

# 1 2.0 1.0 2.0 3.0

# 2 1.0 0.0 2.0 3.5

# 3 0.0 0.0 1.0 5.0

# 4 1.0 1.0 0.0 1.0

# 5 1.0 0.0 1.0 4.0

最後の列はそのままで、その前の3列がラベルデータに変換されている。

概要

使い方

引数

戻り値

実行例

データの準備とモデルによる予測

基本的な使い方

要素のみを得る

要素の並び順を変更する

要素を正規化する～比率で表す

DataFrameによる扱い

ラベルの追加

合計欄

Multiindex

リストの初期化

問題

原因

解決

結論

概要

問題設定

appendメソッド

locプロパティーはインデックス指定に注意

DataFrameの領域を確保した場合

リストで確保した場合

ndarrayで確保した場合

列ごとのリストを加える方法はかなり速い

列ごとの辞書でDataFrameを生成する方法

列単位でリストを加えていく方法

列ごとのndarrayを加える方法

2次元リストから生成する方法がベスト

既存のDataFrameに追加する場合

まとめ

概要

使い方

リスト化した時の表現

引数の長さが違うとき

直接関係ないこと～zipper

概要

clear()メソッド

pop()メソッド

remove()メソッド

delete()メソッド

使い方

実行例

preprocessingの各種モデル

scaler～スケール変換

normalization～正則化

binalize～2値化

encoder～カテゴリーデータのエンコード

スケール変換の頑健性

概要

使い方

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

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

DataFrameによる操作

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

DataFrameの準備

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

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

inverse_transform()

新しいデータの変換

未知のクラスへの対処

概要

使い方

fit～ラベルの設定

transform～ラベルへの変換

categories_パラメーターについて

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

`clear()`メソッド

`pop()`メソッド

`remove()`メソッド

`delete()`メソッド