決定木の分割の考え方

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

決定木の分割の考え方

決定木のデータを特性量によって分割するには、分割後のノードの状態ができるだけうまく分かれていることが必要となる。この「うまく分かれている」状態は、言い換えれば分割後のノード内のデータができるだけ「揃っている」ともいえる。たとえば2クラスの分類をする場合、ノード内に1つのクラスしか含まれていない場合は最も「純度が高い」状態であり、2つのクラスのデータが半分ずつ含まれている場合に最も「純度が低い」状態となる。

このような状態を定量的に表すのにエントロピーとジニ不純度という2つの考え方があるが、ここではそれらを確認する。

エントロピー（平均情報量）とジニ不純度

定義

クラスc = 1~Cに属するデータがノードtに属しており、各クラスごとのデータ数をn_c、データの総数をNとする。この場合、このノードの純度／不純度を表すのに、エントロピー（entropy、平均情報量）とジニ不純度（Gini impurity）という2つの考え方がある。ノードtのエントロピーをI_H(t)、ジニ不純度をI_G(t)と表すと、それぞれの定義は以下の通り。

(1) $\begin{align*} I_H(t) &= - \sum_{c=1}^C p_c(t) \log p_c(t) = - \sum_{c=1}^C \frac{n_c}{N} \log \frac{n_c}{N} \\ I_G(t) &= 1 - \sum_{c=1}^C p_c^2 = 1 - \sum_{c=1}^C \left( \frac{n_c}{N} \right)^2 \end{align*}$

エントロピーの対数の底は何でもいいが、分類するクラス数にすると最も高いエントロピーが1になって都合がよいようだ）。

ジニ不純度については次の表現の方が直感的にわかりやすい。

(2) $\begin{equation*} I_G(t) = \sum_{c=1}^C p_c (1 - p_c) \end{equation*}$

これを展開すると先のI_Gと同じ形になるが、この形だと関数形が上に凸でp_c = 0, 1でI_G = 0となることがわかる。

計算例

クラス数Cのデータについて、あるノード内のデータが全て同じクラスの場合、純度が高い／不純度が低い。

(3) $\begin{align*} I_H(t) &= - \frac{N}{N} \log_C \frac{N}{N} = 0 \\ I_G(t) &= 1 - \left( \frac{N}{N} \right)^2 = 0 \end{align*}$

ノード内で全てのクラスのデータが同じ数ずつある場合、純度が低い／不純度が高い。

(4) $\begin{align*} I_H(t) &= - C \cdot \frac{N/C}{N} \log_C \frac{N/C}{N} = - C \cdot \frac{1}{C} \log_C \frac{1}{C} = 1 \\ I_G(t) &= 1 - C \left( \frac{N/C}{N} \right)^2 = 1 - \frac{1}{C} \end{align*}$

分布

あるノード内にN個の2クラスデータがあり、クラス1のデータ数をnとする。このとき、クラス1のデータの発生率pに対するエントロピー、ジニ不純度の分布は以下のようになる。

(5) $\begin{align*} I_H(p; t) &= - \frac{n}{N} \log_2 \frac{n}{N} - \frac{N-n}{N} \log_2 \frac{N-n}{N} \\ &= -p \log_2 p - (1-p) \log_2 (1-p) \\ I_G(p; t) &= 1 - \left( \frac{n}{N} \right)^2 - \left( \frac{N-n}{N} \right)^2 \\ &= 1 - p^2 - (1-p)^2 \end{align*}$

これらをグラフ化したのが以下の図。p = 0.5で双方最大値をとり、エントロピーは1 、ジニ不純度は0.5。グラフの形状を比較するため、ジニ不純度を2倍した線も入れている。

import numpy as np
import matplotlib.pyplot as plt

eps = 1e-3
p = np.linspace(eps, 1 - eps)
Ih = -p * np.log2(p) - (1 - p) * np.log2(1 - p)
Ig = 1 - p**2 - (1 - p)**2

fig, ax = plt.subplots()

ax.plot(p, Ih, c='tab:blue', label="Entropy", clip_on=False)
ax.plot(p, Ig, c='tab:orange', label="Gini impurity")
ax.plot(p, Ig*2, c='tab:orange', ls='dashed', label="Gini doubled"
    , clip_on=False)

ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
ax.set_xticks(np.linspace(0, 1, 11))
ax.set_yticks(np.linspace(0, 1, 11))
ax.grid(True)
ax.set_aspect('equal')
ax.legend()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

eps = 1e-3

p = np.linspace(eps, 1 - eps)

Ih = -p * np.log2(p) - (1 - p) * np.log2(1 - p)

Ig = 1 - p**2 - (1 - p)**2

fig, ax = plt.subplots()

ax.plot(p, Ih, c='tab:blue', label="Entropy", clip_on=False)

ax.plot(p, Ig, c='tab:orange', label="Gini impurity")

ax.plot(p, Ig*2, c='tab:orange', ls='dashed', label="Gini doubled"

, clip_on=False)

ax.set_xlim(0, 1)

ax.set_ylim(0, 1)

ax.set_xticks(np.linspace(0, 1, 11))

ax.set_yticks(np.linspace(0, 1, 11))

ax.grid(True)

ax.set_aspect('equal')

ax.legend()

plt.show()

ノード分割の考え方～利得

親ノードを子ノードに分割するのに最も妥当な分割とするには、分割後の子ノードの純度ができるだけ高くなるような特徴量を探すことになる。ある特徴量について、親ノードから子ノードに分割したときにどれだけ純度が高くなったかを比較する量として、利得（情報利得、gain）が用いられる。

親ノードt_Pにc = 1~Cのクラスのデータがそれぞれn_cずつあるとする。このときの親ノードのエントロピーI_H(t_P)、ジニ不純度I_G(t_P)は式(1)で計算される。

まずエントロピーについて考える。ある特徴量fを定めると左右のノードのデータ分布が決まり、その時の左ノードt_L、右ノードt_Lのエントロピーが以下のように計算される。

(6) $\begin{align*} & I_H(t_L) = -p_c(t_L) \sum_{c=1}^C \log p_c(t_L) = - \sum_{c=1}^C \frac{n_c(t_L)}{N(t_L)} \log \frac{n_c(t_L)}{N(t_L)} \\ & I_H(t_R) = -p_c(t_R) \sum_{c=1}^C \log p_c(t_R) = - \sum_{c=1}^C \frac{n_c(t_R)}{N(t_R)} \log \frac{n_c(t_R)}{N(t_R)} \end{align*}$

このとき、それぞれのノードのエントロピーにノードの重みw_L, w_Rを掛け、これを親ノードのエントロピーから引いた量を利得（gain、情報利得）という。重みを各ノードのデータ数の比率とすると、利得は以下のように計算される。

(7) $\begin{align*} G_H(t_P, f) &= I_H(t_P) - w_L I_H(t_L) - w_R I_H(t_R) \\ &= I_H(t_P) - \frac{n_L}{N} I_H(t_L) - \frac{n_R}{N} I_H(t_R) \end{align*}$

ジニ不純度についても同様の計算ができる。

(8) $\begin{align*} G_G(t_P, f) &= I_G(t_P) - w_L I_G(t_L) - w_R I_G(t_R) \\ &= I_G(t_P) - \frac{n_L}{N} I_G(t_L) - \frac{n_R}{N} I_G(t_R) \end{align*}$

利得は、ある特徴量の値によって分割した後の状態が、分割前の状態に対してどれだけ純度が高くなったかを表す。

決定木のノードを分割するにあたっては、子ノードの純度ができるだけ高くなるように（エントロピー／ジニ不純度が小さくなるように）fを選ぶことになる。

簡単な例

特徴量が1つでデータ数が少ないケースで、利得の計算を確認してみる。

000111と並んでいる場合

クラス0、1がこのように並んでいるとき、左から境界を動かしていったときの左右のノードの不純度、利得について計算した結果は以下の通り。

