Python – 配列要素の重複数を制限する

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

概要

文字で表現するとわかり難いが、要するに次のようなことを想定している。たとえば次のような1次元の配列があるとする。

import numpy as np

np.random.seed(0)
targets = np.random.randint(0, 5, 20)

print(targets)
# [4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4]

print(np.bincount(targets))
# [5 5 2 4 4]

import numpy as np

np.random.seed(0)

targets = np.random.randint(0, 5, 20)

print(targets)

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

print(np.bincount(targets))

# [5 5 2 4 4]

この配列には20個の要素があり、0～4の数値がそれぞれ5個、5個、2個、2個、4個、4個、順不同で含まれている。

この配列において、各数値の数を最大でも3個以内となるように切り落としたい、というのが目標。

たとえば、機械学習の教師データの数がターゲットごとにばらついている場合、各ターゲットのデータ数をある程度の数以下に抑えたいときが想定される。

上の例で仮に早く出現した準から3つまでを残して後は捨てるとすれば、以下のような配列になる。

内容：4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4
個数：1 1 1 2 3 1 4 1 2 2 3 3 2 2 4 3 4 5 5 4

なお、単に1つの配列の要素を切り落とすだけでなく、これと対応する配列が別にあって、その要素についても同時に切り落とすことも想定する。これは、機械学習のターゲット配列でデータを制限するのに、これに紐づけられた画像データなどを格納した配列も同時に操作するイメージ。

手順

ターゲットごとのインデックスの取得

targetsの20個のデータのうちid=0について考える。targetsの要素のうち値が0のものは5個あり、それらのインデックスは(1, 9, 10, 14, 17)。同様にid=1についても5個あり、インデックスは(5, 13, 15, 16, 18)。

このようにしてid=0～4についてインデックスを書き出すと以下の通りになる。

0：1, 9, 10, 14, 17
1：5, 13, 15, 16, 18
2：7, 12
3：2, 3, 4, 6
4：0, 8, 11, 19

各idに対応する配列はnumpy.where()関数を用いて以下のように得られる。

for id in range(5):
    array = np.where(targets == id)[0]
    print("{}:{}".format(id, array))

# 0:[ 1  9 10 14 17]
# 1:[ 5 13 15 16 18]
# 2:[ 7 12]
# 3:[2 3 4 6]
# 4:[ 0  8 11 19]

for id in range(5):

array = np.where(targets == id)[0]

print("{}:{}".format(id, array))

# 0:[ 1 9 10 14 17]

# 1:[ 5 13 15 16 18]

# 2:[ 7 12]

# 3:[2 3 4 6]

# 4:[ 0 8 11 19]

上の例では、ループのidを0～4と変化させていくのにrange(5)を使っている。ところが一般的には、番号が連続して存在しているとは限らず、またその上限もわからない。

そこで、targetsに出てくる要素を重なりなく、かつ全て使うためにnumpy.unique()関数を使っている。unique()関数は引数の配列の要素の重複を除き、昇順・辞書順に並べてくれる。この引数にtargetsを渡して、要素の重なりを除けば、targets中の要素を重なりなく1つずつ参照できる。

print(np.unique(targets))
# [0 1 2 3 4]

for id in np.unique(targets):
    array = np.where(targets == id)[0]
    print("{}:{}".format(id, array))

# [ 1  9 10 14 17]
# [ 5 13 15 16 18]
# [ 7 12]
# [2 3 4 6]
# [ 0  8 11 19]

print(np.unique(targets))

# [0 1 2 3 4]

for id in np.unique(targets):

array = np.where(targets == id)[0]

print("{}:{}".format(id, array))

# [ 1 9 10 14 17]

# [ 5 13 15 16 18]

# [ 7 12]

# [2 3 4 6]

# [ 0 8 11 19]

取り出す要素の制限

次に、すべてのターゲットのデータ数が3個以下になるようにすることを考える。

これらのデータで各idの個数を3個以下にするのに、出現順位の早いものから3個を選び出すことを考える。

0：1, 9, 10, 14, 17
1：5, 13, 15, 16, 18
2：7, 12
3：2, 3, 4, 6
4：0, 8, 11, 19

各配列の最初の3個を取り出すには、各idに対応する配列の先頭から3個目までをスライスで取り出せばよい。

for id in np.unique(targets):
    array = np.where(targets == id)[0][:3]
    print("{}:{}".format(id, array))

# 0:[ 1  9 10]
# 1:[ 5 13 15]
# 2:[ 7 12]
# 3:[2 3 4]
# 4:[ 0  8 11]

for id in np.unique(targets):

array = np.where(targets == id)[0][:3]

print("{}:{}".format(id, array))

# 0:[ 1 9 10]

# 1:[ 5 13 15]

# 2:[ 7 12]

# 3:[2 3 4]

# 4:[ 0 8 11]

これで値の最大3個までとするのに取り出すべきtargets中のインデックスが得られた。

要素の抽出

targets配列の要素の個数を制限するには、上で絞り込まれたインデックスに対応する要素を残し、それ以外の要素を切り捨てる。そのためには、残すべきインデックス位置の値がTrue、その他のインデックス位置の値がFalseであるbool配列をつくり、これをtargetsの引数とすればよい。

この配列を例えばmaskという名前とすると、targetsと同じサイズですべての要素がFalseである配列としてmaskを準備し、先ほどの切り落とすべきインデックスの位置のみTrueにするとよい。

以下では、まず全要素がFalseでtargetsと同じサイズのbool配列を準備し、各idに対して3つ目までの要素の位置をTrue(1)としている。

ループの1回目で1、9、10番目がTrueになり、2回目で5、13、15番目がTrueに代わっていき、ループを重ねるごとに、取り出すべき要素の位置がTrueになっていることが確認できる。

なおbool配列の初期化では、Falseが数値の0と等価なため、numpy.zeros()関数を使っている。同じ理由で、numpy.where()でTrueをセットするときに、数値の1をセットしている。

mask = np.zeros(targets.size, dtype=np.bool)
print(mask)

# [False False False False False False False False False False False False
#  False False False False False False False False]

for target in np.unique(targets):
    mask[np.where(targets == target)[0][:3]] = 1
    print(mask)

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

mask = np.zeros(targets.size, dtype=np.bool)

print(mask)

# [False False False False False False False False False False False False

# False False False False False False False False]

for target in np.unique(targets):

mask[np.where(targets == target)[0][:3]] = 1

print(mask)

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

# False False False False False False False False]

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

# False True False True False False False False]

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

# True True False True False False False False]

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

# True True False True False False False False]

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

# True True False True False False False False]

最後に、このbool配列をtargetsに適用して、取り出すべき要素の配列を得る。

print(targets[mask])
# [4 0 3 3 3 1 2 4 0 0 4 2 1 1]

print(np.bincount(targets[mask]))
# [3 3 2 3 3]

print(targets[mask])

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

print(np.bincount(targets[mask]))

# [3 3 2 3 3]

他の配列の同時操作

mask配列は、targetsと同じサイズを持つ次元の配列に繰り返し適用できるので、たとえば機械学習でtargetsの各要素に紐づけられた画像データなどを格納した配列などについても、targetsと整合させながら必要な分だけ切出すことができる。

numpy – bincount

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

概要

numpy.bincount()関数の仕様

