CPythonの関数が参照している名前(ローカル変数と自由変数を除く)は、その関数のコードオブジェクトのco_namesに保存されていることは以前書きました。co_namesは、グローバル変数名だけでなく、例えば次の例ではyも含んでいます。

def foo():
    return x.y

foo.__code__.co_names　# => ('x', 'y')

ではグローバル変数の名前だけを取り出したい場合はどうするかについてです。
結論から言うと、dis標準ライブラリで、その関数をディスアセンブリし、LOAD_GLOABLインストラクションの引数を取り出す、という方法があるようです。　

def global_names(func):

    insts = list(dis.get_instructions(func.__code__))

    names = []
    for inst in insts:
        if inst.opname == "LOAD_GLOBAL" and inst.argval not in names:
            names.append(inst.argval)

    return tuple(names)

ただこの方法だと、ネストした関数内で参照されているグローバル変数名は取得できないようです。

def foo():
    def bar():
        return x
    return bar()

global_names(foo)  # => ()

参考: https://stackoverflow.com/questions/60639406/how-to-extract-names-of-global-variables-referenced-in-a-function

はじめに

突然ですが、あなたは多重ループは書けますか？

？？？：「書けますー！」

test.py

cnt = 0
for i0 in range(3):
    for i1 in range(3):
        for i2 in range(3):
            for i3 in range(3):
                ##### ここに処理を書く #####
                cnt += 1
                #####
print(cnt) # 81

これは $4$ 重ループになってますが、これの可変なやつ（詳細は後述）をうまく処理しようというのがこの記事の趣旨です。言語は Python 、特に PyPy での実行を想定しています。

ループを書くことが目的なので「処理」のところは何でもよいのですが、ここではループした回数をカウントしています。実際の問題では、 ans += calc(i0, i1, i2, i3) のような数え上げを計算したり、 ans = max(ans, calc(i0, i1, i2, i3)) のような更新をしたり、あるいは DP テーブルを更新したりするイメージです。

可変長ループとは

だいたいこんなのができるものを可変長ループと呼んでいます ¹。

• 可変個（$K$ 個とします）の変数 $i_0,\ \cdots, i_{K-1}$ でループをする
• $i_k$ は $[l_k,\ r_k)$ の範囲の整数をループする。 $l_k,\ r_k$ は $i_0,\ \cdots,\ i_{k-1}$ に依存してもよい
• 変数間に満たすべき条件 $P(i_{k_0},\ \cdots,\ i_{k_{s-1}}) $ がいくつかある
• 非再帰かつ 空間 計算量 $O(K)$
• $i_0,\ \cdots,\ i_{k-1}$ が満たすべき条件を満足していない場合は $i_k$ 以降のループは回さない ²

いくつか例を挙げてみます。まずは愚直ループで書いてみるので、可変長にするにはどうすれば良いか考えながら見てみてください。

例1（愚直）

変数 $i_0,\ i_1,\ i_2,\ i_3$ が $0\le i_k < 2k+1$ を満たす整数を動くループを書いてください。
愚直に書くとこんな感じ。

test.py

cnt = 0
for i0 in range(1):
    for i1 in range(3):
        for i2 in range(5):
            for i3 in range(7):
                ##### ここに処理を書く #####
                cnt += 1
                #####

print(cnt) # 105

これぐらいなら Python の itertools を使うなどいろんな書き方があると思います³。

例2（愚直）

さっきのに加えて、「隣り合う変数の合計が $3$ の倍数になるものは除く」という条件を入れたらどうなるでしょうか。

test.py

cnt = 0
for i0 in range(1):
    for i1 in range(3):
        if (i0 + i1) % 3 == 0: continue
        for i2 in range(5):
            if (i1 + i2) % 3 == 0: continue
            for i3 in range(7):
                if (i2 + i3) % 3 == 0: continue
                ##### ここに処理を書く #####
                cnt += 1
                #####

print(cnt) # 31

これも itertools などでできそうですが、普通にループして全てのループ変数の組に対して条件を判定するやり方だと無駄なループができて計算量が大きくなってしまう可能性があります。具体的には、上の例だと (i0 + i1) % 3 == 0 の時点でその後の i2 や i3 を見る必要はないにも関わらず、ループを回してしまうことになりそうです。
なので上の continue のように、条件を満たさなくなった時点でそれ以降の変数のループを回さないようにしたいです。

例3（愚直）

次はループ範囲がそれより前の変数に依存する場合を考えてみましょう。
例えば $i_k$ のループ範囲が $[0,\ i_0+\cdots +i_{k-1}+2)$ のように表される場合です。この例では右側だけ動かしていますが、左側が前の変数に依存することもありえます。

test.py

cnt = 0
for i0 in range(1):
    for i1 in range(i0 + 2):
        if (i0 + i1) % 3 == 0: continue
        for i2 in range(i0 + i1 + 2):
            if (i1 + i2) % 3 == 0: continue
            for i3 in range(i0 + i1 + i2 + 2):
                if (i2 + i3) % 3 == 0: continue
                ##### ここに処理を書く #####
                cnt += 1
                #####
print(cnt) # 5

これのループ変数の個数を増やすと（例えば $K=10$ など）結構大変そうですね。
まあ書けなくはないんですけど。

test.py

cnt = 0
for i0 in range(1):
    for i1 in range(i0 + 2):
        if (i0 + i1) % 3 == 0: continue
        for i2 in range(i0 + i1 + 2):
            if (i1 + i2) % 3 == 0: continue
            for i3 in range(i0 + i1 + i2 + 2):
                if (i2 + i3) % 3 == 0: continue
                for i4 in range(i0 + i1 + i2 + i3 + 2):
                    if (i3 + i4) % 3 == 0: continue
                    for i5 in range(i0 + i1 + i2 + i3 + i4 + 2):
                        if (i4 + i5) % 3 == 0: continue
                        for i6 in range(i0 + i1 + i2 + i3 + i4 + i5 + 2):
                            if (i5 + i6) % 3 == 0: continue
                            for i7 in range(i0 + i1 + i2 + i3 + i4 + i5 + i6 + 2):
                                if (i6 + i7) % 3 == 0: continue
                                for i8 in range(i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + 2):
                                    if (i7 + i8) % 3 == 0: continue
                                    for i9 in range(i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + 2):
                                        if (i8 + i9) % 3 == 0: continue
                                        ##### ここに処理を書く #####
                                        cnt += 1
                                        #####
print(cnt) # 5964602

これをきれいに書くのを目標にしましょう ⁴。

他の方法

本記事で示す方法以外にもいくつか方法があります。これらが使えることもあるでしょう。

1. 愚直にループを書く
   上の例で書いたようなやつです。ただこれだとループの深さなどが可変の問題には対応しづらいですね。

2. itertools
   不要なところもループしてしまうので場合によっては計算量が増えてしまう可能性があります。

3. 再帰 DFS
   再帰は言語によっては遅くなるので使いたくなかったりします。

4. BFS
   メモリが $O(K)$ では収まらないです。

5. 本記事の方法
   可変長対応、不要なループをしない ⁵ 、非再帰、メモリは $O(K)$ 、のすべてを満足する方法です。

   アイデア

アイデアというほどでもないですが、本記事の実装方法です。

• 各ループ変数に対して、「初期値」「終了値」を持つ。具体的には $i$ 番目のループ変数の初期値・終了値をそれぞれ L[i] および R[i] で表す
• while 文をでループする

これだけです。

実装

さっきの例1

さっきの例で実装してみます。
chk 関数で満たすべき条件を設定しています。この例では特に NG 条件がないので必ず $0$ を返すようにしています。

test.py

def chk(i):
    if not i: return 0
    # i 番目の変数の条件（OK なら 0 を、NG なら 1 を返す）
    # i-1 番目までの変数に依存しても良い
    return 0

K = 4 # ループ変数の個数
Z = [0] * K
L = [0] * K
R = [0] * K
L[0], R[0] = 0, 1 # 半開区間 [L, R) をループする
i = 0
cnt = 0
while i >= 0:
    while i < K - 1:
        i += 1

        ##### 初期値・終了値の設定 #####
        L[i] = 0
        R[i] = 2 * i + 1
        #####

        Z[i] = L[i]
        if chk(i):
            break
    else:
        ##### ここに処理を書く #####
        cnt += 1
        #####

    Z[i] += 1
    while Z[i] >= R[i] or chk(i):
        if Z[i] < R[i]: Z[i] += 1
        while Z[i] >= R[i]:
            i -= 1
            if i < 0: break
            Z[i] += 1
        if i < 0: break

print(cnt) # 105

さっきの例2