IHP=1.0, IGP=0.5
[0][0 0 1 1 1]:
  IHL=-0.000, IHR= 0.971, G_H= 0.191
  IGL= 0.000, IGR= 0.480, G_G= 0.100
[0 0][0 1 1 1]:
  IHL=-0.000, IHR= 0.811, G_H= 0.459
  IGL= 0.000, IGR= 0.375, G_G= 0.250
[0 0 0][1 1 1]:
  IHL=-0.000, IHR= 0.000, G_H= 1.000
  IGL= 0.000, IGR= 0.000, G_G= 0.500
[0 0 0 1][1 1]:
  IHL= 0.811, IHR= 0.000, G_H= 0.459
  IGL= 0.375, IGR= 0.000, G_G= 0.250
[0 0 0 1 1][1]:
  IHL= 0.971, IHR= 0.000, G_H= 0.191
  IGL= 0.480, IGR= 0.000, G_G= 0.100

IHP=1.0, IGP=0.5

[0][0 0 1 1 1]:

IHL=-0.000, IHR= 0.971, G_H= 0.191

IGL= 0.000, IGR= 0.480, G_G= 0.100

[0 0][0 1 1 1]:

IHL=-0.000, IHR= 0.811, G_H= 0.459

IGL= 0.000, IGR= 0.375, G_G= 0.250

[0 0 0][1 1 1]:

IHL=-0.000, IHR= 0.000, G_H= 1.000

IGL= 0.000, IGR= 0.000, G_G= 0.500

[0 0 0 1][1 1]:

IHL= 0.811, IHR= 0.000, G_H= 0.459

IGL= 0.375, IGR= 0.000, G_G= 0.250

[0 0 0 1 1][1]:

IHL= 0.971, IHR= 0.000, G_H= 0.191

IGL= 0.480, IGR= 0.000, G_G= 0.100

この場合、当然のことながら真ん中でノードを分割することで2つのクラスがきれいに分かれ、利得もこれを表している。

00100111と並んでいる場合

今度は一部に他のクラスが紛れ込んでいる場合。左のクラス0の集団に1つだけクラス1のデータが含まれているときの挙動を確認する。

IHP=1.0, IGP=0.5
[0][0 1 0 0 1 1 1]:
  IHL=-0.000, IHR= 0.985, G_H= 0.138
  IGL= 0.000, IGR= 0.490, G_G= 0.071
[0 0][1 0 0 1 1 1]:
  IHL=-0.000, IHR= 0.918, G_H= 0.311
  IGL= 0.000, IGR= 0.444, G_G= 0.167
[0 0 1][0 0 1 1 1]:
  IHL= 0.918, IHR= 0.971, G_H= 0.049
  IGL= 0.444, IGR= 0.480, G_G= 0.033
[0 0 1 0][0 1 1 1]:
  IHL= 0.811, IHR= 0.811, G_H= 0.189
  IGL= 0.375, IGR= 0.375, G_G= 0.125
[0 0 1 0 0][1 1 1]:
  IHL= 0.722, IHR= 0.000, G_H= 0.549
  IGL= 0.320, IGR= 0.000, G_G= 0.300
[0 0 1 0 0 1][1 1]:
  IHL= 0.918, IHR= 0.000, G_H= 0.311
  IGL= 0.444, IGR= 0.000, G_G= 0.167
[0 0 1 0 0 1 1][1]:
  IHL= 0.985, IHR= 0.000, G_H= 0.138
  IGL= 0.490, IGR= 0.000, G_G= 0.071

IHP=1.0, IGP=0.5

[0][0 1 0 0 1 1 1]:

IHL=-0.000, IHR= 0.985, G_H= 0.138

IGL= 0.000, IGR= 0.490, G_G= 0.071

[0 0][1 0 0 1 1 1]:

IHL=-0.000, IHR= 0.918, G_H= 0.311

IGL= 0.000, IGR= 0.444, G_G= 0.167

[0 0 1][0 0 1 1 1]:

IHL= 0.918, IHR= 0.971, G_H= 0.049

IGL= 0.444, IGR= 0.480, G_G= 0.033

[0 0 1 0][0 1 1 1]:

IHL= 0.811, IHR= 0.811, G_H= 0.189

IGL= 0.375, IGR= 0.375, G_G= 0.125

[0 0 1 0 0][1 1 1]:

IHL= 0.722, IHR= 0.000, G_H= 0.549

IGL= 0.320, IGR= 0.000, G_G= 0.300

[0 0 1 0 0 1][1 1]:

IHL= 0.918, IHR= 0.000, G_H= 0.311

IGL= 0.444, IGR= 0.000, G_G= 0.167

[0 0 1 0 0 1 1][1]:

IHL= 0.985, IHR= 0.000, G_H= 0.138

IGL= 0.490, IGR= 0.000, G_G= 0.071

左から1つ目2つ目と境界を動かしていくと少しずつ利得が上昇するが、左側のノードにクラス1のデータが入ってきたところでその不純度が跳ね上がり、利得が下がる（8～10行目）。その後再び利得は上昇し、右側のデータがクラス1のみ3つとなった時に利得が最大となっている。このとき左側のノードにクラス1のデータが1つ含まれているが、他の4つのデータがクラスゼロと多いため、不純度は比較的低い。

利得が最大となる時でも、完全にクラスが分かれた時に比べて半分近くの利得だが、これはデータ数の多い左側に異なるクラスのデータが含まれているからと考えられる。

ここまでの計算に使ったコードは以下の通り。

import numpy as np

def impurity(node):
    N = node.size
    n0 = node[node==0].size
    n1 = node[node==1].size
    p0, p1 = n0 / N, n1 / N
    entropy = - (p0 * np.log2(p0) if p0 > 0 else 0) \
              - (p1 * np.log2(p1) if p1 > 0 else 0)
    gini = 1 - p0*p0 - p1*p1

    return entropy, gini

#node = np.array([0, 0, 0, 1, 1, 1])
node = np.array([0, 0, 1, 0, 0, 1, 1, 1])

IHP, IGP = impurity(node)
print("IHP={}, IGP={}".format(IHP, IGP))
for pos in range(1, node.size):
    node_left = node[0:pos]
    node_right = node[pos:node.size]
    node_text = "{}{}".format(node_left, node_right)
    IHL, IGL = impurity(node_left)
    IHR, IGR = impurity(node_right)
    wL = node_left.size / node.size
    wR = node_right.size / node.size
    GH = IHP - wL*IHL - wR*IHR
    GG = IGP - wL*IGL - wR*IGR
    print("{}:".format(node_text))
    print("  IHL={:6.3f}, IHR={:6.3f}, G_H={:6.3f}".format(IHL, IHR, GH))
    print("  IGL={:6.3f}, IGR={:6.3f}, G_G={:6.3f}".format(IGL, IGR, GG))

import numpy as np

def impurity(node):

N = node.size

n0 = node[node==0].size

n1 = node[node==1].size

p0, p1 = n0 / N, n1 / N

entropy = - (p0 * np.log2(p0) if p0 > 0 else 0) \

- (p1 * np.log2(p1) if p1 > 0 else 0)

gini = 1 - p0*p0 - p1*p1

return entropy, gini

#node = np.array([0, 0, 0, 1, 1, 1])

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

IHP, IGP = impurity(node)

print("IHP={}, IGP={}".format(IHP, IGP))

for pos in range(1, node.size):

node_left = node[0:pos]

node_right = node[pos:node.size]

node_text = "{}{}".format(node_left, node_right)

IHL, IGL = impurity(node_left)

IHR, IGR = impurity(node_right)

wL = node_left.size / node.size

wR = node_right.size / node.size

GH = IHP - wL*IHL - wR*IHR

GG = IGP - wL*IGL - wR*IGR

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

print(" IHL={:6.3f}, IHR={:6.3f}, G_H={:6.3f}".format(IHL, IHR, GH))

print(" IGL={:6.3f}, IGR={:6.3f}, G_G={:6.3f}".format(IGL, IGR, GG))