整数型の配列を引数にとる
配列中、同じ値の要素の個数をカウントする
0～要素の最大値を要素とし、各要素番号に対応する値の個数を要素とする配列を返す
元のデータの要素ごとの重みを指定することができる

使い方

基本形

引数で与えた整数型配列中の同じ値をカウントして、各値ごとの個数を要素とする配列を返す。

import numpy as np

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

# [1 2 3 2]

import numpy as np

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

print(np.bincount(a))

# [1 2 3 2]

上の結果の意味は、0が1個、1が2個、2が3個、3が2個。

値が飛んでいる場合

引数の配列中、0～最大値までの整数値に対する数をカウントする。値が存在しない場合の個数は0。

b = np.array([1, 3, 3, 5, 5, 5])
print(np.bincount(b))

# [0 1 0 2 0 3]

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

print(np.bincount(b))

# [0 1 0 2 0 3]

上の例では、0～5までの個数がカウントされ、0, 2, 4は配列中に存在しないので0となっている。

順不同

引数の配列中の要素は昇順である必要はない。

c = np.array([2, 2, 3, 3, 3, 1])
print(np.bincount(c))

# [0 1 2 3]

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

print(np.bincount(c))

# [0 1 2 3]

`weights`の意味

引数にweightsを指定する場合。

データの配列と同じ要素数のweightsの配列を与える。
要素をカウントの場合に1ずつ足すのではなく、各要素の位置に対応した重みが加算されていく

w = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])
d = np.array([1, 2, 4, 2, 4, 4])
print(np.bincount(d, weights=w))

# [0.  0.1 0.6 0.  1.4]

w = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])

d = np.array([1, 2, 4, 2, 4, 4])

print(np.bincount(d, weights=w))

# [0. 0.1 0.6 0. 1.4]

上の例では以下のように動作している。

0は存在しないので0
1は0番目に1つだけ存在し、その位置のweightsの値は0.1
2は1番目と3番目に存在するので、weightsの第1要素0.2と第3要素0.4を加えて0.6
3は存在しないので0
4は2番目、4番目、5番目にあるので、weightsの第2要素0.3、第4要素0.5、第5要素0.6を加えて1.4

Python – 平均・分散・共分散

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

1次元配列の場合

平均

平均はmean()メソッドで計算。

import numpy as np

x = np.array([1, 1, 2, 3, 5, 8, 13, 21, 34, 55])

n = x.size
s = x.sum()
m = x.mean()

print(m, s / n)
# 14.3 14.3

import numpy as np

x = np.array([1, 1, 2, 3, 5, 8, 13, 21, 34, 55])

n = x.size

s = x.sum()

m = x.mean()

print(m, s / n)

# 14.3 14.3

分散・標準偏差

標本分散・標本標準偏差

分散はvar()メソッド、標準偏差はstd()メソッドで計算。デフォルトでは標本分散と標本標準偏差。

v = x.var()
sv = x.std()

print(v, np.sum((x - m)**2) / n)
# 285.01000000000005 285.01000000000005

print(sv, np.sqrt(v))
# 16.88223918797504 16.88223918797504

v = x.var()

sv = x.std()

print(v, np.sum((x - m)**2) / n)

# 285.01000000000005 285.01000000000005

print(sv, np.sqrt(v))

# 16.88223918797504 16.88223918797504

不偏推定量

分散の算出では、引数ddof (delta degrees of freedom)で指定した引数をデータ数nから引いた数で偏差の二乗和を割る。デフォルトではddof=0なので標本分散、標本標準偏差になるが、ddof=1を指定すると、不偏分散、標準偏差の不偏推定量が計算される。

u = x.var(ddof=1)
su = x.std(ddof=1)

print(u, np.sum((x - m)**2) / (n - 1))
# 316.6777777777778 316.6777777777778

print(su, np.sqrt(u))
# 17.795442612584207 17.795442612584207

u = x.var(ddof=1)

su = x.std(ddof=1)

print(u, np.sum((x - m)**2) / (n - 1))

# 316.6777777777778 316.6777777777778

print(su, np.sqrt(u))

# 17.795442612584207 17.795442612584207

2次元配列の場合

平均

平均はmean()メソッドで計算。引数axis=0/1で列方向／行方向の計算方向を指定。計算結果は1次元配列で、要素数は列方向の平均なら行数、行方向の平均なら列数と同じになる。

X = np.array([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]).reshape(-1, 2)

n = X.shape[0]
s = X.sum(axis=0)
m = X.mean(axis=0)

print(m, s / n)
# [11.  17.6] [11.  17.6]

X = np.array([1, 1, 2, 3, 5, 8, 13, 21, 34, 55]).reshape(-1, 2)

n = X.shape[0]

s = X.sum(axis=0)

m = X.mean(axis=0)

print(m, s / n)

# [11. 17.6] [11. 17.6]

分散・標準偏差

標本分散・標本標準偏差

分散はvar()メソッド、標準偏差はstd()メソッドで計算。デフォルトでは標本分散、標本標準偏差を計算。デフォルトでは標本分散、標本標準偏差。

v = X.var(axis=0)

print(v, np.sum((X - m)**2, axis=0) / n)
# [150.   398.24] [150.   398.24]

v = X.var(axis=0)

print(v, np.sum((X - m)**2, axis=0) / n)

# [150. 398.24] [150. 398.24]

不偏推定量

引数ddof=1を指定すると、データ数nからddof=1を引いた数で偏差の二乗和が割られ、不偏分散、標準偏差の不偏推定量が計算される。

u = X.var(axis=0, ddof=1)

print(u, np.sum((X - m)**2, axis=0) / (n - 1))
# [187.5 497.8] [187.5 497.8]

u = X.var(axis=0, ddof=1)

print(u, np.sum((X - m)**2, axis=0) / (n - 1))

# [187.5 497.8] [187.5 497.8]

共分散

cov()メソッドで二つのデータの共分散行列を計算する。結果は2次元配列で得られ、対角要素は各データの分散、対角要素以外の要素は行数・列数に対応する共分散。

デフォルトでは引数bias=Falseとなっていて、偏差の積和をn−1で割った不偏推定量が計算される。

print(np.cov(X[:, 0], X[:, 1]))
# [[187.5 305.5]
#  [305.5 497.8]]

Xd = X - m
print(np.sum(Xd[:, 0] * Xd[:, 1]) / (n - 1))
# 305.5

print(np.cov(X[:, 0], X[:, 1]))

# [[187.5 305.5]

# [305.5 497.8]]

Xd = X - m

print(np.sum(Xd[:, 0] * Xd[:, 1]) / (n - 1))

# 305.5

bias=Trueを指定すると、偏差の積和を割る数がnとなり、標本に対する分散・共分散が計算される。

print(np.cov(X[:, 0], X[:, 1], bias=True))
# [[150.   244.4 ]
#  [244.4  398.24]]

print(np.sum(Xd[:, 0] * Xd[:, 1]) / n)
# 244.4

print(np.cov(X[:, 0], X[:, 1], bias=True))

# [[150. 244.4 ]

# [244.4 398.24]]

print(np.sum(Xd[:, 0] * Xd[:, 1]) / n)

# 244.4

Python – 行・列単位の合計・率の計算

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

概要

2次元のndarrayやDataFrameで、行単位や列単位での合計を計算したり、それを使って行単位／列単位の率を計算する方法。

2次元のndarrayの場合は、