ループ変数間に条件がある場合です。
chk 関数に条件を入れています。 $i$ 番目のループ変数の条件のところでは $i$ 番目までの変数に依存して決めて良いです。言い換えると、いくつかのループ変数に関係する条件については、その中で最も大きな番号のループ変数のところで判定をして、 NG ならすぐ次に移るようにしています。

test.py

def chk(i):
    if not i: return 0
    # i 番目の変数の条件（OK なら 0 を、NG なら 1 を返す）
    # i-1 番目までの変数に依存しても良い
    return 1 if (Z[i-1] + Z[i]) % 3 == 0 else 0

K = 4 # ループ変数の個数
Z = [0] * K
L = [0] * K
R = [0] * K
L[0], R[0] = 0, 1 # 半開区間 [L, R) をループする
i = 0
cnt = 0
while i >= 0:
    while i < K - 1:
        i += 1

        ##### 初期値・終了値の設定 #####
        L[i] = 0
        R[i] = 2 * i + 1
        #####

        Z[i] = L[i]
        if chk(i):
            break
    else:
        ##### ここに処理を書く #####
        cnt += 1
        #####

    Z[i] += 1
    while Z[i] >= R[i] or chk(i):
        if Z[i] < R[i]: Z[i] += 1
        while Z[i] >= R[i]:
            i -= 1
            if i < 0: break
            Z[i] += 1
        if i < 0: break

print(cnt) # 31

さっきの例3

$i$ 番目のループ変数の範囲が $i-1$ 番目までのループ変数に依存する場合です。
R[i] = sum(Z[:i]) + 2 のところで設定しています ⁶ 。

test.py

def chk(i):
    if not i: return 0
    # i 番目の変数の条件（OK なら 0 を、NG なら 1 を返す）
    # i-1 番目までの変数に依存しても良い
    return 1 if (Z[i-1] + Z[i]) % 3 == 0 else 0

K = 4 # ループ変数の個数
Z = [0] * K
L = [0] * K
R = [0] * K
L[0], R[0] = 0, 1 # 半開区間 [L, R) をループする
i = 0
cnt = 0
while i >= 0:
    while i < K - 1:
        i += 1

        ##### 初期値・終了値の設定 #####
        L[i] = 0
        R[i] = sum(Z[:i]) + 2
        #####

        Z[i] = L[i]
        if chk(i):
            break
    else:
        ##### ここに処理を書く #####
        cnt += 1
        #####

    Z[i] += 1
    while Z[i] >= R[i] or chk(i):
        if Z[i] < R[i]: Z[i] += 1
        while Z[i] >= R[i]:
            i -= 1
            if i < 0: break
            Z[i] += 1
        if i < 0: break

print(cnt) # 5

さっきみたいに $K=10$ にしてみましょう。

test.py

def chk(i):
    if not i: return 0
    # i 番目の変数の条件（OK なら 0 を、NG なら 1 を返す）
    # i-1 番目までの変数に依存しても良い
    return 1 if (Z[i-1] + Z[i]) % 3 == 0 else 0

K = 10 # ループ変数の個数
Z = [0] * K
L = [0] * K
R = [0] * K
L[0], R[0] = 0, 1 # 半開区間 [L, R) をループする
i = 0
cnt = 0
while i >= 0:
    while i < K - 1:
        i += 1

        ##### 初期値・終了値の設定 #####
        L[i] = 0
        R[i] = sum(Z[:i]) + 2
        #####

        Z[i] = L[i]
        if chk(i):
            break
    else:
        ##### ここに処理を書く #####
        cnt += 1
        #####

    Z[i] += 1
    while Z[i] >= R[i] or chk(i):
        if Z[i] < R[i]: Z[i] += 1
        while Z[i] >= R[i]:
            i -= 1
            if i < 0: break
            Z[i] += 1
        if i < 0: break

print(cnt) # 5964602

ちゃんと同じ結果になりました。

問題（ネタバレ注意）

ABC 161 - D

問題
ループするだけですね。

ACコード
愚直ループ でもできるけど本番では書きたくないです。

ARC 095 - E

問題
想定解じゃないけど、自然に可変長ループすると枝刈りになって通ります ^{7 8}。想定解の方法でも可変長ループが使えます。
ACコード

ARC 104 - E

問題
まあこれぐらいなら可変長ループいらないけど。
ACコード （古い書き方してたときのやつなのでこの記事の書き方とは違う）

Q&A

Q. これ需要あるの？
A. あんまりない気がしています。でも私は結構使ってます。直感的に書ける ⁹ ので気に入っています。

書いても需要ない記事ばかり書く人というのが存在していてほしい

— えびちゃん (@rsk0315_h4x) March 3, 2021

Q. 再帰じゃダメなの？
A. PyPy だと再帰遅いので ¹⁰ 。もちろん計算時間に十分余裕があるなら大丈夫です。

Q. BFS じゃだめなの？
A. これは全然だめじゃないです。本記事の方法だとメモリが $O(K)$ で良いというメリットがありますが、メモリがネックになることはあまりない気がします。

Q. そもそも PyPy だと JIT コンパイルでめちゃくちゃメモリ食うから、メモリ $O(K)$ って意味なくない？
A. それを言われるととてもつらい気持ちになります。

Q. もっときれいに書けない？
A. 書けそう。教えてください。

Q. Step は設定できないの？（ループ変数を $2$ ずつ増やすとか）
A. ちょっといじればできます。

---

1. 私が勝手に呼んでるだけですが ↩

2. これができるものを「枝刈り可変長ループ」とか呼んだりしてます（私が勝手にry ↩

3. 具体的にどう書くかはあんまり考えていません ↩

4. この結果の 5964602 を覚えておいてね ↩

5. 「さっきの例2」セクション参照 ↩

6. ここでは一回ごとに $\Theta(k)$ をかけて設定していますが、ループしながら順に計算することで、それぞれ $O(1)$ で設定することもできます ↩

7. AC コードでは可変長ループを二重に使っています。もちろん一重に全部入れることもできます ↩

8. 嘘解法っぽいけど、嘘かどうかはこの記事の目的とは関係ないので気にしません ↩

9. 個人の感想です ↩

10. 再帰、ダメ、絶対 ↩

はじめに

今日、以下のようなプログラムを書いていました（一部わざとコメントを抜いています）

app.py

from flask import Flask, render_template, send_file
from great_algorithm import GreatAlgorithm

app = Flask(__name__)
# 実際にはセッションごとにインスタンスを作ってるが割愛
algo = GreatAlgorithm()

@app.route('/', methods=['GET'])
def start():
    return render_template('index.html', algo=algo)

# パスパラメータ使って「何番目の画像」とかしてるわけだが割愛
@app.route('/image')
def image():
    return send_file(algo.get_image('jpg'), mimetype='image/jpeg')

@app.route('/', methods=['POST'])
def update():
    # フォーム値をupdateメソッドに渡すわけだが割愛
    algo.update()
    return render_template('index.html', algo=algo)

if __name__ == '__main__':
    app.run(debug=True)

great_algorithm.py

import io
import numpy as np
import matplotlib.pyplot as plt

class GreatAlgorithm:
    def __init__(self):
        # 本題じゃないので適当
        img = np.random.random((400, 400))
        img = img * 255
        img = img.astype('uint8')
        self._img = img

    def update(self):
        # 本題じゃないので割愛
        pass

    def get_image(self, format):
        f = io.BytesIO()
        plt.imsave(f, self._img, format=format)
        f.seek(0)
        return f

何をしているのか

某エッチな絵を作るあれではないですが¹、「画像を提示」→「評価」→「評価に基づいて画像を更新」ということをしています。ただしその部分は今回の萌えポイントとは関係ないので割愛です。

元々Webインタフェースを作る気はなかったのですが、評価値を手入力するのがめんどくさいのでWeb化するかと思って「あれ？ここどうやればいいんだろう」と思って調べたところが今回の本題（萌えポイント）です。
画像は上記のようにNumPy配列です。ターミナル（と言っても別ウインドウは開きますが）でmatplotlib使ってimshowするだけならそれでまったく問題ありません。しかし、Web化するとなると「画像ファイル」を作る必要があります。

萌えポイント

flask.send_file

先にflask側から。今までflaskで「動的に画像作って返す」ということをしたことがなかったので「flask return jpg」でググり以下の記事を見つけ、send_file使えばいけそうということはわかりました。
https://stackoverflow.com/questions/8637153/how-to-return-images-in-flask-response

ただ、「ファイルに書き出したくないな（一時ファイル作りたくないな）」という気持ちがありドキュメントを確認したところ、

send_file(filename_or_fp, mimetype=None, as_attachment=False, attachment_filename=None, add_etags=True, cache_timeout=None, conditional=False, last_modified=None)