線形モデルによる多クラス分類

2020-05-23 / tau / 4件のコメント

概要

この項はO’REILLYの「Pythonではじめる機械学習」の「2.3.3.6　線形モデルによる多クラス分類」を自分なりに理解しやすいようにトレースしたもの。扱いやすい仮想のデータセットを生成し、LinearSVCモデルでこれらを分類する流れを例示している。

例えば特徴量x₁～x_nのデータxをC₁, C₂の2クラスに分類する線形モデルは以下とおり。

(1) $\begin{gather*} y = b + w_1 x_1 + \cdots + w_n x_n \\ \left\{ \begin{array}{ll} y \ge 0 \quad \rightarrow \quad \boldsymbol{x} \in C_1 \\ y < 0 \quad \rightarrow \quad \boldsymbol{x} \in C_2 \end{array} \right. \end{gather*}$

yの符号によってどちらのクラスに分類されるかを決定するが、1つの式で3つ以上のクラスを分類することはできない（ただし一般化線形モデル(GLM)であるLogistic回帰は多クラス分類が可能）。

このような2クラス分類を多クラス分類に拡張する方法の一つが1対その他(one-vs-rest, one-vs-the-rest, 1vR)という考え方で、1つの式によって、あるクラスとその他すべてのクラスを分けようというもの。この式の形は(1)と同じで、yの値は与えられたデータがそのクラスに属する確信度(confidence)を表す。クラスの数だけこの分類器(one-vs-the-rest-classifier)を準備し、あるデータが与えられたとき、最も確信度が高いクラスに属すると考える。たとえばn個の特徴量を持つデータの3クラス分類の場合、次のように3つの分類器を準備し、与えられたデータxはy_cの値が最も大きいクラスに属する。

(2) $\begin{gather*} y_0 = b_0 + w_{01} x_1 + \cdots + w_{0n} x_n \\ y_1 = b_1 + w_{11} x_1 + \cdots + w_{1n} x_n \\ y_2 = b_2 + w_{21} x_1 + \cdots + w_{2n} x_n \end{gather*}$

LinearSVCによる多クラス分類の例

データの準備

準備として、shikit-leran.datasetsのmake_blobs()で、2つの特徴量と3つのクラスのデータセットを生成する。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

X, y = make_blobs(random_state=42)

fig, ax = plt.subplots()

f0_min, f0_max = -10, 8
f1_min, f1_max = -10, 15
markers = ['o', '^', 'v']

for cls, marker in zip(range(3), markers):
    x = X[y==cls]
    ax.scatter(x[:, 0], x[:, 1],
        ec='k', marker=marker, label="Class {}".format(cls))

ax.set_xlim(f0_min, f0_max)
ax.set_ylim(f1_min, f1_max)
ax.set_xlabel("Feature 0")
ax.set_ylabel("Feature 1")
ax.legend()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import make_blobs

X, y = make_blobs(random_state=42)

fig, ax = plt.subplots()

f0_min, f0_max = -10, 8

f1_min, f1_max = -10, 15

markers = ['o', '^', 'v']

for cls, marker in zip(range(3), markers):

x = X[y==cls]

ax.scatter(x[:, 0], x[:, 1],

ec='k', marker=marker, label="Class {}".format(cls))

ax.set_xlim(f0_min, f0_max)

ax.set_ylim(f1_min, f1_max)

ax.set_xlabel("Feature 0")

ax.set_ylabel("Feature 1")

ax.legend()

plt.show()

LinearSVCによる学習

学習とモデルの形

scikit-learn.linear_modelのLinearSVC(Linear Support Vector Classification)は多クラス分類のモデルを提供する。このモデルをmake_blobs()で生成したデータで学習させると、3行2列の係数(LinearSVC.coef_)と3要素の切片(LinearSVC.intercept_)を得る。

import numpy as np
import matplotlib.pyplot as plt
from pandas import DataFrame
from sklearn.datasets import make_blobs
from sklearn.svm import LinearSVC

X, y = make_blobs(random_state=42)
df = DataFrame(X, columns=["f0", "f1"])
df['target'] = y

linsvm = LinearSVC().fit(X, y)
w = linsvm.coef_
b = linsvm.intercept_

print("Intercept: {}".format(b))
print("Coefficients(class, feature):\n{}".format(w))

# Intercept: [-1.07745476  0.13140569 -0.08604816]
# Coefficients(class, feature):
# [[-0.17491916  0.23140527]
#  [ 0.47621794 -0.06937226]
#  [-0.18914243 -0.20399679]]

import numpy as np

import matplotlib.pyplot as plt

from pandas import DataFrame

from sklearn.datasets import make_blobs

from sklearn.svm import LinearSVC

X, y = make_blobs(random_state=42)

df = DataFrame(X, columns=["f0", "f1"])

df['target'] = y

linsvm = LinearSVC().fit(X, y)

w = linsvm.coef_

b = linsvm.intercept_

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

print("Coefficients(class, feature):\n{}".format(w))

# Intercept: [-1.07745476 0.13140569 -0.08604816]

# Coefficients(class, feature):

# [[-0.17491916 0.23140527]

# [ 0.47621794 -0.06937226]

# [-0.18914243 -0.20399679]]

これらの係数の行と切片の要素は分類されるべきクラス、係数の列は特徴量に対応している。クラスに対するインデックスをc = 0, 1, 2、特徴量f₀, f₁に対するインデックスをf= 0, 1とすると、上記の結果は以下のような意味になる。

(3) $\begin{align*} w_{cf} &= \left[ \begin{array}{rrr} -0.17492222 & 0.23140089 \\ 0.4762125 & -0.06936704 \\ -0.18914556 & -0.20399715 \end{array} \right] \\ b_c &= [-1.07745632 \quad 0.13140349 \quad -0.08604899] \end{align*}$

これらの係数、切片を用いたクラス分類の予測式は以下の通りで、LinearSVCではdecision function（決定関数）とされている。

(4) $\begin{equation*} y_c = b_c + w_{c0} \times f_0 + w_{c1} \times f_1 \end{equation*}$

あるデータの特徴量f₀, f₁に対して上記のy_cが正の時にはそのデータはクラスc、負の時にはクラスc以外であると判定される。

coef_やintercept_の値は、実行ごとにわずかに異なる（10⁻⁶くらいのオーダー）。LinearSVCのコンストラクターの引数にrandom_stateが含まれていて、ドキュメントに以下のような記述があった。

The underlying C implementation uses a random number generator to select features when fitting the model. It is thus not uncommon to have slightly different results for the same input data. If that happens, try with a smaller tol parameter.The underlying implementation, liblinear, uses a sparse internal representation for the data that will incur a memory copy.

Predict output may not match that of standalone liblinear in certain cases. See differences from liblinear in the narrative documentation.

訓練データに対する決定関数・確信度

データセットの100個の各データに対してy_c (c = 0, 1, 2)を計算した結果は以下の通り。

df['y0'] = b[0] + w[0, 0] * df['f0'] + w[0, 1] * df['f1']
df['y1'] = b[1] + w[1, 0] * df['f0'] + w[1, 1] * df['f1']
df['y2'] = b[2] + w[2, 0] * df['f0'] + w[2, 1] * df['f1']

print(df)

# DataFrame adding Confidences:
#           f0        f1  target        y0        y1        y2
# 0  -7.726421 -8.394957       2 -1.668593 -2.965677  3.087890
# 1   5.453396  0.742305       1 -1.859585  2.676915 -1.268945
# 2  -2.978672  9.556846       0  1.655077 -1.950071 -1.472221
# 3   6.042673  0.571319       1 -2.002228  2.969401 -1.345521
# 4  -6.521840 -6.319325       2 -1.398985 -2.536026  2.436631
# ..       ...       ...     ...       ...       ...       ...
# 95 -3.186120  9.625962       0  1.707357 -2.053656 -1.447083
# 96 -1.478198  9.945566       0  1.482567 -1.262485 -1.835322
# 97  4.478593  2.377221       1 -1.310745  2.099279 -1.418086
# 98 -5.796576 -5.826308       2 -1.411761 -2.224844  2.198878
# 99 -3.348415  8.705074       0  1.522647 -2.067060 -1.228528
# 
# [100 rows x 6 columns]

df['y0'] = b[0] + w[0, 0] * df['f0'] + w[0, 1] * df['f1']

df['y1'] = b[1] + w[1, 0] * df['f0'] + w[1, 1] * df['f1']

df['y2'] = b[2] + w[2, 0] * df['f0'] + w[2, 1] * df['f1']

print(df)

# DataFrame adding Confidences:

# f0 f1 target y0 y1 y2

# 0 -7.726421 -8.394957 2 -1.668593 -2.965677 3.087890

# 1 5.453396 0.742305 1 -1.859585 2.676915 -1.268945

# 2 -2.978672 9.556846 0 1.655077 -1.950071 -1.472221

# 3 6.042673 0.571319 1 -2.002228 2.969401 -1.345521

# 4 -6.521840 -6.319325 2 -1.398985 -2.536026 2.436631

# .. ... ... ... ... ... ...

# 95 -3.186120 9.625962 0 1.707357 -2.053656 -1.447083

# 96 -1.478198 9.945566 0 1.482567 -1.262485 -1.835322

# 97 4.478593 2.377221 1 -1.310745 2.099279 -1.418086

# 98 -5.796576 -5.826308 2 -1.411761 -2.224844 2.198878

# 99 -3.348415 8.705074 0 1.522647 -2.067060 -1.228528

# [100 rows x 6 columns]

たとえばNo.0のデータはクラス2に属するので確信度はy2が正となり、他の2つのクラスに対しては負の値になっている。

上の計算ではintercept_とcoef_を使ってもともとの決定関数の式から確信度を計算したが、LinearSVCのdecition_function()メソッドで同じ結果を得ることができる。たとえばNo.0～2のデータで計算してみると以下の通りで同じ結果。

print("decision_function values for first 3 data")
print(linsvm.decision_function(df.iloc[0:3, 0:2]))

# decision_function values for first 3 data
# [[-1.668593   -2.96567746  3.08789015]
#  [-1.85958483  2.67691534 -1.26894468]
#  [ 1.65507664 -1.95007141 -1.47222084]]

print("decision_function values for first 3 data")

print(linsvm.decision_function(df.iloc[0:3, 0:2]))

# decision_function values for first 3 data

# [[-1.668593 -2.96567746 3.08789015]

# [-1.85958483 2.67691534 -1.26894468]

# [ 1.65507664 -1.95007141 -1.47222084]]

テストデータに対する予測

3つのテストデータを用意してクラス分類をしてみる。

X_test = np.array([[4, -2], [-2, 2], [-6, 5]])
preds = linsvm.predict(X_test)
print("Prediction:")
for x_test, pred in zip(X_test, preds):
    print("{} -> {}".format(x_test, pred))
print()
print("Confidences of 3 points:\n{}".format(linsvm.decision_function(X_test)))

# Prediction:
# [ 4 -2] -> 1
# [-2  2] -> 2
# [-6  5] -> 0
# 
# Confidences of 3 points:
# [[-2.23994194  2.17502199 -0.43462432]
#  [-0.2648059  -0.95977473 -0.11575688]
#  [ 1.12908656 -3.07276329  0.02882249]]

X_test = np.array([[4, -2], [-2, 2], [-6, 5]])

preds = linsvm.predict(X_test)

print("Prediction:")

for x_test, pred in zip(X_test, preds):

print("{} -> {}".format(x_test, pred))

print()

print("Confidences of 3 points:\n{}".format(linsvm.decision_function(X_test)))

# Prediction:

# [ 4 -2] -> 1

# [-2 2] -> 2

# [-6 5] -> 0

# Confidences of 3 points:

# [[-2.23994194 2.17502199 -0.43462432]

# [-0.2648059 -0.95977473 -0.11575688]

# [ 1.12908656 -3.07276329 0.02882249]]

各データとも分類されたクラスに対応する確信度が最も高い。ただし2つ目のデータについては全てのクラスに対する確信度が負の値で、その中で最も値が大きいクラス2に分類されている。

これらを図示すると以下のようになり、クラス2に分類された▼のデータは確かにどのデータにも属していそうな位置にある。

以上のコードをまとめておく。

import numpy as np
import matplotlib.pyplot as plt
from pandas import DataFrame
from sklearn.datasets import make_blobs
from sklearn.svm import LinearSVC

X, y = make_blobs(random_state=42)
df = DataFrame(X, columns=["f0", "f1"])
df['target'] = y

linsvm = LinearSVC().fit(X, y)
w = linsvm.coef_
b = linsvm.intercept_

print("Intercept: {}".format(b))
print("Coefficients(class, feature):\n{}".format(w))

print()

df['y0'] = b[0] + w[0, 0] * df['f0'] + w[0, 1] * df['f1']
df['y1'] = b[1] + w[1, 0] * df['f0'] + w[1, 1] * df['f1']
df['y2'] = b[2] + w[2, 0] * df['f0'] + w[2, 1] * df['f1']

print("DataFrame adding Confidences:\n{}".format(df))

print()

print("decision_function values for first 3 data")
print(linsvm.decision_function(df.iloc[0:3, 0:2]))

print()

X_test = np.array([[4, -2], [-2, 2], [-6, 5]])
preds = linsvm.predict(X_test)
print("Prediction:")
for x_test, pred in zip(X_test, preds):
    print("{} -> {}".format(x_test, pred))
print()
print("Confidences of 3 points:\n{}".format(linsvm.decision_function(X_test)))

fig, ax = plt.subplots()

f0_min, f0_max = -10, 8
f1_min, f1_max = -10, 15
markers = ['o', '^', 'v']

for cls, marker in zip(range(3), markers):
    x = X[y==cls]
    ax.scatter(x[:, 0], x[:, 1],
        ec='k', marker=marker, label="Class {}".format(cls))

ax.scatter(X_test[0][0], X_test[0][1],
    ec='k', c='tab:orange', marker=markers[1], s=80)
ax.scatter(X_test[1][0], X_test[1][1],
    ec='k', c='tab:green', marker=markers[2], s=80)
ax.scatter(X_test[2][0], X_test[2][1],
    ec='k', c='tab:blue', marker=markers[0], s=80)

ax.set_xlim(f0_min, f0_max)
ax.set_ylim(f1_min, f1_max)
ax.set_xlabel("Feature 0")
ax.set_ylabel("Feature 1")
ax.legend()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from pandas import DataFrame

from sklearn.datasets import make_blobs

from sklearn.svm import LinearSVC

X, y = make_blobs(random_state=42)

df = DataFrame(X, columns=["f0", "f1"])

df['target'] = y

linsvm = LinearSVC().fit(X, y)

w = linsvm.coef_

b = linsvm.intercept_

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

print("Coefficients(class, feature):\n{}".format(w))

print()

df['y0'] = b[0] + w[0, 0] * df['f0'] + w[0, 1] * df['f1']

df['y1'] = b[1] + w[1, 0] * df['f0'] + w[1, 1] * df['f1']

df['y2'] = b[2] + w[2, 0] * df['f0'] + w[2, 1] * df['f1']

print("DataFrame adding Confidences:\n{}".format(df))

print()

print("decision_function values for first 3 data")

print(linsvm.decision_function(df.iloc[0:3, 0:2]))

print()

X_test = np.array([[4, -2], [-2, 2], [-6, 5]])

preds = linsvm.predict(X_test)

print("Prediction:")

for x_test, pred in zip(X_test, preds):

print("{} -> {}".format(x_test, pred))

print()

print("Confidences of 3 points:\n{}".format(linsvm.decision_function(X_test)))

fig, ax = plt.subplots()

f0_min, f0_max = -10, 8

f1_min, f1_max = -10, 15

markers = ['o', '^', 'v']

for cls, marker in zip(range(3), markers):

x = X[y==cls]

ax.scatter(x[:, 0], x[:, 1],

ec='k', marker=marker, label="Class {}".format(cls))

ax.scatter(X_test[0][0], X_test[0][1],

ec='k', c='tab:orange', marker=markers[1], s=80)

ax.scatter(X_test[1][0], X_test[1][1],

ec='k', c='tab:green', marker=markers[2], s=80)

ax.scatter(X_test[2][0], X_test[2][1],

ec='k', c='tab:blue', marker=markers[0], s=80)

ax.set_xlim(f0_min, f0_max)

ax.set_ylim(f1_min, f1_max)

ax.set_xlabel("Feature 0")

ax.set_ylabel("Feature 1")

ax.legend()

plt.show()

LinearSVCの決定境界

クラスごとのone-vs-restの決定境界

blobsデータは明確に分かれた3つのクラスに分類され、それぞれに対する決定関数の切片と係数が得られた。そこで、各決定関数の決定関数の意思決定境界(decision boundary)を描いてみる。意思決定境界は決定関数の値がゼロとなる線なので、以下の式で表される。

(5) $\begin{gather*} b_c + w_0 f_0 + w_1 f_1 = 0 \quad \rightarrow \quad f_1 = \frac{-(b_c + w_{c0} f_0)}{w_{c1}} \end{gather*}$

3つの決定関数について決定境界を描いたのが以下の結果。

たとえばClass 0の実線は、Class 0の塊とその他(Class1, Class 2)の塊を1対その他で分けている。この線の上側では確信度はプラスで、下側ではマイナスとなっている。

import matplotlib.pyplot as plt
from pandas import DataFrame
from sklearn.datasets import make_blobs
from sklearn.svm import LinearSVC

f0_min, f0_max = -10, 8
f1_min, f1_max = -10, 15

X, y = make_blobs(random_state=42)
df = DataFrame(X, columns=["feature-0", "feature-1"])
df['target'] = y

linsvm = LinearSVC().fit(X, y)
w = linsvm.coef_
b = linsvm.intercept_

fig, ax = plt.subplots(figsize=(7.2, 4.8))

markers = ['o', '^', 'v']
line_styles = ['solid', 'dashed', 'dotted']

for c, marker, ls in zip(range(3), markers, line_styles):
    x = X[y==c]
    ax.scatter(x[:, 0], x[:, 1], marker=marker, label="Class {}".format(c))

    f1_left = -(b[c] + w[c, 0] * f0_min) / w[c, 1]
    f1_right = -(b[c] + w[c, 0] * f0_max) / w[c, 1]
    ax.plot([f0_min, f0_max], [f1_left, f1_right],
        linestyle=ls, linewidth=2, label="Class {}".format(c))

ax.set_xlim(f0_min, f0_max)
ax.set_ylim(f1_min, f1_max)
ax.legend(bbox_to_anchor=(1, 1))
fig.tight_layout()

plt.show()

import matplotlib.pyplot as plt

from pandas import DataFrame

from sklearn.datasets import make_blobs

from sklearn.svm import LinearSVC

f0_min, f0_max = -10, 8

f1_min, f1_max = -10, 15

X, y = make_blobs(random_state=42)

df = DataFrame(X, columns=["feature-0", "feature-1"])

df['target'] = y

linsvm = LinearSVC().fit(X, y)

w = linsvm.coef_

b = linsvm.intercept_

fig, ax = plt.subplots(figsize=(7.2, 4.8))

markers = ['o', '^', 'v']

line_styles = ['solid', 'dashed', 'dotted']

for c, marker, ls in zip(range(3), markers, line_styles):

x = X[y==c]

ax.scatter(x[:, 0], x[:, 1], marker=marker, label="Class {}".format(c))

f1_left = -(b[c] + w[c, 0] * f0_min) / w[c, 1]

f1_right = -(b[c] + w[c, 0] * f0_max) / w[c, 1]

ax.plot([f0_min, f0_max], [f1_left, f1_right],

linestyle=ls, linewidth=2, label="Class {}".format(c))

ax.set_xlim(f0_min, f0_max)

ax.set_ylim(f1_min, f1_max)

ax.legend(bbox_to_anchor=(1, 1))

fig.tight_layout()

plt.show()

全体を融合した決定境界

先の図の中で、各クラスの塊の近くでは、そのクラスの決定関数の値はプラスで他はマイナスとなっているが、真ん中の三角形の中や、その対角にある三角形の領域では、複数の確信度がマイナスあるいはプラスとなる。このような場合には、全クラスに対して着目するデータの決定関数値を計算し、その確信度が最も大きいクラスをそのデータのクラスラベルとして与える。

以下の図は、領域内の点について全て確信度を計算し、各点において最も確信度が大きいクラスをその点のクラスとして表現した図である。

各領域の境界が3つの決定関数から導かれた意思決定境界であり、その線上で決定関数の値が等しくなっている。

import numpy as np
import matplotlib.pyplot as plt
from pandas import DataFrame
from sklearn.datasets import make_blobs
from sklearn.svm import LinearSVC

f0_min, f0_max = -10, 8
f1_min, f1_max = -10, 15

X, y = make_blobs(random_state=42)
df = DataFrame(X, columns=["feature-0", "feature-1"])
df['target'] = y
n_classes = max(y + 1)

linsvm = LinearSVC().fit(X, y)
w = linsvm.coef_
b = linsvm.intercept_

markers = ['o', '^', 'v']
line_styles = ['solid', 'dashed', 'dotted']
colors = ['tab:blue', 'tab:orange', 'tab:green']

fig, ax = plt.subplots()

for f0 in np.linspace(f0_min, f0_max, 75):
    for f1 in np.linspace(f1_min, f1_max, 55):
        conf = [b[c] + w[c, 0] * f0 + w[c, 1] * f1 for c in range(n_classes)]
        ax.scatter(f0, f1, c=colors[np.argmax(conf)], marker='s', s=20, alpha=0.2)

for c, marker, ls in zip(range(3), markers, line_styles):
    x = X[y==c]
    ax.scatter(x[:, 0], x[:, 1], marker=marker, label="Class {}".format(c))

    f1_left = -(b[c] + w[c, 0] * f0_min) / w[c, 1]
    f1_right = -(b[c] + w[c, 0] * f0_max) / w[c, 1]
    ax.plot([f0_min, f0_max], [f1_left, f1_right], linestyle=ls, linewidth=2)

ax.set_xlim(f0_min, f0_max)
ax.set_ylim(f1_min, f1_max)
ax.legend()

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from pandas import DataFrame

from sklearn.datasets import make_blobs

from sklearn.svm import LinearSVC

f0_min, f0_max = -10, 8

f1_min, f1_max = -10, 15

X, y = make_blobs(random_state=42)

df = DataFrame(X, columns=["feature-0", "feature-1"])

df['target'] = y

n_classes = max(y + 1)

linsvm = LinearSVC().fit(X, y)

w = linsvm.coef_

b = linsvm.intercept_

markers = ['o', '^', 'v']

line_styles = ['solid', 'dashed', 'dotted']

colors = ['tab:blue', 'tab:orange', 'tab:green']

fig, ax = plt.subplots()

for f0 in np.linspace(f0_min, f0_max, 75):

for f1 in np.linspace(f1_min, f1_max, 55):

conf = [b[c] + w[c, 0] * f0 + w[c, 1] * f1 for c in range(n_classes)]

ax.scatter(f0, f1, c=colors[np.argmax(conf)], marker='s', s=20, alpha=0.2)

for c, marker, ls in zip(range(3), markers, line_styles):

x = X[y==c]

ax.scatter(x[:, 0], x[:, 1], marker=marker, label="Class {}".format(c))

f1_left = -(b[c] + w[c, 0] * f0_min) / w[c, 1]

f1_right = -(b[c] + w[c, 0] * f0_max) / w[c, 1]

ax.plot([f0_min, f0_max], [f1_left, f1_right], linestyle=ls, linewidth=2)

ax.set_xlim(f0_min, f0_max)

ax.set_ylim(f1_min, f1_max)

ax.legend()

plt.show()

scikit-learn – Ridge/Lasso

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

概要

scikit-learnのRidge/Lassoは、それぞれRidge回帰、Lasso回帰のモデルを提供する。それぞれのモデルは、LinearRegression回帰に対してL2ノルム、L1ノルムによる正則化を付加する（Ridge回帰とLasso回帰を参照）。

モデルの利用方法の概要は以下の手順でLinearRegressionとほぼ同じだが、モデルインスタンス生成時に正則化に関するハイパーパラメーターalphaを与える。

Ridge/Lassoのクラスをインポートする
ハイパーパラメーターalpha、solver（収束計算方法）などを指定し、モデルのインスタンスを生成する
fit()メソッドに訓練データを与えて学習させる

学習済みのモデルの利用方法は以下の通り。

score()メソッドにテストデータを与えて適合度を計算する
predict()メソッドに説明変数を与えてターゲットを予測
モデルインスタンスのプロパティーからモデルのパラメーターを利用
- 切片はintercept_、重み係数はcoef_(末尾のアンダースコアに注意)

利用例

以下はscikit-learnのBoston hose pricesデータのうち、2つの特徴量RM(1戸あたり部屋数)とLSTAT(下位層の人口比率)を取り出して、Ridge回帰/Lasso回帰のモデルを適用している。ハイパーパラメーターはalpha=1.0で設定している(ここではpandasのDataFrameを利用しているが、配列による操作についてはLinearRegressionを参照)。

import pandas as pd
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso

ds = load_boston()
df = pd.DataFrame(ds.data, columns=ds.feature_names)

X = df[['RM', 'LSTAT']]
y = ds['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

ridge = Ridge(alpha=1.0)
lasso = Lasso(alpha=1.0)
ridge.fit(X_train, y_train)
lasso.fit(X_train, y_train)

print("Ridge")
print("Score:{}".format(ridge.score(X_test, y_test)))
print("Prediction for (7, 5):{}".format(ridge.predict([[7, 5]])))
print("Intercept:{}".format(ridge.intercept_))
print("Coefficients:{}".format(ridge.coef_))
print()
print("Lasso")
print("Score:{}".format(lasso.score(X_test, y_test)))
print("Prediction for (7, 5):{}".format(lasso.predict([[7, 5]])))
print("Intercept:{}".format(lasso.intercept_))
print("Coefficients:{}".format(lasso.coef_))

# Ridge
# Score:0.5691622120420186
# Prediction for (7, 5):[31.13688148]
# Intercept:-0.29837159723311046
# Coefficients:[ 4.97435821 -0.67705088]
# 
# Lasso
# Score:0.525315118713477
# Prediction for (7, 5):[30.24109273]
# Intercept:21.32451435742197
# Coefficients:[ 1.87429627 -0.84069911]

import pandas as pd

from sklearn.datasets import load_boston

from sklearn.model_selection import train_test_split

from sklearn.linear_model import Ridge

from sklearn.linear_model import Lasso

ds = load_boston()

df = pd.DataFrame(ds.data, columns=ds.feature_names)

X = df[['RM', 'LSTAT']]

y = ds['target']

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

ridge = Ridge(alpha=1.0)

lasso = Lasso(alpha=1.0)

ridge.fit(X_train, y_train)

lasso.fit(X_train, y_train)

print("Ridge")

print("Score:{}".format(ridge.score(X_test, y_test)))

print("Prediction for (7, 5):{}".format(ridge.predict([[7, 5]])))

print("Intercept:{}".format(ridge.intercept_))

print("Coefficients:{}".format(ridge.coef_))

print()

print("Lasso")

print("Score:{}".format(lasso.score(X_test, y_test)))

print("Prediction for (7, 5):{}".format(lasso.predict([[7, 5]])))

print("Intercept:{}".format(lasso.intercept_))

print("Coefficients:{}".format(lasso.coef_))

# Ridge

# Score:0.5691622120420186

# Prediction for (7, 5):[31.13688148]

# Intercept:-0.29837159723311046

# Coefficients:[ 4.97435821 -0.67705088]

# Lasso

# Score:0.525315118713477

# Prediction for (7, 5):[30.24109273]

# Intercept:21.32451435742197

# Coefficients:[ 1.87429627 -0.84069911]

利用方法

Ridge/Lassoの利用方法はLineaRegressionとほとんど同じで、以下はそれぞれに特有の設定についてまとめる。

モデルクラスのインポート

scikit-learn.linear_modelパッケージからRidgeクラスをインポートする。

from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso

1 2	from sklearn.linear_model import Ridge from sklearn.linear_model import Lasso

モデルのインスタンスの生成

Ridge/Lassoでは、ハイパーパラメーターalphaによって正則化の強さを指定する。

ridge = Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True,
              max_iter=None, tol=0.001, solver='auto', random_state=None)

lasso = Lasso(alpha=1.0, fit_intercept=True, normalize=False, precompute=False,
              copy_X=True, max_iter=1000, tol=0.0001, warm_start=False,
              positive=False, random_state=None, selection='cyclic')

ridge = Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True,

max_iter=None, tol=0.001, solver='auto', random_state=None)