合計はsum()メソッドの引数にaxisを指定
- 列和ならaxis=0、行和ならaxis=1
- 結果は1次元配列で得られる
率の計算はこれらの合計の配列を使うが、列和に対する各列要素の率なら1次元配列の行ベクトルのまま、行和に対する各行要素の率なら2次元の列ベクトルに変換して除算

DataFrameの場合、まず合計を求めるには、

合計はsum()メソッドの引数にaxisを指定
- 列和ならaxis=0、行和ならaxis=1
- 結果はSeriesオブジェクトで得られる

その上で率の計算には2通りある。1つ目はSeriesオブジェクトの内容をndarrayとして取り出して計算する方法で、

Series.valuesで列和／行和の配列を取り出し、ndarrayの場合と同じ方法で計算する

もう1つの方法はSeriesオブジェクトのままでdiv()メソッドにaxisを指定する方法で、

列和に対する各列要素の率を計算するには、div(列和Series, axis=1)
行和に対する各行要素の率を計算するには、div(列和Series, axis=0)

`ndarray`の場合

確認

まず確認のために、以下の配列を準備する。

import numpy as np

a = np.arange(1, 10).reshape(3, 3)
vrow = np.arange(1, 4)
vcol = np.arange(1, 4).reshape(-1, 1)

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

print(vrow)
# [1 2 3]

print(vcol)
# [[1]
#  [2]
#  [3]]
# ]

import numpy as np

a = np.arange(1, 10).reshape(3, 3)

vrow = np.arange(1, 4)

vcol = np.arange(1, 4).reshape(-1, 1)

print(a)

# [[1 2 3]

# [4 5 6]

# [7 8 9]]

print(vrow)

# [1 2 3]

print(vcol)

# [[1]

# [2]

# [3]]

# ]

行ベクトルを2次元配列に加えると、配列の各行に対して行ベクトルが加えらえる。

print(a + vrow)

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

print(a + vrow)

# [[ 2 4 6]

# [ 5 7 9]

# [ 8 10 12]]

列ベクトルを2次元配列に加えると、配列の各列に対して列ベクトルが加えられる。

print(a + vcol)

# [[ 2  3  4]
#  [ 6  7  8]
#  [10 11 12]]

print(a + vcol)

# [[ 2 3 4]

# [ 6 7 8]

# [10 11 12]]

つまり、ndarrayの2次元配列に行または列のベクトルを加えると、加える方のベクトルの形状に合わせて各行／列に演算が実行される。これは他のオペレーターについても同じ。

この演算は直感的にも分かりやすく、列ごと／行ごとの小計に対する比率の計算も思い浮かべることができる。

合計

ndarrayの各列／行に沿った合計を計算する。合計計算はndarrayのsum()メソッドを使うが、引数を省略すると全要素の和となる。引数にaxis=0を指定すると列方向に処理がされ（つまり配列の各列の要素が列方向に足され）、axis=1を指定すると行方向に処理がされる（つまり配列の各行の要素が行方向に足される）。

以下の例は、最初に使った2次元配列の列方向の和（の行ベクトル）と行方向の和（の列ベクトル）を計算している。

sums_along_cols = a.sum(axis=0)
sums_along_rows = a.sum(axis=1).reshape(-1, 1)

print(sums_along_cols)
# [12 15 18]

print(sums_along_rows)
# [[ 6]
#  [15]
#  [24]]

sums_along_cols = a.sum(axis=0)

sums_along_rows = a.sum(axis=1).reshape(-1, 1)

print(sums_along_cols)

# [12 15 18]

print(sums_along_rows)

# [[ 6]

# [15]

# [24]]

率の計算

2次元配列を行合計ベクトルで割ると、各行の要素が合計ベクトルの各要素で割られる（各列の行要素の合計は1になる）。

print(a / sums_along_cols)

# [[0.08333333 0.13333333 0.16666667]
#  [0.33333333 0.33333333 0.33333333]
#  [0.58333333 0.53333333 0.5       ]]

# NOTE
# 1/12 2/15 3/18
# 4/12 5/15 6/18
# 7/12 8/15 9/18

print(a / sums_along_cols)

# [[0.08333333 0.13333333 0.16666667]

# [0.33333333 0.33333333 0.33333333]

# [0.58333333 0.53333333 0.5 ]]

# NOTE

# 1/12 2/15 3/18

# 4/12 5/15 6/18

# 7/12 8/15 9/18

また、2次元配列を列合計ベクトルで割ると、各列の要素が合計ベクトルの各要素で割られる。繰り返しになるが、この場合の合計ベクトルは2次元の列ベクトルになっている。

print(a / sums_along_rows)

# [[0.16666667 0.33333333 0.5       ]
#  [0.26666667 0.33333333 0.4       ]
#  [0.29166667 0.33333333 0.375     ]]

# NOTE
#  1/6  2/6  3/6
# 4/15 5/15 6/15
# 7/24 8/24 9/24

print(a / sums_along_rows)

# [[0.16666667 0.33333333 0.5 ]

# [0.26666667 0.33333333 0.4 ]

# [0.29166667 0.33333333 0.375 ]]

# NOTE

# 1/6 2/6 3/6

# 4/15 5/15 6/15

# 7/24 8/24 9/24

以下の図のように、この

`DataFrame`の場合

確認

まず確認のために、以下のDataFrameとSeriesを準備する。2次元配列はndarrayの例と同じものを流用。

import pandas as pd

df = pd.DataFrame(a)
sr = pd.Series(np.arange(1, 4))

print(df)
#    0  1  2
# 0  1  2  3
# 1  4  5  6
# 2  7  8  9

import pandas as pd

df = pd.DataFrame(a)

sr = pd.Series(np.arange(1, 4))

print(df)

# 0 1 2

# 0 1 2 3

# 1 4 5 6

# 2 7 8 9

合計ベクトルが`ndarray`の場合

演算をほどこすベクトルがndarrayの場合、2次元配列の時と同じように、ベクトルが行／列によって自動的に加えられる方向が決められる。

vrow = np.arange(1, 4)
vcol = np.arange(1, 4).reshape(-1, 1)

print(vrow)
# [1 2 3]

print(vcol)
# [[1]
#  [2]
#  [3]]

print(df + vrow)
#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df + vcol)
#     0   1   2
# 0   2   3   4
# 1   6   7   8
# 2  10  11  12

vrow = np.arange(1, 4)

vcol = np.arange(1, 4).reshape(-1, 1)

print(vrow)

# [1 2 3]

print(vcol)

# [[1]

# [2]

# [3]]

print(df + vrow)

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

print(df + vcol)

# 0 1 2

# 0 2 3 4

# 1 6 7 8

# 2 10 11 12

合計ベクトルが`Series`の場合

DataFrameのsum()メソッドで行や列の合計を計算するとSeriesオブジェクトで結果が得られるため、その挙動を確認しておく。

sr = pd.Series(np.arange(1, 4))
print(sr)

0    1
1    2
2    3
dtype: int32

sr = pd.Series(np.arange(1, 4))

print(sr)

0 1

1 2

2 3

dtype: int32

Seriesを単純にDataFrameと演算子で結ぶと、行ベクトルとして扱われる。

print(df + sr)

#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df + sr)

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

Seriesは行・列の概念を持たないが、演算の方向を明示するのに以下の方法をとる。

演算子の代わりに演算メソッドを使う
演算メソッドの引数axisで演算の方向を指定する

print(df.add(sr, axis=0))

