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

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列がラベルデータに変換されている。

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()を持たない。

リストの初期化

問題

原因

解決

結論

概要

問題設定

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()`メソッド