グラフのラベルがはみ出てしまう場合がある。
このようなときは、pyplotやfigureに対してsubplots_adjust()でleft、bottomなどの引数でマージンを指定する。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import numpy as np import matplotlib.pyplot as plt subjects = np.array(["math", "physics", "chemistry", "earth science"]) scores = np.array([95, 92, 83, 75]) fig, ax = plt.subplots() fig.subplots_adjust(left=0.2) ax.barh(subjects, scores) plt.show() |
Scikit-learnの決定木モデル、DecisionTreeClassifierについていろいろ試した際のコードをストック。
DecisionTreeClassifierオブジェクトのプロパティーtree_はデータセットに対して生成された決定木の構造が保存されている。以下はその内容を確認するためのコード。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier X, y = make_moons(n_samples=20, noise=0.25, random_state=3) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) tree = treeclf.tree_ n_nodes = tree.node_count children_left = tree.children_left children_right = tree.children_right features = tree.feature thresholds = tree.threshold value = tree.value print("number of nodes: {}".format(n_nodes)) print("Chlidren(Left) : {}".format(children_left)) print("Chlidren(Right): {}".format(children_right)) print("Features : {}".format(features)) print("Thresholds : {}".format(np.round(thresholds, 3))) print("Values:\n{}".format(value)) print() for i in range(n_nodes): print("Node-{}".format(i), end="") print("(Feature[{:2d}]<{:6.3f}):"\ .format(features[i], thresholds[i]), end="") print("LeftNode[{:2d}], RightNode[{:2d}]"\ .format(children_left[i], children_right[i])) |
Treeクラスはツリー内の各ノードの情報を1次元の配列でもっていて、子ノードを参照するにはノード番号に対応する配列のインデックスを参照する。Treeクラスが持っている主なプロパティーは以下の通り。
node_countchildren_left, children_rightfeaturethresholdfeatureで示された特性量で分割する際の閾値を格納した1次元配列。valueコードの実行結果は以下の通り。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
number of nodes: 7 Chlidren(Left) : [ 1 2 -1 -1 5 -1 -1] Chlidren(Right): [ 4 3 -1 -1 6 -1 -1] Features : [ 1 0 -2 -2 0 -2 -2] Thresholds : [ 0.072 -0.643 -2. -2. 1.536 -2. -2. ] Values: [[[10. 10.]] [[ 1. 9.]] [[ 1. 0.]] [[ 0. 9.]] [[ 9. 1.]] [[ 9. 0.]] [[ 0. 1.]]] Node-0(Feature[ 1]< 0.072):LeftNode[ 1], RightNode[ 4] Node-1(Feature[ 0]<-0.643):LeftNode[ 2], RightNode[ 3] Node-2(Feature[-2]<-2.000):LeftNode[-1], RightNode[-1] Node-3(Feature[-2]<-2.000):LeftNode[-1], RightNode[-1] Node-4(Feature[ 0]< 1.536):LeftNode[ 5], RightNode[ 6] Node-5(Feature[-2]<-2.000):LeftNode[-1], RightNode[-1] Node-6(Feature[-2]<-2.000):LeftNode[-1], RightNode[-1] |
親ノードと子ノードの関係は、たとえばノード0の左右の子ノードはchildren_leftとchildren_rightの0番目の要素からノード1とノード4、ノード1の左右の子ノードはノード2とノード3、という風に追っていくことができる。
valueがややこしい。この配列は各ノードにおけるクラスごとのデータ数を格納している。全体配列の中にこのケースだとノード数に対応する7個の配列が要素として格納されているが、その配列が2次元配列になっていて、その要素の配列がクラスごとのデータを格納した配列になっている。例えば3番目の要素のクラス1の要素を取り出す場合にはvalue[3, 0, 1]と言う風に指定することになる。
Treeオブジェクトのツリー構造を確認し、決定境界の描画などの準備とするために書いたコード。決定木の構造をコンソールに表示させる。2つの再帰関数を定義していて、本体は決定木学習後にそれらの関数を呼び出すのみ。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier def print_node1(tree, i_node, n_level=0): print("{}{:2d}-feature:{:2d}"\ .format(" " * n_level, i_node, tree.feature[i_node])) if tree.children_left[i_node] == -1: return print_node1( tree=tree, i_node=tree.children_left[i_node], n_level=n_level+1) print_node1( tree=tree, i_node=tree.children_right[i_node], n_level=n_level+1) def print_node2(tree, i_node, n_level=0): if tree.children_left[i_node] == -1: print("{}{:2d}-feature:{:2d}"\ .format(" " * n_level, i_node, tree.feature[i_node])) return print_node2( tree=tree, i_node=tree.children_left[i_node], n_level=n_level+1) print("{}{:2d}-feature:{:2d}"\ .format(" " * n_level, i_node, tree.feature[i_node])) print_node2( tree=tree, i_node=tree.children_right[i_node], n_level=n_level+1) X, y = make_moons(n_samples=20, noise=0.25, random_state=3) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) tree = treeclf.tree_ print_node1(tree=tree, i_node=0) print("-"*40) print_node2(tree=tree, i_node=0) |
関数print_node1()は、ツリー構造をルートノードから階層が下がるごとに段下げして表示していく。このため、まず親ノードを表示してから左右の子ノードを引数として再帰呼び出しをしている。
終了条件はノードが子ノードを持たない葉(leaf)であることを利用するが、リーフの時のパラメータは以下の通りで、ここでは左子ノードの番号が−1となることを利用している。
関数print_node2は、決定木の構造を枝分かれした木の形で表示する。左側のノードから右側に移るのを、コンソール上で上から下に表示していく。手順としては、
引数に現在のノードの階層を保持する変数があり、その階層に応じた数のスペースでインデントすることで木の構造を表す。
出力は以下の通り。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
0-feature: 1 1-feature: 0 2-feature:-2 3-feature:-2 4-feature: 0 5-feature:-2 6-feature:-2 ---------------------------------------- 2-feature:-2 1-feature: 0 3-feature:-2 0-feature: 1 5-feature:-2 4-feature: 0 6-feature:-2 |
make_monns()による2特性量のデータについて、順次ノードを分割する過程を図で描画するためのコード。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
import numpy as np import matplotlib.pyplot as plt import matplotlib.patches as patch from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier def draw_tree_boundary(tree, ax, left, right, bottom, top, i_node=0, stop_level=None, n_level=0): if tree.children_left[i_node] == -1 or stop_level == n_level: fc =\ 'tab:orange' if np.argmax(tree.value[i_node][0])==0 else 'tab:blue' rect = patch.Rectangle(xy=(left, bottom), width=right-left, height=top-bottom, fc=fc, alpha=0.2) ax.add_patch(rect) return if tree.feature[i_node] == 0: f0 = tree.threshold[i_node] ax.plot([f0, f0], [top, bottom]) draw_tree_boundary(tree=tree, ax=ax, left=left, right=f0, top=top, bottom=bottom, i_node=tree.children_left[i_node], stop_level=stop_level, n_level=n_level+1,) draw_tree_boundary(tree=tree, ax=ax, left=f0, right=right, top=top, bottom=bottom, i_node=tree.children_right[i_node], stop_level=stop_level, n_level=n_level+1) else: f1 = tree.threshold[i_node] ax.plot([left, right], [f1, f1]) draw_tree_boundary(tree=tree, ax=ax, left=left, right=right, top=f1, bottom=bottom, i_node=tree.children_left[i_node], stop_level=stop_level, n_level=n_level+1) draw_tree_boundary(tree=tree, ax=ax, left=left, right=right, top=top, bottom=f1, i_node=tree.children_right[i_node], stop_level=stop_level, n_level=n_level+1) X, y = make_moons(n_samples=20, noise=0.25, random_state=5) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) tree = treeclf.tree_ fig, ax = plt.subplots() ax.scatter(X[y==0][:, 0], X[y==0][:, 1], ec='k', s=60, marker='o', label="Class 0") ax.scatter(X[y==1][:, 0], X[y==1][:, 1], ec='k', s=60, marker='^', label="Class 1") x0_min, x0_max = -2, 2.5 x1_min, x1_max = -1, 1.5 draw_tree_boundary(tree=tree, i_node=0, ax=ax, left=x0_min, right=x0_max, bottom=x1_min, top=x1_max, stop_level=None) ax.set_xlim(x0_min, x0_max) ax.set_ylim(x1_min, x1_max) ax.legend() plt.show() |
draw_tree_boundary()関数は再帰関数で、もしそのノードがリーフノードか指定された終了階層の場合はクラスに応じた色で領域を塗りつぶす。リーフノードでなければ、閾値が特性量0の場合と1の場合で境界線の縦横や開始終了位置を変化させて再帰的に関数を呼び出す。引数stop_levelに正の整数を指定することで、その階層までの描画に留めることができる。関数の内容についてはこちらを参照。
本体はデータをクラスごとの色で散布図として描き、ルートノードについてdraw_tree_boundary()を呼び出している。
以下は、実行例。
以下は、stop_levelを順次増やしていって、領域が分割される過程を描いた例。
DecisionTreeClassificationオブジェクトを可視化する環境によって、決定木を表示する例。
pydotplusパッケージを導入sklearn.tree.export_graphviz()で決定木のdotデータを得るpydotplus.graph_from_dot_data()でDotオブジェクトを生成write_png()などのメソッドでグラフを画像として書き出す|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import numpy as np import pydotplus as pdp from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier, export_graphviz X, y = make_moons(n_samples=20, noise=0.25, random_state=5) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) dot_data = export_graphviz(treeclf, max_depth=None, feature_names=["feature-0", "feature-1"], class_names=["class-0", "class-1"]) graph = pdp.graph_from_dot_data(dot_data) graph.write_png("tree.png") # C:...\atom\app-1.47.0 |
このコードはAtom上でコードを実行したため、Atomのディレクトリーに画像ファイルが書き出される。
pyplotでグラフを描画したとき、軸の端の方でグラフが見切れてしまう。軸の外側も使って線や点をクリップせずに表示させるには、各グラフ描画の引数でclip_on=Falseを指定する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import numpy as np import matplotlib.pyplot as plt x = np.linspace(-np.pi, np.pi, num=200) ys = np.sin(3*x) yc = np.sin(3*x - np.pi) xp = [-np.pi, np.pi] yp1 = [-1, 1] yp2 = [1, -1] fig, ax = plt.subplots() ax.plot(x, ys, linewidth=4) ax.plot(x, yc, linewidth=4, clip_on=False) ax.scatter(xp, yp1, s=80) ax.scatter(xp, yp2, s=80, clip_on=False) ax.set_xlim(-np.pi, np.pi) ax.set_ylim(-1, 1) plt.show() |
Pythonのscikit-learnで提供される決定木のクラス分類モデルDecisionTreeClassifierの実行結果を可視化する環境について。
この方法は、決定木の画像がPDFとして生成され、デフォルトのPDFリーダーが自動的に起動して確認できる。画像ファイルを利用する場合、PDFから切り出すか、以下のpydotplusパッケージを利用する。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import graphviz from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier, export_graphviz X, y = make_moons(n_samples=20, noise=0.25, random_state=3) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) dot_data = export_graphviz(treeclf, out_file=None, feature_names=["f0", "f1"], class_names=["c0", "c1"]) graph = graphviz.Source(dot_data) graph.render("image", view=True) |
この方法は、決定木の画像がファイルとして生成・保存される。画像を確認するためにファイルが保存されたディレクトリでファイルを開く手順が必要になるが、得られたファイルをそのまま活用することができる。
pydotplusをインストールする。
|
1 |
> pip install pydotplus |
これだけでは次のようなエラーが出る。
|
1 |
pydotplus.graphviz.InvocationException: GraphViz's executables not found |
Graphvizのサイトから実行ファイル(msiファイル)をダウンロード、インストールする。
以下のコード例13行目のように、Graphvizの実行プログラムの位置を指定。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import pydotplus as pdp from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier, export_graphviz X, y = make_moons(n_samples=20, noise=0.25, random_state=3) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) dot_data = export_graphviz(treeclf, out_file=None, feature_names=["f0", "f1"], class_names=["c0", "c1"]) graph = pdp.graph_from_dot_data(dot_data) graph.progs = {'dot': u"C:\\Program Files (x86)\\Graphviz2.38\\bin\\dot.exe"} graph.write_png("graph.png") |
環境変数に上記のGraphvizのパスを指定する。
環境変数を設定しておくと、毎回パスを指定しなくてよい。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import pydotplus as pdp from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier, export_graphviz X, y = make_moons(n_samples=20, noise=0.25, random_state=3) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) dot_data = export_graphviz(treeclf, out_file=None, feature_names=["f0", "f1"], class_names=["c0", "c1"]) graph = pdp.graph_from_dot_data(dot_data) graph.write_png("graph.png") |
dtreevizをインストールする。
|
1 |
> pip install dtreeviz |
Graphvizの実行方法2で環境変数を追加。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
from sklearn.datasets import make_moons from sklearn.tree import DecisionTreeClassifier from dtreeviz.trees import dtreeviz X, y = make_moons(n_samples=20, noise=0.25, random_state=3) treeclf = DecisionTreeClassifier(random_state=0) treeclf.fit(X, y) viz = dtreeviz(treeclf, X, y, target_name="Classes", feature_names=["f0", "f1"], class_names=["c0", "c1"]) viz.view() |
sklearn.datasets.make_moons()はクラス分類のためのデータを生成する。上向き、下向きの弧が相互にかみ合う形で生成され、単純な直線では分離できないデータセットを提供する。クラス数は常に2クラス。
2つの配列X, yが返され、配列Xは列が特徴量、行がレコードの2次元配列。ターゲットyはレコード数分のクラス属性値の整数。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
from sklearn.datasets import make_moons X, y = make_moons(n_samples=10, random_state=0) print("X:\n{}".format(X)) print("y:{}".format(y)) # X: # [[ 6.12323400e-17 1.00000000e+00] # [ 1.70710678e+00 -2.07106781e-01] # [-1.00000000e+00 1.22464680e-16] # [ 2.00000000e+00 5.00000000e-01] # [ 7.07106781e-01 7.07106781e-01] # [ 2.92893219e-01 -2.07106781e-01] # [ 1.00000000e+00 -5.00000000e-01] # [-7.07106781e-01 7.07106781e-01] # [ 1.00000000e+00 0.00000000e+00] # [ 0.00000000e+00 5.00000000e-01]] # y:[0 1 0 1 0 1 1 0 0 1] |
以下の例では、noiseパラメーターを変化させている。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import matplotlib.pyplot as plt from sklearn.datasets import make_moons noises = [0, 0.1, 0.2, 0.3] fig, axs = plt.subplots(2, 2) axs_1d = axs.reshape(axs.size) for ax, noise in zip(axs_1d, noises): plt.subplots_adjust(hspace=0.4) X, y = make_moons(noise=noise, random_state=0) ax.scatter(X[y==0][:, 0], X[y==0][:, 1], s=5, marker='o') ax.scatter(X[y==1][:, 0], X[y==1][:, 1], s=5, marker='^') ax.set_title("noise={}".format(noise)) plt.show() |
|
1 |
sklearn.datasets.make_moons(n_samples=100, shuffle=True, noise=None, random_state=None) |
n_samples
shufflenoiserandom_state
a.reshape(d1, ..., dn)として変形する場合
d1 + ... + dn = a.sizeでなければならないndarrayの引数に1つの数値を指定するとndarrayクラスだが数値のように表示される。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import numpy as np a = np.array(1) print(a) print(type(a)) print(a.size) print(a * 2) # 1 # <class 'numpy.ndarray'> # 1 # 2 |
これをreshape(1)とすると、1要素の1次元配列になる。
|
1 2 3 4 |
b = a.reshape(1) print(b) # [1] |
reshape(1, 1)とすると、1要素の2次元配列になる。reshape(1, 1, 1)なら3次元配列。
|
1 2 3 4 5 6 7 8 |
c = a.reshape(1, 1) print(c) d = a.reshape(1, 1, 1) print(d) # [[1]] # [[[1]]] |
2次元化、3次元化された配列をreshape(1)とすると、1要素の1次元配列になる。
|
1 2 3 4 5 |
print(c.reshape(1)) print(d.reshape(1)) # [1] # [1] |
1次元配列をreshape(1, -1)とすると、その配列を要素とする2次元1行の配列になる。
|
1 2 3 4 5 6 7 8 9 10 |
import numpy as np a = np.arange(4) print(a) b = a.reshape(1, -1) print(b) # [0 1 2 3] # [[0 1 2 3]] |
1次元配列をreshape(-1, 1)とすると、その配列を要素とする2次元1列の配列となる。
|
1 2 3 4 5 6 7 |
c = a.reshape(-1, 1) print(c) # [[0] # [1] # [2] # [3]] |
1次元配列をreshape(m, n)とすると、m行n列の2次元配列になる。m×nが配列のサイズと等しくないとエラーになる（いずれかを−1として自動設定させることは可能）。
|
1 2 3 4 5 |
d = a.reshape(2, 2) print(d) # [[0 1] # [2 3]] |
3次元以上の配列へも変形可能。
|
1 2 3 4 5 6 7 8 9 10 |
e = np.arange(12) print(e) print(e.reshape(2, 2, 3)) # [ 0 1 2 3 4 5 6 7 8 9 10 11] # [[[ 0 1 2] # [ 3 4 5]] # # [[ 6 7 8] # [ 9 10 11]]] |
任意の形状の配列aについてreshape(a.size)とすることで、1次元の配列に変換できる。
|
1 2 3 4 5 6 7 8 9 |
print(b.reshape(b.size)) print(c.reshape(c.size)) print(d.reshape(d.size)) print(e.reshape(e.size)) # [0 1 2 3] # [0 1 2 3] # [0 1 2 3] # [ 0 1 2 3 4 5 6 7 8 9 10 11] |
itertoolsは高速でメモリー効率のよいイテレーターを生成するツールを提供する。
主となる引数にはコレクション（リスト、タプル）を与える。
|
1 2 3 4 5 6 7 |
from itertools import cycle for n, next in enumerate(cycle(['A', 'B', 'C'])): print(next, end='') if n == 6: break # ABCABCA |
文字列を渡すと文字列中の1文字ずつを要素としたリストと同じ効果。
|
1 2 3 4 5 |
for n, next in enumerate(cycle("ABC")): print(next, end='') if n == 6: break # ABCABCA |
range()関数などコレクションを生成する対象も使える。
|
1 2 3 4 5 |
for n, next in enumerate(cycle(range(3))): print(next, end='') if n == 6: break # 0120120 |
無限イテレーターは、コレクションの要素を繰り返し取り出し続ける。ループ処理に使う場合、break文などの終了処理が必要。
itertools.count(start, [step])|
1 2 3 4 5 |
for n, digit in enumerate(count(3, 2)): print(digit, end=',') if n==5: break # 3,5,7,9,11,13, |
itertools.cycle(p)|
1 2 3 4 5 6 7 |
from itertools import cycle for n, digit in enumerate(cycle(range(4))): print(digit, end=',') if n==10: break # 0,1,2,3,0,1,2,3,0,1,2, |
itertools.repeat(elem [, n])|
1 2 3 4 |
for ch in repeat('Ha', 8): print(ch, end='') # HaHaHaHaHaHaHaHa |
組み合わせイテレーターは、コレクションの要素から指定した数を取り出し、それらの直積、順列、組み合わせを結果とする。
itertools.product(p [, repeat=n])pの要素について、repeatで指定した数の直積の結果をタプルで返す。同一の要素、順番の異なる同じ組み合わせの要素を持つ結果を許す。repeatを省略すると要素数1のタプルを返す。|
1 2 3 4 5 6 7 8 9 10 11 12 |
from itertools import product for str in product(['A', 'B', 'C'], repeat=2): print(str, end='') print() for str in product(['A', 'B', 'C']): print(str, end='') # ('A', 'A')('A', 'B')('A', 'C')('B', 'A')('B', 'B')('B', 'C')('C', 'A')('C', 'B')('C', 'C') # ('A',)('B',)('C',) |
itertools.permutations（p [, r=n]）pの要素について、rで指定した数の順列の結果をタプルで返す。統一要素の組はなく、同じ組み合わせの要素の順番が異なる結果は許す。repeatではなくrである点に注意。rを省略すると、全ての要素に対する組み合わせを返す。|
1 2 3 4 5 6 7 8 9 10 11 12 |
from itertools import permutations for str in permutations("ABC", r=2): print(str, end='') print() for str in permutations("ABC"): print(str, end='') # ('A', 'B')('A', 'C')('B', 'A')('B', 'C')('C', 'A')('C', 'B') # ('A', 'B', 'C')('A', 'C', 'B')('B', 'A', 'C')('B', 'C', 'A')('C', 'A', 'B')('C', 'B', 'A') |
itertools.combinations(p, repeat=n)pの要素について、repeatで指定した数の組み合わせの結果をタプルで返す。同一要素の組はなく、同じ組み合わせで順番が異なるものは同じ結果となる。rは省略できない。省略するとそれ以降の実行がされないなど動作が不定になる。|
1 2 3 4 5 6 |
from itertools import combinations for str in combinations("ABC", r=2): print(str, end='') # ('A', 'B')('A', 'C')('B', 'C'), |
itertools.combinations_with_replacement(iterable, r)rは省略できない。省略するとそれ以降の実行がされないなど動作が不定になる。|
1 2 3 4 5 6 |
from itertools import combinations for str in combinations("ABC", r=2): print(str, end='') # ('A', 'A')('A', 'B')('A', 'C')('B', 'B')('B', 'C')('C', 'C') |
itertools.chain(*iterables)'*'は複数のiterablesを展開したものであることを表す。戻り値はイテレーターオブジェクト。
|
1 2 3 4 5 |
from itertools import chain print(chain([0, 1, 2, 3], [4, 5])) # <itertools.chain object at 0x028081B0> |
list()関数でリスト化すると、展開されたリストが得られる。
|
1 2 3 |
print(list(chain([0, 1, 2, 3], [4, 5]))) # [0, 1, 2, 3, 4, 5] |
引数にはRangeのようなイテレーターも混在可能。
|
1 2 3 |
print(list(chain(range(3), [3, 4, 5]))) # [0, 1, 2, 3, 4, 5] |
蛇足だが単一のiteratableはそのまま返されるだけ。
|
1 2 3 |
print(list(chain([0, 1, 2, 3, 4, 5]))) # [0, 1, 2, 3, 4, 5] |
itertools.chain.from_iterable(iterables)たとえば複数のリストを含む2次元リストの全要素を1次元に展開可能。from_iterable()はchainのコンストラクターの一つであり、モジュールのインポート方法とコンストラクターの呼び方に注意。
|
1 2 3 4 5 |
from itertools import chain print(list(chain.from_iterable([[0], [1, 2], [3, 4, 5]]))) # [0, 1, 2, 3, 4, 5] |
1次元リストは要素がiterableでないのでエラー。
|
1 2 3 |
print(list(chain.from_iterable([0, 1, 2]))) # TypeError: 'int' object is not iterable |
ndarrayを要素とするリストは、要素の配列が展開されて1次元リストに。
|
1 2 3 |
print(list(chain.from_iterable([np.array([1]), np.array([2, 3])]))) # [1, 2, 3] |
ndarrayの2次元配列も展開可能。結果をリストでほしいときはlist()関数、配列でほしいときは一旦list()関数でリスト化してからnumpy.array()で配列化。
|
1 2 3 4 5 6 7 8 9 10 |
ary = np.array([[1, 2], [3, 4]]) print(ary) # [[1 2] # [3 4]] print(list(chain.from_iterable(ary))) # [1, 2, 3, 4] print(np.array(list(chain.from_iterable(ary)))) # [1 2 3 4] |
itertools.zip_longest(*iterables, fillvalue=None)fillvalueで埋められる。|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from itertools import zip_longest iterable1 = "ABCDE" iterable2 = [1, 2, 3] for item1, item2 in zip_longest(iterable1, iterable2): print(item1, item2) # A 1 # B 2 # C 3 # D None # E None for item1, item2 in zip_longest(iterable1, iterable2, fillvalue=0): print(item1, item2) # A 1 # B 2 # C 3 # D 0 # E 0 |
sklearn.datasets.make_blobls()は、クラス分類のためのデータを生成する。blobとはインクの染みなどを指し、散布図の点の様子からつけられてるようだ。
標準では、データの総数、特徴量の数、クラスターの数などを指定して実行し、特徴量配列X、ターゲットとなるクラスデータyのタプルが返される（引数の指定によってはもう1つ戻り値が追加される）。
特徴量配列Xは列が特徴量、行がレコードの2次元配列。ターゲットyはレコード数分のクラス属性値の整数。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
from sklearn.datasets import make_blobs X, y = make_blobs(n_samples=10, random_state=0) print(X) print(y) # [[ 1.12031365 5.75806083] # [ 1.7373078 4.42546234] # [ 2.36833522 0.04356792] # [ 0.87305123 4.71438583] # [-0.66246781 2.17571724] # [ 0.74285061 1.46351659] # [-4.07989383 3.57150086] # [ 3.54934659 0.6925054 ] # [ 2.49913075 1.23133799] # [ 1.9263585 4.15243012]] # [0 0 1 0 2 2 2 1 1 0] |
そのままscikit-learnのモデルの入力とする。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from sklearn.datasets import make_blobs from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier X, y = make_blobs(n_samples=100, centers=2, random_state=0) X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) clf = KNeighborsClassifier(n_neighbors=1) clf.fit(X_train, y_train) print(clf.score(X_train, y_train)) print(clf.score(X_test, y_test)) # 1.0 # 0.96 |
クラスごとに色やマークを変えて散布図を描く。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import make_blobs X, y = make_blobs(n_samples=30, centers=3, random_state=10) markers = ['o', '^', 'v'] fig, ax = plt.subplots() for cluster, marker in zip(range(3), markers): x = X[y==cluster] ax.scatter(x[:, 0], x[:, 1], marker=marker) plt.show() |
|
1 2 |
make_blobs(n_samples, n_features, centers, cluster_std, center_box, shuffle, random_state, return_centers) |
主なもの。
n_samplesn_featurescentersn_samplesを整数で指定してcentersを指定しない場合（デフォルトのNoneの場合）、centers=3となる。n_samplesを配列で指定した場合はNoneか[n_centers, n_features]の配列。center_std
breast_cancerデータセットに対してLogistic回帰モデル、scikit-learnのLogisticRegression適用し、訓練データとテストデータのスコアを計算してみる。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression ds = load_breast_cancer() X_train, X_test, y_train, y_test = train_test_split( ds.data, ds.target, stratify=ds.target, random_state=42) logreg = LogisticRegression().fit(X_train, y_train) print("") print("Training score: {}".format(logreg.score(X_train, y_train))) print("Test score : {}".format(logreg.score(X_test, y_test))) # Training score: 0.9530516431924883 # Test score : 0.958041958041958 |
（注）solverに関する警告と計算結果
上のコードを実行したとき、結果は書籍と整合しているが、警告表示が出た
|
1 2 3 4 |
...FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning. FutureWarning) Training score: 0.9530516431924883 Test score : 0.958041958041958 |
この時点でscikit-learnのバージョンが古く(0.21.3)、将来のデフォルトが変更されるとのこと。そこでインスタンス生成時にデフォルトのソルバーを明示的にsolver='liblinear'と指定して実行すると、警告は出ず値もそのまま。
なお、solver='lbfgs'としてみたところ、計算が収束しない旨の警告が出た。
|
1 |
logreg = LogisticRegression(solver='lbfgs').fit(X_train, y_train) |
|
1 2 3 4 |
...ConvergenceWarning: lbfgs failed to converge. Increase the number of iterations. "of iterations.", ConvergenceWarning) Training score: 0.9483568075117371 Test score : 0.951048951048951 |
そこで収束回数を増やしていったところ、最大回数2000では収束せず、3000で収束し、警告は出なくなった。
|
1 |
logreg = LogisticRegression(solver='lbfgs', max_iter=3000).fit(X_train, y_train) |
|
1 2 |
Training score: 0.9577464788732394 Test score : 0.958041958041958 |
その後、scikit-learnのバージョンを0.23.0にアップグレードしたところ、デフォルトで警告は表示されず、収束回数に関する警告が同じように出て、結果も再現された。以下、ソルバーとしてliblinearを明示的に指定し、random_stateの値も書籍と同じ値として確認する。
先のC=1.0とliblinearによるスコアは、訓練データに対して0.953、テストデータに対して0.958と両方に対して高い値となっている。ここで、訓練データとテストデータのスコアが近いということは、適合不足の可能性がある。そこでC=100と値を大きくして、より柔軟なモデルにしてみる（柔軟なモデルとは、正則化を弱めて訓練データによりフィットしやすくしたモデル）。
|
1 2 3 4 5 6 |
logreg100 = LogisticRegression(C=100, solver='liblinear').fit(X_train, y_train) print("Training score: {}".format(logreg100.score(X_train, y_train))) print("Test score : {}".format(logreg100.score(X_test, y_test))) # Training score: 0.9788732394366197 # Test score : 0.965034965034965 |
訓練データ、テストデータともそれぞれ若干向上している。なお、Cの値を1000、10000ともっと大きくしてもスコアはほとんど変わらない。
今度は逆に、Cの値を1.0より小さくして正則化を強めてみると、訓練データ、テストデータ両方に対するスコアが下がってしまう。
|
1 2 3 4 5 6 |
logreg001 = LogisticRegression(C=0.01, solver='liblinear').fit(X_train, y_train) print("Training score: {}".format(logreg001.score(X_train, y_train))) print("Test score : {}".format(logreg001.score(X_test, y_test))) # Training score: 0.9342723004694836 # Test score : 0.9300699300699301 |
Cを変化させたときの学習率曲線は以下の通り。Cが10より小さいところでは正則化が強く学習不足、そこを超えると学習率が頭打ちで、学習率の改善はそれほど顕著ではない。Logistic回帰モデルの学習率曲線のバリエーションについては、こちらでまとめている。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression C_pow_min = -4 C_pow_max = 3 C_pow_num = 100 Cs_pows = np.linspace(C_pow_min, C_pow_max, C_pow_num) Cs = 10**Cs_pows ds = load_breast_cancer() X_train, X_test, y_train, y_test = train_test_split( ds.data, ds.target, stratify=ds.target, random_state=42) fig, ax = plt.subplots() score_trains = np.empty(0) score_tests = np.empty(0) for C in Cs: logreg = LogisticRegression(C=C, solver='liblinear').fit(X_train, y_train) score_trains = np.append(score_trains, logreg.score(X_train, y_train)) score_tests = np.append(score_tests, logreg.score(X_test, y_test)) ax.plot(Cs, score_trains, label="Training") ax.plot(Cs, score_tests, label="Test") ax.set_xscale('log') ax.legend() plt.show() |
breast_cancerデータセットに対してLogisticRegressionを学習させた場合の、30個の特徴量に対する係数をプロットする。liblinearソルバーで、デフォルトでL2正則化を行っている。Cの値が大きいほど正則化の効果が弱く、係数の絶対値が大きくなっている。
書籍で注意喚起しているのは3番目の特徴量mean perimeterで、モデルによって正負が入れ替わることから、クラス分類に対する信頼性を問題にしている。
ここで書籍について以下の点が気になった。
logreg001のインスタンス生成時にC=0.01としているが、凡例で”C=0.001″としている（グラフの結果はあまり変わらない）logreg100でC=100とすると、書籍にあるような結果にならない（worst concave pointsが-8以下になるなど、分布が大幅に変わってくる）C=20とすると、概ね書籍と同じ分布になる（若干異なる部分は残る）いずれにしても”Pythonではじめる機械学習”は、入門者にとってとてもありがたいきっかけを提供してくれる良著であることに変わりはない。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
import numpy as np import matplotlib.pyplot as plt import matplotlib.patches as pch from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression ds = load_breast_cancer() X_train, X_test, y_train, y_test = train_test_split( ds.data, ds.target, stratify=ds.target, random_state=42) logreg1 = LogisticRegression(solver='liblinear').fit(X_train, y_train) logreg20 = LogisticRegression(C=20, solver='liblinear').fit(X_train, y_train) logreg001 = LogisticRegression(C=0.01, solver='liblinear').fit(X_train, y_train) x_scatter = np.linspace(0, 1, len(ds.feature_names)) fig, ax = plt.subplots(figsize=(6.4, 6.4)) ax.scatter(x_scatter, logreg1.coef_, marker='o', c='grey', s=100, label="C=1.0") ax.scatter(x_scatter, logreg001.coef_, marker='1', c='blue', s=100, label="C=0.01") ax.scatter(x_scatter, logreg20.coef_, marker='2', c='red', s = 100, label="C=20") ax.plot([0, 1], [0, 0], c='k', zorder=-100) ax.add_patch(pch.Arrow(2/30, -4, 0, 3, width=1/30)) ax.set_xticks(x_scatter) ax.set_xticklabels(ds.feature_names, rotation=90) ax.set_xlim(0, 1) ax.legend() fig.subplots_adjust(bottom=0.3) plt.show() |
ソルバーを同じliblinearとして、penalty='l1'と明示的に指定する。今回はL2正則化の時と違って、C=0.001はコード中に明示され、C=100としてスコアの計算結果まで合う。ただしset_ylim()によって表示範囲を制限しており、C=100に対するいくつかの点が枠外にある。
L1正則化によって、多くの係数がゼロとなり、少ない特徴量によるシンプルなモデルでそれなりのスコアを出している。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
logreg1 = LogisticRegression(solver='liblinear', penalty='l1').\ fit(X_train, y_train) logreg100 = LogisticRegression(C=100, solver='liblinear', penalty='l1').\ fit(X_train, y_train) logreg001 = LogisticRegression(C=0.001, solver='liblinear', penalty='l1').\ fit(X_train, y_train) print("C=0.001") print(" Training score: {:5.3f}".format(logreg001.score(X_train, y_train))) print(" Test score : {:5.3f}".format(logreg001.score(X_test, y_test))) print("C=1") print(" Training score: {:5.3f}".format(logreg1.score(X_train, y_train))) print(" Test score : {:5.3f}".format(logreg1.score(X_test, y_test))) print("C=100") print(" Training score: {:5.3f}".format(logreg100.score(X_train, y_train))) print(" Test score : {:5.3f}".format(logreg100.score(X_test, y_test))) # C=0.001 # Training score: 0.913 # Test score : 0.923 # C=1 # Training score: 0.960 # Test score : 0.958 # C=100 # Training score: 0.986 # Test score : 0.979 |
ターゲットのクラスは、malignant(悪性)が0、benign(良性)が1で、係数が正の場合は良性となる確率を上げる方向に、負の場合は悪性となる確率を上げる方向に効くことになる。
ここでL2正則化のworst concavityを見てみると、負～0の値をとっているが、元のデータを俯瞰すると良性の集団の方が全体的に高い値を示していて矛盾している。一方、L1正則化の場合は、C=0.001で全ての係数がゼロとなっていて、結果に影響していないことを示唆している。
L1正則化で正則化の程度を弱めて、C=1, 0.5, 0.1としてみると、worst concavityは結局ゼロとなるが、worst textureは一貫して負の値を維持している。この傾向はarea errorにも僅かだが見られる。
cancerデータを俯瞰してみると、worst textureは良性・悪性の分布がかなり重なっていて、悪性のデータのボリュームが大きい。area errorも両クラスのデータが近く、値が小さく、良性のデータ量が卓越している。
ヒストグラムを見る限りほとんどの特性量の値が大きいときに良性を示唆しているようみ見えるが、Logistic回帰の結果からは、多くの特性量が効いておらず、中には分布からの推測と逆の傾向を示す。
scikit-learnのLogisticRegressionモデルはLogistic回帰のモデルを提供する。利用方法の概要は以下の手順で、LinearRegressionなど他の線形モデルとほぼ同じだが、モデルインスタンス生成時に与える正則化パラメーターCはRidge/Lassoのalphaと逆で、正則化の効果を強くするにはCを小さくする（Cを大きくすると正則化が弱まり、訓練データに対する精度は高まるが過学習の可能性が高くなる）。
また、正則化の方法をL1正則化、L2正則化、Elastic netから選択できる。
LogisticRegressのクラスをインポートするC、正則化方法、solver（収束計算方法）などを指定し、モデルのインスタンスを生成するfit()メソッドに訓練データを与えて学習させる学習済みのモデルの利用方法は以下の通り。
score()メソッドにテストデータを与えて適合度を計算するpredict()メソッドに説明変数を与えてターゲットを予測intercept_、重み係数はcoef_(末尾のアンダースコアに注意)以下は、breast_cancerデータセットに対してLogisticRegressionを適用した例。デフォルトのsolverは'lbfgs'でデフォルトの最大収束回数(100)では収束しなかったため、max_iter=3000を指定している。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression ds = load_breast_cancer() X_train, X_test, y_train, y_test = train_test_split( ds.data, ds.target, stratify=ds.target, random_state=42) logreg = LogisticRegression(max_iter=3000).fit(X_train, y_train) print("") print("Training score: {}".format(logreg.score(X_train, y_train))) print("Test score : {}".format(logreg.score(X_test, y_test))) print("Prediction") for i in range(3): print("{} -> {}".format(y_test[i], logreg.predict(X_test[i].reshape(1, -1)))) # Training score: 0.9577464788732394 # Test score : 0.958041958041958 # Prediction # 1 -> [1] # 0 -> [0] # 1 -> [1] |
LogisticRgressionの主な利用方法はLineaRegressionとほとんど同じで、以下は特有の設定を中心にまとめる。
scikit-learn.linear_modelパッケージからLogisticRegressonクラスをインポートする。
|
1 |
from sklearn.linear_model import LogisticRegression |
LogisticRegressionでは、ハイパーパラメーターCによって正則化の強さを指定する。このCはRidge/Lassoのalphaと異なり、正則化の効果を強めるためには値を小さくする。デフォルトはC=1.0。
|
1 2 3 4 |
logreg = LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None) |
以下、RidgeとLassoに特有のパラメーターのみ説明。LinearRegressionと共通のパラメーターはLinearRegressionを参照。
penalty'l1', 'l2', 'elasticnet', 'none'で正則化項のノルムのタイプを指定する。ソルバーの'newton-cg','sag','lbfgs'はL2正則化のみサポートし、'elasticnet'は'saga'のみがサポートする。デフォルトは'none'で正則化は適用されない('liblinear'は'none'に対応しない)。tolCsolver'newton-cg'、'lbfgs'、'liblinear'、'sag'、'saga'のうちから選択される。デフォルトは'lbfgs'。小さなデータセットには'liblnear'が適し、大きなデータセットに対しては'sag'、'saga'の計算が速い。複数クラスの問題には、'newton-cg'、'sag'、'saga'、'lbfgs'が対応し、'liblinear'は一対他しか対応しない。その他ノルムの種類とソルバーの対応。max_iterrandom_statesolver='sag'の際に用いる。l1_ratiopenalty='elasticnet'の時のみ使われる。fit()メソッドに特徴量とターゲットの訓練データを与えてモデルに学習させる(回帰係数を決定する)。
|
1 |
lr.fit(X, y) |
Xreshape(-1, 1)かスライス([:, n:n+1])を使って1列の列ベクトルに変換する必要がある。y3つ目の引数sample_weightは省略。
score()メソッドに特徴量とターゲットを与えて適合度を計算する。
|
1 |
lr.score(X, y) |
decision_function(X)densiffy()predict_proba(X)predict_log_proba()sparsify()