#     0   1   2
# 0   2   3   4
# 1   6   7   8
# 2  10  11  12

print(df.add(sr, axis=1))

#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df.add(sr, axis=0))

# 0 1 2

# 0 2 3 4

# 1 6 7 8

# 2 10 11 12

print(df.add(sr, axis=1))

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

演算子に対応するメソッドは、add、sub、mul、div、mod、powが準備されている。

合計

列／行ごとの合計は、ndarrayと同じくDataFrameのsum()メソッドで引数axisを指定して計算する。

sums_along_cols = df.sum(axis=0)
sums_along_rows = df.sum(axis=1)

print(sums_along_cols)
# 0    12
# 1    15
# 2    18
# dtype: int64

print(sums_along_rows)
# 0     6
# 1    15
# 2    24
# dtype: int64

sums_along_cols = df.sum(axis=0)

sums_along_rows = df.sum(axis=1)

print(sums_along_cols)

# 0 12

# 1 15

# 2 18

# dtype: int64

print(sums_along_rows)

# 0 6

# 1 15

# 2 24

# dtype: int64

率の計算

`Series`を`ndarray`で取り出して計算する方法

Seriesのvaluesプロパティーでその内容をndarrayとして取り出せる。

列和に対しては、それを行ベクトルのまま除算すれば、各列の要素を行ベクトルの対応する要素で割った値となる。

print(df / sums_along_cols.values)

#           0         1         2
# 0  0.083333  0.133333  0.166667
# 1  0.333333  0.333333  0.333333
# 2  0.583333  0.533333  0.500000

print(df / sums_along_cols.values)

# 0 1 2

# 0 0.083333 0.133333 0.166667

# 1 0.333333 0.333333 0.333333

# 2 0.583333 0.533333 0.500000

行和に対しては、ndarrayを1列の列ベクトルに変換して除算すれば、各行の要素を列ベクトルの対応する要素で割った値となる。

print(df / sums_along_rows.values.reshape(-1, 1))

#           0         1      2
# 0  0.166667  0.333333  0.500
# 1  0.266667  0.333333  0.400
# 2  0.291667  0.333333  0.375

print(df / sums_along_rows.values.reshape(-1, 1))

# 0 1 2

# 0 0.166667 0.333333 0.500

# 1 0.266667 0.333333 0.400

# 2 0.291667 0.333333 0.375

`Series`のままで計算する方法

合計Seriesをそのまま使って除算する場合はDataFrameのdiv()メソッドを使いaxisを指定するが、axisの指定の仕方に注意が必要。

列和で除算する場合は、その各要素が各行の各要素に対応するため、列和を行ベクトルとみて各行に除算を適用する(axis=1)。

print(df.div(sums_along_cols, axis=1))

#           0         1         2
# 0  0.083333  0.133333  0.166667
# 1  0.333333  0.333333  0.333333
# 2  0.583333  0.533333  0.500000

print(df.div(sums_along_cols, axis=1))

# 0 1 2

# 0 0.083333 0.133333 0.166667

# 1 0.333333 0.333333 0.333333

# 2 0.583333 0.533333 0.500000

分かりにくいので図示すると以下のようになる。まず合計を求めるのにsum()メソッドでaxis=0として列和を求める。この合計で各要素を割るのに1列目の要素は合計の1つ目の要素、2列目の要素は合計の2つ目の要素・・・で割る必要があるので、div()メソッドでaxis=1とする。こうすると合計のSeriesは行ベクトルとみなされて、それが各行の要素に適用される。

行和で除算する場合は、その各要素が各列の各要素に対応するため、行和を列ベクトルとみて各列に除算を適用する(axis=0)。

print(df.div(sums_along_rows, axis=0))

#           0         1      2
# 0  0.166667  0.333333  0.500
# 1  0.266667  0.333333  0.400
# 2  0.291667  0.333333  0.375

print(df.div(sums_along_rows, axis=0))

# 0 1 2

# 0 0.166667 0.333333 0.500

# 1 0.266667 0.333333 0.400

# 2 0.291667 0.333333 0.375

これも分かりにくいので以下のように図示する。合計を求めるのにsum()メソッドでaxis=1として行和を求める。この合計で各要素を割るのに1行目の要素は合計の1つ目の要素、2行目の要素は合計の2つ目の要素・・・で割る必要があるので、div()メソッドでaxis=1とする。こうすると合計のSeriesは列ベクトルとみなされて、それが各列の要素に適用される。

このように、div()のような演算子メソッドでaxisを使う方法はややこしい（少なくとも私には）。

実行速度

各計算方法の実行速度には、あまり大きな差は出なかった。

import numpy as np
import pandas as pd
import time

counter = 100

a = np.arange(1000000).reshape(1000, 1000)
df = pd.DataFrame(a)

sum_of_cols = df.sum(axis=0)
sum_of_rows = df.sum(axis=1)

t0 = time.time()

for n in range(counter):
    df.values / sum_of_cols.values
t_array_c = time.time()
print(t_array_c - t0)

for n in range(counter):
    df.values / sum_of_rows.values.reshape(-1, 1)
t_array_r = time.time()
print(t_array_r - t_array_c)

for n in range(counter):
    df / sum_of_cols.values
t_df_array_c = time.time()
print(t_df_array_c - t_array_r)

for n in range(counter):
    df / sum_of_rows.values.reshape(-1, 1)
t_df_array_r = time.time()
print(t_df_array_r - t_df_array_c)

for n in range(counter):
    df.div(sum_of_cols, axis=1)
t_df_div_c = time.time()
print(t_df_div_c - t_df_array_r)

for n in range(counter):
    df.div(sum_of_rows, axis=0)
t_df_div_r = time.time()
print(t_df_div_r - t_df_div_c)

import numpy as np

import pandas as pd

import time

counter = 100

a = np.arange(1000000).reshape(1000, 1000)

df = pd.DataFrame(a)

sum_of_cols = df.sum(axis=0)

sum_of_rows = df.sum(axis=1)

t0 = time.time()

for n in range(counter):

df.values / sum_of_cols.values

t_array_c = time.time()

print(t_array_c - t0)

for n in range(counter):

df.values / sum_of_rows.values.reshape(-1, 1)

t_array_r = time.time()

print(t_array_r - t_array_c)

for n in range(counter):

df / sum_of_cols.values

t_df_array_c = time.time()

print(t_df_array_c - t_array_r)

for n in range(counter):

df / sum_of_rows.values.reshape(-1, 1)

t_df_array_r = time.time()

print(t_df_array_r - t_df_array_c)

for n in range(counter):

df.div(sum_of_cols, axis=1)

t_df_div_c = time.time()

print(t_df_div_c - t_df_array_r)

for n in range(counter):

df.div(sum_of_rows, axis=0)

t_df_div_r = time.time()

print(t_df_div_r - t_df_div_c)

実行時間は以下の通りで、各計算手法の間に差はない。敢えて言えば、DataFrameを使った場合に僅かに時間がかかっている。

0.4757249355316162
0.4577751159667969
0.524827241897583
0.5440847873687744
0.5674364566802979
0.5242717266082764

0.4757249355316162

0.4577751159667969

0.524827241897583

0.5440847873687744

0.5674364566802979

0.5242717266082764

なお、この計算はpandasのバージョン1.1.4で実行したが、upgrade前のバージョン0では、3つ目と5つ目、DataFrameで行単位の演算を行うときに20秒台と2桁長い時間がかかっていた。

