matplotlib.pyplot – figure～複数の図の描画

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

概要

pyplot.figure()は、実行のたびに新たなfigureオブジェクトを生成する。コンソールからの実行環境下では、各figureオブジェクトは別々のウィンドウとして表示され、それぞれにファイルへの保存が可能。

以下の例では、2つのfigureオブジェクトを生成し、それぞれにグラフをプロットし、それらをファイルに保存している。

figureで生成される図のサイズはfigsize=(width, height)で指定し、width, heightはインチ単位で指定する。省略した場合のデフォルトサイズは、6.4in×4.8in。

なお、figureオブジェクトを生成してグラフを描画する場合、直接figureに対してではなく、その中にaxesオブジェクトを追加して操作するのが通常。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
y1 = np.sin(x)
y2 = np.cos(x)

fig1 = plt.figure(figsize=(8, 6))
fig1.suptitle("Figure-1")
plt.plot(x, y1)

fig2 = plt.figure()
fig2.suptitle("Figure-2")
plt.plot(x, y2)

fig1.savefig("matplotlib_pyplot_fig_1.png")
fig2.savefig("matplotlib_pyplot_fig_2.png")

plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

y1 = np.sin(x)

y2 = np.cos(x)

fig1 = plt.figure(figsize=(8, 6))

fig1.suptitle("Figure-1")

plt.plot(x, y1)

fig2 = plt.figure()

fig2.suptitle("Figure-2")

plt.plot(x, y2)

fig1.savefig("matplotlib_pyplot_fig_1.png")

fig2.savefig("matplotlib_pyplot_fig_2.png")

plt.show()

matplotlib_pyplot_fig_1.png

matplotlib_pyplot_fig_2

matplotlib.pyplot – subplotによる複数グラフの描画

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

概要

pyplot.subplot()によって、一つのウィンドウに複数のグラフを描画できる。

subplot(rows, cols, positon) subplot(rcp)

rowsでグラフの行数、colsで列数を指定。positionはrows*colsの中での描画位置を1つの数値で指定し、1行1列目→1行2列目→・・・→2行1列目→2行2列目の順番に1から1つずつ増えていく。

ここで引数指定に2つの方法があって、rows, col, positionをそれぞれ1つの数値として指定する方法と、rcpの形で1つの数値として指定する方法がある。たとえば2行3列のグラフエリアの2行2列目を指定する場合は(2, 3, 5)か(235)となる。

以下の例は、2×2のグラフを描画する例。

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.sin(x*2)
y4 = np.cos(x*2)

plt.subplots_adjust(wspace=0.4, hspace=0.4)

plt.subplot(2, 2, 1)
plt.title("sin x")
plt.plot(x, y1, label="sin x")

plt.subplot(2, 2, 2)
plt.title("cos x")
plt.plot(x, y2)

plt.subplot(223)
plt.plot(x, y3)

plt.subplot(224)
plt.title("cos 2x")
plt.plot(x, y4)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

y1 = np.sin(x)

y2 = np.cos(x)

y3 = np.sin(x*2)

y4 = np.cos(x*2)

plt.subplots_adjust(wspace=0.4, hspace=0.4)

plt.subplot(2, 2, 1)

plt.title("sin x")

plt.plot(x, y1, label="sin x")

plt.subplot(2, 2, 2)

plt.title("cos x")

plt.plot(x, y2)

plt.subplot(223)

plt.plot(x, y3)

plt.subplot(224)

plt.title("cos 2x")

plt.plot(x, y4)

plt.show()

matplotlib.pyplot – グラフエリアの表示要素

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

概要

pyplotで直接グラフを描画する際の基本的なオプションの例示。

import numpy as np
import matplotlib.pyplot as plt

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

plt.plot(x, y, label="sin x")

# タイトル設定
plt.title("sin x")
# x軸・y軸のラベル
plt.xlabel("x")
plt.ylabel("cos x")
# x軸・y軸の範囲
plt.xlim(-3, 3)
plt.ylim(-1, 1)
# x軸・y軸の目盛設定
plt.xticks([-3, -2, -1, 0, 1, 2, 3])
plt.yticks([-1, -0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75, 1])
# 凡例
plt.legend(loc="lower right")
# 格子の表示
plt.grid(True)
# 水平線・垂直線
plt.hlines([-0.5, 0.5], -3, 3, linestyles="dashed", colors=["red", "blue"])
plt.vlines([-np.pi/2, np.pi/2], -1, 1, linestyles=["dashdot", "dotted"])

plt.plot(x, y)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

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

y = np.sin(x)

plt.plot(x, y, label="sin x")

# タイトル設定

plt.title("sin x")

# x軸・y軸のラベル

plt.xlabel("x")

plt.ylabel("cos x")

# x軸・y軸の範囲

plt.xlim(-3, 3)

plt.ylim(-1, 1)

# x軸・y軸の目盛設定

plt.xticks([-3, -2, -1, 0, 1, 2, 3])

plt.yticks([-1, -0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75, 1])

# 凡例

plt.legend(loc="lower right")

# 格子の表示

plt.grid(True)

# 水平線・垂直線

plt.hlines([-0.5, 0.5], -3, 3, linestyles="dashed", colors=["red", "blue"])

plt.vlines([-np.pi/2, np.pi/2], -1, 1, linestyles=["dashdot", "dotted"])

plt.plot(x, y)

plt.show()

各オプションの説明

グラフタイトル

pyplot.tytle(label[, loc])

文字列labelをグラフ上部に表示する。表示位置はloc="left"/"center"/"right"で指定(デフォルトは"center")

軸ラベル

pyplot.xlabel(label) pyplot.ylabel(label)

文字列labelをx軸/y軸のラベルとして表示する。

軸の範囲

pyplot.xlim(left, right) pyplot.ylim(bottom, top)

x軸・y軸の上限・下限を設定する。設定は2つの変数で与えるか、以下のようにタプルで与えてもよい。

pyplot.xlim((left, right))

また、上下限のいずれか1つの値を指定し、他方の値を保持したまま値の変更が可能。

pyplot.xlim(right=1)
pyplot.ylim(bottom=-1)

引数なしで実行すると、上限・下限の値がタプルで返される。

left, right = pyplot.xlim()

軸目盛の設定

pyplot.xticks(ticks[, labels]) pyplot.yticks(ticks[, labels])

リストなどで与えた値を軸目盛とする。labelsをticksと同じ要素数で与えると、その内容が軸目盛のラベルに置き換えられる。

凡例の表示

pyplot.legend(loc=location)

データに設定されたラベルで、locationで指定した位置に凡例を表示する。

locationは文字列か整数のコードで以下のように指定。

location string	location code
‘best’	0
‘upper right’	1
‘upper left’	2
‘lower left’	3
‘lower right’	4
‘right’	5
‘center left’	6
‘center right’	7
‘lower center’	8
‘upper center’	9
‘center’	10

格子の表示

pyplot.grid(True/False)

Trueを指定すると、軸目盛に対応した格子が描かれる。

水平線・垂直線の表示