filename_or_fp – the filename of the file to send. This is relative to the root_path if a relative path is specified. Alternatively a file object might be provided in which case X-Sendfile might not work and fall back to the traditional method. Make sure that the file pointer is positioned at the start of data to send before calling send_file().

「ファイル名ではなく、ファイルオブジェクトを渡せる」ことが確認できました。

matplotlib.pyplot.imsave

次に画像を作る側のmatplotlibです。imsaveを使えば画像ファイルとして書き出せるわけですが、

imsave(fname, arr, **kwargs)
fname : str or path-like or file-like

おぉ！こっちもファイルオブジェクトを渡せる！これで勝てる！

io.BytesIO

「ファイルオブジェクト」と言っても、「本物のファイルを開いて（ファイルに対応するオブジェクトを作成して）」上記のsend_fileやimsaveに渡すわけではありません。
「ファイルのような挙動をする」オブジェクトを渡してreadさせたりwriteさせたりすればいいわけです。そう、みんな大好きダックタイピングですね。readやwriteの呼び出しに応じてくれれば別に本物のファイルである必要はないわけです。

Pythonにはそのような「ファイルのような挙動をする」クラスがあらかじめ用意されています。io.BytesIOです。
というわけで一番の萌えポイントを今度はコメント付きで見てみましょう。

great_algorithm.py抜粋

    def get_image(self, format):
        # ファイルに出力するのではなくメモリに出力させる
        f = io.BytesIO()
        plt.imsave(f, self._img, format=format)
        # 読み込み側が便利なようにoffsetを先頭にしておく
        f.seek(0)
        return f

app.py抜粋

@app.route('/image')
def image():
    return send_file(algo.get_image('jpg'), mimetype='image/jpeg')

BytesIOオブジェクトに「画像ファイルの内容」を出力させ、それをそのままsend_fileに渡して最終的にブラウザまで届くようになっています。
一時ファイルなど作らないで済みます！
ちなみに、matplotlib側のformat引数、flask側のmimetype引数は普通なら指定しませんが今回は「ファイル名から決定」ができないので指定する必要があります（指定しないとエラーになります）

まとめ

• 保持している情報を画像ファイルにして返したいが一時ファイルは作りたくない
• flaskのsend_fileは「ファイルオブジェクト」を受け付けてくれる
• matplotlibのimsaveも「ファイルオブジェクト」を受け付けてくれる
• よしBytesIOの出番だ

「ファイルパスでもファイルオブジェクトでもよい」というのは使う側にとってはとてもありがたい仕様です。
作る側は大変ですが。特にPythonみたいな言語的にオーバーロードのない言語だと・・・

オチ

その後に考えた結果、「世代ごとの画像」はログ的に残す必要あるなということで結局「ファイル出力」しないといけないかという考えに至りました。

---

1. 一応私、「遺伝的アルゴリズムﾁｮｯﾄﾜｶﾙ」な人間なのですが、あらためて考えてみるとあれ提示される画像が2枚だけだけど、多様性考えると母集団が2個体だけなんてことはないよな、どう管理されてるんだろう（一定数保持して評価の低い古い世代から消していく？）と思いました。 ↩

Open CVで作業をするとき毎回忘れてそのたびに解決策を探す小ネタの一つに上のものがある。
結構面倒なので毎回ゲンナリしてしばらくやる気を失いがちなのでこれ以上繰り返さないために書く。
pythonです。

結論はこれ

import cv2
import numpy as np

def cutByPoints(src_img,poly):
    mask = np.zeros_like(src_img) # (y, x, c)
    mytest=cv2.cvtColor(mask,cv2.COLOR_BGR2BGRA)#アルファ追加　全画素黒
    mytest[:] = (0, 0, 0,0)#全画素透過
    mytest = cv2.fillConvexPoly(mytest, np.array(poly), color=(255, 255, 255,255))#図＝白　背景＝透明
    src_img2=cv2.cvtColor(src_img,cv2.COLOR_BGR2BGRA)
    masked_src_img00 = np.where(mytest==255, src_img2, mytest)#図＝元画像　背景＝透明
    minx =-1
    miny=-1
    maxx=-1
    maxy=-1
    leng=len(poly)
    for i  in range(leng):
       if i==0: 
           minx=poly[i][0]
           maxx=poly[i][0]
           miny=poly[i][1]
           maxy=poly[i][1]
       else :
           if minx>poly[i][0]:
               minx=poly[i][0]
           if maxx<poly[i][0]:
               maxx=poly[i][0]
           if miny>poly[i][1]:
               miny=poly[i][1]
           if maxy<poly[i][1]:
               maxy=poly[i][1]         


    resimg=masked_src_img00[miny : maxy, minx : maxx]

    return resimg

これ以上googleしないために書いた

使い方はこんな感じ

src_img = cv2.imread("/home/kokawa2003/ピクチャ/kyBXv.png")#元画像
#座標（星の右半分）
poly= [
            [200, 0],
            [260, 160],
            [400, 160],
            [300, 240],
            [400, 400],
            [200, 320],
]
img_bool=cutByPoints(src_img,poly)    

cv2.imwrite("./masked_crop.png", img_bool)

今回、例に出す図形

今回、例として出す入力は、

例１(文字列の場合)
4 7
O O O X O O O
O O X X X O O
O X X X X X O
X X X X X X X

例２(数字列の場合)
4 7
0 0 0 1 0 0 0
0 0 1 1 1 0 0
0 1 1 1 1 1 0
1 1 1 1 1 1 1

文字列の場合

h ,w = [int(x) for x in input().split()]
l = [input().split() for _ in range(h)]
print(l)

数字列の場合

h ,w = [int(x) for x in input().split()]
l = [[int(x) for x in input().split()] for _ in range(h)]
print(l)

全ての結果

#結果(文字列の結果)
[['O', 'O', 'O', 'X', 'O', 'O', 'O'],
 ['O', 'O', 'X', 'X', 'X', 'O', 'O'],
 ['O', 'X', 'X', 'X', 'X', 'X', 'O'],
 ['X', 'X', 'X', 'X', 'X', 'X', 'X']]