axisの方向

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

概要

配列などのメソッドの引数で指定するaxis=0/1について確認。

axis=0は配列やDataFrameを列単位で捉えて、その列の中で処理を行いながら、すべての列に対して処理が行われる
- SerieseオブジェクトがDataFrameの処理の対象となる場合は列として扱われ、DataFrameの各列を処理しながらすべての列に適用される
axis=1は配列やDataFrameを行単位で捉えて、その行の中で処理を行いながら、すべての行に対して処理が行われる。
- SerieseオブジェクトがDataFrameの処理の対象となる場合は行として扱われ、DataFrameの各行を処理しながらすべての行に適用される

`ndarray`の場合

まずndarrayの2次元配列で確認する。

ary = np.arange(1, 7).reshape(2, 3)
print(ary)

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

ary = np.arange(1, 7).reshape(2, 3)

print(ary)

# [[1 2 3]

# [4 5 6]]

`max()`メソッド

axis=0は列単位で各列の最大値を探し、それらを要素とする配列（要素数＝列数の1次元配列）
axis=1は行単位で各行の最大値を探し、それらを要素とする配列（要素数＝行数の1次元配列）

print(ary.max(axis=0))
# [4 5 6]

print(ary.max(axis=1))
# [3 6]

print(ary.max(axis=0))

# [4 5 6]

print(ary.max(axis=1))

# [3 6]

`sum()`メソッド

axis=0は列単位で各列の合計を要素とする配列（要素数＝列数の1次元配列）
axis=1は行単位で各行の合計を要素とする配列（要素数＝行数の1次元配列）

print(ary.sum(axis=0))
# [5 7 9]

print(ary.sum(axis=1))
# [ 6 15]

print(ary.sum(axis=0))

# [5 7 9]

print(ary.sum(axis=1))

# [ 6 15]

`repeat()`メソッド

axis=0は列単位で各列の要素が指定回数繰り返される
axis=1は行単位で各行の要素が指定回数繰り返される

print(ary.repeat(2, axis=0))

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

print(ary.repeat(2, axis=1))

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

print(ary.repeat(2, axis=0))

# [[1 2 3]

# [1 2 3]

# [4 5 6]

# [4 5 6]]

print(ary.repeat(2, axis=1))

# [[1 1 2 2 3 3]

# [4 4 5 5 6 6]]

図による理解

sum()メソッドを例に、axis=0/1に対する挙動を図にすると、以下のようになる。

`DataFrame`の場合

以下のDataFrameとSeriesオブジェクトで確認する。Seriesオブジェクトは行として扱われ、array_like、1次元の配列でも同じ結果になる。

df = pd.DataFrame(np.arnge(1, 9).reshape(3, 3))
sr = pd.Series(np.arange(1, 3))

print(df)

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

print(sr)

# 0    1
# 1    2
# 2    3
# dtype: int32

df = pd.DataFrame(np.arnge(1, 9).reshape(3, 3))

sr = pd.Series(np.arange(1, 3))

print(df)

# 0 1 2

# 0 1 2 3

# 1 4 5 6

# 2 7 8 9

print(sr)

# 0 1

# 1 2

# 2 3

# dtype: int32

`min()`メソッドなど

min、max、sumなどのメソッドの考え方はndarrayと同じ挙動。

`add()`などの演算メソッド

DataFrameには演算子による演算の代替となるメソッドがある（add、sub、mul、div、mod、pow）。addメソッドを例にとると、以下のように引数を指定。

add(array_like, axis=0/1)

axis=0はarray_likeを列とみなして、DataFrameオブジェクトの各列の要素との和を計算する
axis=1はarray_likeを行とみなして、DataFrameオブジェクトの各行の要素との和を計算する

print(df.add(sr, axis=0))

#     0   1   2
# 0   2   3   4
# 1   6   7   8
# 2  10  11  12

print(df.add(sr, axis=1))

#    0   1   2
# 0  2   4   6
# 1  5   7   9
# 2  8  10  12

print(df.add(sr, axis=0))

# 0 1 2

# 0 2 3 4

# 1 6 7 8

# 2 10 11 12

print(df.add(sr, axis=1))

# 0 1 2

# 0 2 4 6

# 1 5 7 9

# 2 8 10 12

`apply()`メソッド

applyメソッドは、行または列を指定した関数に渡す。

axis=0はDataFrameオブジェクトの各列を指定した関数に渡す
axis=1はDataFrameオブジェクトの各行を指定した関数に渡す

print(df.apply(lambda x: sum(x) / 3, axis=0))

# 0    4.0
# 1    5.0
# 2    6.0
# dtype: float64

print(df.apply(lambda x: sum(x) / 3, axis=1))

# 0    2.0
# 1    5.0
# 2    8.0
# dtype: float64

print(df.apply(lambda x: sum(x) / 3, axis=0))

# 0 4.0

# 1 5.0

# 2 6.0

# dtype: float64

print(df.apply(lambda x: sum(x) / 3, axis=1))

# 0 2.0

# 1 5.0

# 2 8.0

# dtype: float64

演算メソッドの図による理解

演算メソッドは少し挙動が違うので図で整理しておく。1次元のarray_likeオブジェクトがaxisの指定によって列／行としてみなされる点に注意。

補足

1次元配列の場合

1次元配列に対してaxis引数を使う場合、行ベクトルとしてaxis=1に反応しそうだが、実際にはaxis=0で各要素に対する処理が行われる。axis=1を指定すると、たとえば以下のようなエラーになる。

ary.min(axis=1)->numpy.AxisError: axis 1 is out of bounds for array of dimension 1

1	ary.min(axis=1)->numpy.AxisError: axis 1 is out of bounds for array of dimension 1

元々多次元配列を意図した引数なので、1次元配列に使うのはナンセンスだろう（axis=0を行単位の処理にしておけば自然ではあったかもしれないが）。

1行の2次元配列の場合

1行の配列（1つの1次元配列を要素に持つ2次元配列：行ベクトル）に対するaxisの効果を、sumメソッドで見てみる。

ary = np.arange(1, 4).reshape(1, -1)
print(ary)
# [[1 2 3]]

print(ary.sum(axis=0))
# [1 2 3]

print(ary.sum(axis=1))
# [6]

ary = np.arange(1, 4).reshape(1, -1)

print(ary)

# [[1 2 3]]

print(ary.sum(axis=0))

# [1 2 3]

print(ary.sum(axis=1))

# [6]

axis=0の場合は各要素が1要素の列ベクトルとみなされ、3つの列（要素）ごとに処理される。その結果は3つの要素を持つ1次元配列（行ベクトル）となる。

axis=1の場合は行ベクトル全体が1つの行とみなされ、それらの要素に対して処理がされる。その結果は1つの数値となるが、1つの要素を持つ1次元配列で返される。

1列の2次元配列の場合

1列の配列（列ベクトル）に対するaxisの効果を、sumメソッドで見てみる。

ary = np.arange(1, 4).reshape(-1, 1)
print(ary)
# [[1]
#  [2]
#  [3]]

print(ary.sum(axis=0))
# [6]

print(ary.sum(axis=1))
# [1 2 3]

ary = np.arange(1, 4).reshape(-1, 1)

print(ary)

# [[1]

# [2]

# [3]]

print(ary.sum(axis=0))

# [6]