lasso = Lasso(alpha=1.0, fit_intercept=True, normalize=False, precompute=False,

copy_X=True, max_iter=1000, tol=0.0001, warm_start=False,

positive=False, random_state=None, selection='cyclic')

以下、RidgeとLassoに特有のパラメーターのみ説明。LinearRegressionと共通のパラメーターはLinearRegressionを参照。

alpha: 正則化の強さを実数で指定する。値が大きいほど正則化が強く効き、小さいほど弱くなる。alpha=0で正則化の効果はゼロとなり、通常線形回帰と同じになる。デフォルトは1.0。
max_iter: 共役勾配法による収束計算の制限回数を指定する。’sparse_cg’と’lsqr’の場合はデフォルト値はscipy.sparse.linalgで規定され、’sag’の場合はデフォルト値は1000。
tol: 収束計算の解の精度で、デフォルトは1e-3。
solver: 'auto'、'svd'、'cholesky'、'lsqr'、'sparse_cg'、'sag'、'saga'のうちから選択される。デフォルトは'auto'。
random_state: データをシャッフルする際のランダム・シードで、solver=’sag’の際に用いる。

モデルの学習

fit()メソッドに特徴量とターゲットの訓練データを与えてモデルに学習させる(回帰係数を決定する)。

lr.fit(X, y)