pyplot.hlines([y, xmin, xmax, colors='k', linestyles='solid', label='']
pyplot.vlines([x, ymin, ymax, colors='k', linestyles='solid', label='']

たとえばhlinesの場合、水平線を引くyの値をリスト等で与え、xmin～xmaxの間に線を描く。colorsは線の色、linestylesは線のスタイルで'solid', 'dashed', 'dashdot', 'dotted'のいずれか。

colorsとlinestylesは、1つ指定した場合は全ての水平線／垂直線に適用されるほか、yの要素数にあわせて個別に指定することもできる。

colors→color、linestyles→linestyleと単数形で指定しても実行される。

numpy – arange, linspace～数列の生成

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

`numpy.arange()`～間隔を指定した数列の生成

引数・戻り値

numpy.arange([start, ]stop, [step, ]dtype = None)

引数	型	概要
`start`	`int/float`	数列の開始値。省略可(デフォルトは0)
`stop`	`int/float`	数列の終了値。省略不可。
`step`	`int/float`	数列の間隔。省略可(デフォルトは1)。
`dtype`	`dtype`	生成される数列のデータ型。指定しない場合は引数の型が適用される。

戻り値：開始値startからstepずつ増加し、stop未満の数列のndarray

引数の指定例

必ず以下のように指定する。numpy.arange(stop=5, step=2)のような指定はできない。

numpy.arange(stop): 0以上stop未満で増分1の数列を返す。数列の型は引数の型による。
numpy.arange(start, stop): start以上stop未満で増分1の数列を返す。数列の型は引数の型による。
numpy.arange(start, stop, step): startから始まり、stepずつ増加／減少し、stepの手前までの数列を返す。数列の型は引数の型による。

print(np.arange(10))
print(np.arange(3, 10))
print(np.arange(3, 10, 2))

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

print(np.arange(10))

print(np.arange(3, 10))

print(np.arange(3, 10, 2))

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

# [3 4 5 6 7 8 9]

# [3 5 7 9]

その他

降順の数列

stepを負の値にして降順の指定も可能。この場合はstart≥n>endの範囲となる。

print(np.arange(10, 3, -2))

# [10  8  6  4]

print(np.arange(10, 3, -2))

# [10 8 6 4]

実数列

stepを指定して実数の列も作れる。

print(np.arange(0.2, 0.8, 0.2))

# [0.2 0.4 0.6 0.8]

print(np.arange(0.2, 0.8, 0.2))

# [0.2 0.4 0.6 0.8]

ただしデフォルトでstart=0(0.0)、step=1(1.0)なので以下のような挙動になる。

print(np.arange(2.2))
print(np.arange(2.3, 6.4))

# [0. 1. 2.]
# 　0から始まり1.0ずつ増加させて2.2を越えない範囲
# [2.3 3.3 4.3 5.3 6.3]
# 　2.3から始まり1.0ずつ増加させて6.5を超えない範囲

print(np.arange(2.2))

print(np.arange(2.3, 6.4))

# [0. 1. 2.]

# 　0から始まり1.0ずつ増加させて2.2を越えない範囲

# [2.3 3.3 4.3 5.3 6.3]

# 　2.3から始まり1.0ずつ増加させて6.5を超えない範囲

dtypeによる型指定

dtypeで強制的に型を指定可能。

print(np.arange(5, 10, dtype=float))
print(np.arange(2.3, 6.4, dtype=int))

# [5. 6. 7. 8. 9.]
# [2 3 4 5 6]
# 　先に引数を整数化すると[2 3 4 5]となるがこうなっていない
# 　まず[2.3 3.3 4.3 5.3 6.3]の列を作り、それを整数化しているらしい

print(np.arange(5, 10, dtype=float))

print(np.arange(2.3, 6.4, dtype=int))

# [5. 6. 7. 8. 9.]

# [2 3 4 5 6]

# 　先に引数を整数化すると[2 3 4 5]となるがこうなっていない

# 　まず[2.3 3.3 4.3 5.3 6.3]の列を作り、それを整数化しているらしい

`numpy.linspace()`～個数を指定した数列の生成

引数・戻り値

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

引数	型	概要
`start`	`int/float`	数列の開始値。省略不可。
`stop`	`int/float`	数列の終了値。省略不可。
`num`	`int`	数列の要素数。省略可(デフォルトは50)。
`endpoint`	`bool`	stopを要素に含むかどうかを指定。`True`で含み、`False`なら含まない。省略可(デフォルトは`True`で`stop`を含む)。
`retstep`	`bool`	戻り値として配列に加えて公差を返すかどうかを指定。Trueで配列を第1要素、公差を第2要素とするタプルを返し、Falseなら配列のみを返す。
`dtype`	`dtype`	生成される数列のデータ型。指定しない場合は`float`が適用される。

戻り値：startからstopまでをnum等分した数列のndarray

引数の指定例

numpy.linspace(start, stop): startから始まりstopで終わる50個の数列を返す。
numpy.linspace(start, stop, num): startから始まりstopで終わるnum個の数列を返す。
numpy.linspace(start, stop, num, endpoint=False): startから始まりstopの手前で終わるnum個の数列を返す。

print(np.linspace(-2.4, 2.5))
print(np.linspace(-2, 2, 11))
print(np.linspace(-2, 2, 20, endpoint=False))
print(np.linspace(-1, 1, 5, retstep=True))
a, d = np.linspace(-1, 1, 5, retstep=True)
print(a)
print(d)

# [-2.4000000e+00 -2.3000000e+00 -2.2000000e+00 -2.1000000e+00
#  -2.0000000e+00 -1.9000000e+00 -1.8000000e+00 -1.7000000e+00
# .....
#   2.0000000e+00  2.1000000e+00  2.2000000e+00  2.3000000e+00
#   2.4000000e+00  2.5000000e+00]
[-2.  -1.6 -1.2 -0.8 -0.4  0.   0.4  0.8  1.2  1.6  2. ]
[-2.  -1.6 -1.2 -0.8 -0.4  0.   0.4  0.8  1.2  1.6]
# (array([-1. , -0.5,  0. ,  0.5,  1. ]), 0.5)
# [-1.  -0.5  0.   0.5  1. ]
# 0.5

print(np.linspace(-2.4, 2.5))

print(np.linspace(-2, 2, 11))

print(np.linspace(-2, 2, 20, endpoint=False))

print(np.linspace(-1, 1, 5, retstep=True))

a, d = np.linspace(-1, 1, 5, retstep=True)

print(a)

print(d)

# [-2.4000000e+00 -2.3000000e+00 -2.2000000e+00 -2.1000000e+00

# -2.0000000e+00 -1.9000000e+00 -1.8000000e+00 -1.7000000e+00

# .....

# 2.0000000e+00 2.1000000e+00 2.2000000e+00 2.3000000e+00

# 2.4000000e+00 2.5000000e+00]

[-2. -1.6 -1.2 -0.8 -0.4 0. 0.4 0.8 1.2 1.6 2. ]

[-2. -1.6 -1.2 -0.8 -0.4 0. 0.4 0.8 1.2 1.6]

# (array([-1. , -0.5, 0. , 0.5, 1. ]), 0.5)

# [-1. -0.5 0. 0.5 1. ]

# 0.5

その他

dtypeによる型指定

dtype=intと指定して、整数列を生成できる。

print(np.linspace(-2, 2, 5, dtype=int))

# [-2 -1  0  1  2]

print(np.linspace(-2, 2, 5, dtype=int))

# [-2 -1 0 1 2]

ただし分割個数を適切に指定しないと、変な結果になる。

print(np.linspace(-2, 2, 6, dtype=int))

# [-2  0  0  2]
# 　まずfloatで以下の数列が生成される
# 　[-2.         -0.66666667  0.66666667  2.        ]
# 　その後にこれらの小数部が切り捨てられて上の結果になる

print(np.linspace(-2, 2, 6, dtype=int))

# [-2 0 0 2]

# 　まずfloatで以下の数列が生成される

# 　[-2. -0.66666667 0.66666667 2. ]

# 　その後にこれらの小数部が切り捨てられて上の結果になる

retstepを指定した公差の取り出し

retstep=Trueと指定すると、第1要素に数列のndarray、第2要素に公差を持つタプルが返される。

print(np.linspace(-1, 1, 5, retstep=True))
a, d = np.linspace(-1, 1, 5, retstep=True)
print(a)
print(d)

# (array([-1. , -0.5,  0. ,  0.5,  1. ]), 0.5)
# [-1.  -0.5  0.   0.5  1. ]
# 0.5

print(np.linspace(-1, 1, 5, retstep=True))

a, d = np.linspace(-1, 1, 5, retstep=True)

print(a)

print(d)

# (array([-1. , -0.5, 0. , 0.5, 1. ]), 0.5)

# [-1. -0.5 0. 0.5 1. ]

# 0.5

Python3 – forループの最初と最後だけ処理を変えたい

2019-12-31 / tau / コメントする

やりたいこと

たとえば多数の計算結果を表示するとき、リストなら最初だけ"["がついて、各要素の後ろに", "が付加されて、最後の要素だけそのカンマがなくて"]"が表示される。このような処理をいろいろな形で実装したいというような場合。

単純に考えると次のように格好が悪い。

lst = [10, 20, 30, 40]

print("<", end="")
for e in lst:
    print("{}, ".format(e), end="")
print(">")

# <10, 20, 30, 40, >

lst = [10, 20, 30, 40]

print("<", end="")

for e in lst:

print("{}, ".format(e), end="")

print(">")

# <10, 20, 30, 40, >

これを、<0, 1, 2, 3, 4>のように末尾だけ表示方法を変えたい、さらには、何個かごとに改行させて、2行目以降の行頭を1行目と変更したいときの処理を考える。

インデックスを利用する方法

1行で表示する場合

以下の例では、enumerateでコレクションのインデックスを取り出して、その値によって処理を分けている。行頭"<"の処理はforループの前でやってもよいが、次の複数行表示の準備としてif文で判定している。

for i, e in enumerate(lst):
    # 1文字目の場合、要素表示に先立って"<"を表示
    if i == 0:
        print("<", end="")

    # 要素を表示
    print(e, end="")

    # 最終要素の場合は">"、そうでなければ", "を表示
    if i == len(lst) - 1:
        print(">")
    else:
        print(", ", end="")

# <10, 20, 30, 40>

for i, e in enumerate(lst):

# 1文字目の場合、要素表示に先立って"<"を表示

if i == 0:

print("<", end="")

# 要素を表示

print(e, end="")

# 最終要素の場合は">"、そうでなければ", "を表示

if i == len(lst) - 1:

print(">")

else:

print(", ", end="")

# <10, 20, 30, 40>

複数行に分けて表示する場合

長いリストや多次元の配列などを複数行に分けて表示したい場合、行ごとの行末文字も変わってくる。そのような処理をforループで書いてみた。

lst = [2, 4, 6, 8, 10, 12, 14, 16]

num_in_line = 3
for i, e in enumerate(lst):
    # 1行目の場合行頭文字は"<"、そうでなければ" "で段下げ
    prefix = "<" if i // num_in_line == 0 else " "

    # 要素の後に表示する文字を、最後の文字だけ">"、その他の場合は", "とする
    suffix = ">" if i == len(lst) - 1 else ", "

    # 1文字目の場合、要素表示に先立ってprefixを表示
    if i % num_in_line == 0:
        print(prefix, end="")

    # 要素とsuffixを表示
    print("{:2d}{}".format(e, suffix), end="")

    # 行末要素か最終要素の場合は改行
    if i % num_in_line == num_in_line - 1 or i == len(lst) - 1: print()

# < 2,  4,  6, 
#   8, 10, 12, 
#  14, 16>

lst = [2, 4, 6, 8, 10, 12, 14, 16]

num_in_line = 3

for i, e in enumerate(lst):

# 1行目の場合行頭文字は"<"、そうでなければ" "で段下げ

prefix = "<" if i // num_in_line == 0 else " "

# 要素の後に表示する文字を、最後の文字だけ">"、その他の場合は", "とする

suffix = ">" if i == len(lst) - 1 else ", "

# 1文字目の場合、要素表示に先立ってprefixを表示

if i % num_in_line == 0:

print(prefix, end="")

# 要素とsuffixを表示

print("{:2d}{}".format(e, suffix), end="")

# 行末要素か最終要素の場合は改行

if i % num_in_line == num_in_line - 1 or i == len(lst) - 1: print()

# < 2, 4, 6,

# 8, 10, 12,

# 14, 16>

ジェネレーターを使う方法

ジェネレーターを使った方法。このジェネレーターは、各要素のprefix、本体要素、suffixの3つを返す。

1文字目だけ処理を変えるため、コレクションをイテレーターとし、ループに入る前に最初の要素を取り出している。next()関数でイテレーターの内容を取り出すと、その後のforループでは以降の要素が順次取り出されることを利用している。

prefixは最初だけ"<"を使い、その後は""としてprefixなしとして扱っている。

1行で表示する場合

lst = [10, 20, 30, 40]

def generator(lst):
    # 先頭に表示させる文字
    prefix = "<"

    # 与えられたコレクションをイテレーターとする
    it = iter(lst)

    # まず最初の要素を取得しておく
    next_element = next(it)

    # 最初の要素は既に取得されているので、current_elementは2つ目の要素から
    # 取得される
    for current_element in it:
        # ジェネレーターはprefix、本体要素、suffixを返す
        yield prefix, next_element, ", "
        # 以下、取得した要素をnext_elementに順次移していく
        next_element = current_element
        # 2つ目の要素以降はprefixなし
        prefix = ""
    # 最後の要素のみsuffixを">"にする
    yield prefix, next_element, ">"

for prefix, e, suffix in generator(lst):
    print("{}{}{}".format(prefix, e, suffix), end="")
print()

# <10, 20, 30, 40>

lst = [10, 20, 30, 40]

def generator(lst):

# 先頭に表示させる文字

prefix = "<"

# 与えられたコレクションをイテレーターとする

it = iter(lst)

# まず最初の要素を取得しておく

next_element = next(it)

# 最初の要素は既に取得されているので、current_elementは2つ目の要素から

# 取得される

for current_element in it:

# ジェネレーターはprefix、本体要素、suffixを返す

yield prefix, next_element, ", "

# 以下、取得した要素をnext_elementに順次移していく

next_element = current_element

# 2つ目の要素以降はprefixなし

prefix = ""

# 最後の要素のみsuffixを">"にする

yield prefix, next_element, ">"

for prefix, e, suffix in generator(lst):

print("{}{}{}".format(prefix, e, suffix), end="")

print()

# <10, 20, 30, 40>

複数行に分けて表示する場合

複数行に分ける場合、1行当たりの要素数を設定し、カウンターで要素位置を検出している。カウンターの値から先頭要素と判定した場合にprefixを" "とし、その他の場合は""としている。

lst = [2, 4, 6, 8, 10, 12, 14, 16]

def generator(lst):
    num_in_line = 3
    prefix = "<"

    it = iter(lst)
    next_element = next(it)

    # 行内の要素位置用のカウンター
    counter = 0
    for current_element in it:
        # counterは1～最大要素数でサイクリックに変化させる
        counter += 1
        # 行内の最終位置の要素なら改行、そうでなければ継続
        if counter == num_in_line:
            suffix = ",\n"
            counter = 0
        else:
            suffix = ", "

        yield prefix, next_element, suffix
        next_element = current_element
        # 2行目以降の先頭ならprefixを" "とする
        prefix = " " if counter == 0 else ""
    yield prefix, next_element, ">"

for prefix, e, suffix in generator(lst):
    print("{}{:2d}{}".format(prefix, e, suffix), end="")
print()

# < 2,  4,  6,
#   8, 10, 12,
#  14, 16>

lst = [2, 4, 6, 8, 10, 12, 14, 16]

def generator(lst):

num_in_line = 3

prefix = "<"

it = iter(lst)

next_element = next(it)

# 行内の要素位置用のカウンター

counter = 0

for current_element in it:

# counterは1～最大要素数でサイクリックに変化させる

counter += 1

# 行内の最終位置の要素なら改行、そうでなければ継続

if counter == num_in_line:

suffix = ",\n"

counter = 0

else:

suffix = ", "

yield prefix, next_element, suffix

next_element = current_element

# 2行目以降の先頭ならprefixを" "とする

prefix = " " if counter == 0 else ""

yield prefix, next_element, ">"

for prefix, e, suffix in generator(lst):

print("{}{:2d}{}".format(prefix, e, suffix), end="")

print()

# < 2, 4, 6,

# 8, 10, 12,

# 14, 16>

Python3 – yield文によるジェネレーターの実装

2019-12-30 / tau / コメントする

`return`文の確認

yield文はreturn文と同様に関数の中で使われ、戻り値を指定するが、その挙動は全く異なる。

まず準備として、通常のreturn文を持つ関数の動作を確認。呼び出されるたびに常に関数の先頭からreturn文まで実行される。

def func0():
    print("called")
    return 1

print(func0())
print(func0())

# called
# 1
# called
# 1

def func0():

print("called")

return 1

print(func0())

# called

# 1

# called

# 1

`yield`文にするとジェネレーターが生成される

このreturn文をyield文に変更してみると、関数の戻り値を返すのではなく、この関数がジェネレーターオブジェクトのコンストラクターとなっている。

def func1():
    print("called")
    yield 2

print(func1())

# <generator object func1 at 0x047BCF30>

def func1():

print("called")

yield 2

print(func1())

# <generator object func1 at 0x047BCF30>

ジェネレーターオブジェクトには、(Python3では)__next__()メソッドがあって、ジェネレーターで生成された値を順次取り出してくれる。そこで上のfunc1()でジェネレーターのインスタンスを生成し、直接値を取り出してみる。

generator = func1()
print(generator.__next__())
print(generator.__next__())

# called
# 2
# Traceback (most recent call last):
# .....
# StopIteration

generator = func1()

print(generator.__next__())

# called

# 2

# Traceback (most recent call last):

# .....

# StopIteration

このジェネレーターは値を1つしか生成しないので、2つ目を取り出そうとするとStopIteration例外を投げる。

`yield`文によるジェネレーターの挙動

以下の例は、3つの値を返すジェネレーターの例で、確認のためにyield文の前の処理をprint文で表示させるようにしている。なお、ここでは__next__()メソッドの代わりに組み込み関数next()を用いている。

def func3():
    print("He said:")
    yield "How are you?"

    print("She replied and asked:")
    yield "I'm fine. How are you?"

    print("He replied:")
    yield "I'm fine too."

generator = func3()
print(next(generator))
print(next(generator))
print(next(generator))

# He said:
# How are you?
# She replied and asked:
# I'm fine. How are you?
# He replied:
# I'm fine too.

def func3():

print("He said:")

yield "How are you?"

print("She replied and asked:")

yield "I'm fine. How are you?"

print("He replied:")

yield "I'm fine too."

generator = func3()

print(next(generator))

# He said:

# How are you?

# She replied and asked:

# I'm fine. How are you?

# He replied:

# I'm fine too.

関数で生成されるのはジェネレーターでStopIterationを投げるので、次のようにfor文で使える。

for x in func3():
    print(x)

# He said:
# How are you?
# She replied and asked:
# I'm fine. How are you?
# He replied:
# I'm fine too.

for x in func3():

print(x)

# He said:

# How are you?

# She replied and asked:

# I'm fine. How are you?

# He replied:

# I'm fine too.

`yiled`文と`return`文を混ぜた場合

関数の中でyield文を書くと、return文があってもジェネレーターが生成される。

def func4():
    yield 1
    yield 2
    yield 3
    return 4

print(func4())
for x in func4():
    print(x)

# <generator object func4 at 0x03B5CF30>
# 1
# 2
# 3

def func4():

yield 1

yield 2

yield 3

return 4

print(func4())

for x in func4():

print(x)

# <generator object func4 at 0x03B5CF30>

# 1

# 2

# 3

ただしreturn文があるとそこでStopIterationが投げられる。このとき、return文で指定した戻り値が得られるようだが、ジェネレーターとしては無視されるらしい。

def func5():
    yield 1
    yield 2
    return 3
    yield 4

g = func5()
print(next(g))
print(next(g))
print(next(g))

# 1
# 2
# Traceback (most recent call last):
# .....
# StopIteration: 3

def func5():

yield 1

yield 2

return 3

yield 4

g = func5()

print(next(g))

# 1

# 2

# Traceback (most recent call last):

# .....

# StopIteration: 3

このジェネレーターをfor文で使うと、以下のようにreturn文の手前まで実行される。

for x in func5():
    print(x)

# 1
# 2

for x in func5():

print(x)

# 1

# 2

実装の例

たとえば引数を与えて、その数以下であるフィボナッチ数列を返すジェネレーターを考える。

ef fibonacci(max):
    a = 1
    b = 1
    yield a
    yield b
    next_value = a + b
    while next_value < max:
        yield next_value
        a = b
        b = next_value
        next_value = a + b

for x in fibonacci(100):
    print(x)

# 1
# 1
# 2
# 3
# 5
# 8
# 13
# 21
# 34
# 55
# 89

ef fibonacci(max):

a = 1

b = 1

yield a

yield b

next_value = a + b

while next_value < max:

yield next_value

a = b

b = next_value

next_value = a + b

for x in fibonacci(100):

print(x)

# 1

# 2

# 3

# 5

# 8

# 13

# 21

# 34

# 55

# 89

Python3 – イテレーターとジェネレーター

2019-12-30 / tau / コメントする

イテレーター

__iter()__によるイテレーターの実装

itertools

イテレーターは再利用できない

ジェネレーター

yield文によるジェネレーターの実装

ジェネレーターの実装

k平均法

2019-11-10 / tau / コメントする

概要

k平均法(k-means clustering)はクラスタリングの手法の1つで、与えられたデータ群の特徴と初期値に基づいて、データを並列(非階層)のクラスターに分類する。

ここではk平均法の簡単な例を実装したKMeansClusteringクラスによって、その挙動を確認する。

テストケース

基本形

2つのクラスターがある程度明確なケースで試してみる。一定の円内にランダムに点を発生させ、そのグループを2つ近づけた例。

x_means[0], y_means[0] = 15, 15
x_means[1], y_means[1] = 20, 15

plot_steps = [0, 1, 2, 4, 6]

x_means[0], y_means[0] = 15, 15

x_means[1], y_means[1] = 20, 15

plot_steps = [0, 1, 2, 4, 6]

以下のように、重なった部分は仕方がないが、かなり元のグループに近い分類となっている。

convergion times = 7
[14.567003574164632, 15.215775486294216]
[25.31190419286806, 25.871321239241027]

convergion times = 7

[14.567003574164632, 15.215775486294216]

[25.31190419286806, 25.871321239241027]

初期値を変えた場合

代表点の初期値を変えて実行してみる。

x_means[0], y_means[0] = 25, 25
x_means[1], y_means[1] = 25, 30

plot_steps = [0, 1, 2, 4, 8]

x_means[0], y_means[0] = 25, 25

x_means[1], y_means[1] = 25, 30

plot_steps = [0, 1, 2, 4, 8]

上記とはかなり離れた初期値を設定しても、解は同じになる。

収束解も上記と全く同じ値になる。

convergion times = 9
[14.567003574164632, 15.215775486294216]
[25.31190419286806, 25.871321239241027]

convergion times = 9

[14.567003574164632, 15.215775486294216]

[25.31190419286806, 25.871321239241027]

クラスターが不明確な場合

先の結果だけを見ると、かなり初期値がずれてもクラス分類は安定なように見える。

そこで次に、元々の分布に明確なクラス分けが見えない場合に3つのクラスターに分ける例を考える。

初期値1

x_means[0], y_means[0] = 10, 18
x_means[1], y_means[1] = 18, 18
x_means[2], y_means[2] = 25, 18

plot_steps = [0, 1, 4, 8, 12]

x_means[0], y_means[0] = 10, 18

x_means[1], y_means[1] = 18, 18

x_means[2], y_means[2] = 25, 18

plot_steps = [0, 1, 4, 8, 12]

convergion times = 13
[11.359345006841108, 15.215511281942952]
[21.33481062455269, 13.05930376628775]
[19.777630465074534, 23.850681586725297]

convergion times = 13

[11.359345006841108, 15.215511281942952]

[21.33481062455269, 13.05930376628775]

[19.777630465074534, 23.850681586725297]

初期値2

上記に対して初期値を変更。

_means[0], y_means[0] = 18, 10
x_means[1], y_means[1] = 18, 18
x_means[2], y_means[2] = 18, 25

plot_steps = [0, 1, 4, 8, 10]

_means[0], y_means[0] = 18, 10

x_means[1], y_means[1] = 18, 18

x_means[2], y_means[2] = 18, 25

plot_steps = [0, 1, 4, 8, 10]

データは同じだが、クラスター分けは違ってきている。

convergion times = 11
[18.43160436224161, 11.596987217637075]
[12.210575780454143, 19.032933149086162]
[22.418606246186307, 23.158839350112153]

convergion times = 11

[18.43160436224161, 11.596987217637075]

[12.210575780454143, 19.032933149086162]

[22.418606246186307, 23.158839350112153]

極端な例

次に、元の分布でクラスターが見いだせないような極端な場合を考える。

初期値1

代表点の初期値は縦に並んでおり、クラスターも縦方向に分割されている。

x_means[0], y_means[0] = 15, 15
x_means[1], y_means[1] = 15, 20

plot_steps = [0, 1, 3, 5, 8]

x_means[0], y_means[0] = 15, 15

x_means[1], y_means[1] = 15, 20

plot_steps = [0, 1, 3, 5, 8]

convergion times = 9
[19.1770479839392, 13.104941433078057]
[20.361677232475646, 26.9785132838531]

convergion times = 9

[19.1770479839392, 13.104941433078057]

[20.361677232475646, 26.9785132838531]

初期値2

全く同じデータで代表点の初期値を横に並べた場合、クラスター分けは大きく異なっている。

x_means[0], y_means[0] = 15, 15
x_means[1], y_means[1] = 20, 15

x_lim = 40
y_lim = 40

plot_steps = [0, 1, 2, 4]

x_means[0], y_means[0] = 15, 15

x_means[1], y_means[1] = 20, 15

x_lim = 40

y_lim = 40

plot_steps = [0, 1, 2, 4]

convergion times = 5
[12.933983667295676, 20.22594500107436]
[25.46963894609307, 21.15223763731067]

convergion times = 5

[12.933983667295676, 20.22594500107436]

[25.46963894609307, 21.15223763731067]

3クラスター

最後に、元のデータでクラスターがかなり明確な場合を試してみる。

初期値1

_means[0], y_means[0] = 10, 15
x_means[1], y_means[1] = 15, 15
x_means[2], y_means[2] = 20, 15

plot_steps = [0, 2, 4, 6, 9]

_means[0], y_means[0] = 10, 15

x_means[1], y_means[1] = 15, 15

x_means[2], y_means[2] = 20, 15

plot_steps = [0, 2, 4, 6, 9]

初期値が隅の方から始まっていても、3つのクラスターによく分かれている。

convergion times = 10
[14.610459971900003, 15.428114490958492]
[25.252313933530775, 30.84369233062165]
[34.43506243558404, 14.084017148769334]

convergion times = 10

[14.610459971900003, 15.428114490958492]

[25.252313933530775, 30.84369233062165]

[34.43506243558404, 14.084017148769334]

初期値2

x_means[0], y_means[0] = 25, 25
x_means[1], y_means[1] = 25, 30
x_means[2], y_means[2] = 25, 35

plot_steps = [0, 1, 3, 6, 10]

x_means[0], y_means[0] = 25, 25

x_means[1], y_means[1] = 25, 30

x_means[2], y_means[2] = 25, 35

plot_steps = [0, 1, 3, 6, 10]

初期値の場所や並びがかなり異なっていても、クラスター分けは安定している。

convergion times = 11
[34.43506243558404, 14.084017148769334]
[14.665546643275666, 15.615970568228104]
[25.413807412324008, 30.963999916166244]

convergion times = 11

[34.43506243558404, 14.084017148769334]

[14.665546643275666, 15.615970568228104]

[25.413807412324008, 30.963999916166244]

まとめ

k平均法は初期値によって解が変動するとされているが、明らかにクラスターが明確な場合には解は安定している。

ただしそのようなケースは、特徴量の数が少なく分布が一目瞭然の場合に相当するので、特徴量が多く一目ではそのクラスターがわかりにくいような場合には、やはり初期値の取り方に大きく影響されるものと考えられる。

Python3 – KMeansClustering

2019-11-10 / tau / 3件のコメント

概要

アルゴリズムはシンプルで、以下の手順。

クラスターの数だけクラスターの代表点の初期値を設定する
代表点の位置が収束するまで以下を繰り返す
1. データの各点から最も近い代表点を選ぶ
2. 同じ代表点の点群から重心を算出し、新しい代表点の位置とする

このクラスは、特徴量が2つのデータ群と代表点の初期値を与えて、k平均法でクラスタリングを行うテストクラス。

2つの特徴量x_data、y_dataを与えてオブジェクトを生成し、代表点の初期値x_means、y_meansを与えてメソッドを実行して結果を得る。

全コード

KMeansClusteringクラスの全コードは以下の通り。

import numpy as np
import sys


class KMeansClustering:
    def __init__(self, x_data, y_data):
        self._x = x_data
        self._y = y_data
        self._x_means = None
        self._y_means = None
        self._num_data = len(self._x)
        self._num_means = 0
        self._groups = np.empty((0, self._num_data), dtype=int)

    def _distance(self, x0, y0, x1, y1):
        return (x0 - x1)**2 + (y0 - y1)**2

    def _point_converged(self, x0, y0, x1, y1):
        return True if x0==x1 and y0==y1 else False

    def _all_points_converged(self, x_old, y_old, x_new, y_new):
        for x0, y0, x1, y1 in zip(x_old, y_old, x_new, y_new):
            if not self._point_converged(x0, y0, x1, y1):
                return False
        return True

    def _set_nearest_mean_point(self):
        groups = np.zeros(self._num_data, int)
        for i, (x, y) in enumerate(zip(self._x, self._y)):
            min_dist = sys.float_info.max
            for j, (xm, ym) in \
                    enumerate(zip(self._x_means[-1], self._y_means[-1])):
                d = self._distance(x, y, xm, ym)
                if d < min_dist:
                    groups[i] = j
                    min_dist = d
        self._groups = np.vstack((self._groups, groups))

    def _revise_mean_points(self):
        x_means_new = np.zeros(self._num_means)
        y_means_new = np.zeros(self._num_means)

        for k in range(self._num_means):
            target = [True if j==k else False for j in self._groups[-1]]
            x_means_new[k] = np.mean(self._x[target])
            y_means_new[k] = np.mean(self._y[target])

        return x_means_new, y_means_new

    def get_result(self, x_means, y_means):
        self._x_means = np.array([x_means.copy()])
        self._y_means = np.array([y_means.copy()])
        self._num_means = len(x_means)

        while True:
            self._set_nearest_mean_point()
            xm, ym = self._revise_mean_points()

            if self._all_points_converged( \
                    self._x_means[-1], self._y_means[-1], xm, ym):
                return self._x_means, self._y_means, self._groups
            else:
                self._x_means = np.vstack((self._x_means, xm))
                self._y_means = np.vstack((self._y_means, ym))

        return self._x_means, self._y_means, self._groups

import numpy as np

import sys

class KMeansClustering:

def __init__(self, x_data, y_data):

self._x = x_data

self._y = y_data

self._x_means = None

self._y_means = None

self._num_data = len(self._x)

self._num_means = 0

self._groups = np.empty((0, self._num_data), dtype=int)

def _distance(self, x0, y0, x1, y1):

return (x0 - x1)**2 + (y0 - y1)**2

def _point_converged(self, x0, y0, x1, y1):

return True if x0==x1 and y0==y1 else False

def _all_points_converged(self, x_old, y_old, x_new, y_new):

for x0, y0, x1, y1 in zip(x_old, y_old, x_new, y_new):

if not self._point_converged(x0, y0, x1, y1):

return False

return True

def _set_nearest_mean_point(self):

groups = np.zeros(self._num_data, int)

for i, (x, y) in enumerate(zip(self._x, self._y)):

min_dist = sys.float_info.max

for j, (xm, ym) in \

enumerate(zip(self._x_means[-1], self._y_means[-1])):

d = self._distance(x, y, xm, ym)

if d < min_dist:

groups[i] = j

min_dist = d

self._groups = np.vstack((self._groups, groups))

def _revise_mean_points(self):

x_means_new = np.zeros(self._num_means)

y_means_new = np.zeros(self._num_means)

for k in range(self._num_means):

target = [True if j==k else False for j in self._groups[-1]]

x_means_new[k] = np.mean(self._x[target])

y_means_new[k] = np.mean(self._y[target])

return x_means_new, y_means_new

def get_result(self, x_means, y_means):

self._x_means = np.array([x_means.copy()])

self._y_means = np.array([y_means.copy()])

self._num_means = len(x_means)

while True:

self._set_nearest_mean_point()

xm, ym = self._revise_mean_points()

if self._all_points_converged( \

self._x_means[-1], self._y_means[-1], xm, ym):

return self._x_means, self._y_means, self._groups

else:

self._x_means = np.vstack((self._x_means, xm))

self._y_means = np.vstack((self._y_means, ym))

return self._x_means, self._y_means, self._groups

利用方法

クラスタリングを行うインスタンスの生成

初期データを与え、KMeansClusteringクラスのインスタンスを生成する。

clustering = KMeansClustering(x_data, y_data)

1	clustering = KMeansClustering(x_data, y_data)

コンストラクターに与える引数は以下の通り。

x_data, y_data: クラスタリングを行うデータの特徴量x、yの配列(1次元のndarray)。

クラスタリングの実行

生成したインスタンスに対して、クラスタリングを行うメソッドを実行して結果を得る。

xm, ym, groups = clustering.get_result(x_means, y_means)

1	xm, ym, groups = clustering.get_result(x_means, y_means)

メソッドに与える引数は以下の通り。

x_means, y_means: k個のクラスターの代表点の初期値(1次元のndarray)。

結果は以下のタプルで与えられる。

x_means, y_means: クラスターの代表点のx、yの配列。収束までの各計算段階の値を記録しており、2次元のndarrayの各行が各計算ステップに相当。
groups: 各データが属するクラスター(代表点)番号のndarray。

実行例

以下のコードでKMeansClusteringクラスをテスト。内容は以下の通り。

2つの円状に散らばるランダムな点群を発生させ、1つのデータとしてまとめる
- random_scatter_dataは指定した中心・半径の円内に指定した数のランダムな点を発生させるモジュールで、別途作成（最後の方にコードを掲載）
クラスターの代表点の数と位置、散布図を描画するパラメーターを設定する
- プロットする図の数は2行3列で固定し、初期状態を除いた5つの図を表示させる
- 予め実行させてコンソールで収束回数を確認し、33行目で表示させる計算ステップを指定している
初期状態の散布図をプロット
クラスタリングを行うKMeansClustringオブジェクトを生成し、結果を得るためのメソッドを実行(53-54行目)
結果をプロット

import numpy as np
import matplotlib.pyplot as plt
import random_scatter_data as rsd
from k_means_clustering import KMeansClustering


##################################################
# generate random points
#
np.random.seed(10)

num_data_1 = 100
num_data_2 = 100

x1, y1 = rsd.scatter_in_circle(15, 15, 10, num=num_data_1)
x2, y2 = rsd.scatter_in_circle(25, 25, 10, num=num_data_2)

x_data = np.hstack((x1, x2))
y_data = np.hstack((y1, y2))

##################################################
# settings
#
k = 2
x_means = np.zeros(k)
y_means = np.zeros(k)
x_means[0], y_means[0] = 15, 15
x_means[1], y_means[1] = 20, 15

x_lim = 40
y_lim = 40

plot_steps = [0, 1, 2, 4, 6]
plot_rows = 2
plot_cols = 3

##################################################
# plot initial state with original cluster
#
fig = plt.figure(figsize=(8, 6))

ax = fig.add_subplot(plot_rows, plot_cols, 1, aspect=1.0)
ax.set_xlim(0, x_lim)
ax.set_ylim(0, y_lim)

ax.scatter(x1, y1, s=5)
ax.scatter(x2, y2, s=5)
ax.scatter(x_means, y_means, c='red', marker='x')

##################################################
# create clustring object and get result
#
clustering = KMeansClustering(x_data, y_data)
xm, ym, groups = clustering.get_result(x_means, y_means)

print("convergion times = {}".format(len(xm)))
for n_mean in range(k):
    print("[{}, {}]".format(xm[-1][n_mean], ym[-1][n_mean]))

##################################################
# plot the states of designated steps
#
for n_plot, n_step in enumerate(plot_steps):
    ax = fig.add_subplot(plot_rows, plot_cols, n_plot + 2, aspect=1.0)
    ax.set_xlim(0, x_lim)
    ax.set_ylim(0, y_lim)
    for j in range(k):
        target = [True if jj==j else False for jj in groups[n_step]]
        ax.scatter(x_data[target], y_data[target], s=5)
        ax.scatter(xm[n_step], ym[n_step], marker='x')

plt.show()

import numpy as np

import matplotlib.pyplot as plt

import random_scatter_data as rsd

from k_means_clustering import KMeansClustering

##################################################

# generate random points

np.random.seed(10)

num_data_1 = 100

num_data_2 = 100

x1, y1 = rsd.scatter_in_circle(15, 15, 10, num=num_data_1)

x2, y2 = rsd.scatter_in_circle(25, 25, 10, num=num_data_2)

x_data = np.hstack((x1, x2))

y_data = np.hstack((y1, y2))

##################################################

# settings

k = 2

x_means = np.zeros(k)

y_means = np.zeros(k)

x_means[0], y_means[0] = 15, 15

x_means[1], y_means[1] = 20, 15

x_lim = 40

y_lim = 40

plot_steps = [0, 1, 2, 4, 6]

plot_rows = 2

plot_cols = 3

##################################################

# plot initial state with original cluster

fig = plt.figure(figsize=(8, 6))

ax = fig.add_subplot(plot_rows, plot_cols, 1, aspect=1.0)

ax.set_xlim(0, x_lim)

ax.set_ylim(0, y_lim)

ax.scatter(x1, y1, s=5)

ax.scatter(x2, y2, s=5)

ax.scatter(x_means, y_means, c='red', marker='x')

##################################################

# create clustring object and get result

clustering = KMeansClustering(x_data, y_data)

xm, ym, groups = clustering.get_result(x_means, y_means)

print("convergion times = {}".format(len(xm)))

for n_mean in range(k):

print("[{}, {}]".format(xm[-1][n_mean], ym[-1][n_mean]))

##################################################

# plot the states of designated steps

for n_plot, n_step in enumerate(plot_steps):

ax = fig.add_subplot(plot_rows, plot_cols, n_plot + 2, aspect=1.0)

ax.set_xlim(0, x_lim)

ax.set_ylim(0, y_lim)

for j in range(k):

target = [True if jj==j else False for jj in groups[n_step]]

ax.scatter(x_data[target], y_data[target], s=5)

ax.scatter(xm[n_step], ym[n_step], marker='x')

plt.show()

このコードの実行結果はコンソールで以下のように表示される。

convergion times = 7
[14.567003574164632, 15.215775486294216]
[25.31190419286806, 25.871321239241027]
[Finished in 3.529s]

convergion times = 7

[14.567003574164632, 15.215775486294216]

[25.31190419286806, 25.871321239241027]

[Finished in 3.529s]

この結果から1、2、3、5、7回目の計算結果を図示するよう上のコードでセットした表示結果は以下の通り。

グループが比較的明確なので、早い段階で代表点の位置が定まっている。

クラス説明

`init()`～インスタンス生成

    def __init__(self, x_data, y_data):
        self._x = x_data
        self._y = y_data
        self._x_means = None
        self._y_means = None
        self._num_data = len(self._x)
        self._num_means = 0
        self._groups = np.empty((0, self._num_data), dtype=int)

def __init__(self, x_data, y_data):

self._x = x_data

self._y = y_data

self._x_means = None

self._y_means = None

self._num_data = len(self._x)

self._num_means = 0

self._groups = np.empty((0, self._num_data), dtype=int)

クラスタリングを行うデータの特徴量x_data、y_dataをndarrayで与えてインスタンスを生成。

プライベート・メンバーは以下の通り。

_x, _y: クラスタリングを行うデータの2つの特徴量の配列。計算過程で変更されない。
_x_means, _y_means: 代表点の計算結果を保存していく配列。分析実行時に初期値が与えられるため、初期値はNone。
_num_data: データの個数。
_num_means: 代表点(クラスターの個数)。代表点が分析実行時に与えられるため、初期値は0。
_groups: 各データの属するクラスターを保存していく配列。

`get_result()`～分析の実行

    def get_result(self, x_means, y_means):
        self._x_means = np.array([x_means.copy()])
        self._y_means = np.array([y_means.copy()])
        self._num_means = len(x_means)

        while True:
            self._set_nearest_mean_point()
            xm, ym = self._revise_mean_points()

            if self._all_points_converged( \
                    self._x_means[-1], self._y_means[-1], xm, ym):
                return self._x_means, self._y_means, self._groups
            else:
                self._x_means = np.vstack((self._x_means, xm))
                self._y_means = np.vstack((self._y_means, ym))

        return self._x_means, self._y_means, self._groups

def get_result(self, x_means, y_means):

self._x_means = np.array([x_means.copy()])

self._y_means = np.array([y_means.copy()])

self._num_means = len(x_means)

while True:

self._set_nearest_mean_point()

xm, ym = self._revise_mean_points()

if self._all_points_converged( \

self._x_means[-1], self._y_means[-1], xm, ym):

return self._x_means, self._y_means, self._groups

else:

self._x_means = np.vstack((self._x_means, xm))

self._y_means = np.vstack((self._y_means, ym))

return self._x_means, self._y_means, self._groups

k個の代表点のx、yを引数として渡し、結果を得る。

引数

_x_means, _y_means: k個の代表点の初期値x、yを、それぞれ1次元のndarrayで与える。引数で与えた配列は変更されない。

戻り値

x_means, y_means: 代表点の計算結果が保存された配列。各行は計算ステップに相当。

groups: 各計算ステップにおける、各点のクラスターが保存された配列。各行は計算ステップに相当。

処理内容

代表点の初期値をプライベート・メンバーにコピーし、代表点の個数をセット
全ての代表点の位置が収束するまで、以下を繰り返す
1. 各データについて、最も近い代表点をセット
2. 共通の代表点を持つデータから、新しい代表点の位置を計算
3. 代表点の前回最後の計算値と今回の計算値が収束したならループ終了、でなければ計算結果を追加してループ継続
計算結果を戻り値として終了

プライベートメソッド

`_distance()`～2点間の距離

    def _distance(self, x0, y0, x1, y1):
        return (x0 - x1)**2 + (y0 - y1)**2

1 2	def _distance(self, x0, y0, x1, y1): return (x0 - x1)2 + (y0 - y1)2

2つの点の距離を与える。ここではユークリッド距離の2乗。

`_point_converged()`～収束判定

    def _point_converged(self, x0, y0, x1, y1):
        return True if x0==x1 and y0==y1 else False

1 2	def _point_converged(self, x0, y0, x1, y1): return True if x0==x1 and y0==y1 else False

2つの点の座標から、点の位置が収束したかどうかを判定。

本来、各座標値はfloatなので'=='による判定は危険だが、ここでは収束の速さと確実性を信じて簡易に設定。

`_all_points_converged()`～全ての点の収束判定

    def _all_points_converged(self, x_old, y_old, x_new, y_new):
        for x0, y0, x1, y1 in zip(x_old, y_old, x_new, y_new):
            if not self._point_converged(x0, y0, x1, y1):
                return False
        return True

def _all_points_converged(self, x_old, y_old, x_new, y_new):

for x0, y0, x1, y1 in zip(x_old, y_old, x_new, y_new):

if not self._point_converged(x0, y0, x1, y1):

return False

return True

配列で与えた2組の点がすべて収束条件を満たしているか判定。

`_set_nearest_mean_point()`～各点に最も近い代表点

    def _set_nearest_mean_point(self):
        groups = np.zeros(self._num_data, int)
        for i, (x, y) in enumerate(zip(self._x, self._y)):
            min_dist = sys.float_info.max
            for j, (xm, ym) in \
                    enumerate(zip(self._x_means[-1], self._y_means[-1])):
                d = self._distance(x, y, xm, ym)
                if d < min_dist:
                    groups[i] = j
                    min_dist = d
        self._groups = np.vstack((self._groups, groups))

def _set_nearest_mean_point(self):

groups = np.zeros(self._num_data, int)

for i, (x, y) in enumerate(zip(self._x, self._y)):

min_dist = sys.float_info.max

for j, (xm, ym) in \

enumerate(zip(self._x_means[-1], self._y_means[-1])):

d = self._distance(x, y, xm, ym)

if d < min_dist:

groups[i] = j

min_dist = d

self._groups = np.vstack((self._groups, groups))

処理内容

各データについて、それぞれから最も近い距離にある代表点を探し、その番号を1次元の配列groupsに記録
_groups配列に、今回の分類結果を行として追加

`_revise_mean_points()`～代表点の更新

    def _revise_mean_points(self):
        x_means_new = np.zeros(self._num_means)
        y_means_new = np.zeros(self._num_means)

        for k in range(self._num_means):
            target = [True if j==k else False for j in self._groups[-1]]
            x_means_new[k] = np.mean(self._x[target])
            y_means_new[k] = np.mean(self._y[target])

        return x_means_new, y_means_new

def _revise_mean_points(self):

x_means_new = np.zeros(self._num_means)

y_means_new = np.zeros(self._num_means)

for k in range(self._num_means):

target = [True if j==k else False for j in self._groups[-1]]

x_means_new[k] = np.mean(self._x[target])

y_means_new[k] = np.mean(self._y[target])

return x_means_new, y_means_new

同じ代表点に属するデータからそれらの重心を計算し、新しい代表点として返す。

random_scatter_data.py

今回整理のためにつくったモジュールで、内容は以下の通り。

import numpy as np


def scatter_in_circle(x_org=0, y_org=0, r=1, num=100):
    x = np.zeros(num)
    y = np.zeros(num)

    for i in range(num):
        while True:
            xw = np.random.rand() * 2 * r - r
            yw = np.random.rand() * 2 * r - r
            if xw*xw + yw*yw <= r*r:
                x[i], y[i] = xw + x_org, yw + y_org
                break
    return x, y


def scatter_in_2dnormal(x_org=0, y_org=0, r=1, nsigma=1, num=100):
    x = np.random.randn(num) * r/nsigma + x_org
    y = np.random.randn(num) * r/nsigma + y_org
    return x, y

import numpy as np

def scatter_in_circle(x_org=0, y_org=0, r=1, num=100):

x = np.zeros(num)

y = np.zeros(num)

for i in range(num):

while True:

xw = np.random.rand() * 2 * r - r

yw = np.random.rand() * 2 * r - r

if xw*xw + yw*yw <= r*r:

x[i], y[i] = xw + x_org, yw + y_org

break

return x, y

def scatter_in_2dnormal(x_org=0, y_org=0, r=1, nsigma=1, num=100):

x = np.random.randn(num) * r/nsigma + x_org

y = np.random.randn(num) * r/nsigma + y_org

return x, y

Python3 – 2次元配列への行・列の追加

2019-11-10 / tau / コメントする

概要

2次元配列をデータテーブルのように使っていて、行や列を追加する場合の方法を整理。

リストの場合とndarrayの場合それぞれについて、行の追加、列の追加のためのメソッドや関数と、その使い方の注意を記しておく。

結論として、ndarrayを使う場合はnumpy.vstack()関数、numpy.hstack()関数を用いるのが、配列の2次元化や追加方向のaxis指定がなく紛れがない。

リストの場合

リストの場合はappend()メソッド、insert()メソッドで行や列を追加する。ただし、より現実的な方法をこちらに整理した。

注意点

リストのappend()メソッド、insert()メソッドは元のリストを書き換える
各メソッドは戻り値を持たない(None)
初期データが1行／1列の場合に2次元配列であることを明示する必要がある

初期リストが空の場合は単に1次元の空のリストを準備すればいいので、初期リストがある場合でも、空のリストを準備してからそこに追加するように決めておけばミスは減りそう。

行の追加

`append()`メソッド

append()メソッドは素直に引数のリストをもとのリストに追加する。ただし、下のコードの1行目のように元のリストが2次元配列であることを明示しなければならない。

a = [[0, 1, 2]]
print(a)
b = [3, 4, 5]
a.append(b)
print(a)

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

a = [[0, 1, 2]]

print(a)

b = [3, 4, 5]

a.append(b)

print(a)

# [[0, 1, 2]]

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

以下は失敗。元のリストを単なる要素リストで定義してしまうと、追加するリストが要素の一つとして扱われてしまう。

a = [0, 1, 2]
print(a)
b = [3, 4, 5]
a.append(b)
print(a)

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

a = [0, 1, 2]

print(a)

b = [3, 4, 5]

a.append(b)

print(a)

# [0, 1, 2]

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

空のリストへの追加。

この場合は1次元の空のリストを用意すれば、追加されるリストが要素として順次追加されていく。

a = []
print(a)
b = [0, 1, 2]
a.append(b)
print(a)
b = [3, 4, 5]
a.append(b)
print(a)

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

a = []

print(a)

b = [0, 1, 2]

a.append(b)

print(a)

b = [3, 4, 5]

a.append(b)

print(a)

# []

# [[0, 1, 2]]

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

`insert()`メソッド

insert()メソッドも素直にリストを追加してくれるが、追加位置を指定するのに一手間かかる。行の最後に追加するときは、追加位置をlen(元のリスト)で指定する

その他の仕様はappend()メソッドと同じ。

a = [[0, 1, 2]]
print(a)
b = [3, 4, 5]
a.insert(len(a), b)
print(a)

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

a = [[0, 1, 2]]

print(a)

b = [3, 4, 5]

a.insert(len(a), b)

print(a)

# [[0, 1, 2]]

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

空のリストへの追加もappend()メソッドと同様。

a = []
print(a)
b = [0, 1, 2]
a.insert(len(a), b)
print(a)
b = [3, 4, 5]
a.insert(len(a), b)
print(a)

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

a = []

print(a)

b = [0, 1, 2]

a.insert(len(a), b)

print(a)

b = [3, 4, 5]

a.insert(len(a), b)

print(a)

# []

# [[0, 1, 2]]

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

列の追加

列の追加の場合、各要素が縦に並んだ列ベクトルとしての定義になる。

`append()`メソッド

行の追加と同様。最初の1列から定義する場合、明示的に列ベクトルの2次元配列であることを明示する必要がある。

a = [[[0], [1], [2]]]
print(a)
b = [[3], [4], [5]]
a.append(b)
print(a)

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

a = [[[0], [1], [2]]]

print(a)

b = [[3], [4], [5]]

a.append(b)

print(a)

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

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

空のリストへの追加の場合は、行の追加と同様シンプル。

a = []
print(a)
b = [[0], [1], [2]]
a.append(b)
print(a)
b = [[3], [4], [5]]
a.append(b)
print(a)

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

a = []

print(a)

b = [[0], [1], [2]]

a.append(b)

print(a)

b = [[3], [4], [5]]

a.append(b)

print(a)

# []

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

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

`insert()`メソッド

insert()メソッドの場合も行の追加と同様。

a = [[[0], [1], [2]]]
print(a)
b = [[3], [4], [5]]
a.insert(len(a), b)
print(a)

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

a = [[[0], [1], [2]]]

print(a)

b = [[3], [4], [5]]

a.insert(len(a), b)

print(a)

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

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

空のリストへの追加も行の追加と同様。

a = []
print(a)
b = [[0], [1], [2]]
a.insert(len(a), b)
print(a)
b = [[3], [4], [5]]
a.insert(len(a), b)
print(a)

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

a = []

print(a)

b = [[0], [1], [2]]

a.insert(len(a), b)

print(a)

b = [[3], [4], [5]]

a.insert(len(a), b)

print(a)

# []

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

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

`ndarray`の場合

ndarrayの場合は、numpyのモジュール関数append()、insert()のほか、hstack()関数、vstack()関数も使える。

注意点

リストのメソッドと異なり、numpyの各モジュール関数は元の配列を変更せず、変更後の新たな配列を戻り値として返す
append()関数、insert()関数では、行の追加／列の追加に応じて引数axisを指定する
append()関数は、行を追加する場合は追加する配列も2次元で明示する必要があるが、列を追加する場合にはそのまま指定する
空の配列はempty()関数で準備し、型を指定しておく
hstack()関数、vstack()関数は、元の配列と追加する配列をタプルで指定する

行の追加

ndarrayで行を追加する場合、numpyモジュールのappend()関数、insert()関数でaxis=0を指定するか、vstack()関数を利用する。

`numpy.append()`関数

初期配列が2次元であることを明示しなければならない点はリストのappend()メソッドと同じだが、追加配列でもこれが必要になる。

numpy.append(元の配列, 追加する配列, axis=0)

追加する配列は、元の配列と次元・列数があっていなければならない
→行ベクトルでもndarrayの2次元配列としなければならない
→下記コード例では4行目のnp.array([b])
→こうしないと”次元が合わない”としてエラーになる
追加する配列を行として追加する場合は、axis=0の指定が必須(これを指定しないと、単に元の要素に続いて追加配列の要素が追加されるだけ)

a = np.array([[0, 1, 2]])
print(a)
b = np.array([3, 4, 5])
print(np.append(a, np.array([b]), axis=0))

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

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

print(a)

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

print(np.append(a, np.array([b]), axis=0))

# [[0 1 2]]

# [[0 1 2]

# [3 4 5]]

空の配列への追加の場合、numpy.empty(0, n)で空の配列を準備する。

numpy.empty((行数, 列数), dtype=型)

確保する配列の各次元のサイズはタプルで指定
行が空なので行数は0で指定
dtype引数で型を明示しないとデフォルトのfloat型になる

a = np.empty((0, 3), dtype=int)
print(a)
b = np.array([0, 1, 2])
a = np.append(a, np.array([b]), axis=0)
print(a)
b = np.array([3, 4, 5])
a = np.append(a, np.array([b]), axis=0)
print(a)

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

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

print(a)

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

a = np.append(a, np.array([b]), axis=0)

print(a)

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

a = np.append(a, np.array([b]), axis=0)

print(a)

# []

# [[0 1 2]]

# [[0 1 2]

# [3 4 5]]

`numpy.insert()`関数

リストのinsert()メソッドと同様だが、いくつか注意が必要。

numpy.insert(元の配列, 追加する行位置, 追加する配列, axis=0)

追加する位置は最後の行の次の行番号で、これは元の配列のshapeプロパティーで得られる(shape[0]は配列各次元のサイズで、2次元配列の場合shape[0]は行数、shape[1]は列数を表す)
追加する配列はそのまま指定する(2次元で定義しない)
→追加する配列は2次元化しても同じ結果になる
axis=0の指定が必要

a = np.array([np.array([0, 1, 2])])
print(a)
b = np.array([3, 4, 5])
print(np.insert(a, a.shape[0], b, axis=0))

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

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

print(a)

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

print(np.insert(a, a.shape[0], b, axis=0))

# [[0 1 2]]

# [[0 1 2]

# [3 4 5]]

空の配列への追加する場合は、元の配列をnumpy.empty(0, n)で生成。

a = np.empty((0, 3), dtype=int)
print(a)
b = np.array([0, 1, 2])
a = np.insert(a, a.shape[0], b, axis=0)
print(a)
b = np.array([3, 4, 5])
a = np.insert(a, a.shape[0], b, axis=0)
print(a)

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

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

print(a)

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

a = np.insert(a, a.shape[0], b, axis=0)

print(a)

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

a = np.insert(a, a.shape[0], b, axis=0)

print(a)

# []

# [[0 1 2]]

# [[0 1 2]

# [3 4 5]]

`numpy.vstack()`関数

numpy.vstack()関数は引数に2以上の配列を指定し、それらを縦に連結していく。特に2次元配列化や軸の指定の必要はない。

a = np.array([0, 1, 2])
print(a)
b = np.array([3, 4, 5])
print(np.vstack((a, b)))

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

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

print(a)

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

print(np.vstack((a, b)))

# [0 1 2]

# [[0 1 2]

# [3 4 5]]

空の配列への追加の場合は、numpy.empty(0, n)で生成した空の配列を含めて、順次タプルの中に追加したい配列を指定するだけでよい。

a = np.empty((0, 3), int)
print(a)
b = np.array([0, 1, 2])
c = np.array([3, 4, 5])
print(np.vstack((a, b, c)))

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

a = np.empty((0, 3), int)

print(a)

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

c = np.array([3, 4, 5])

print(np.vstack((a, b, c)))

# []

# [[0 1 2]

# [3 4 5]]

列の追加

ndarrayを列として追加していく場合、追加する配列も列形式である必要がある。列方向の追加をaxis引数で指定する必要がある。

通常の行形式の1次元配列を列として追加する場合、reshape(列数, 1)で列ベクトル化する
追加するベクトルを[]で囲って2次元化する必要はない
axisi=1で列方向の追加として指定

`numpy.append()`関数

行の追加の時と違って、元の配列も追加する配列も2次元化しない。

a = np.array([0, 1, 2]).reshape(3, 1)
print(a)
b = np.array([3, 4, 5]).reshape(3, 1)
print(np.append(a, b, axis=1))

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

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

print(a)

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

print(np.append(a, b, axis=1))

# [[0]

# [1]

# [2]]

# [[0 3]

# [1 4]

# [2 5]]

空の配列への追加は、列数をゼロとしてnumpy.empty(n, 0)で指定する。

a = np.empty((3, 0), dtype=int)
print(a)
b = np.array([0, 1, 2]).reshape(3, 1)
a = np.append(a, b, axis=1)
print(a)
b = np.array([3, 4, 5]).reshape(3, 1)
a = np.append(a, b, axis=1)
print(a)

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

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

print(a)

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

a = np.append(a, b, axis=1)

print(a)

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

a = np.append(a, b, axis=1)

print(a)

# []

# [[0]

# [1]

# [2]]

# [[0 3]

# [1 4]

# [2 5]]

`numpy.insert()`関数

numpy.insert()関数も行の追加と同じだが、以下の点に注意。

列の追加位置(最後の列の次)は元の変数のshapeプロパティーの2つ目shape[1]で指定する
追加する配列は2次元化せずそのまま指定
列方向の追加なのでaxis=1を指定する

a = np.array([0, 1, 2]).reshape(3, 1)
print(a)
b = np.array([3, 4, 5])
print(np.insert(a, a.shape[1], b, axis=1))

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

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

print(a)

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

print(np.insert(a, a.shape[1], b, axis=1))

# [[0]

# [1]

# [2]]

# [[0 3]

# [1 4]

# [2 5]]

空の配列への追加はこれまでと同様。

a = np.empty((3, 0), dtype=int)
print(a)
b = np.array([0, 1, 2])
a = np.insert(a, a.shape[1], b, axis=1)
print(a)
b = np.array([3, 4, 5])
a = np.insert(a, a.shape[1], b, axis=1)
print(a)

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

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

print(a)

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

a = np.insert(a, a.shape[1], b, axis=1)

print(a)

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

a = np.insert(a, a.shape[1], b, axis=1)

print(a)

# []

# [[0]

# [1]

# [2]]

# [[0 3]

# [1 4]

# [2 5]]

`numpy.hstack()`関数

numpy.hstack()関数はvstack()と同様、引数に2以上の配列を指定し、それらを横に連結していく。1次元配列はreshape(-1, 1)などで列ベクトル化する必要がある。

a = np.array([0, 1, 2]).reshape(3, 1)
print(a)
b = np.array([3, 4, 5]).reshape(3, 1)
print(np.hstack((a, b)))
# [[0]
#  [1]
#  [2]]
# [[0 3]
#  [1 4]
#  [2 5]]

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

print(a)

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

print(np.hstack((a, b)))

# [[0]

# [1]

# [2]]

# [[0 3]

# [1 4]

# [2 5]]

空の配列への追加の場合は、numpy.empty(n, 0)で生成した空の配列から始めて、順次タプルの中に追加したい配列を指定するだけでよい。

a = np.empty((3, 0), int)
print(a)
b = np.array([0, 1, 2]).reshape(3, 1)
c = np.array([3, 4, 5]).reshape(3, 1)
print(np.hstack((a, b, c)))

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

a = np.empty((3, 0), int)

print(a)

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

c = np.array([3, 4, 5]).reshape(3, 1)

print(np.hstack((a, b, c)))

# []

# [[0 3]

# [1 4]

# [2 5]]

概要

概要

概要

各オプションの説明

グラフタイトル

軸ラベル

軸の範囲

軸目盛の設定

凡例の表示

格子の表示

水平線・垂直線の表示

numpy.arange()～間隔を指定した数列の生成

引数・戻り値

引数の指定例

その他

降順の数列

実数列

dtypeによる型指定

numpy.linspace()～個数を指定した数列の生成

引数・戻り値

引数の指定例

その他

dtypeによる型指定

retstepを指定した公差の取り出し

やりたいこと

インデックスを利用する方法

1行で表示する場合

複数行に分けて表示する場合

ジェネレーターを使う方法

1行で表示する場合

複数行に分けて表示する場合

return文の確認

yield文にするとジェネレーターが生成される

yield文によるジェネレーターの挙動

yiled文とreturn文を混ぜた場合

実装の例

イテレーター

ジェネレーター

概要

テストケース

基本形

初期値を変えた場合

クラスターが不明確な場合

初期値1

初期値2

極端な例

初期値1

初期値2

3クラスター

初期値1

初期値2

まとめ

概要

全コード

利用方法

クラスタリングを行うインスタンスの生成

クラスタリングの実行

実行例

クラス説明

__init__()～インスタンス生成

get_result()～分析の実行

プライベートメソッド

_distance()～2点間の距離

_point_converged()～収束判定

_all_points_converged()～全ての点の収束判定

_set_nearest_mean_point()～各点に最も近い代表点

_revise_mean_points()～代表点の更新

random_scatter_data.py

概要

リストの場合

行の追加

append()メソッド

insert()メソッド

列の追加

append()メソッド

insert()メソッド

ndarrayの場合

行の追加

numpy.append()関数

numpy.insert()関数

`numpy.arange()`～間隔を指定した数列の生成

`numpy.linspace()`～個数を指定した数列の生成

`return`文の確認

`yield`文にするとジェネレーターが生成される

`yield`文によるジェネレーターの挙動

`yiled`文と`return`文を混ぜた場合

`init()`～インスタンス生成

`get_result()`～分析の実行

`_distance()`～2点間の距離

`_point_converged()`～収束判定

`_all_points_converged()`～全ての点の収束判定

`_set_nearest_mean_point()`～各点に最も近い代表点

`_revise_mean_points()`～代表点の更新

`append()`メソッド

`insert()`メソッド

`append()`メソッド

`insert()`メソッド

`ndarray`の場合

`numpy.append()`関数

`numpy.insert()`関数

`numpy.vstack()`関数

`numpy.append()`関数

`numpy.insert()`関数

`numpy.hstack()`関数