print(ary.sum(axis=1))

# [1 2 3]

axis=0の場合は3つの要素を持つ1つの列に対して処理される。その結果は1つの数値となるが、1つの要素を持つ1次元配列で返される。

axis=1の場合は列の各要素が1要素の行とみなされ、3つの行（要素）ごとに処理される。その結果は3つの要素を持つ列ベクトルだが、3つの要素を持つ1次元配列（行ベクトル）で返される。

ndarrayの書式設定 – printoptions

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

概要

配列をprintで表示させようとして、書式設定でよく間違える。たとえば以下のように。

import numpy as np

a = np.array([0.0123, 1.2345, 12.3456789])
print("{:.3f}".format(a))
# TypeError: unsupported format string passed to numpy.ndarray.__format__

import numpy as np

a = np.array([0.0123, 1.2345, 12.3456789])

print("{:.3f}".format(a))

# TypeError: unsupported format string passed to numpy.ndarray.__format__

配列の各要素の書式を指定して表示させたい場合、formatメソッドではなく、Numpyのset_printoptionsを使う必要がある。

`get_printoptions()`

配列の書式オプションの一覧は、numpy.get_printoptions()で得られる。各オプションは辞書形式で保存されている。

import numpy as np

options = np.get_printoptions()

for k, v in zip(options.keys(), options.values()):
    print("{:<9}: {}".format(k, v))

# edgeitems: 3
# threshold: 1000
# floatmode: maxprec
# precision: 8
# suppress : False
# linewidth: 75
# nanstr   : nan
# infstr   : inf
# sign     : -
# formatter: None
# legacy   : False

import numpy as np

options = np.get_printoptions()

for k, v in zip(options.keys(), options.values()):

print("{:<9}: {}".format(k, v))

# edgeitems: 3

# threshold: 1000

# floatmode: maxprec

# precision: 8

# suppress : False

# linewidth: 75

# nanstr : nan

# infstr : inf

# sign : -

# formatter: None

# legacy : False

`set_printoptions()`

これらのオプションを個別に設定するにはnumpy.set_printoptions()メソッドでキーと値を指定する。

numpy.set_printoptions([キー]=[値])

よく使いそうないくつかのオプションについてまとめる。

省略表示

`threshold`と`edgeitems`

要素数（列数・行数）がthresholdに指定した値を越えた場合に省略表示する。

np.set_printoptions(threshold=20)

print(np.arange(20))
# [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

print(np.arange(21))
# [ 0  1  2 ... 18 19 20]

np.set_printoptions(threshold=20)

print(np.arange(20))

# [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]

print(np.arange(21))

# [ 0 1 2 ... 18 19 20]

edgeitemsは省略時に表示する要素数（列数・行数）を指定する。

np.set_printoptions(edgeitems=5)

print(np.arange(40))

# [ 0  1  2  3  4 ... 35 36 37 38 39]

np.set_printoptions(edgeitems=5)

print(np.arange(40))

# [ 0 1 2 3 4 ... 35 36 37 38 39]

threshold=0を指定すると、edgeitemsの値を超えると常に省略表示する（デフォルトの場合、edgeitems=3を越えると省略表示）。

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

print(np.arange(6))
# [0 1 2 3 4 5]

print(np.arange(7))
# [0 1 2 ... 4 5 6]

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

print(np.arange(6))

# [0 1 2 3 4 5]

print(np.arange(7))

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

2次元配列の行も同じ条件で省略表示される。

print(np.arange(36).reshape(6, 6))

# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]
#  [12 13 14 15 16 17]
#  [18 19 20 21 22 23]
#  [24 25 26 27 28 29]
#  [30 31 32 33 34 35]]

print(np.arange(49).reshape(7, 7))

# [[ 0  1  2 ...  4  5  6]
#  [ 7  8  9 ... 11 12 13]
#  [14 15 16 ... 18 19 20]
#  ...
#  [28 29 30 ... 32 33 34]
#  [35 36 37 ... 39 40 41]
#  [42 43 44 ... 46 47 48]]

print(np.arange(36).reshape(6, 6))

# [[ 0 1 2 3 4 5]

# [ 6 7 8 9 10 11]

# [12 13 14 15 16 17]

# [18 19 20 21 22 23]

# [24 25 26 27 28 29]

# [30 31 32 33 34 35]]

print(np.arange(49).reshape(7, 7))

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

# [ 7 8 9 ... 11 12 13]

# [14 15 16 ... 18 19 20]

# ...

# [28 29 30 ... 32 33 34]

# [35 36 37 ... 39 40 41]

# [42 43 44 ... 46 47 48]]

数値の書式

`supress`

デフォルトでは要素にオーダーが小さい数値が含まれていると浮動小数点表示となり、1つの要素でも浮動小数点表示になるとすべての要素が浮動小数点表示になる。

オプションで'supress=True'を指定すると、強制的に固定小数点で表示される。

import numpy as np

a = np.array([0.0000123, 0.123, 12.3])

print(a)
# [1.23e-05 1.23e-01 1.23e+01]

np.set_printoptions(suppress=True)

print(a)
# [ 0.0000123  0.123     12.3      ]

import numpy as np

a = np.array([0.0000123, 0.123, 12.3])

print(a)

# [1.23e-05 1.23e-01 1.23e+01]

np.set_printoptions(suppress=True)

print(a)

# [ 0.0000123 0.123 12.3 ]

`precision`

precisionで精度の桁数を指定する。固定小数点数の場合は小数点以下の桁数、浮動小数点数の場合は仮数部の桁数。

import numpy as np

a = np.array([x / 7 for x in [0.1, 1, 10, 100]])
print(a)
# [ 0.01428571  0.14285714  1.42857143 14.28571429]

np.set_printoptions(precision=3)
print(a)
# [ 0.014  0.143  1.429 14.286]

b = np.array([x / 7 for x in [0.01, 1, 10, 100]])
print(b)
# [1.429e-03 1.429e-01 1.429e+00 1.429e+01]

import numpy as np

a = np.array([x / 7 for x in [0.1, 1, 10, 100]])

print(a)

# [ 0.01428571 0.14285714 1.42857143 14.28571429]

np.set_printoptions(precision=3)

print(a)

# [ 0.014 0.143 1.429 14.286]

b = np.array([x / 7 for x in [0.01, 1, 10, 100]])

print(b)

# [1.429e-03 1.429e-01 1.429e+00 1.429e+01]

`floatmode`

floatmodeでキーワードを指定し、あらかじめ定められた書式を設定する。

次のような配列でキーワードごとの挙動を確認する。配列aは最大でもprecision設定より低い精度、配列bはprecisionを超える精度の要素を持ち、デフォルトのprecision=8で表示が丸められている。

a = np.array([0.1, 0.123, 0.123456])
b = np.array([0.1, 0.12345, 0.123456789])
print("default      :{}".format(a))
print("             :{}".format(b))

# default      :[0.1      0.123    0.123456]
#              :[0.1        0.12345    0.12345679]

a = np.array([0.1, 0.123, 0.123456])

b = np.array([0.1, 0.12345, 0.123456789])

print("default :{}".format(a))

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

# default :[0.1 0.123 0.123456]

# :[0.1 0.12345 0.12345679]

`maxprec`

デフォルトの設定。各要素がそれぞれ最大の精度で表示される。いずれの配列も、最大精度となる最後尾の要素の桁幅に統一されていて、0埋めはされない。デフォルトはこの設定なので、結果は上と同じ。