#結果(数字列の場合)
[[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [1, 1, 1, 1, 1, 1, 1]]

終わりに

初めてQiitaで記事を試しに書いてみました。まだPython3の経験が3ヶ月なので、これから暇つぶしに書いていこうと思います。

今回、例に出す図形

今回、例として出す入力は、

例１(文字列の場合)
4 7
O O O X O O O
O O X X X O O
O X X X X X O
X X X X X X X

例２(数字列の場合)
4 7
0 0 0 1 0 0 0
0 0 1 1 1 0 0
0 1 1 1 1 1 0
1 1 1 1 1 1 1

文字列の場合

h ,w = [int(x) for x in input().split()]
l = [input().split() for _ in range(h)]
print(l)

数字列の場合

h ,w = [int(x) for x in input().split()]
l = [[int(x) for x in input().split()] for _ in range(h)]
print(l)

全ての結果

#結果(文字列の結果)
[['O', 'O', 'O', 'X', 'O', 'O', 'O'],
 ['O', 'O', 'X', 'X', 'X', 'O', 'O'],
 ['O', 'X', 'X', 'X', 'X', 'X', 'O'],
 ['X', 'X', 'X', 'X', 'X', 'X', 'X']]
#結果(数字列の場合)
[[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 1, 1, 0],
 [1, 1, 1, 1, 1, 1, 1]]

終わりに

初めてQiitaで記事を試しに書いてみました。まだPython3の経験が3ヶ月なので、これから暇つぶしに書いていこうと思います。

関数合成的な何か

$ python -V
Python 3.8.6

a.py

import functools

class F:
    @staticmethod
    def __cmp(f1, f2):
        def __i1(*args1, **kwargs1):
            def __i2(*args2, **kwargs2):
                return f1(*args2, **kwargs2)
            return f2(__i2(*args1, **kwargs1))
        return __i1


    @classmethod
    def composite(cls, *fs):
        return functools.reduce(cls.__cmp, fs)

test

a_test.py

import pytest
import functools

from a import F

def test_args1():
    """1引数の関数合成"""
    def d1(a):
        r = a * 2
        print(f"d1: {a} * 2 = {r}")
        return r

    def d2(a):
        r = a + 1
        print(f"d2: {a} + 1 = {r}")
        return r

    def d3(a):
        r = a // 3
        print(f"d3: {a} / 3 = {r}")
        return r

    f = F.composite(d1, d2, d3, d1, d2)
    assert f(123) == 165

def test_args2():
    """2引数以上はできないので適当にカリー化するとよい"""
    def d1(a, b):
        r = a * b
        print(f"d1: {a} * {b} = {r}")
        return r

    def d2(a, b):
        r = a + b
        print(f"d2: {a} + {b} = {r}")
        return r

    d3 = functools.partial(d1, b=2)
    d4 = functools.partial(d2, b=1)
    d5 = functools.partial(d1, b=3)
    d6 = functools.partial(d2, b=4)

    f = F.composite(d3, d4, d5, d6)
    assert f(123) == 745


def test_args3():
    """2引数以上は(ry"""
    def d1(a, b, c):
        r = a // b - c
        print(f"d1: {a} // {b} - {c} = {r}")
        return r

    def d2(a, b, c):
        r = (a + b) ** c
        print(f"d2: ({a} + {b}) ** {c} = {r}")
        return r

    d3 = functools.partial(d1, b=5, c=5)
    d4 = functools.partial(d2, b=3, c=2)
    d5 = functools.partial(d1, b=345, c=3)
    d6 = functools.partial(d2, b=4, c=8)

    f = F.composite(d3, d4, d5, d6)
    assert f(123) == 256

run test

bash

$ pytest -V
pytest 6.1.2

$ pytest -s -v a_test.py
=============================================== test session starts ===============================================
platform darwin -- Python 3.8.6, pytest-6.1.2, py-1.9.0, pluggy-0.13.1 -- /Users/kuryu/.pyenv/versions/3.8.6/bin/python3.8
cachedir: .pytest_cache
rootdir: /Users/kuryu/workspace/work
plugins: Faker-4.16.0
collected 3 items

a_test.py::test_args1 d1: 123 * 2 = 246
d2: 246 + 1 = 247
d3: 247 / 3 = 82
d1: 82 * 2 = 164
d2: 164 + 1 = 165
PASSED
a_test.py::test_args2 d1: 123 * 2 = 246
d2: 246 + 1 = 247
d1: 247 * 3 = 741
d2: 741 + 4 = 745
PASSED
a_test.py::test_args3 d1: 123 // 5 - 5 = 19
d2: (19 + 3) ** 2 = 484
d1: 484 // 345 - 3 = -2
d2: (-2 + 4) ** 8 = 256
PASSED

================================================ 3 passed in 0.06s ================================================

カレー食べたい。

a.py

import functools

class F:
    @staticmethod
    def __cmp(f1, f2):
        def __i1(*args1, **kwargs1):
            def __i2(*args2, **kwargs2):
                return f1(*args2, **kwargs2)
            return f2(__i2(*args1, **kwargs1))
        return __i1


    @classmethod
    def composite(cls, *fs):
        return functools.reduce(cls.__cmp, fs)


def d1(a):
    r = a * 2
    print("called d1", a, r)
    return r

def d2(a):
    r = a + 1
    print("called d2", a, r)
    return r

def d3(a):
    r = a / 3
    print("called d3", a, r)
    return r

if __name__ == '__main__':
    f = F.composite(d1, d2, d3, d1, d2)
    print(f(123))

bash

$ python a.py
called d1 123 246
called d2 246 247
called d3 247 82.33333333333333
called d1 82.33333333333333 164.66666666666666
called d2 164.66666666666666 165.66666666666666
165.66666666666666

検算

In [1]: a = 123

In [2]: a = a * 2

In [3]: a = a + 1

In [4]: a = a / 3

In [5]: a = a * 2

In [6]: a = a - 1

In [7]: a
Out[7]: 163.66666666666666

概要

関数結果をキャッシュしたい時に、functools.lru_cachedを使えば良い。

自前で作らなくても大丈夫かもしれない。

内容

環境

macOS Catalina
Python 3.7.0

全体像

fibo.py

import functools

@functools.lru_cache(maxsize=None)
def factorial(n):
    print('in', n)
    return n * factorial(n-1) if n else 1


print('fac 5', factorial(5))
print('fac 3', factorial(3))
print('fac 12', factorial(12))

output

in 5
in 4
in 3
in 2
in 1
in 0
fac 5 120
fac 3 6
in 12
in 11
in 10
in 9
in 8
in 7
in 6
fac 12 479001600

同じ引数は2度評価されていないことが分かる。

解説

lru: least recently used

最近使ったものだけをmaxsizeまでキャッシュする。
maxsize=Noneとすると、全てキャッシュされる。

蛇足

wrapにより、以下のメソッド・属性が追加される。
- factorial.cache_info()：maxsizeやcache済数などを示す
- factorial.__wrapped__：wrap前の関数。cache回避や別のwrapに有用。
- factorial.cache_clear()：cacheを削除する
- factorial.cache_parameters()：3.9以降で使用可能。dictで返す。

参考にさせていただいた本・頁

• https://docs.python.org/3/library/functools.html#functools.lru_cache
• https://docs.python.org/ja/3/library/functools.html

感想

便利！使えそう。

今後

使っていきたい。

はじめに

Google Colaboratory上でYOLOv5を使用して、物体検出（object detection）する方法についてまとめました。

目次

• はじめに
• 目次
• YOLOv5とは
• 実装
  • YOLOv5の準備
  • 学習データの準備
  • 学習
  • 推論
• まとめ
• 注釈
• 参考文献

YOLOv5とは

※上図は、YOLOv5のGitHubページからの引用
物体検出モデルとしては、SSDやYOLOが有名です。
YOLOのversion3であるYOLOv3は、その精度と処理の速さから広く使用されています。
YOLOv5はそのYOLOのversion5にあたり、2020年にリリースされました。
現在でも精力的に開発が進められています。

YOLO v3については、以下の記事をご参照下さい。

実装

※言語はPython、環境はGoogle Colaboratoryを使用しています。ご自身の環境に合わせて適宜読み替えて下さい。
※以下の実装は、YOLOv5のGitHubページの、「Train Custom Data」のチュートリアルの内容を一部改変したものです。

YOLOv5の準備

まず事前準備として作業ディレクトリを作成しておき、以降その配下で作業を進めていきます。

WORKING_DIR = '/content/tmp'
!mkdir $WORKING_DIR
%cd $WORKING_DIR

YOLOv5をインストールします。

!git clone https://github.com/ultralytics/yolov5

無事インストールが完了したら、yolov5配下に移動して依存ライブラリをインストールします。

%cd yolov5/
!pip install -qr requirements.txt

学習データの準備

それでは早速学習してモデルを作成したいのですが、そのためには学習データが必要になります。
物体検出における学習データは、画像とそのラベルになります。ラベルは、物体のクラス（その物体が何かを表す）と座標（その物体が画像内のどこに写っているか）になります。
学習データについては、画像を多数用意し、それぞれの画像にラベル付け（何が、どこに、写っているか。アノテーションとも言う）を行って正解データを作成する必要があります。
しかし、この作業にはかなりの時間と労力を要するので、今回はすでに用意されている公開データである、COCOデータセットを使用することにします。

それでは、COCOデータセットをダウンロードしてきます。

!wget https://github.com/ultralytics/yolov5/releases/download/v1.0/coco128.zip
!unzip coco128.zip

COCOデータセットの中身を確認してみましょう。
上記でダウンロードして展開したcoco128のディレクトリ構成は以下のようになっています。

coco128
   |_images
   |  |_train2017
   |     |_000000000009.jpg
   |     |_000000000025.jpg
   |     |_000000000030.jpg
   |       ︙
   |_labels
      |_train2017
         |_000000000009.txt
         |_000000000025.txt
         |_000000000030.txt
           ︙

imagesディレクトリにはjpgファイルが、labelsディレクトリにはtxtファイルが入っています。
また、それぞれ（拡張子を除いて）ファイル名が一致するものが対応しており、画像とそのラベルになっています。
例えば、000000000009.jpgと000000000009.txtは、以下のようになっています。

000000000009.txt

45 0.479492 0.688771 0.955609 0.5955
45 0.736516 0.247188 0.498875 0.476417
50 0.637063 0.732938 0.494125 0.510583
45 0.339438 0.418896 0.678875 0.7815
49 0.646836 0.132552 0.118047 0.096937
49 0.773148 0.129802 0.090734 0.097229
49 0.668297 0.226906 0.131281 0.146896
49 0.642859 0.079219 0.148063 0.148062

この写真には、検出対象となる物体が8つあり、それぞれのクラス（45, 49, 50）および座標が
クラス、$x$座標、$y$座標、幅、高さ
の順に記載されています（注釈）。

これら2つのファイルは、以下のラベル付きデータを表しています（以下のアノテーションはRoboflowを使用）。

今回は、公開データであるCOCOデータセットを使用しますが、オリジナルのデータの場合にも上記と同様のディレクトリ構成、同様のフォーマットのtxtデータを用意してあげることでモデルを作成することができます。

学習

学習データが用意できたので、学習を行います。
学習は、非常に大きな処理を必要とするため、通常GPUを使用します。
今回はGoogle Colaboratoryを使用していますので、無料でGPUを使うことができます。
「ランタイム>ランタイムのタイプを変更」から「ハードウェア アクセラレータ」を「GPU」
に設定しておきます。

GPUに設定できたら、以下のコマンドを実行して学習を行います。

!python train.py --img 640 --batch 16 --epochs 300 --data coco128.yaml --weights yolov5x.pt

ここでは、yolov5xというモデルを使用して、300エポックの学習を行っています。
学習にはしばらく時間がかかるのでご注意下さい。

5xは最も大きなモデルのため、精度が出やすい分学習には時間がかかります。
試しに学習してみたいという場合には、最も軽量な5sのモデルでかつ少ないエポック数で学習してみることをオススメします。

学習中には、以下のように表示されるので、どれぐらい学習が進んでいるかを確認することができます。

     Epoch   gpu_mem       box       obj       cls     total   targets  img_size
     0/299     3.29G   0.04357   0.06778   0.01869      0.13       207       640: 100% 8/8 [00:05<00:00,  1.58it/s]
               Class      Images     Targets           P           R      mAP@.5  mAP@.5:.95: 100% 4/4 [00:04<00:00,  1.22s/it]
                 all         128         929       0.647       0.626       0.659       0.432

     Epoch   gpu_mem       box       obj       cls     total   targets  img_size
     1/299     6.66G   0.04307   0.06652   0.02082    0.1304       227       640: 100% 8/8 [00:02<00:00,  2.69it/s]
               Class      Images     Targets           P           R      mAP@.5  mAP@.5:.95: 100% 4/4 [00:02<00:00,  1.45it/s]
                 all         128         929        0.68       0.607       0.664       0.434

     Epoch   gpu_mem       box       obj       cls     total   targets  img_size
     2/299     6.66G   0.04457   0.06889   0.01857     0.132       191       640: 100% 8/8 [00:02<00:00,  2.69it/s]
               Class      Images     Targets           P           R      mAP@.5  mAP@.5:.95: 100% 4/4 [00:02<00:00,  1.44it/s]
                 all         128         929       0.647        0.63       0.666       0.436

　　　　　　　　　　　　　　　　　　　　　　　　　︙

     Epoch   gpu_mem       box       obj       cls     total   targets  img_size
   299/299     6.66G   0.02718   0.03315  0.004541   0.06487       235       640: 100% 8/8 [00:02<00:00,  2.88it/s]
               Class      Images     Targets           P           R      mAP@.5  mAP@.5:.95: 100% 4/4 [00:05<00:00,  1.35s/it]
                 all         128         929       0.953       0.911       0.966       0.795
Optimizer stripped from runs/train/exp/weights/last.pt, 14.8MB
Optimizer stripped from runs/train/exp/weights/best.pt, 14.8MB
300 epochs completed in 0.574 hours.

無事学習が完了したら、TensorBoardを使用して学習の様子をグラフで確認してみましょう。

# tensorboardの表示
%load_ext tensorboard
%tensorboard --logdir runs

以下のように、学習の推移が確認できます。
※オレンジがyolov5s, 青がyolov5xのグラフです

推論

それでは、上記でつくったモデル（学習済みモデル）を使用して、推論を行ってみましょう。

!python detect.py --source data/images --weights yolov5x.pt --conf 0.50

ここでは、data/images配下の画像に対して推論を行い、確信度が0.50以上のものについてオーバーレイ（検出した物体のクラスと座標を枠で囲んで表示）しています。

まとめ

今回、YOLOv5を使用してGoogle Colaboratory上で物体検出をしてみました。
今回の流れをおさらいすると、以下になります。

• YOLOv5の準備
• 学習データの準備
• 学習
• 推論

また、学習に際しては、最も大きなモデルである5xを300エポック学習させてみました。
これらの選定については、

• どれぐらいの精度が欲しいか
• 学習にかけられる時間はどれぐらいか

が判断材料になるかと思います。

注釈

• 実際には、画像全体の大きさで割ったもの（規格化したもの）になります。画像全体の幅を$W$、高さを$H$としたとき、それぞれ$x\rightarrow x/W, y\rightarrow y/H, w\rightarrow w/W,h\rightarrow h/H$となります。詳しくは、YOLOv5公式ページを参照下さい。

参考文献

• https://github.com/ultralytics/yolov5

#Pythonで学ぶ制御工学< 極・零点と振る舞い >

はじめに

基本的な制御工学をPythonで実装し，復習も兼ねて制御工学への理解をより深めることが目的である．
その第12弾として「極・零点と振る舞い」を扱う．

極と振る舞い

前回(https://qiita.com/Yuya-Shimizu/items/2c9acdb6fdc2ef7440e5 )で，システムの安定性について学び，伝達関数において，極の実部が負であるとき安定となると知った．今回は，もう少し詳細に極とシステムの振る舞いについて知る．また，零点と振る舞いについても後述する．

まず，極と振る舞いついて，図を使っての説明を以下に示す．

式から考えると，おおむねこんな感じである．続いて，前回示した安定領域を複素数平面で表現したものに実際に条件別に出力させた応答信号を配置した．以下にその図を示す．

少し見づらいが，先ほどの式から得られた特徴から見ていくと分かりやすい．まず，1次遅れ系のものは，すべて実軸上にあることが分かる．また，2次遅れ系において，$\zeta$を固定させて$\omega_n$を変化させたものが図の上方4つになるが，1次遅れ系も2次遅れ系も実部の大きさによって，応答速度が変化していることが分かる．残るは，図の下方3つだが，これらは2次遅れ系において，$\omega_n$を固定させて$\zeta$を変化させたものである．これらも先ほどの説明どおり，$\zeta=0$，すなわち虚軸上にあるものは，持続振動になっており，また$\zeta$が小さいほど，虚部は大きくなり，より振動的になっていることが分かる．また，虚部が大きいほど振動周期も短くなる．

以下にそれぞれの条件に合わせた比較図を3つ示しておく．1つ目は1次遅れ系の時定数変化による振る舞いの違い．2つ目は2次遅れ系の固有角振動数の変化による振る舞いの違い．3つ目は2次遅れ系の減衰係数の変化による振る舞いの違いである．

　　　　　　　　　　図 1次遅れ系の時定数変化による振る舞いの違い

　　　　　　　図 2次遅れ系の固有角振動数の変化による振る舞いの違い

　　　　　　　　図 2次遅れ系の減衰係数の変化による振る舞いの違い

なお，ここで示した応答信号を出力するプログラムのソースコードは最後に示す．

零点と振る舞い

続いて，零点と振る舞いついて，図を使っての説明を以下に示す．

式でいうと，おおむねこんな感じである．続いて，それらの応答信号の振る舞いを次に示す．

$P_1$と$P_2$の応答を比べることで，説明にあったとおり，零点があるときの方が振動が大きくなっていることが分かる．また，$P_3$に注目すると，はじめに少し外れたところへ応答している．このことから，不安定零点であるとき，逆ぶれが生じていることが分かる．

ソースコード

最後に，今回の図を作成するときに作ったプログラムのソースコードを示しておく．

ソースコード①：極と振る舞い（1次遅れ系）

step1.py

"""
2021/03/05
@Yuya Shimizu

極と振る舞い（1次遅れ系）
"""

from control.matlab import *
import matplotlib.pyplot as plt
import numpy as np
from for_plot import *    #自分で定義した関数をインポート
#定義した関数について (https://qiita.com/Yuya-Shimizu/items/f811317d733ee3f45623)


##1次遅れ系のステップ応答

K = 1   #ゲインの設定
T = (1, 0.2, -0.2, -1)  #時定数の設定

y=[]
t=[]

for i in range(len(T)):
    P = tf([0, K], [T[i], 1])  #1次遅れ系
    yy, tt = step(P, np.arange(0, 5, 0.01))   #ステップ応答（0~5秒で，0.01刻み）
    y.append(yy)
    t.append(tt)

for i in range(len(T)):
    fig, ax = plt.subplots()
    ax.plot(t[i], y[i])
    plot_set(ax, 't', 'y') #グリッドやラベルを与える関数(自作のfor_plotライブラリより)
    plt.title(f"T={T[i]}, K={K}")
    plt.show()

#1つの図にまとめる
fig, ax = plt.subplots()
LS = linestyle_generator()  #線種を与える関数(自作のfor_plotライブラリより)
for i in range(len(T)):
    ax.plot(t[i], y[i], ls=next(LS), label=f"T={T[i]}")
plot_set(ax, 't', 'y', 'best')
ax.set_ylim(-1.2, 1.2)
plt.title(f"T={T}, K={K}")
plt.show()

ソースコード②：極と振る舞い（2次遅れ系）

step2.py

"""
2021/03/05
@Yuya Shimizu

極と振る舞い（2次遅れ系）
"""

from control.matlab import *
import matplotlib.pyplot as plt
import numpy as np
from for_plot import *    #自分で定義した関数をインポート
#定義した関数について (https://qiita.com/Yuya-Shimizu/items/f811317d733ee3f45623)

##2次遅れ系のステップ応答（固有角振動数omega_nを変化させる）
zeta = 0.8
omega_n = (-1, -0.5, 0, 0.5, 1)   #3種類の固有角振動数を用意
K = 1

y=[]
t=[]

for i in range(len(omega_n)):
    P = tf([0, K*omega_n[i]**2], [1, 2*zeta*omega_n[i], omega_n[i]**2])  #2次遅れ系
    yy, tt = step(P, np.arange(0, 5, 0.01))   #ステップ応答（0~5秒で，0.01刻み）
    y.append(yy)
    t.append(tt)

#図示
for i in range(len(omega_n)):
    fig, ax = plt.subplots()
    ax.plot(t[i], y[i])
    plot_set(ax, 't', 'y') #グリッドやラベルを与える関数(自作のfor_plotライブラリより)
    plt.title(f"$\zeta$={zeta}, $\omega_n$={omega_n[i]}, K={K}")
    plt.show()

#図示の準備
fig, ax = plt.subplots()
LS = linestyle_generator()  #線種を与える関数(自作のfor_plotライブラリより)

for i in range(len(omega_n)):
    ax.plot(t[i], y[i], ls=next(LS), label=f"$\omega_n$={omega_n[i]}")

plot_set(ax, 't', 'y', 'best')
ax.set_ylim(0, 1.2)
plt.title(f"$\zeta$={zeta}, $\omega_n$={omega_n}, K={K}")
plt.show()

##2次遅れ系のステップ応答（減衰係数zetaを変化させる）
zeta = (0, 0.2, 0.8)   #5種類の減衰係数を用意
omega_n = 5
K = 1

y=[]
t=[]

for i in range(len(zeta)):
    P = tf([0, K*omega_n**2], [1, 2*zeta[i]*omega_n, omega_n**2])  #2次遅れ系
    yy, tt = step(P, np.arange(0, 5, 0.01))   #ステップ応答（0~5秒で，0.01刻み）
    y.append(yy)
    t.append(tt)

#図示
for i in range(len(zeta)):
    fig, ax = plt.subplots()
    ax.plot(t[i], y[i])
    plot_set(ax, 't', 'y') #グリッドやラベルを与える関数(自作のfor_plotライブラリより)
    plt.title(f"$\zeta$={zeta[i]}, $\omega_n$={omega_n}, K={K}")
    plt.show()

#図示の準備
fig, ax = plt.subplots()
LS = linestyle_generator()  #線種を与える関数(自作のfor_plotライブラリより)

for i in range(len(zeta)):
    ax.plot(t[i], y[i], ls=next(LS), label=f"$\zeta$={zeta[i]}")

plot_set(ax, 't', 'y', 'best')
plt.title(f"$\zeta$={zeta}, $\omega_n$={omega_n}, K={K}")
plt.show()

ソースコード③：零点と振る舞い

step3.py

"""
2021/03/05
@Yuya Shimizu

零点と振る舞い
"""

from control.matlab import *
import matplotlib.pyplot as plt
import numpy as np
from for_plot import *    #自分で定義した関数をインポート
#定義した関数について (https://qiita.com/Yuya-Shimizu/items/f811317d733ee3f45623)


##零点による振る舞いの変化
zeta = 0.3          #減衰係数
omega_n = 5      #固有角振動数
K = 1                 #ゲイン

Np = [[0, K*omega_n**2],        #P1 : 零点なし 
          [3, K*omega_n**2],        #P2 : 安定零点
          [-3, K*omega_n**2]]        #P3 :  不安定零点

#図示の準備
fig, ax = plt.subplots()
LS = linestyle_generator()  #線種を与える関数(自作のfor_plotライブラリより)

for i in range(len(Np)):
    P = tf(Np[i], [1, 2*zeta*omega_n, omega_n**2])
    y, t = step(P, np.arange(0, 5, 0.01))   #ステップ応答（0~5秒で，0.01刻み）
    ax.plot(t, y, ls=next(LS), label=f"$P_{i+1}$")

plot_set(ax, 't', 'y', 'best')
plt.title(f"$\zeta$={zeta}, $\omega_n$={omega_n}, K={K}")
plt.show()

感想

今回は，式からと図から極・零点と振る舞いについて学んだ．これらは，システムの振る舞いを理解するのに非常に重要な部分であると思う．

参考文献

Pyhtonによる制御工学入門　　南 祐樹　著　　オーム社

野球選手のデータをRailsで扱いたかったんですが、活用できるAPIがなかったので自力で集めてみました。
PythonはGoogleColaboratoryを使用してます。

0.流れ

Wikipediaの情報をGoogleColaboratoryからスクレイピング
↓
データを整え、CSVに保存
↓
Railsのデータベースに保存
↓
表示する

1.スクレイピング

準備

import requests
import pandas as pd
from bs4 import BeautifulSoup

# 広島東洋カープの選手一覧
url = "https://ja.wikipedia.org/wiki/%E5%BA%83%E5%B3%B6%E6%9D%B1%E6%B4%8B%E3%82%AB%E3%83%BC%E3%83%97%E3%81%AE%E9%81%B8%E6%89%8B%E4%B8%80%E8%A6%A7"

データの取得

df = pd.read_html(url)
df[5].head()

df[4]には投手の情報が入っています。
df[5],[6],[7]に捕手、内野手、外野手の情報が入っているので、野手として1つにまとめます。

df_before_fielder = pd.concat([df[5], df[6], df[7]], ignore_index=True) #新たに行番号の割り当てのオプション

カラム名を英語表記に変更

df_before_fielder.rename(columns={"背番号":"number", "選手名":"player_name", "投":"hand", "打":"bat", "備考":"remark"}, inplace=True)
df_fielder=df_before_fielder.drop("remark", axis=1) #備考蘭がいらなかったため削除
df_fielder["team"]="C" #チーム名として、カープ(Carp)の省略英表記のCを追加
df_fielder.head()

2.CSV保存

from google.colab import files
import datetime

# ファイル名に日時を挿入
dt_now = datetime.datetime.now()
dt = dt_now.strftime('%Y%m%d%H%M%S')
file_name = "c_pitcher_"+ dt + ".csv"

# CSVに変換
df_fielder.to_csv(file_name, index=False)

# CSVファイルのダウンロード
files.download(file_name)

3.Rails

モデルの作成

$ rails g model Player number:integer player_name:string hand:string bat:string team:string

CSVの情報をデータベースに保存

require 'csv'

CSV.foreach("c_fielder_20210304124010.csv", headers: true) do |row|  #「headers: true」先頭行をヘッダーとするので、rowには入らない
  Player.create!(
    # rowには、["22", "中村奨成", "右", "右", "C"]と各選手の情報が入っている。
    number: row[0].to_i,  #ファイル内で文字列になっていたため数値へ変換
    player_name: row[1],
    hand: row[2],
    bat: row[3],
    team: row[4]
  )
end

puts "Finish!"

コントローラの作成

$ rails g controller Players index

コントローラからDBの情報を取得

class PlayersController < ApplicationController
  def index
    @players = Player.all
  end
end

ビューで表示

<% @players.each do |player| %>
  <li style="list-style: none"> 
    <%= player.number %>
    <%= player.player_name %>
    <%= player.hand %>
    <%= player.bat %>
    <%= player.team %>
  </li>
<% end %>

4.結果

こんな感じに表示することができました。

背景

手習いでFizzBuzzをやってみようと思う。

FizzBuzzの仕様

1から100までの数をプリントするプログラムを書け。ただし3の倍数のときは数の代わりに｢Fizz｣と、5の倍数のときは｢Buzz｣とプリントし、3と5両方の倍数の場合には｢FizzBuzz｣とプリントすること。

コード

for cnt in range(1, 101):
    if cnt % 15 == 0:
        print("FizzBuzz")
    elif cnt % 3 == 0:
        print("Fizz")
    elif cnt % 5 == 0:
        print("Buzz")
    else:
        print(cnt)

感想

この後、やさしい本でよく確認しようと思います。

はじめに

最初に断っておきますが、Pythonでは公式で動的クラス継承をサポートしていません。ということは推奨されないということですので、基本的に使わないでください。というか使わなくてもなんとかなるでしょう。
本記事の方法では一応普通のクラス継承と見た目変わらなさそうな動作をしますが、もしかしたら意図しない動作をする可能性も大いにあります。
その辺りの詳しい検証はしていませんので、使う場合は自分だけとか、ごく小規模なグループ内程度に留めておいてください。もちろん自己責任でよろしくお願いします。
また、そういった詳細についてご存知の方いらっしゃればご教授よろしくお願いします！

概要

動的クラス継承できたらなんか便利じゃね？ということが研究中にありましたので、できないかな〜といろいろ調べたところ、残念ながら求める記事には辿り着けず...しかしいろいろなサイトを参考にそれっぽいことを実現しましたので覚書しておきます。
多重継承とはまた違いますのでご注意ください。(Pythonの多重継承もなかなか闇が深いみたいですね〜)

目次

• クラスの継承
• 動的クラス継承
  • アトリビュートの継承
  • メソッド・プロパティの継承

クラスの継承

まずはクラスの継承について簡単に触れておきます。
クラスの継承はオブジェクト指向プログラミングにおける最大のメリットの一つで、使えるとコードがスッキリして見やすくなることが多いです。

図で例えると、「動物」がインターフェイス/抽象クラス、「猫」「犬」が親クラス、それ以外が子クラスといった感じで名前がつけられています。

インターフェイス/抽象クラス

インターフェイスや抽象クラスの違いについてはこちらなどをご覧ください。
Pythonではabcというパッケージを利用すれば生成することができます。
正直インターフェイスと抽象クラスの違いについてはイマイチ理解できていない感が否めませんが、まあこれらを継承したクラスに対して特定のメソッドなどを強制的に実装させる、というのがキーポイントのようです。
実装の設計図みたいな理解でいいのではないでしょうか。先の図では「動物」がその役割を担っています。
例えば「鳴く」というメソッドを定義しておけば、子クラスで鳴き方の詳細を実装するように強制できます。

親クラス

インターフェイスや抽象クラスとは違い、子クラスにメソッドの実装を強制したりはできません。(NotImplementedErrorを投げておけば似たようなことはできます)
子クラス群に共通した処理を実装しておけば、子クラスでそのメソッドを実装する必要がなくなります。
例えば「猫」クラスに「グルーミング」というメソッドを実装しておけば、子クラスである「ペルシャ」などでいちいち「グルーミング」を実装する必要がなくなります。

子クラス

子クラスはインターフェイスや抽象クラス、親クラスを継承したクラスのことを言います。
図では「猫」「犬」「ペルシャ」「ジャーマンシェパード」などにあたります。
それぞれに固有のメソッドなどを実装することを目的としており、まあ詳細の実装をするためのクラスって感じです。

動的クラス継承

さて、本題である動的クラス継承の実装詳細について見ていきましょう。
とりあえずコード全文を載せます。

動的クラス継承コード全体

dynamic_class_inheritance.py

from dataclasses import dataclass

import numpy as np


@dataclass
class Survive():
    heart_beat: int = 150

    def meow(self):
        print("ミャー")


@dataclass
class Dead():
    heart_bead: int = 0
    year_of_enjoyment: int = 5


@dataclass
class SchrodingerCat():
    threshold: float = 0.5

    def __post_init__(self, *args, **kwds):
        if np.random.rand() > self.threshold:
            obj = Survive()
        else:
            obj = Dead()

        # Add attributes to myself
        for k, v in obj.__dict__.items():
            if k not in self.__dict__:
                self.__dict__[k] = v
        # Keep them under the control of dataclass and rename my class name.
        my_fields = []
        for k, v in self.__dict__.items():
            if isinstance(v, (dict, list, set)):
                my_fields.append((k, type(v), field(default_factory=v)))
            else:
                my_fields.append((k, type(v), v))
        self.__class__ = make_dataclass(f"{obj.__class__.__name__}SchrodingerCat",
                                        my_fields, bases=(SchrodingerCat, obj.__class__))
        # Add funcgtions and properties to myself.
        for k in dir(obj):
            if k not in dir(self):
                setattr(self, k, getattr(obj, k))

    def hello(self):
        print("吾輩は猫である。名前はまだない。")


cat = SchrodingerCat()
print(cat.__class__)
print(f"{isinstance(cat, SchrodingerCat)=}")
print(f"{isinstance(cat, Survive)=}")
print(f"{isinstance(cat, Dead)=}")
print(cat)
pprint(fields(cat))
for x in dir(cat):
    if x[0] != "_":
        print(x)

cat.hello()
if isinstance(cat, Survive):
    cat.meow()

みんな大好きシュレーディンガーの猫に登場してもらいました。

(画像はwikipediaより)
__post_init__にて確率で猫の生死が決まり、それを元にアトリビュートや関数の継承が行われます。
詳しく見ていきます。

アトリビュートの継承

まずアトリビュートの継承から見ていきます。

アトリビュートの継承コード

dynamic_class_inheritance.py

        # Add attributes to myself
        for k, v in obj.__dict__.items():
            if k not in self.__dict__:
                self.__dict__[k] = v
        # Keep them under the control of dataclass and rename my class name.
        my_fields = []
        for k, v in self.__dict__.items():
            if isinstance(v, (dict, list, set)):
                my_fields.append((k, type(v), field(default_factory=v)))
            else:
                my_fields.append((k, type(v), v))
        self.__class__ = make_dataclass(f"{obj.__class__.__name__}SchrodingerCat",
                                        my_fields, bases=(SchrodingerCat, obj.__class__))

オブジェクトのアトリビュートを取得するにはobj.__dict__を利用します。この__dict__にはオブジェクトが持つ全てのアトリビュートが含まれており、objにあってselfにないアトリビュートのみselfに追加するようにしてあります。
もし双方が同じアトリビュートを持つ場合にobjの値へ上書きしたい場合は、if文を消してしまえばOKなはずです。

後半部分はdataclassを使用している場合にのみ必要な処理で、追加したアトリビュートを含めた全てのアトリビュートを持つdataclassクラスを生成してself.__class__に上書きしています。
リスト型や辞書型、集合型はfieldを利用した時の宣言方法が異なるため場合分けしてあります。
また、make_dataclassのbasesキーワードは親クラスの設定をしてくれるクラスです。
つまるところ、この部分での処理をまとめると、

1. フィールドを生成
2. SchrodingerCatとobj.__class__を継承した新しいクラスを生成
3. self.__class__に上書き

といったことをしています。

メソッド・プロパティの継承

メソッド・プロパティの継承コード

dynamic_class_inheritance.py

        # Add funcgtions and properties to myself.
        for k in dir(obj):
            if k not in dir(self):
                setattr(self, k, getattr(obj, k))

メソッドやプロパティの一覧を取得するにはdir関数を利用します。(ちなみに実はアトリビュートも取得されますが、コードの読みやすさのためにわざと分けています)
ここでもobjにあってselfにないメソッド・プロパティのみselfに追加しています。
もし上書きしたい場合はやはりif文を削除すればOKのはずです。ただ__init__などの特殊メソッドも上書きされてしまうので注意/工夫が必要です。

おわりに

シュレーディンガーの猫って、それ自体は超有名ですが、実際きちんと知ってる人ってどのくらいいるんでしょうか？
ぼく自身も「猫かわいそう」くらいにしか思ってませんでしたが、実は結構奥が深い、面白い思考実験だと知って驚きました。量子力学の世界は摩訶不思議ですね〜

参考

• python - フィールドをデータクラスオブジェクトに動的に追加する

こんにちは！

今日のエラー原因を書きます。

使用した本：「０から作るDeepLearning」

リポジトリしたプログラム　→　deep-learning-from-scratch

「hyperparameter.optimization.py」の写経について

・9割方写し間違いで文法的な間違いはなかった。

エラー対策

移し直すのみ

所感

3日連続で写経していると段々と移すスピードが早くなってきている感覚があります。
後は詳細なプログラムの内容を理解していきたいと思います。

はじめに

Dashで作成したアプリをHerokuにデプロイでアプリを Heroku にデプロイした。GitHub と連携させることができるようなので試してみた。私の GitHub アカウントはこれ。

GitHub にコードをプッシュ

自身の GitHub にて whc-app という名前のリモートレポジトリを作成。Dashで作成したアプリをHerokuにデプロイにて、すでにローカルレポジトリが存在するため、リモートレポジトリにプッシュする。

$ git remote add origin https://github.com/bemac-honda/whc-app.git
$ git branch -M main
$ git push -u origin main

GitHub と連携

Heroku Dashboardにて、[ whc-app ] → [ Deploy タブ ] → [ Deployment method ] から "GitHub" を選択。[ Connect to GitHub ] で自身のレポジトリを検索して [ Connect ]。
連携がうまくできれば Automatic deploys と Manual deploy の 2 通りのデプロイができるようになるので、順に試す。

Manual deploy

文字とおり手動でデプロイを行う。
[ Manual deploy ] にて、ブランチを選択して [ Deploy Branch ] を押すだけ。なにもなければ main ブランチでよいと思う。問題なくデプロイできれば [ View ] からそのままアプリを見ることができる。

Automatic deploys

GitHub にプッシュするとソースコードの変更を検知して、自動で Heroku のビルドを実行し、デプロイしてくれる。
[ Automatic deploys ] にて、ブランチを選択して [ Enable Automatic Deploys ] をクリック。

これで今後コードを変更した際は GitHub にさえプッシュしておけば自動でデプロイされる。

Ghidraを勉強した記録として残しておく。
基本的な stack strings の問題なのでsimpleと名付けられたのだと思う。

表層解析で得られる文字列 incorrect を検索
普通にmain関数内

main関数のデコンパイル結果（当初）

undefined8 main(void)
{
  size_t sVar1;
  undefined8 uVar2;
  char local_78 [48];
  char local_48 [60];
  uint local_c;

  printf("input flag : ");
  __isoc99_scanf(&DAT_00100922,local_48);
  sVar1 = strlen(local_48);
  if (sVar1 == 0x24) {
    local_78[0] = 'F';
    local_78[1] = 0x4c;
    local_78[2] = 0x41;
    （中略）
    local_78[33] = 0x67;
    local_78[34] = 0x73;
    local_78[35] = 0x7d;
    local_c = 0;
    while (local_c < 0x24) {
      if (local_48[(int)local_c] != local_78[(int)local_c]) {
        puts("Incorrect");
        return 1;
      }
      local_c = local_c + 1;
    }
    printf("Correct! Flag is %s\n",local_48);
    uVar2 = 0;
  }
  else {
    puts("incorrect");
    uVar2 = 1;
  }
  return uVar2;
}

変数の型を変更してデコンパイル結果の誤りを正し，わかりやすい変数名に変更

undefined8 main(void)
{
  size_t size;
  undefined8 uVar1;
  char flag [48];
  char input_value [60];
  int i;

  printf("input flag : ");
  __isoc99_scanf(&DAT_00100922,input_value);
  size = strlen(input_value);
  if (size == 0x24) {
    flag[0] = 'F';
    flag[1] = 0x4c;
    flag[2] = 0x41;
    （中略）
    flag[33] = 0x67;
    flag[34] = 0x73;
    flag[35] = 0x7d;
    i = 0;
    while ((uint)i < 0x24) {
      if (input_value[i] != flag[i]) {
        puts("Incorrect");
        return 1;
      }
      i = i + 1;
    }
    printf("Correct! Flag is %s\n",input_value);
    uVar1 = 0;
  }
  else {
    puts("incorrect");
    uVar1 = 1;
  }
  return uVar1;
}

ソルバー ( Ghidra Script )

ans=[]

inst = getInstructionAt(toAddr(0x00100793))

i = 0
while i < 0x24:
    ans.append(inst.getOpObjects(1)[0].getValue())
    inst = inst.getNext()
    i = i + 1

print(ans)
print(''.join(map(chr,ans)))

こんにちは、N高人工知能研究会のまさきです
AIの大衆化をモットーに誰もがAIに興味を持てる教材(記事)を作っていきます！

２回目である今回は ロジスティック回帰 というアルゴリズムを体験してもらいます
よろしくお願いします

開発環境や前提知識について

こちらの前回の記事と全く同じです。
GoogleColabでのノートブック作成方法も前回を参考に進めてください。

分類アルゴリズムと回帰アルゴリズムの違い

まずは分類アルゴリズムと回帰アルゴリズムの違いから説明していきます。
例えば前回の記事で紹介した 線形回帰 は

このような連続値を表現しました。
具体的には

• 過去の気象データを使用して明日の天気を予想する
• 今までの動画視聴履歴からおすすめの動画を導き出す

などなど大雑把にいうと過去のデータから未来の何かを予測するものです

---

そしてもう一つの分類アルゴリズムは

• 花弁の長さや幅を元に数種類の花を分類する
• 映画のレビューを元にそれが好意的なレビューなのか批判的なレビューなのかを予測する

などなど分類は受け取ったデータが何に属するのかを予測するものです

今回紹介するロジスティック回帰は後者の分類アルゴリズムです。
名前に「回帰」とついていますが分類アルゴリズムなので注意してくださいね

ロジスティック回帰を体験する

今回は「LogisticRegression.ipynb」という名前でファイルを作成しました

今回の課題

こちらのコードを実行してみてください

from sklearn import datasets
import matplotlib.pyplot as plt

# Irisデータセット(後述)をロード
iris = datasets.load_iris()
# (cm単位の花びらの長さ),(がく片の長さ)の二つの特徴量を抽出
X = iris.data[:100, [0, 2]]
# クラスラベルを取得
y = iris.target[:100]

plt.scatter(X[:50, 0], X[:50, 1], c='red')
plt.scatter(X[50:, 0], X[50:, 1], c='blue', marker='x')

すると

こんなグラフが表示されるはずです。
今回はこの赤と青のクラスを分ける下の画像のような線をコンピュータに見つけてもらうのが目的です！

irisデータセットについて

コードのコメントに書いてあったirisデータセットというのはネット上に公開されていて誰でも利用できるデータセットのことです。
他にも色々なデータセットが存在しています。
今回利用するirisはアヤメという花の花弁とがくに関する4つの特徴量を元に3種類のアヤメをクラス分けするというものです。

上のコードではわかりやすさを優先し花の種類を二種類に、特徴量も同じく二種類に限定しています

ロジスティック回帰で学習する

次に学習させます！
と言っても学習データもすでに作成しているので少しコードを書くだけです！

from sklearn import linear_model

# ロジスティック回帰の識別器を用意
lr = linear_model.LogisticRegression()

# 識別器を学習させる
lr.fit(X, y)

これだけ。

ではどんな感じに線を引いてくれてるかみてみましょう

w_0 = lr.intercept_[0]
w_1 = lr.coef_[0,0]
w_2 = lr.coef_[0,1]

# 元データをプロット
plt.scatter(X[:50, 0], X[:50, 1], c='red')
plt.scatter(X[50:, 0], X[50:, 1], c='blue', marker='x')
# 境界線 プロット
plt.plot([4,7], list(map(lambda x: (-w_1 * x - w_0)/w_2, [4,7])), color='limegreen')

バッチリ分けられていますね！

次の課題：3つのクラスを分ける

学習データを定義しなおした下のコードを実行してみてください

X = iris.data[:, [0, 2]]
y = iris.target

plt.scatter(X[:50, 0], X[:50, 1], c='red')
plt.scatter(X[50:100, 0], X[50:100, 1], c='blue', marker='x')
plt.scatter(X[100:150, 0], X[100:150, 1], c='green', marker='^')

先程の二つのクラスに新しく緑の三角のクラスが加わっていますね！
同じようにロジスティック回帰で分類してみましょう

# ロジスティック回帰の識別器を用意
lr = linear_model.LogisticRegression(multi_class='ovr')

# 識別器を学習させる
lr.fit(X, y)

multi_classというパラメータを新しく設定します
次に可視化してみましょう

# 元データをプロット
plt.scatter(X[:50, 0], X[:50, 1], c='red')
plt.scatter(X[50:100, 0], X[50:100, 1], c='blue', marker='x')
plt.scatter(X[100:150, 0], X[100:150, 1], c='green', marker='^')

# 赤と青の境界線
w_0 = lr.intercept_[0]
w_1 = lr.coef_[0,0]
w_2 = lr.coef_[0,1]
# 境界線 プロット
plt.plot([4,8], list(map(lambda x: (-w_1 * x - w_0)/w_2, [4,7])), color='limegreen')

# 青と緑の境界線
w_0 = lr.intercept_[2]
w_1 = lr.coef_[2,0]
w_2 = lr.coef_[2, 1]
plt.plot([4,8], list(map(lambda x: (-w_1 * x - w_0)/w_2, [4,7])), color='limegreen')

直線しか引けないので緑と青の境界線が完璧ではありませんが、いい感じに引けましたね

実践問題

X = iris.data[:, [1, 3]]
y = iris.target

plt.scatter(X[:50, 0], X[:50, 1], c='red')
plt.scatter(X[50:100, 0], X[50:100, 1], c='blue', marker='x')
plt.scatter(X[100:150, 0], X[100:150, 1], c='green', marker='^')

こちらのグラフを同じように3つのクラスに分けてみてください！

うまくできるとこんなふうになるはずです

参考書籍

Python機械学習プログラミング

終わりに

この記事を最後まで読んでいただいてありがとうございます
これからもAI初心者なりに頑張ってわかりやすい教材(記事)をたくさん作っていくのでよろしくお願いします！

N高生の方であればぜひslackの「人工知能研究会」チャンネルに参加してみてくださいね