1	lr.fit(X, y)

X: 特徴量の配列。2次元配列で、各列が各々の説明変数に対応し、行数はデータ数を想定している。変数が1つで1次元配列の時はreshape(-1, 1)かスライス([:, n:n+1])を使って1列の列ベクトルに変換する必要がある。
y: ターゲットの配列で、通常は1変数で1次元配列。

3つ目の引数sample_weightは省略。

適合度の計算

score()メソッドに特徴量とターゲットを与えて適合度を計算する。

lr.score(X, y)

1	lr.score(X, y)

戻り値は適合度を示す実数で、回帰計算の決定係数R²で計算される。

(1) $\begin{equation*} R^2 = 1 - \frac{RSS}{TSS} = 1 - \frac{\sum (y_i - \hat{y}_i)^2}{\sum (y_i - \overline{y})^2} \end{equation*}$

モデルによる予測

predict()メソッドに特徴量を与えて、ターゲットの予測結果を得る。

y_pred = lr.predict(X)

1	y_pred = lr.predict(X)

ここで特徴量Xは複数のデータセットの2次元配列を想定しており、1組のデータの場合でも2次元配列とする必要がある。

y_pred = lr.pred([[x1, x2,..., xm]])

1	y_pred = lr.pred([[x1, x2,..., xm]])