np.set_printoptions(floatmode='maxprec')
print("maxprec      :{}".format(a))
print("             :{}".format(b))

# maxprec      :[0.1      0.123    0.123456]
#              :[0.1        0.12345    0.12345679]

np.set_printoptions(floatmode='maxprec')

print("maxprec :{}".format(a))

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

# maxprec :[0.1 0.123 0.123456]

# :[0.1 0.12345 0.12345679]

`maxprec_equal`

maxplecは0埋めされなかったが、maxprec_equalは最大精度の桁数に統一された上で0で埋められる(equalの意味が曖昧、maxprec_zeroとでもしてくれればよかったのに)。

np.set_printoptions(floatmode='maxprec')
print("maxprec      :{}".format(a))
print("             :{}".format(b))

# maxprec_equal:[0.100000 0.123000 0.123456]
#              :[0.10000000 0.12345000 0.12345679]

np.set_printoptions(floatmode='maxprec')

print("maxprec :{}".format(a))

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

# maxprec_equal:[0.100000 0.123000 0.123456]

# :[0.10000000 0.12345000 0.12345679]

`fixed`

全ての要素の精度がprecisionに統一され、それより低い精度の場合は0で埋められる。下の例では、2つの配列のすべての要素が小数点以下8桁に統一され、0で埋められている。

np.set_printoptions(floatmode='fixed')
print("fixed        :{}".format(a))
print("             :{}".format(b))

# fixed        :[0.10000000 0.12300000 0.12345600]
#              :[0.10000000 0.12345000 0.12345679]

np.set_printoptions(floatmode='fixed')

print("fixed :{}".format(a))

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

# fixed :[0.10000000 0.12300000 0.12345600]

# :[0.10000000 0.12345000 0.12345679]

`unique`

precisionは無視され、各要素で必要な分だけの精度が保たれ、桁数は最大精度に統一される。配列bの最後の要素が丸められていないことに注意。

np.set_printoptions(floatmode='unique')
print("unique       :{}".format(a))
print("             :{}".format(b))

# unique       :[0.1      0.123    0.123456]
#              :[0.1         0.12345     0.123456789]

np.set_printoptions(floatmode='unique')

print("unique :{}".format(a))

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

# unique :[0.1 0.123 0.123456]

# :[0.1 0.12345 0.123456789]

`formatter`

書式設定文字列とformatを渡して、任意の書式を設定する。渡し方は以下の通り。

formatter={'型名' : "{:書式}".format }

型名としては'int'、'float'のほか'numpystr'で文字列も指定できる。

import numpy as np

a = np.array([0.0123, 1.2345, 12.3456789])

np.set_printoptions(formatter={'float' : "{:10.5f}".format})
print(a)

np.set_printoptions(formatter={'float' : "{:15.7e}".format})
print(a)

# [   0.01230    1.23450   12.34568]
# [  1.2300000e-02   1.2345000e+00   1.2345679e+01]

import numpy as np

a = np.array([0.0123, 1.2345, 12.3456789])

np.set_printoptions(formatter={'float' : "{:10.5f}".format})

print(a)

np.set_printoptions(formatter={'float' : "{:15.7e}".format})

print(a)

# [ 0.01230 1.23450 12.34568]

# [ 1.2300000e-02 1.2345000e+00 1.2345679e+01]

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

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

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

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

import numpy as np

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

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

import numpy as np

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

print(y)

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

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

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

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

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

print(names[y])

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

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

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

# zero one two

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

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

# zero one two

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(names[y])

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

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

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

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

z = np.array([

[0, 1, 2],

[1, 2, 0]

])

print(names[z])

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

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

ndarray.min/max – 配列の最小値と最大値

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

ndarray.min()/max()は、配列の最小値／最大値を返すメソッド。また、ndarray.argmin()/argmax()は、最小／最大の要素のインデックスを配列で返す。

なお、numpy.amin()/amax()、numpy.argmin()/argmax()もほぼ同じ動作をする。

以下、次の配列で動作を確認する。

import numpy as np

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

import numpy as np

a = np.array([

[1, 3, 2],

[4, 6, 5],

[7, 9, 8]

])

引数に何も指定しない場合、配列の全要素の中の最小値と最大値を返す。このとき、argmin/argmaxでは、配列をreshape(-1)で1次元化したときのインデックスが返される。

print(a.min(), a.max())
# 1 9

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

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

# 1 9

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

# 0 8

引数にaxis=0を指定すると、各列ベクトルの行方向の中での最小値／最大値を返す。以下の例では、各列ごとの最小値／最大値とそれらに対する行インデックスが配列で返されている。

axis=0の0を2次元配列の引数の位置と考えると0番目の引数で、各列における行の位置を表す。これはargmin/argmaxの意味合いと符合する。

print(a.min(axis=0), a.max(axis=0))
# [1 3 2] [7 9 8]

print(a.argmin(axis=0), a.argmax(axis=0))
# [0 0 0] [2 2 2]

print(a.min(axis=0), a.max(axis=0))

# [1 3 2] [7 9 8]

print(a.argmin(axis=0), a.argmax(axis=0))

# [0 0 0] [2 2 2]

引数にaxis=1を指定すると、各行ベクトルの列方向の中での最小値／最大値を返す。以下の例では、各行ごとの最小値／最大値とそれらに対する列インデックスが配列で返されている。

axis=1の1を2次元配列の引数の位置と考えると1番目の引数で、各行における列の位置を表す。これはargmin/argmaxの意味合いと符合する。

print(a.min(axis=1), a.max(axis=1))
# [1 4 7] [3 6 9]

print(a.argmin(axis=1), a.argmax(axis=1))
# [0 0 0] [1 1 1]

print(a.min(axis=1), a.max(axis=1))

# [1 4 7] [3 6 9]

print(a.argmin(axis=1), a.argmax(axis=1))

# [0 0 0] [1 1 1]

numpy – r_とc_

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

概要

numpy.r_ / numpy.c_は配列を結合するオブジェクト。r_は縦方向に配列を結合し、c_は横方向に配列を結合する。vstack() / hstack()やlinspace()と似たような使い方ができるが、少し癖がある。

配列と数値を混在させて結合できる
スライスでステップ数やか分割数を指定して数列をつくれる
vstack()やhstack()の代わりに使える

vstack()やhstack()と同じように使う。

import numpy as np

a1 = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
a2 = np.array([
    [10, 20, 30],
    [40, 50, 60]
])

print(np.r_[a1, a2])
# [[ 1  2  3]
#  [ 4  5  6]
#  [10 20 30]
#  [40 50 60]]

print(np.c_[a1, a2])
# [[ 1  2  3 10 20 30]
#  [ 4  5  6 40 50 60]]

import numpy as np

a1 = np.array([

[1, 2, 3],

[4, 5, 6]

])

a2 = np.array([

[10, 20, 30],

[40, 50, 60]

])

print(np.r_[a1, a2])

# [[ 1 2 3]

# [ 4 5 6]

# [10 20 30]

# [40 50 60]]

print(np.c_[a1, a2])

# [[ 1 2 3 10 20 30]

# [ 4 5 6 40 50 60]]

`r_`について

numpy.r_で2次元配列に1行だけ追加するとき、1次元配列のままだ”次元が異なる”とエラー。素直にvstack()を使った方がよい。