また、結果は複数のデータセットに対する1次元配列で返されるため、ターゲットが1つの場合でも要素数1の1次元配列となる。

切片・係数の利用

fit()メソッドによる学習後、モデルの学習結果として切片と特徴量に対する重み係数を得ることができる。

各々モデル・インスタンスのプロパティーとして保持されており、切片はintercept_で1つの実数、重み係数はcoeff_で特徴量の数と同じ要素数の1次元配列となる(特徴量が1つの場合も要素数1の1次元配列)。

ic = lr.intercept_
cf = lr.coeff_

1 2	ic = lr.intercept_ cf = lr.coeff_

末尾のアンダースコアに注意。

Python3 – range関数

2019-07-21 / tau / コメントする

概要

Python3のrange関数は引数で指定した範囲の整数列をrangeオブジェクトで返す。rangeオブジェクトを表示するには、list関数でリスト化する必要がある。

>>> range(0, 5)
range(0, 5)
>>> list(range(0, 5))
[0, 1, 2, 3, 4]

>>> range(0, 5)

range(0, 5)

>>> list(range(0, 5))

[0, 1, 2, 3, 4]

書式

range(end): 0から始まり、1ずつ増加してendに達しない範囲の数列
range(start, end): startから始まり、1ずつ増加してendに達しない範囲の数列
range(start, end, step): startから始まり、stepずつ増加してendに達しない範囲の数列