a3 = np.array([10, 20, 30])
#print(np.r_[a1, a3])
# -> ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 1 dimension(s)

print(np.r_[a1, a3.reshape(1, -1)])
# [[ 1  2  3]
#  [ 4  5  6]
#  [10 20 30]]

a3 = np.array([10, 20, 30])

#print(np.r_[a1, a3])

# -> ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 1 dimension(s)

print(np.r_[a1, a3.reshape(1, -1)])

# [[ 1 2 3]

# [ 4 5 6]

# [10 20 30]]

r_のデフォルトで1次元配列同士を結合すると、単に横方向に結合される。配列と要素が混在していてもok。文字列の配列も結合できるが、文字列要素が混在するとエラーになる。

print(np.r_[[1, 2, 3], 4, 5, [6, 7]])
# [1 2 3 4 5 6 7]

print(np.r_[['A', 'B', 'C'], ['D', 'E']])
# ['A' 'B' 'C' 'D' 'E']

#print(np.r_[['A', 'B', 'C'], 'D', 'E', ['E', 'F']])
# -> ValueError: special directives must be the first entry.

print(np.r_[[1, 2, 3], 4, 5, [6, 7]])

# [1 2 3 4 5 6 7]

print(np.r_[['A', 'B', 'C'], ['D', 'E']])

# ['A' 'B' 'C' 'D' 'E']

#print(np.r_[['A', 'B', 'C'], 'D', 'E', ['E', 'F']])

# -> ValueError: special directives must be the first entry.

スライスを使って数列を生成。

print(np.r_[:10])
# [0 1 2 3 4 5 6 7 8 9]

print(np.r_[4:10:2])
# [4 6 8]

print(np.r_[0.5:5.5:0.5])
# [0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5 5. ]

print(np.r_[:10])

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

print(np.r_[4:10:2])

# [4 6 8]

print(np.r_[0.5:5.5:0.5])

# [0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5. ]

3つ目の引数に'j'をつけてnumpy.linspace()と同様の動作。このときは終了値が含まれる。

print(np.r_[0:10:5j])
# [ 0.   2.5  5.   7.5 10. ]

1 2	print(np.r_[0:10:5j]) # [ 0. 2.5 5. 7.5 10. ]

`c_`について

numpy.c_で2次元配列にその行数と同じ要素数の1次元配列を結合すると、列ベクトルとみなされて1列追加される。hstack()が1次元配列を列ベクトル化する必要があるのに比べると手軽。

a5 = np.array([10, 20])
print(np.c_[a1, a5])
# [[ 1  2  3 10]
#  [ 4  5  6 20]]

a5 = np.array([10, 20])

print(np.c_[a1, a5])

# [[ 1 2 3 10]

# [ 4 5 6 20]]

さらに要素数が同じ1次元配列同士を結合すると、それらが列ベクトルとみなされて結合される。

b1 = np.array([1, 2, 3])
b2 = np.array([4, 5, 6])
print(np.c_[b1, b2])

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

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

b2 = np.array([4, 5, 6])

print(np.c_[b1, b2])

# [[1 4]

# [2 5]

# [3 6]]

空の配列に対して順次列ベクトルを追加する場合には、empty(n, 0, dtype=type)を準備する。

b0 = np.empty((3, 0), dtype=int)
b0 = np.c_[b0, b1]
print(b0)
# [[1]
#  [2]
#  [3]]

b0 = np.c_[b0, b2]
print(b0)
# [[1 4]
#  [2 5]
#  [3 6]]

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

b0 = np.c_[b0, b1]

print(b0)

# [[1]

# [2]

# [3]]

b0 = np.c_[b0, b2]

print(b0)

# [[1 4]

# [2 5]

# [3 6]]

numpy.percentile()～パーセンタイル

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

numpy.percentile()は、与えた配列から指定したパーセンタイル値を計算する。

percentile(a, q): a：パーセンタイルを計算する元の配列。; q：パーセンタイル値、または配列。パーセンタイル値は0～100で、百分率表示であることに注意。1次元配列を指定すると、各要素のパーセンタイル値に相当する値が同じサイズの配列で返される。

以下は実行例。パーセンタイル値が要素の間になる場合は内挿される。

import numpy as np

a = np.arange(11)

print("source = {}".format(a))
print("40 percentile = {}".format(np.percentile(a, 40)))
print("43 percentile = {}".format(np.percentile(a, 43)))

# source = [ 0  1  2  3  4  5  6  7  8  9 10]
# 40 percentile = 4.0
# 43 percentile = 4.3

import numpy as np

a = np.arange(11)

print("source = {}".format(a))

print("40 percentile = {}".format(np.percentile(a, 40)))

print("43 percentile = {}".format(np.percentile(a, 43)))

# source = [ 0 1 2 3 4 5 6 7 8 9 10]

# 40 percentile = 4.0

# 43 percentile = 4.3

元の配列はソートされていなくてもよい。

np.random.shuffle(a)
print(np.percentile(a, 63))

# 6.3

np.random.shuffle(a)

print(np.percentile(a, 63))

# 6.3

パーセンタイル値を配列で指定した場合。

print(np.percentile(a, [55, 75]))
# [5.5 7.5]

1 2	print(np.percentile(a, [55, 75])) # [5.5 7.5]

95%両側信頼区間の場合、以下のように計算できる。

print(np.percentile(a, [2.5, 97.5]))
# [0.25 9.75]

1 2	print(np.percentile(a, [2.5, 97.5])) # [0.25 9.75]

概要

手順

ターゲットごとのインデックスの取得

取り出す要素の制限

要素の抽出

他の配列の同時操作

概要

使い方

基本形

値が飛んでいる場合

順不同

weightsの意味

1次元配列の場合

平均

分散・標準偏差

標本分散・標本標準偏差

不偏推定量

2次元配列の場合

平均

分散・標準偏差

標本分散・標本標準偏差

不偏推定量

共分散

概要

ndarrayの場合

確認

合計

率の計算

DataFrameの場合

確認

合計ベクトルがndarrayの場合

合計ベクトルがSeriesの場合

合計

率の計算

Seriesをndarrayで取り出して計算する方法

Seriesのままで計算する方法

実行速度

概要

ndarrayの場合

max()メソッド

sum()メソッド

repeat()メソッド

図による理解

DataFrameの場合

min()メソッドなど

add()などの演算メソッド

apply()メソッド

演算メソッドの図による理解

補足

1次元配列の場合

1行の2次元配列の場合

1列の2次元配列の場合

概要

get_printoptions()

set_printoptions()

省略表示

thresholdとedgeitems

数値の書式

supress

precision

floatmode

maxprec

maxprec_equal

fixed

unique

formatter

概要

r_について

c_について

`weights`の意味

`ndarray`の場合

`DataFrame`の場合

合計ベクトルが`ndarray`の場合

合計ベクトルが`Series`の場合

`Series`を`ndarray`で取り出して計算する方法

`Series`のままで計算する方法

`ndarray`の場合

`max()`メソッド

`sum()`メソッド

`repeat()`メソッド

`DataFrame`の場合

`min()`メソッドなど

`add()`などの演算メソッド

`apply()`メソッド

`get_printoptions()`

`set_printoptions()`

`threshold`と`edgeitems`

`supress`

`precision`

`floatmode`

`maxprec`

`maxprec_equal`

`fixed`

`unique`

`formatter`

`r_`について

`c_`について