引数は整数である必要があり、そうでなければエラーとなる。

共通なのは、開始値からステップ値ずつ変化させ、終了値に達する直前までの数列を返す、というもので、ステップ値が正の場合にはstart ≤ 値 < endを、ステップ値が負の場合にはstart ≥ 値 > endを要素とする数列となる。

実行例

引数を1つだけ指定した場合は、0から引数未満の整数列となる。

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

1 2	>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

引数を2つ指定すると、第1引数以上、第2引数未満の整数列となる。

>>> list(range(3, 10))
[3, 4, 5, 6, 7, 8, 9]

1 2	>>> list(range(3, 10)) [3, 4, 5, 6, 7, 8, 9]

引数を3つ指定すると、第1引数から第3引数ずつ増加して第2引数を超える手前までの整数列となる。

>>> list(range(0, 10, 3))
[0, 3, 6, 9]

1 2	>>> list(range(0, 10, 3)) [0, 3, 6, 9]

第3引数を負の数とすると、降順の数列になる。このとき、第2引数の終了値以下になる前までの数列となっていることに注意。

>>> list(range(10, 0, -1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list(range(10, 0, -4))
[10, 6, 2]

>>> list(range(10, 0, -1))

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

>>> list(range(10, 0, -4))

[10, 6, 2]

なお、2つだけ引数を指定して、第1引数＞第2引数としても、降順の数列は得られず、空となる。

>>> list(range(10, 0))
[]

1 2	>>> list(range(10, 0)) []

囲碁 – 手筋：ゲタ

2017-02-04 / tau / コメントする

ゲタの基本形

カケ

ケイマガケ

実戦例

シチョウが悪くても

使い分け

断点が多い時、下手にゲタにかけると大変。

ケイマガケでも方向を間違えると・・・

それでも取れるときは取れる。

応用例

囲碁 – 隅の曲がり四目

2017-01-29 / tau / コメントする

基本形

隅の曲がり四目は、日本棋院囲碁規約(平成元年四月)の第七条-2において「死」とされている。

第九条の「対局の停止」後での、死活確認の際における同一の劫での取り返しは、行うことができない。ただし劫を取られた方が取り返す劫のそれぞれにつき着手放棄を行った後は、新たにその劫を取ることができる。

隅の曲がり四目になる形

第1形

第2系

第3系

隅の曲がり四目にならない形

囲碁 – 定石：単独の三々入り

2017-01-22 / tau / コメントする

閉じ込め

基本形

単独で三々に入った場合、布石によって厚みが期待できるなら押さえる方向を選択。外勢を張るが後手になる。

三々に入って生きた方が先手
押さえて外勢を張った方が後手

入った方が生きてから先手で他へ回る。

定石はずれはこちら

三々入り後の死活はこちら

デギリ対策

デギリは無理。「グルグルマワシ」が痛快。

二段バネ

基本形

黒が伸びずに二段にハネる定石で、外勢を張りながら先手を取る方法と、後手になるが外勢と実利をある程度とる方法がある。

先手で外勢を張る場合

先手で外勢を張りたいときの打ち方。

後手で外勢と実利を取る場合

外勢と実利の両方を取りたい場合。後手になる。

変化～分かれ

二段バネに対して反対側をハネて、守らずに切ってくるケース。

WordPress – functions.phpの場所

2016-11-29 / tau / コメントする

functions.phpは各テーマのディレクトリ下に存在する。

/[wpのインストール場所]/wp-content/themes/[テーマ名]/functions.php

1	/[wpのインストール場所]/wp-content/themes/[テーマ名]/functions.php

functions.phpは各テーマごとに生成されるため、意図をもってその内容を変更した後にテーマをアップデートすると、変更内容が失われる。

テーマをアップデートしても変更内容が失われないようにするには、元のテーマに対する「子テーマ」を作り、そのfunctions.phpに付加する内容を書くとよい。

Python3 – property – getter/setter

2016-09-25 / tau / コメントする

一般的な書き方

クラス定義でgetter/setterなどのアクセサを一般的に書くと次のようになる。

class MyClass:
    def __init__(self):
        self._x = None

    def get_x(self):
        print("getting")
        return self._x

    def set_x(self, x):
        print("setting")
        self._x = x

obj = MyClass()
obj.get_x()
obj.set_x(1)

# getting
# setting

class MyClass:

def __init__(self):

self._x = None

def get_x(self):

print("getting")

return self._x

def set_x(self, x):

print("setting")

self._x = x

obj = MyClass()

obj.get_x()

obj.set_x(1)

# getting

# setting

Pythonでは、メンバ変数(インスタンス変数)はパブリックアクセスが可能だが、メンバ変数への代入や参照を行った際に、裏でセッターやゲッターを呼び出すようにすることができる。また同じ手順で、インスタンスのdelete時の処理もプロパティとして登録できる。

obj = MyClass()

obj.prop = val
# ここで実際には、MyClass内で定義されたsome_setter(val)が実行される

val = obj.prop
# ここで実際には、MyClass内で定義されたval = some_getter()が実行される

del obj
# ここで実際には、MyClass内で定義されたsome_deleter()が実行される

obj = MyClass()

obj.prop = val

# ここで実際には、MyClass内で定義されたsome_setter(val)が実行される

val = obj.prop

# ここで実際には、MyClass内で定義されたval = some_getter()が実行される

del obj

# ここで実際には、MyClass内で定義されたsome_deleter()が実行される

このように見かけ上の参照・代入・削除処理から各アクセサを呼び出すために、Pythonでは組み込み関数のproperty()を使う方法と、@マークに続けたデコレータを使う方法がある。

property()関数

property関数を使うことで、getterなどをプロパティとして登録できる。次の例では、インスタンス変数_xに関するgetter、setter、deleterをxという名前のプロパティとして登録している。

class MyClass:
    def __init__(self):
        self._x = None

    def get_x(self):
        print("getting")
        return self._x

    def set_x(self, x):
        print("setting")
        self._x = x

    def del_x(self):
        print("deleting")
        del self._x

    x = property(get_x, set_x, del_x, "Property x")

obj = MyClass()
obj.x
obj.x = 1
del obj.x

# getting
# setting
# deleting

class MyClass:

def __init__(self):

self._x = None

def get_x(self):

print("getting")

return self._x

def set_x(self, x):

print("setting")

self._x = x

def del_x(self):

print("deleting")

del self._x

x = property(get_x, set_x, del_x, "Property x")

obj = MyClass()

obj.x

obj.x = 1

del obj.x

# getting

# setting

# deleting

property()関数の引数は以下の通り。

property(fget=None, fset=None, fdel=None, doc=None)

fget　getterのメソッド名
fset　setterのメソッド名
fdel　deleterのメソッド名
doc　プロパティの説明文(ドキュメント文字列)

propertyデコレータ

使い方

以下のように@マークに続けて書くデコレータでアクセサを定義できる。ただし以下の点に注意。

デコレータの最初は、@property
@propertyで定義できるのはgetterのみ

class MyClass:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        print("getting")
        return self._x

    @x.setter
    def x(self, x):
        print("setting")
        self._x = x

    @x.deleter
    def x(self):
        print("deleting")
        del self._x

obj = MyClass()
obj.x
obj.x = 1
del obj.x

# getting
# setting
# deleting

class MyClass:

def __init__(self):

self._x = None

@property

def x(self):

print("getting")

return self._x

@x.setter

def x(self, x):

print("setting")

self._x = x

@x.deleter

def x(self):

print("deleting")

del self._x

obj = MyClass()

obj.x

obj.x = 1

del obj.x

# getting

# setting

# deleting

つまり、必ず最初に@propertyで、かつgetterを定義しなければならない。

@propertyは最初でなければならない

たとえば次のように@propertyがsetterよりも後にあると、”setterでxが定義されていませんよ”と怒られる。

class MyClass:
    def __init__(self):
        self._x = None

    @x.setter
    def x(self, x):
        print("setting")
        self._x = x

    @property
    def x(self):
        print("getting")
        return self._x

    @x.deleter
    def x(self):
        print("deleting")
        del self._x

obj = MyClass()
obj.x
obj.x = 1
del obj.x

# Traceback (most recent call last):
#   File "test.py", line 1, in <module>
#     class MyClass:
#   File "test.py", line 5, in MyClass
#     @x.setter
# NameError: name 'x' is not defined

class MyClass:

def __init__(self):

self._x = None

@x.setter

def x(self, x):

print("setting")

self._x = x

@property

def x(self):

print("getting")

return self._x

@x.deleter

def x(self):

print("deleting")

del self._x

obj = MyClass()

obj.x

obj.x = 1

del obj.x

# Traceback (most recent call last):

# File "test.py", line 1, in <module>

# class MyClass:

# File "test.py", line 5, in MyClass

# @x.setter

# NameError: name 'x' is not defined

@propertyはgetterしか定義できない

また@propertyでsetterを定義し、@*.getterでgetterを定義しようとすると、getterは実行されてsetterの方で”引数をセットできない”とエラーになる。

class MyClass:
    def __init__(self):
        self._x = None

    @property
    def x(self, x):
        print("setting")
        self._x = x

    @x.getter
    def x(self):
        print("getting")
        return self._x

    @x.deleter
    def x(self):
        print("deleting")
        del self._x

obj = MyClass()
obj.x
obj.x = 1
del obj.x

# getting
# Traceback (most recent call last):
#   File "test.py", line 22, in <module>
#     obj.x = 1
# AttributeError: can't set attribute

class MyClass:

def __init__(self):

self._x = None

@property

def x(self, x):

print("setting")

self._x = x

@x.getter

def x(self):

print("getting")

return self._x

@x.deleter

def x(self):

print("deleting")

del self._x

obj = MyClass()

obj.x

obj.x = 1

del obj.x

# getting

# Traceback (most recent call last):

# File "test.py", line 22, in <module>

# obj.x = 1

# AttributeError: can't set attribute

@propertyでダミーのアクセサを定義する方法

@propertyでダミーのアクセサを定義して、その後にgetterのデコレータで定義をするのは通る。

class MyClass:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        pass

    @x.getter
    def x(self):
        print("getting")
        return self._x

    @x.setter
    def x(self, x):
        print("setting")
        self._x = x

    @x.deleter
    def x(self):
        print("deleting")
        del self._x

obj = MyClass()
obj.x
obj.x = 1
del obj.x

# getting
# setting
# deleting

class MyClass:

def __init__(self):

self._x = None

@property

def x(self):

pass

@x.getter

def x(self):

print("getting")

return self._x

@x.setter

def x(self, x):

print("setting")

self._x = x

@x.deleter

def x(self):

print("deleting")

del self._x

obj = MyClass()

obj.x

obj.x = 1

del obj.x

# getting

# setting

# deleting

property()でドキュメント文字列だけを定義する方法

また、property()関数でメンバ変数のドキュメント文字列だけを定義したのちに、getter/setter/deleterのデコレータでそれぞれのメソッドを定義する方法もあるらしい。

class MyClass:
    def __init__(self):
        self._x = None

    x = property(doc="property x")

    @x.getter
    def x(self):
        print("getting")
        return self._x

    @x.setter
    def x(self, x):
        print("setting")
        self._x = x

    @x.deleter
    def x(self):
        print("deleting")
        del self._x

obj = MyClass()
obj.x
obj.x = 1
del obj.x

class MyClass:

def __init__(self):

self._x = None

x = property(doc="property x")

@x.getter

def x(self):

print("getting")

return self._x

@x.setter

def x(self, x):

print("setting")

self._x = x

@x.deleter

def x(self):

print("deleting")

del self._x

obj = MyClass()

obj.x

obj.x = 1

del obj.x

Python3 – オブジェクトの文字列表現

2016-09-25 / tau / コメントする

str/repr

__str__メソッドはprint文やformat文の引数にオブジェクトが指定された場合に呼び出され、オブジェクトの”非公式の”文字列表現を返す。

__repr__メソッドはより正式なオブジェクトの内容を文字列で返し、2つのオブジェクトの同値性をインタープリタがチェックするときに使われる。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return "<Name:{}, Age:{}>".format(self.name, self.age)

john = Person("John", 38)
luice = Person("Luice", 32)
print(john)
print(luice)

# <Name:John, Age:38>
# <Name:Luice, Age:32>

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __str__(self):

return "<Name:{}, Age:{}>".format(self.name, self.age)

john = Person("John", 38)

luice = Person("Luice", 32)

print(john)

print(luice)

# <Name:John, Age:38>

# <Name:Luice, Age:32>

print文やformat文での__str__や__repr__の使われ方は次の通り。

__str__のみが定義されていれば__str__が使われる
__repr__のみが定義されていれば__repr__が使われる
__str__と__repr__の両方が定義されていれば__str__が使われる

エラー～str()関数による明示的な変換

ただし、以下のように文字列として直接操作しようとするとエラーになる。

class Person:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return "My name is {}".format(self.name)

john = Person("John")
print("Hello, " + john) 
# TypeError: Can't convert 'Person' object to str implicitly

class Person:

def __init__(self, name):

self.name = name

def __str__(self):

return "My name is {}".format(self.name)

john = Person("John")

print("Hello, " + john)

# TypeError: Can't convert 'Person' object to str implicitly

これはprint文で扱われるかどうか以前の問題で、文字列にオブジェクトを結合しようとしたときに起こる。先行のオペランドが文字列で、その次に結合演算子が出てきたのでオブジェクトを文字列に変換しようとして、”オブジェクトを暗黙で文字列に変換できませんよ”とエラーになる。

また演算の順序を入れ替えると、次のようなエラーになる。

class Person:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return "My name is {}".format(self.name)

john = Person("John")
print(john + " ") 
# unsupported operand type(s) for +: 'Person' and 'str'

class Person:

def __init__(self, name):

self.name = name

def __str__(self):

return "My name is {}".format(self.name)

john = Person("John")

print(john + " ")

# unsupported operand type(s) for +: 'Person' and 'str'

今度はオブジェクトが先行しているので、これに対して+演算子を読んだ瞬間に、インタプリタは”このオブジェクトと文字列の演算子として+はサポートされていない”と言ってくる。

これを解決するには、str()関数でオブジェクトを明示的に文字列に変換してやればよい。

class Person:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return "My name is {}".format(self.name)

john = Person("John")
print("Hello, " + str(john))
# Hello, My name is John

class Person:

def __init__(self, name):

self.name = name

def __str__(self):

return "My name is {}".format(self.name)

john = Person("John")

print("Hello, " + str(john))

# Hello, My name is John