マスゲームだから、意味ない（当たり前）かなと思いつつ、でも惑星直列などを考えると、こういう計算も実は意味のあるものかなと思い、まとめておくこととします。
なんといってもポアンカレの再帰定理。
「力学系は、ある種の条件が満たされれば、その任意の初期状態に有限時間内にほぼ回帰する」の具体的な事例としての意味があるということだと思いなおしました。
なお、惑星直列の計算とシミュレーションは今回はやりません。
ということで、今回は前回の式を個数と周期を自由に変更したいと思います。
※コード全体はおまけに載せました。
　また、gifアニメーションがエラーが出て貼れないのでYoutubeに載せました

100個を1ダンス120秒のシミュレーション

そして、100個の場合に拡張です。
これだと、前回の式では無理なので、以下のように変更します。

N = 60
z0 =500
L0=980*(120/130)**2/(2*np.pi)**2
Fc0=1.0
Fc=[]
fc=1
Fc.append(fc)
for i in range(1,100,1):
    fc=fc*((131-i)/(130-i))
    Fc.append(fc)

あと、120secで元に戻るようにしたので、結果は以下のようになります。

蛇の振り子100個をシミュレーションして遊んでみた♬

1５個を1ダンス120秒のシミュレーション

今度は、１５個の振り子を120秒という長さの周期のダンスをさせてみる。
これで、実質的にあらゆる振り子の個数、長さ、周期のものが設計できることが分かる。
【蛇の振り子】1５個を1ダンス120秒のシミュレーション作成して遊んでみた♬

主要なコードは、以下で実現できた。

N = 60
L0=980*(120/65)**2/(2*np.pi)**2  #ここの120/65の120が重要
print(L0, 2*np.pi/np.sqrt(980/L0))
Fc0=1.0
z0 =150
Fc=[]
fc=1
Fc.append(fc)
for i in range(1,15,1):
    fc=fc*((66-i)/(65-i))  #65/64で1個1個のずらしを調整
    Fc.append(fc)

dataz=[]
linez=[]
y=0
for j in range(15):
    y += 2  #振り子のy軸方向の間隔
    dataz0 = np.array(list(genxy(N,L=L0*Fc[j]**2,z0=z0,y0=y))).T
    linez0, = ax.plot(dataz0[0, 0:1], dataz0[1, 0:1], dataz0[2, 0:1],'o')
    dataz.append(dataz0)
    linez.append(linez0)

generatorは前回のものと比べると、以下のようにy軸方向に配置できるように拡張している。

def genxy(n,L=20,z0=0,y0=0):
    phi = 0
    g = 980
    x0=5  #2.5
    omega = np.sqrt(g/L)
    theta0 = np.arcsin(x0/L)
    while phi < 600:
        yield np.array([L*np.sin(np.sin(phi*omega+np.pi/2)*theta0), y0,z0-L+L*(1-np.cos(np.sin(phi*omega+np.pi/2)*theta0))])
        phi += 1/n

まとめ

・蛇振り子の個数や長さを自由を変更できるように拡張した
・100個の圧倒的な迫力と、120秒周期という長周期は鑑賞という意味で面白い

・惑星直列など自然界にあるポアンカレの再帰定理の具現化をシミュレーションしたいと思う
・現実の蛇振り子を自由な周期で実現したいと思う

おまけ

from matplotlib import pyplot as plt
import numpy as np
import mpl_toolkits.mplot3d.axes3d as p3
from matplotlib import animation

fig, ax = plt.subplots(1,1,figsize=(1.6180 * 4, 4*1),dpi=200)
ax = p3.Axes3D(fig)

def genxy(n,L=20,z0=0,y0=0):
    phi = 0
    g = 980
    x0=5
    omega = np.sqrt(g/L)
    theta0 = np.arcsin(x0/L)
    while phi < 600:
        yield np.array([L*np.sin(np.sin(phi*omega+np.pi/2)*theta0), y0,z0-L+L*(1-np.cos(np.sin(phi*omega+np.pi/2)*theta0))])
        phi += 1/n

def update(num, data, line,s):
    line.set_data(data[:2,num-1 :num])
    line.set_3d_properties(data[2,num-1 :num])
    ax.set_xticklabels([])
    ax.grid(False)

N = 60
L0=980*(120/65)**2/(2*np.pi)**2
print(L0, 2*np.pi/np.sqrt(980/L0)) #84.6cm 1.846sec
Fc0=1.0   #omega=2pi/T
z0 =150
Fc=[]
fc=1
Fc.append(fc)
for i in range(1,15,1):
    fc=fc*((66-i)/(65-i))
    Fc.append(fc)

dataz=[]
linez=[]
y=0
for j in range(15):
    y += 2
    dataz0 = np.array(list(genxy(N,L=L0*Fc[j]**2,z0=z0,y0=y))).T
    linez0, = ax.plot(dataz0[0, 0:1], dataz0[1, 0:1], dataz0[2, 0:1],'o')
    dataz.append(dataz0)
    linez.append(linez0)

# Setting the axes properties
ax.set_xlim3d([-10., 10])
ax.set_xlabel('X')

ax.set_ylim3d([0.0, 30.0])
ax.set_ylabel('Y')

ax.set_zlim3d([0.0, z0-L0])
ax.set_zlabel('Z')
elev=0 #20. 
azim=90 #35.
ax.view_init(elev, azim)

frames =60*120
fr0=60
s0=0
s=s0

while 1:
    s+=1
    num = s
    for j in range(15):        
        update(num,dataz[j],linez[j],s0)
    """
    if s%fr0==0:
        print(s/fr0, s)
    plt.pause(0.001)    
    """

    if s%(fr0/10)==0:
        ax.set_title("s={}_sec".format(int(10*s/fr0)/10),loc='center')
        plt.pause(0.001)
        print(s/fr0)
        plt.savefig('./pendulum/'+str(int(10*s/fr0))+'.png')
        if s>=s0+frames:
            break

s0=30*120
s=s0+30*120
fr0=60
from PIL import Image,ImageFilter
images = []
for n in range(1,1201,1):
    exec('a'+str(n)+'=Image.open("./pendulum/'+str(n)+'.png")')
    images.append(eval('a'+str(n)))
images[0].save('./pendulum/pendulum_{}_.gif'.format(100),
               save_all=True,
               append_images=images[1:],
               duration=100,
               loop=1)

動画保存

gifアニメーションが貼れないので以下のコードでmp4ファイルを保存し、youtubeにアップします。

from matplotlib import pyplot as plt
import numpy as np
import mpl_toolkits.mplot3d.axes3d as p3
import cv2

def cv_fourcc(c1, c2, c3, c4):
        return (ord(c1) & 255) + ((ord(c2) & 255) << 8) + \
            ((ord(c3) & 255) << 16) + ((ord(c4) & 255) << 24)

OUT_FILE_NAME = "output_video.mp4"
fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
dst = cv2.imread('./pendulum/1.png')
rows,cols,channels = dst.shape
out = cv2.VideoWriter(OUT_FILE_NAME, int(fourcc), int(10), (int(cols), int(rows)))

from PIL import Image,ImageFilter
for n in range(1,1201,1):
    dst = cv2.imread('./pendulum/'+str(n)+'.png')
    out.write(dst) #mp4やaviに出力します

目的

チートシートを作らないと厳しくなってきたので整理用に。

c++ならかなりコードが公知になってるものが多いようですが、pythonは暗黙知っぽい書き方とかがあるように感じます。
解答をみると、みんなが当たり前に使っているライブラリやデータ構造などが多いです。
これらの暗黙知っぽいものをメモを取りながらやってますが、頭が混乱してきたので自分用にまとめます。
Atcoderをpythonでスタートするときにこういう前提知識のまとめが欲しかったです。。。

間違っているところも多いでしょうが多めにみてください。

前提となるチートシート

Python 競技プログラミング　チートシート自分用
入力の仕方はいつもここをみて入力しています。

---

競プロチートシート(python3)
約数と累乗はここをみる。約数のライブラリは意味わからないけど使えばすごい便利。

---

Python標準ライブラリ：順序維持のbisect
bisectはここをみる

---

Pythonでリストをソートするsortとsortedの違い
ソートはここをみる

---

pythonのsorted関数で使われるlambdaとは何なのか
lamda関数はこれがわかりやすかった。

---

Python, set型で集合演算（和集合、積集合や部分集合の判定など）
set,len,add,discard(), remove(), pop(), clear()

---

【Python】スライス操作についてまとめ
スライスはここをみる

---

Pythonで最大公約数と最小公倍数を算出・取得
gcd(最大公約数)、lcm（最小公倍数）はここをみる。数字が3つでも４つでも出せる。

---

Pythonのdivmodで割り算の商と余りを同時に取得
商とあまりはここをみる

---

Pythonのfor文によるループ処理（range, enumerate, zipなど）
range, enumerate, zipはここをみる
([式 for 変数名 in イテラブルオブジェクト]みたいな内包表現とか、
多重ループ: itertools.product()とか、
自分では使わないけど他人のコード読む時に使えるやつもここ)

---

PythonのCounterでリストの各要素の出現個数をカウント
今の自分には厳しいが、配列やらどこかの要素をサーチしてくるのに無茶苦茶便利

小技

10^0.5
n**0.5

---

カウントする
l.count('a')

---

かぶりをなくす
set([1,1,2,2,3,3]) ⇨[1,2,3]

---

if X not in p: #pのリストにXがない

---

大文字小文字変換
str.upper(): すべての文字を大文字に変換
str.lower(): すべての文字を小文字に変換

---

絶対値:abs()
総和:sum(list)

---

大きい方:max(,)
小さい方:min(,)

---

count.values()

---

逆順: reversed()

---

forで複数列での循環:enumerate()
forで複数列での循環:zip()

---

modは大抵、mod=10**9+7

---

10^12の試行回数は結構厳し目だから、枝カリとか工夫とかしがち。
10^6は、２乗でかなりギリギリになるから、O(N^2)はギリギリになりがちで工夫が必要。

---

print("".join(lis)):これで、リストをジョインできる

---

print(list(itertools.permutations([1, 2, 3])))
-> [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

---

c = collections.Counter(l)
⇨Counter({'a': 4, 'c': 2, 'b': 1})
⇨c.keys()は['a', 'b', 'c']
⇨c.values()は[4, 1, 2]
⇨c.items()は[('a', 4), ('b', 1), ('c', 2)]
⇨c.most_common()は('a', 4), ('c', 2), ('b', 1)
⇨c.most_common()[::-1]は[('b', 1), ('c', 2), ('a', 4)]　つまり、[::-1]は反対から並べるの意味
（引用: PythonのCounterでリストの各要素の出現個数をカウント）

---

a = lambda x : x*x
print(a(4)) #16
（aに無名関数λを挿入し、xに４を入れるとx^2）

---

コードテストで、挙動が良くわからない時は、print(変数)で変数がどのようになっているかチェックするとデバッグが楽

---

さらに前提となるpythonの基本文法

for _ in range(N):
これは 0~N-1を出力
末尾に":"をつける
for文の次の行はインデント（スペース4つなりtabなりでスペースをあける）
for文の次の行でtabとスペースを混用しているとエラーになることがある。
for c in l[2:5]:みたいに、スライスしてその分だけcを代入していくこともできる。
for i in range(1:N):にすれば、１からスタートもできる

---

if s == 1:
=は１つではなく、2つでつながないと条件にならない（＝だけだと代入になる）
末尾に":"をつける
if文の次の行はインデント（スペース4つなりtabなりでスペースをあける）
if文の次の行でtabとスペースを混用しているとエラーになることがある。

---

while n!=1:
while文の次の行はインデント（スペース4つなりtabなりでスペースをあける）
while　は、「この条件式が成立している間」やりますって意味。

---

個人的に今後理解する予定のもの

dfs,bfs,Union Findのプログラム

レッドコーダーが教える、競プロ・AtCoder上達のガイドライン【中級編：目指せ水色コーダー！】
100問で水色、それどころか青色が狙える内容らしいです。
手法ごとに問題が分類されているので、苦手手法を鍛えるのに良さげです。
こちらの記事をpythonで解いている記事が
【Python】初中級者が解くべき過去問精選 100 問を解いてみた【Part4/22】

ACL Beginner Contest 参戦記

ABLA - Repeat ACL

1分で突破. 書くだけ.

K = int(input())

print('ACL' * K)

ABLB - Integer Preference

2分半で突破、WA1 orz. A < B < C < D のパターンを見落とした.

A, B, C, D = map(int, input().split())

if A <= C <= B or A <= D <= B or C <= A <= D or C <= B <= D:
    print('Yes')
else:
    print('No')

ABLC - Connect Cities

3分半で突破. Union Find して Union 数 - 1 が答え.

from sys import setrecursionlimit, stdin


def find(parent, i):
    t = parent[i]
    if t < 0:
        return i
    t = find(parent, t)
    parent[i] = t
    return t


def unite(parent, i, j):
    i = find(parent, i)
    j = find(parent, j)
    if i == j:
        return
    parent[j] += parent[i]
    parent[i] = j


readline = stdin.readline
setrecursionlimit(10 ** 6)

N, M = map(int, readline().split())

parent = [-1] * N
for _ in range(M):
    A, B = map(lambda x: int(x) - 1, readline().split())
    unite(parent, A, B)

print(sum(1 for i in range(N) if parent[i] < 0) - 1)

ABLD - Flat Subsequence

32分で突破、WA1 orz. Go のコードを Python で提出した、アホすぎる. それまでの各値の最大経由数を記録しておけば SegmentTree で O(logN) で現値の最大経由数が求まるので O(NlogN) になり解ける.

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func min(x, y int) int {
    if x < y {
        return x
    }
    return y
}

func max(x, y int) int {
    if x > y {
        return x
    }
    return y
}

type segmentTree struct {
    offset int
    data   []int
    op     func(x, y int) int
    e      int
}

func newSegmentTree(n int, op func(x, y int) int, e int) segmentTree {
    var result segmentTree
    t := 1
    for t < n {
        t *= 2
    }
    result.offset = t - 1
    result.data = make([]int, 2*t-1)
    for i := 0; i < len(result.data); i++ {
        result.data[i] = e
    }
    result.op = op
    result.e = e
    return result
}

func (st segmentTree) update(index, value int) {
    i := st.offset + index
    st.data[i] = value
    for i >= 1 {
        i = (i - 1) / 2
        st.data[i] = st.op(st.data[i*2+1], st.data[i*2+2])
    }
}

func (st segmentTree) query(start, stop int) int {
    result := st.e
    l := start + st.offset
    r := stop + st.offset
    for l < r {
        if l&1 == 0 {
            result = st.op(result, st.data[l])
        }
        if r&1 == 0 {
            result = st.op(result, st.data[r-1])
        }
        l = l / 2
        r = (r - 1) / 2
    }
    return result
}

const (
    maxA = 300000
)

func main() {
    defer flush()

    N := readInt()
    K := readInt()

    st := newSegmentTree(maxA+1, max, 0)
    for i := 0; i < N; i++ {
        A := readInt()
        st.update(A, st.query(max(A-K, 0), min(A+K+1, maxA+1))+1)
    }

    println(st.query(0, maxA+1))
}

const (
    ioBufferSize = 1 * 1024 * 1024 // 1 MB
)

var stdinScanner = func() *bufio.Scanner {
    result := bufio.NewScanner(os.Stdin)
    result.Buffer(make([]byte, ioBufferSize), ioBufferSize)
    result.Split(bufio.ScanWords)
    return result
}()

func readString() string {
    stdinScanner.Scan()
    return stdinScanner.Text()
}

func readInt() int {
    result, err := strconv.Atoi(readString())
    if err != nil {
        panic(err)
    }
    return result
}

var stdoutWriter = bufio.NewWriter(os.Stdout)

func flush() {
    stdoutWriter.Flush()
}

func println(args ...interface{}) (int, error) {
    return fmt.Fprintln(stdoutWriter, args...)
}

追記: Python では TLE になってしまうが、PyPy なら AC した.

class SegmentTree:
    def __init__(self, size, op, e):
        self._op = op
        self._e = e
        self._size = size
        t = 1
        while t < size:
            t *= 2
        self._offset = t - 1
        self._data = [e] * (t * 2 - 1)

    def update(self, index, value):
        op = self._op
        data = self._data
        i = self._offset + index
        data[i] = value
        while i >= 1:
            i = (i - 1) // 2
            data[i] = op(data[i * 2 + 1], data[i * 2 + 2])

    def query(self, start, stop):
        def iter_segments(data, l, r):
            while l < r:
                if l & 1 == 0:
                    yield data[l]
                if r & 1 == 0:
                    yield data[r - 1]
                l = l // 2
                r = (r - 1) // 2
        op = self._op
        it = iter_segments(self._data, start + self._offset,
                           stop + self._offset)
        result = self._e
        for v in it:
            result = op(result, v)
        return result


max_A = 300000

N, K, *A = map(int, open(0).read().split())

st = SegmentTree(max_A + 1, max, 0)
for a in A:
    st.update(a, st.query(max(a - K, 0), min(a + K + 1, max_A + 1)) + 1)

print(st.query(0, max_A + 1))

ABLE - Replace Digits

突破できず. Lazy Segtree なんだろうなとは思ったけど、ACL の lazy_segtree の mapping, composition, id が理解できなくて利用できなかった.

はじめに

仕事でReactによるフロント開発に携わり始めたので、アウトプットの練習も兼ねて簡易webアプリを作成しました。

どんなアプリにするかアイデアはまったく思い浮かばなかったので、手元にあったmecabを使った分かち書きスクリプトを使って、フロントで受け取った入力テキストをサーバー側で分かち書きをし、その結果をフロントで表示するという非常にシンプルなアプリです。
(主目的はreactとflaskをつなぐ部分を勉強することだったため、アプリの見た目や機能は全然作り込んでいませんのであしからず。)

表題の通り、フロント側はReact、サーバー側はpython flaskで実装しています。

今回実装したスクリプトはこちらで公開しています。

完成品

画面

分かち書きしてみる

実装環境

OS: Ubuntu 18.04.2 LTS
Python: 3.6
flask==1.0.2

npm: 6.14.7

reactの環境構築については今回触れませんが、公式チュートリアルが日本語でも充実していて非常に参考になりました。
- https://ja.reactjs.org/

こちらもすごくおすすめです。
- https://mae.chab.in/archives/2529

実装する

構成図

今回実装したアプリの構成は以下のようになっています(主要部分のみ)。

サーバー側

サーバー側は以下のような構成になっています。

backend/
   ├─ requirements.txt
   ├─ server.py
   └─ utils.py

server.pyはflaskサーバーを立ち上げるコードです。

アドレスやポートは一番下、app.run(host='127.0.0.1', port=5000)で指定します。

server.py

from flask import Flask
from flask import request, make_response, jsonify
from flask_cors import CORS
from utils import wakati

app = Flask(__name__, static_folder="./build/static", template_folder="./build")
CORS(app) #Cross Origin Resource Sharing

@app.route("/", methods=['GET'])
def index():
    return "text parser:)"

@app.route("/wakati", methods=['GET','POST'])
def parse():
    #print(request.get_json()) # -> {'post_text': 'テストテストテスト'}
    data = request.get_json()
    text = data['post_text']

    res = wakati(text)
    response = {'result': res}
    #print(response)
    return make_response(jsonify(response))

if __name__ == "__main__":
    app.debug = True
    app.run(host='127.0.0.1', port=5000)

@app.route("/wakati", methods=['GET','POST')部分でフロントからテキストを受け取り、分かち書き処理した後、フロントへ返す処理をしています。
data = request.get_json()によってフロントからポストされてきた内容をjson形式で取得します。
ここから必要なデータを取り出して、何らかの処理(関数にかけたり、DBに入れたりし)をし、response = {'result': res}のようにjson形式にしてフロントに返します。

(補足：CORSとは)
別リソースへアクセス(＝クロスサイトHTTPリクエスト)できるようにするために必要なルールです。これがないとフロント側から立ち上げたflaskサーバへアクセスできません。
- 参考：https://aloerina01.github.io/blog/2016-10-13-1

フロント側

今回はcreate-react-appの雛形を用いました。
(create-react-appの設定および使い方はこちらが非常にわかりやすいです！)

フロント側は以下のような構成になっています(主要ファイルのみ掲載)。

frontend/app/
   ├─ node_modules/
   ├─ public/
   ├─ src/
   |   ├─ App.css
   |   ├─ App.js
   |   ├─ index.js
   |   └─ ...
   └─ ...

自動生成された雛形の中のApp.jsを以下のように書き換えました。

App.js

import React from 'react';
import './App.css';
import Axios from 'axios';

//function App() {
export class App extends React.Component {
  constructor(props) {
    super(props);
    this.state = {value: ''};

    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  render() {
    return (
      <div className="App">
        <header className="App-header">
          <h1>text parser</h1>
          <form onSubmit={this.handleSubmit}>
            <label>
              <textarea name="text" cols="80" rows="4" value={this.state.value} onChange={this.handleChange} />
            </label>
            <br/>
            <input type="submit" value="Parse" />
          </form>
        </header>
      </div>
    );
  }


  wakati = text => {
    //console.log("input text >>"+text)
    Axios.post('http://127.0.0.1:5000/wakati', {
      post_text: text
    }).then(function(res) {
      alert(res.data.result);
    })
  };

  handleSubmit = event => {
    this.wakati(this.state.value)
    event.preventDefault();
  };

  handleChange = event => {
    this.setState({ value: event.target.value });
  };
}

export default App;

この中の以下の部分でサーバー側とのやり取りを行なっています。

  wakati = text => {
    //console.log("input text >>"+text)
    Axios.post('http://127.0.0.1:5000/wakati', {
      post_text: text
    }).then(function(res) {
      alert(res.data.result);
    })
  };

server.pyで立てたhttp://127.0.0.1:5000/wakatiにthis.state.valueの値をポストします。
サーバー側で処理された後、返ってきたresultの値がalert(res.data.result);によってブラウザに表示されます。

動かす

フロントエンド/バックエンド用にそれぞれターミナルを立ち上げて以下のコマンドを実行します。

サーバー側

$ cd backend
$ python server.py

フロント側

$ cd frontend/app
$ yarn start

ブラウザからlocalhost:3000にアクセスすることでアプリを利用できます(yarn startで自動で立ち上がります)。

おわりに

今回はReactとPython flaskを用いて簡易的なWebアプリを実装しました。
簡易的とはいえ、短時間で楽にWebアプリを実装できるので素晴らしいですね。

フロント修行中の身なので、見た目や機能についてはまだまだなのでご意見、アドバイス等いただければ幸いです。
最後まで読んでいただきありがとうございました！

1.はじめに

皆さんこんにちは！今回はpythonとOpenCVを扱って、カメラを起動させてリアルタイムで人の顔にモザイクを書けるプログラムを作成しました。
もしかしたら、すでに他の人が記事を書いているかもしれませんが…多分出ています。
とにかくやってみよう！

2.手順

プログラムの流れはこちらになります。
1.カメラを起動させる。
2.人の顔を認識する。（Haar-like特徴分類器）
3.人の顔があるところをモザイク処理をする。
以上です。

3.カメラを起動させる。

OpenCVを用いてカメラを起動させます。

kido.py

import cv2
cap = cv2.VideoCapture(0)
while True:
    ret, img = cap.read()
    cv2.imshow('video image', img)#'video image'はカメラのウィンドウの名前
    key = cv2.waitKey(10)
    if key == 27:  # ESCキーで終了
        break
cap.release()
cv2.destroyAllWindows()

これでカメラの軌道はできますEscキーを押せばウィンドウが閉じてくれます。

4.人の顔を認識させる（Haar-like特徴分類器）

OpenCVではHaar-like特徴分類器があらかじめ用意されています。便利です！
しかし、ファイルを保存しないと扱えないです。今回は人の顔を認識したいのでこちらのhaarcascade_frontalface_alt.xmlを扱います。

ちなみに、Haar-like特徴分類器とは画像の特徴をとられる特徴量から明暗差に着目したHaar-like特徴とアダブーストによってHaar-likeフィルタのサイズを変えながら特徴量を抽出し顔を検出しています。
では、カメラを起動して人の顔を認識させてみましょう。

ninsiki.py

import cv2

#Haar-like特徴分類器を扱えるようにする。
face_cascade_path="haarcascade_frontalface_alt.xml" #pathを指定してください。
face_cascade = cv2.CascadeClassifier(face_cascade_path)

cap = cv2.VideoCapture(0)
while True:
    ret, img = cap.read()
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)
    #人の顔を矩形的に囲む
    for x, y, w, h in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
        face = img[y: y + h, x: x + w]
        face_gray = gray[y: y + h, x: x + w]
    cv2.imshow('video image', img)
    key = cv2.waitKey(10)
    if key == 27:  # ESCキーで終了
        break

cap.release()
cv2.destroyAllWindows()

これで人の顔を検出できました。

5.モザイクをかける

モザイク処理は難しいことは考えずに顔画像を一旦縮小してから拡大して顔画像に張り付けます。

mozaic.py

import cv2

#Haar-like特徴分類器を扱えるようにする。
face_cascade_path="haarcascade_frontalface_alt.xml"
face_cascade = cv2.CascadeClassifier(face_cascade_path)
ratio = 0.07 #ここの値を変えるとモザイクの粗さが変わる。

cap = cv2.VideoCapture(0)
while True:
    ret, img = cap.read()
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)
    for x, y, w, h in faces:
        #モザイクの処理を個々の二行でしている。
        small = cv2.resize(img[y: y+h, x: x+w], None,fy=ratio, fx=ratio,interpolation=cv2.INTER_NEAREST)
        img[y: y + h, x: x + w] = cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)
    cv2.imshow('video image', img)
    key = cv2.waitKey(10)
    if key == 27:  # ESCキーで終了
        break

cap.release()
cv2.destroyAllWindows()

完成しました。

6.まとめ

今回は、リアルタイムで顔認識して顔にモザイク加工を施しました。明暗差で分類しているため、似顔絵でも反応してしまいます。（誤検知も結構ある）ですが、短いコードで顔検出（顔認識）が試せるのでOpenCV楽しいです。
今までブログなどの情報発信をしたことがないためわかりにくい文章になっているかもしれません。
これから、情報発信をしていき文章力をつけていきたいと思います、また技術で遊べる人間になるのが僕の夢なので温かい目で見守っててください。
これから、よろしくお願いします。
それでは！

0.はじめに

Pythonの抽象クラスが思いのほか特殊だったので
メタクラスの説明も踏まえて少しばかり丁寧に解説したい

1.ABCmetaの基本的な使い方

PythonのAbstract(抽象クラス)は少し特殊で、メタクラスと呼ばれるものに
ABCmetaを指定してクラスを定義する(メタクラスについては後ほど説明)

from abc import ABC, ABCMeta, abstractmethod

class Person(metaclass = ABCMeta):
    pass

ちなみにABCクラスというのもあってこちらはmetaclassを指定せず
継承するだけなので基本こっちの方が分かりやすい

class Person(ABC):
    pass

抽象化したいメソッドに@abstractmethodを付ける

@abstractmethod
def greeting(self):
    pass

継承したクラスで実装する

class Yamada(Person):

    def greeting(self):
        print("こんにちわ、山田です。")

もちろん実装しないで、インスタンス化するとエラー

class Yamada(Person):
    pass

yamada = Yamada()
---------------------------------------------------------------------------------------------------------------
TypeError: Can't instantiate abstract class Yamada with abstract methods greeting

以上が、基本的な抽象クラスの使い方

1.1そもそもメタクラスとはなんなのか

ここから少しそれてメタクラスの話、興味なかったら飛ばしてください

メタクラスとは

オブジェクト指向プログラミングにおいてメタクラスとは、インスタンスがクラスとなるクラスのことである。通常のクラスがそのインスタンスの振る舞いを定義するように、メタクラスはそのインスタンスであるクラスを、そして更にそのクラスのインスタンスの振る舞いを定義する。

【出典】: メタクラス - wikipedia

とまあよくわからないので、実例を出すと
実は、Pythonの隠し機能(?)でtypeからクラスを動的に定義できてしまう

def test_init(self):
    pass

Test_Class = type('Test_Class', (object, ), dict(__init__ = test_init, ))

もちろん、このクラスをインスタンス化できる

Test_Class_instance = Test_Class()
print(type(Test_Class_instance))
-------------------------------------------------------------------------------------------------------------------
<class '__main__.Test_Class'>

このときtypeで生成したTest_Classは、インスタンスともクラスの定義ともいえる
これが、狭義的な意味でのメタクラス

驚きなのは、Pythonにおいて普段何気なく定義しているclassは
type型のインスタンスだったりするのだ

class define_class:
    pass

print(type(define_class))
-------------------------------------------------------------------------------------------------------------------
<class 'type'>

結局のところ、Pythonはclassを定義すると内部で
type('classname', ...)が自動で呼び出されるという仕組みになっている
ということになる

この自動で呼び出せれるクラスを変えてしまえという
超強力な機能が__metaclass__ の正体で、
ABCmetaというのはtypeを継承したクラスということになる
ABCmetaのソースコード

ちなみに、metaclassは強力すぎて言語の仕様自体変えてしまう
黒魔術のため乱用しないほうがいいです

2.classmethod、staticmethod、propertyの抽象化

@abstractclassmethod、@abstractstaticmethod、@abstractproperty
がともに非推奨になってしまったので、デコレータを重ねる必要がある

抽象クラス

class Person(ABC):

    @staticmethod
    @abstractmethod
    def age_fudging(age):
        pass

    @classmethod
    @abstractmethod
    def weight_fudging(cls, weight):
        pass

    @property
    @abstractmethod
    def age(self):
        pass

    @age.setter
    @abstractmethod
    def age(self, val):
        pass

    @property
    @abstractmethod
    def weight(self):
        pass

    @weight.setter
    @abstractmethod
    def weight(self, val):
        pass

実装

class Yamada(Person):

    def __init__(self):
        self.__age = 30
        self.__weight = 120

    #10歳サバ読み
    @staticmethod
    def age_fudging(age):
        return age - 10

    #20kgサバ読み
    @classmethod
    def weight_fudging(cls, weight):
        return weight - 20

    @property
    def age(self):
        return Yamada.age_fudging(self.__age)

    @age.setter
    def age(self):
        return

    @property
    def weight(self):
        return self.weight_fudging(self.__weight)

    @weight.setter
    def weight(self):
        return

y = Yamada()
print("名前:山田 年齢:{0} 体重:{1}".format(y.age, y.weight))
-----------------------------------------------------------------------------------------------------------------
名前:山田 年齢:20 体重:100

多少長くなってしまったが、基本的な使い方は同じ
ただ、@abstractmethodが下に来るようにしないとエラーを吐くので注意

ちなみに、Pythonではメンバ変数の前に「__」を付けるとプライベート化できます

3.抽象クラスの多重継承

Pythonでは多重継承が使えるが、抽象クラスではどうでしょう

ご存じの通り、多重継承はいろいろと問題があるので(菱形継承問題、名前衝突)
基本的に多重継承は使わない方が無難だが、使う場合はMixinなクラスであることが求められる

3.1Mixinとは？

mixin とはオブジェクト指向プログラミング言語において、
サブクラスによって継承されることにより機能を提供し、単体で動作することを意図しないクラスである。言語によっては、
その言語でクラスや継承と呼ぶものとは別のシステムとして mixin がある場合もある（#バリエーションの節で詳述）。

【出典】: Mixin - wikipedia

またWikipediaからの引用だが要するに
継承しないとまともに動かないクラスのことで
抽象クラスやインターフェイスもMixinなクラスといえる

ということで、猫と人間を継承した獣人クラスを作っていく

class Cat(ABC):

    @abstractmethod
    def mew(self):
        pass

    #Personにもある
    @abstractmethod
    def sleep(self):
        pass

class Person(ABC):

    @abstractmethod
    def greeting(self):
        pass

    #Catにもある
    @abstractmethod
    def sleep(self):
        pass

class Therianthrope(Person, Cat):

    def greeting(self):
        print("こんにちわ")

    def mew(self):
        print("にゃー")

    def sleep(self):
        print("zzz…")

cat_human = Therianthrope()

cat_human.greeting()
cat_human.mew()
cat_human.sleep()
-----------------------------------------------------------------------------------------------------------------
こんにちわ
にゃー
zzz…

ABCmetaでも難なく動作することがわかる
今回は、sleepというメソッドを名前衝突させているが
継承元で実装されているわけではないので、問題がない

最後にPythonの公式サイトにも書いてある通り
メタクラス同士の衝突には十分注意したほうがいい

4.抽象クラスの多段継承

多段継承で懸念になるのはABCmetaは継承すると引き継ぐのか
言い換えると、Pythonは抽象クラスを継承すると抽象クラスに
なってしまうのかという点

結論から言うとABCmetaは引き継ぐし、抽象クラスを継承すると抽象クラスになります

class Animal(metaclass=ABCMeta):
    pass

class Person(Animal):
    pass

class Yamada(Person):
    pass

print(type(Person))
print(type(Yamada))
-------------------------------------------------------------------------------------------------------------------
<class 'abc.ABCMeta'>
<class 'abc.ABCMeta'>

つまるところ抽象メソッドはどこかしらで
実装すればよいということになる

class Animal(metaclass=ABCMeta):

    @abstractmethod
    def run(self):
        pass


class Person(Animal):
    pass

class Yamada(Person):

    def run(self):
        print("時速12km")

y = Yamada()
y.run()
-------------------------------------------------------------------------------------------------------------------
時速12km

5.仮引数に抽象クラスをとる

だいぶ長くなってしまったが、最後に抽象クラスのざっくりとした
Pythonでも使える使用法の一例を紹介

実は、Pythonでも仮引数、戻り値の型を指定することができるので
先ほど作った親クラスであり抽象クラスでもある「Person」を仮引数の型に指定した
fall_asleepという関数を作っていきましょう

from abstract import Person
import time

def fall_asleep(p:Person):
    sleep_time = p.sleep()
    time.sleep(sleep_time)
    print("!")

class Person(ABC):

    @abstractmethod
    def greeting(self):
        pass

    @abstractmethod
    def sleep(self) -> float:
        pass

抽象クラスやら型指定やらと、もはやPythonではなくなって来てますが
この様なテクニックは、Pythonで少し規模が大きいソフトフェアを作るとき
なんかに役に立ちます。

例えばfall_asleepを作っている人は、具象クラスの実態(YamadaなのかIkedaなのかYosidaなのか)を
気にせず(知らず)、またいくら変更しようともsleepという関数が要件さえ満たしてれば
完成させられるので、fall_asleepは具象クラスではなく抽象クラス(Person)に依存しているといえる

このことをアーキテクチャでは「依存関係逆転の原則(DIP)」なんて
言ったりします

DIPは以下の物が該当

• (変化しやすい)具象クラスを参照しない
• (変化しやすい)具象クラスを継承しない
• 具象関数をオーバーライドしない

結局のところ抽象クラスに依存したほうが、
強固なアーキテクチャを実現できるというわけです

y = Yamada()
fall_asleep(y)
-------------------------------------------------------------------------------------------------------------------
zzz…
!

概要

最近家族とオンライン麻雀サイト天鳳で週に1回2時間ほど楽しんでいます。

今回は対戦成績の分析を家族が皆がウェブ上で見れるようにしたのでその解説です。

プロセスとしては：

1. Pythonで分析
2. Dashを使って可視化
3. HerokuとGithubを使ってデブロイ

こんな感じに仕上がりました↓
https://drmahjong.herokuapp.com/

Codeは以下のGithubで見ることができます。
https://github.com/mottoki/mahjan-score

データを取る

天鳳のデータはログから取ることができます。requestというModuleを使用してデータを取ります。

python.py

import requests
import datetime

new_date = datetime.datetime.now().strftime('%Y%m%d')
url = "https://tenhou.net/sc/raw/dat/"+f"sca{new_date}.log.gz"
filename = f"sca{new_date}.log.gz"

# Download gz file from the url
with open(filename, "wb") as f:
    r = requests.get(url)
    f.write(r.content)

PythonとPandasを使ってデータ処理

Rawデータをプレイヤーの名前でフィルターをかけて、splitを使用してプレイヤーの名前とポイントだけのデータフレームを摘出します。

new_data.py

import os
import pickle
import pandas as pd

# プレイヤーの名前
playercol = ['date', 'Mirataro', 'Shinwan', 'ToShiroh', 'yukoron']

# Pandasのデータフレームに変換
df = pd.read_csv(filename, usecols=[0], error_bad_lines=False, header=None)
df[len(df.columns)] = new_date

# プレイヤーの名前でフィルターをかける
df = df[(df[0].str.contains(playercol[1])) & 
    (df[0].str.contains(playercol[2])) & 
    (df[0].str.contains(playercol[3])) &
    (df[0].str.contains(playercol[4]))]

# データフレームの処理を行う
df[['one','two','three','four']] = df[0].str.split('|', 3, expand=True)
df.columns = ['original', 'date', 'room', 'time', 'type', 'name1']
df['date'] = pd.to_datetime(df['date'], format='%Y%m%d')
df[['empty', 'n1', 'n2', 'n3', 'n4']] = df.name1.str.split(" ", n=4, expand=True)
# 重要なコラムだけ使用
df = df[['date', 'n1', 'n2', 'n3', 'n4']]

# スコアと名前についているカギカッコを取り去りデータフレーム化する
new_score = pd.DataFrame(columns=playercol)
k=0
for i, j in df.iterrows():
   dd = j[0]
   new_score.loc[k, 'date'] = dd
   for name in df.columns[1:]:
       s = j[name]
       player = s.split('(')[0]
       score = [p.split(')')[0] for p in s.split('(') if ')' in p][0]
       score = int(float(score.replace('+', '')))
       new_score.loc[k, player] = score
   k += 1

# 古いデータをPickleから呼ぶ
current_dir = os.getcwd()
old_score = pd.read_pickle(f"{current_dir}/players_score.pkl")

# 新しいデータと古いデータを合わせる
concat_score = pd.concat([old_score, new_score], ignore_index=True)
concat_score.to_pickle(f"{current_dir}/players_score.pkl")

Dashを使って可視化する

Dashというライブラリを使って素早くデータの可視化を行います。

Dashのチュートリアルが一番わかりやすいです。（参考：Dash Documentation & User Guide)

Dashで引っかかるところのはCallbackという機能ですが、Pythonの可視化ライブラリDashを使う　2　Callbackをみるなど詳しく説明されている方がいますのでそちらを参照してください。

1. Front側（ウェブに見えるもの）

全てのコードを説明すると長くなってしまうので、コアとなる部分を例として説明します。

基本的に最初の app.layout＝ の中に書かれているものは全てウェブサイトで表示されるものです。

表示したくないもの（例えば何度も使うデータ「intermediate-values」）は style={'display': 'none'} と入れるとウェブ上で見えなくなります。

# フロントエンドはこのなかに書く
app.layout = html.Div([
    # データに反映される日付をユーザーが選べるようにする
    html.Div([
        html.H2("DR.麻雀"),
        dcc.DatePickerRange(
            id='my-date-picker-range',
            min_date_allowed=dt(2020, 3, 1),
            max_date_allowed=dt.today(),
            end_date=dt.today()
        ),
        ], className="mytablestyle"),

    # 何度も使うデータ:style={'display': 'none'}で見えなくする
    html.Div(id='intermediate-value', style={'display': 'none'}),

    # ポイントの推移（グラフ）
    dcc.Graph(id='mygraph'),

    # 総合ポイント（テーブル）
    html.Div([
            html.Div(html.P('現在の総合ポイント')),
            html.Div(id='totalscore'),
        ], className="mytablestyle"),

])

2. CallbackでデータをJson化する

データをpandasのread_pickleで読み込み、日付でフィルターをかけ、json化して戻します。

こうすることによって同じデータをグラフやテーブルに何度も使えるようになります。

@app.callback(Output("intermediate-value", "children"),
    [Input("my-date-picker-range", "start_date"),
    Input("my-date-picker-range", "end_date")])
def update_output(start_date, end_date):
    players = pd.read_pickle('players_score.pkl')
    if start_date is not None:
        start_date = dt.strptime(re.split('T| ', start_date)[0], '%Y-%m-%d')
        players = players.loc[(players['date'] >= start_date)]
    if end_date is not None:
        end_date = dt.strptime(re.split('T| ', end_date)[0], '%Y-%m-%d')
        players = players.loc[(players['date'] <= end_date)]
    return players.to_json(date_format='iso', orient='split')

3. Callbackでデータをグラフ化＆テーブル化

json化したデータをPandasのデータフレームに戻し、グラフ化とテーブル化していきます。

グラフ化はPlotlyの様式に乗っ取り、go.Figure()で表します。

テーブル化はhtml.Tableで表しました。テーブルはdash_tableというライブラリもあるのですが、今回のテーブルは簡易なものだったので必要ないろ思いこのスタイルにしました。

@app.callback([Output('mygraph', 'figure'),
    Output('totalscore', 'children')],
    [Input('intermediate-value', 'children'),
    Input('datatype', 'value')])
def update_fig(jsonified_df, data_type):
    # Json化したデータをPandasでもとに戻す。
    players = pd.read_json(jsonified_df, orient='split')

    # グラフ化
    fig = go.Figure()
    for i, name in enumerate(players.columns[1:]):
        fig.add_trace(go.Scatter(x=players.date, 
                            y=np.array(players[name]).cumsum(),
                            mode='lines',
                            name=name,
                            line=dict(color=colors[i], width=4)))

    fig.update_layout(plot_bgcolor='whitesmoke',
        title='合計ポイントの推移',
        legend=dict(
            orientation="h",
            yanchor="bottom",
            y=1.02,
            xanchor="right",
            x=1,)
    )

    # 総合ポイントを計算
    summed = players.sum()

    # グラフと表を返す
    return fig, html.Table([
        html.Thead(
            html.Tr([html.Th(col) for col in summed.index])
            ),
        html.Tbody(
            html.Tr([html.Td(val) for val in summed])
            ),
        ])

HerokuとGithubを使ってデプロイ

最後にHerokuとGithubを使ってデプロイしていきます。

公式サイト（Deploying Dash Apps）にはGitとHerokuのやりかたが詳しく載っているので、ほとんどやり方は一緒です。

プロセスはこんな感じです：

1. Githubのアカウントにサインアップする
2. Githubの新しいレポジトリを作成する
3. GithubにSSH接続する。（オプショナルですが、やったほうが楽。参照：GitHubにssh接続できるようにする)
4. デプロイに必要なファイル(.ignore, Procfile, requirements.txt)を作成する。gunicornも必要なので pip install gunicornでインストールする。

5. Gitコマンドで上記のファイルとapp.pyやplayers_score.pklのデータファイルをGithubにプッシュする。

   git init
   git add .
   git commit -m "メッセージ"
   git remote add origin git@github.com:<ユーザー名>/＜レポジトリ名＞
   git push origin master
   

6. Githubにプッシュされているのを確認したらHerokuのアカウントを作成してNew > create new appのボタンで新しいアプリを作成（Regionは日本がないので、United Statesを選択）。

7. 作成されたアプリのDeployのタブをクリックし、Deployment methodをGithubにし、2.で作成したレポジトリに接続します。

8. 最後にManual deployのDeploy Branchという黒いボタンを押すと勝手にデプロイしてくれます。

最後に

いかかでしたでしょうか。

cronとHerokuのAutomatic Deployを使えば天鳳から取ってくる新しいデータのアップデートを自動化することも可能です。（参考：cronでGithubにPushするプロセスを自動化する）

　参考

• 天鳳個室の自動成績管理アプリをLINE botとPythonで作る
• Dash Documentation & User Guide
• Deploying Dash Apps
• Pythonの可視化ライブラリDashを使う　2　Callbackをみる
• cronでGithubにPushするプロセスを自動化する

最近では機械学習を取り入れたサービス開発も増え始め、私自身もそのディレクションをすることがあります。

ただ、データサイエンティスト、MLエンジニアと呼ばれる人々が作る学習モデルを盲目的に利用するだけの簡単なお仕事です、というのは否めず、初心者（私）が、機械学習の知識レベルを上げるために、簡単な学習モデルを作れるようになるまでの過程をまとめてみました。

今回のゴール

pythonによる環境構築からスタートして、一番手っ取り早いと思われるロジスティック回帰による分類モデルを構築してみるところまで実施してみます。題材は趣味と実益を兼ねて、競馬予測モデルに挑戦してみます。

※なお、競馬の専門用語を使用してますが、不明な点は調べて頂ければと思います。

環境構築

前提

実施した環境は以下の通りです。

• Python：3.7.7
• pip：20.2.2

pipenvインストール

pythonの実行環境をpipenvを使って構築していくことにします。

$ pip install pipenv

pythonを実行する仮想環境を構築します。

$ export PIPENV_VENV_IN_PROJECT=true
$ cd <project_dir>
$ pipenv --python 3.7

PIPENV_VENV_IN_PROJECTは仮想環境をプロジェクトのディレクトリ配下(./.venv/)に構築する設定です。

ライブラリインストール

ここでは、最低限必要なライブラリをインストールしていきます。

$ pipenv install pandas
$ pipenv install sklearn
$ pipenv install matplotlib
$ pipenv install jupyter

インストール後、カレントディレクトリのPipfileとPipfile.lockが更新されています。
これらの4ライブラリは必須アイテムと言えるので、有無を言わさずインストールしましょう。

ライブラリ	用途
pandas	データの格納と前処理（クレンジング、統合、変換など）
sklearn	様々な機械学習アルゴリズムを使用した学習と予測
matplotlib	グラフ描画によるデータ可視化
jupyter	ブラウザ上で対話形式のプログラミング

jupyter notebookの起動方法

$ cd <project_dir>
$ pipenv run jupyter notebook
...
    To access the notebook, open this file in a browser:
        file:///Users/katayamk/Library/Jupyter/runtime/nbserver-4261-open.html
    Or copy and paste one of these URLs:
        http://localhost:8888/?token=f809cb2bcb716ba5726912d43738dd51992d3d7f20942d71
     or http://127.0.0.1:8888/?token=f809cb2bcb716ba5726912d43738dd51992d3d7f20942d71

ターミナルに出力されたlocalhostのURLにアクセスすることで、ローカルサーバでjupyter notebookをブラウジングできるようになります。

以上で、環境構築は完了です。

モデル構築

機械学習と一言で言っても、教師あり学習、教師なし学習、強化学習、ディープラーニングと種類は様々ありますが、今回は冒頭でも記載したように、簡単な学習モデルを作れるようになるために、教師あり学習の分類モデルを構築します。

機会学習のワークフロー

AWSの記事が分かりやすかったので、こちらを参照するといいと思います。
機械学習のワークフローってどうなっているの ? AWS の機械学習サービスをグラレコで解説

簡単にまとめると上記の流れになるかと思いますので、この順番で、学習モデルを構築していきます。

1. データの取得

競馬予測モデルを構築するということで、まずは過去の競馬データが必要になります。
インターネット上には競馬情報サイトをスクレイピングする方法なども紹介されてますが、将来的な運用を見据えて、JRAの公式データを購入して取得することにします。
取得データ：JRA-VAN データラボ

自分でデータを取得するプログラムを作るのもいいですが、あらかじめ提供されている無料の競馬ソフトを使ってデータをファイル出力する方法も可能です。（本筋の話じゃないので詳細は省きます。）

今回は以下の2種類のデータファイルを取得しました。データの対象期間は2015年〜2019年の5年分です。

ファイル名	データ種別	データ説明
syutsuba_data.csv	出馬表データ	開催されるレースの出走馬などが記載された番組表データ
seiseki_data.csv	成績データ	開催されたレースの着順などが記載された成績データ

2. データの前処理

データの前処理とは

機械学習において、一番重要とも言われるステップがこちらです。取得したデータに合わせて、以下の処理を実施します。

データクレンジング

ノイズとなるデータを取り除いたり、欠損値を違う値で埋める作業などを行います。

データ統合

学習に必要なデータが、最初から一つにまとまっていることは稀であり、分散したデータを統合することで一貫したデータを生成します。

データ変換

モデルの品質を向上させるため、データを指定のフォーマットに変換するプロセスです。例えば、数値データを-1から1の範囲に収まるデータに標準化したり、犬か猫のどちらかが選択されているようなカテゴリーデータをダミー変数化して数値に変換するなど、様々なデータの加工を実施します。

競馬データの前処理

ここから実際に競馬データの前処理を実装してきますが、起動したjupyter notebookを使用すると、対話形式でデータの状態を確認しながらのプログラミングが可能です。

まずは、取得した競馬データをpandasのDataFrameにロードしますが、データの前処理を実施した結果、最終的には以下の構造にデータを加工しようと思います。

データ項目	用途	データ説明
race_index	index	開催されるレースを特定した識別ID
本賞金	説明変数	出走馬の獲得賞金の合計金額
騎手名	説明変数	騎手名をダミー変数化して使用
3着以内	目的変数	出走馬の着順を3着以内なら1、4着以下なら0に変換

今回は出走馬の実力を測る特徴量として、各馬がこれまでに獲得した賞金の合計金額を使用します。また、騎手の手腕による差も大きいと考え、騎手名も採用しました。この二つの説明変数だけで、どの程度の予測精度になるか試してみます。

build.ipynb

import os
import pandas as pd

# 出馬表データ
syutsuba_path = './data/sample/syutsuba_data.csv'
df_syutsuba = pd.read_csv(syutsuba_path, encoding='shift-jis')
df_syutsuba = df_syutsuba[['レースID', '本賞金', '騎手名']]

# 成績データ
seiseki_path = './data/sample/seiseki_data.csv'
df_seiseki = pd.read_csv(seiseki_path, encoding='shift-jis')
df_seiseki = df_seiseki[['レースID', '確定着順']]

DataFrameでは、以下のようにデータが構成されています。

参考） レースIDのデータフォーマット

添字（レンジ）	データ長	項目説明
0〜3	4byte	年
4〜5	2byte	月
6〜7	2byte	日
8〜9	2byte	競馬場コード
10〜11	2byte	開催回次
12〜13	2byte	開催日次
14〜15	2byte	レース番号
16〜17	2byte	馬番

続いて、取得データを統合して、データのクレンジングや変換などを実施していきます。

build.ipynb

# 出馬表データと成績データをマージ
df = pd.merge(df_syutsuba, df_seiseki, on = 'レースID')

# 欠損値があるレコードは除去
df.dropna(how='any', inplace=True)

# 着順が3着以内かどうかのカラムを追加する
f_ranking = lambda x: 1 if x in [1, 2, 3] else 0
df['3着以内'] = df['確定着順'].map(f_ranking)

# ダミー変数を生成
df = pd.get_dummies(df, columns=['騎手名'])

# インデックスを設定（レースだけを特定する場合は、16バイト目までを使用）
df['race_index'] = df['レースID'].astype(str).str[0:16]
df.set_index('race_index', inplace=True)

# 不要なカラムを削除
df.drop(['レースID', '確定着順'], axis=1, inplace=True)

DataFrameを確認すると、ダミー変数化したカラムは、そこに所属するカテゴリー数分の新たなカラムに置き換わって、0か1のフラグが設定されているのが分かります。

騎手名をダミー変数化したことで、カラム数が295まで増えてますが、カテゴリー数の多いカラムをダミー変数化すると過学習の原因にもなりますので、注意してください。

3. モデルの学習

続いてモデルの学習を行っていきましょう。
まず、データを説明変数と目的変数ごとに学習用データと評価用データに分割します。

build.ipynb

from sklearn.model_selection import train_test_split

# 説明変数をdataXに格納
dataX = df.drop(['3着以内'], axis=1)

# 目的変数をdataYに格納
dataY = df['3着以内']

# データの分割を行う（学習用データ 0.8 評価用データ 0.2）
X_train, X_test, y_train, y_test = train_test_split(dataX, dataY, test_size=0.2, stratify=dataY)

要は以下の4種類のデータに分割しています。

変数名	データ種別	用途
X_train	説明変数	学習データ
X_test	説明変数	評価データ
y_train	目的変数	学習データ
y_test	目的変数	評価データ

今回は、train_test_splitを使用して、簡易的に学習データと評価データを分割してますが、競馬のように、時系列の概念があるデータに関しては、（過去）-> 学習データ -> 評価データ ->（現在）という並びになるように、データを分割した方が、精度も上がると思われます。

続いて、用意したデータを学習させていきます。基本的なアルゴリズムならsklearnに内包されており、今回はロジスティック回帰を使用します。

build.ipynb

from sklearn.linear_model import LogisticRegression

# 分類器を作成（ロジスティック回帰）
clf = LogisticRegression()

# 学習
clf.fit(X_train, y_train)

これだけで完了です。とても簡単ですね。

4. モデルの評価

まずは、評価データを予測して、その結果をもとに正解率を確認してみましょう。

build.ipynb

# 予測
y_pred = clf.predict(X_test)

# 正解率を表示
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, y_pred))
0.7874043003746538

正解率は0.7874043003746538と78%も正しく予測できていることになります。
一見、「おーすげー！めっちゃ儲かるやん！」と喜んでしまいそうですが、このaccuracy_scoreには要注意です。続いて以下のコードを実行してみます。

build.ipynb

# 混同行列を表示
from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[  339 10031]
 [  410 38332]]

この2次元配列は混同行列と言いますが、以下を表しています。

	予測：3着以内	予測：4着以下
実際：3着以内	339	10031
実際：4着以下	410	38332

このうち、正解率は予測：3着以内 × 実際：3着以内と予測：4着以下 × 実際：4着以下の合算値になります。

正解率：0.78 = (339 + 38332) / (339 + 38332 + 410 + 10031)

	予測：3着以内	予測：4着以下
実際：3着以内	339	10031
実際：4着以下	410	38332

この結果から、3着以内と予測した件数がそもそも少なすぎて、大半を4着以下と予測していることで、正解率が押し上げられていることが分かります。

正解率には要注意というのが分かったところで、では何を基準にモデルの精度を評価すればいいかですが、この混同行列を活用した方法としては、F値を確認するという方法があります。

F値とは

以下の1と2を合わせたものになります。
1）3着以内と予測した出走馬のうち、正解した割合（適合率と言います）
2）実際に3着以内だった出走馬のうち、正解した割合（再現率と言います）

適合率：0.45 = 339 / (339 + 410)
再現率：0.03 = 339 / (339 + 10031)

	予測：3着以内	予測：4着以下
実際：3着以内	339	10031
実際：4着以下	410	38332

build.ipynb

# F値を表示
from sklearn.metrics import f1_score
print(f1_score(y_test, y_pred))
0.06097670653835776

今回のF値を確認したところ、0.06097670653835776でした。F値ですが、ランダムに0と1に振り分けたケースの場合、0.5に収束する性質のものであるため、今回の0.06という値は極めて低い数値であるというのが分かります。

データ不均衡を修正

build.ipynb

print(df['3着以内'].value_counts())
0    193711
1     51848

目的変数の3着以内と4着以下のデータ比率は1:4で、ややデータに偏りが見られますので、ここを少し是正してみます。

まず、追加で以下のライブラリをインストールします。

$ pipenv install imbalanced-learn

学習データの3着以内と4着以下のデータ比率を1:2にアンダーサンプリングします。アンダーサンプリングとは、少数データに合わせて多数データの件数をランダムに絞ることを意味します。

build.ipynb

from imblearn.under_sampling import RandomUnderSampler

# 学習データをアンダーサンプリング
f_count = y_train.value_counts()[1] * 2
t_count = y_train.value_counts()[1]
rus = RandomUnderSampler(sampling_strategy={0:f_count, 1:t_count})
X_train_rus, y_train_rus = rus.fit_sample(X_train, y_train)

これで、データ不均衡を少し是正したので、再度モデルの学習と評価を実施します。

build.ipynb

# 学習
clf.fit(X_train_rus, y_train_rus)

# 予測
y_pred = clf.predict(X_test)

# 正解率を表示
print(accuracy_score(y_test, y_pred))
0.7767958950969214

# 混同行列を表示
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[ 1111  9259]
 [ 1703 37039]]

# F値を表示
print(f1_score(y_test, y_pred))
0.1685376213592233

F値が0.1685376213592233となり、かなり改善されましたね。

説明変数を標準化

説明変数が本賞金と騎手名の二つですが、騎手名はダミー変数化により0か1の値、一方で本賞金は以下のような特徴量の分布になっています。

build.ipynb

import matplotlib.pyplot as plt
plt.xlabel('prize')
plt.ylabel('freq')
plt.hist(dataX['本賞金'], range=(0, 20000), bins=20)

値の大きさが違いすぎるため、本賞金と騎手名を対等に比較できない可能性が高く、それぞれの特徴量を同じ範囲にスケールしてあげる必要があります。その手法の一つが標準化になります。

build.ipynb

from sklearn.preprocessing import StandardScaler

# 説明変数を標準化
sc = StandardScaler()
X_train_rus_std = pd.DataFrame(sc.fit_transform(X_train_rus), columns=X_train_rus.columns)
X_test_std = pd.DataFrame(sc.transform(X_test), columns=X_test.columns)

標準化することで、全ての説明変数の値が一定の範囲内に収まるように変換されたので、再度モデルの学習と評価を実施します。

build.ipynb

# 学習
clf.fit(X_train_rus_std, y_train_rus)

# 予測
y_pred = clf.predict(X_test_std)

# 正解率を表示
print(accuracy_score(y_test, y_pred))
0.7777732529727969

# 混同行列を表示
print(confusion_matrix(y_test, y_pred, labels=[1, 0]))
[[ 2510  7860]
 [ 3054 35688]]

# F値を表示
print(f1_score(y_test, y_pred))
0.3150495795155014

F値が0.3150495795155014となり、前回からさらに精度向上し、30%台に乗りました。また、適合率が0.45、再現率が0.24で、競馬の予測結果としてはまずまずかと思います。

回帰係数の重みを確認

最後に説明変数のどの値が、競馬予測に強く影響しているかを回帰係数で確認します。

build.ipynb

pd.options.display.max_rows = X_train_rus_std.columns.size
print(pd.Series(clf.coef_[0], index=X_train_rus_std.columns).sort_values())

騎手名_下原理    -0.092015
騎手名_左海誠二   -0.088886
騎手名_江田照男   -0.081689
騎手名_三津谷隼   -0.078886
騎手名_山本聡哉   -0.075083
騎手名_御神本訓   -0.073361
騎手名_伴啓太    -0.072113
騎手名_岩部純二   -0.070202
騎手名_武士沢友   -0.069766
騎手名_宮崎光行   -0.068009
...（省略）
騎手名_岩田康誠    0.065899
騎手名_田辺裕信    0.072882
騎手名_モレイラ    0.073010
騎手名_武豊      0.084130
騎手名_福永祐一    0.107660
騎手名_川田将雅    0.123749
騎手名_戸崎圭太    0.127755
騎手名_Ｍ．デム    0.129514
騎手名_ルメール    0.185976
本賞金         0.443854

本賞金が最も、3着以内に入ると予測するPositiveな影響を及ぼし、続いてはメジャーな騎手が影響度の上位を形成しているのが分かります。

5. モデルの運用

ここまでの作業で、モデルの構築を何とか実現することができました。次は実際の運用を考えてみましょう。競馬は毎週定期開催されていますが、毎レースの3着以内に入るであろう出走馬を予測して、あわよくばお金持ちになりたいと考えています。

では毎週、機械学習のワークフローを最初から順番に実施していきますか？1. データの取得は最新の出馬表データを取得するために毎回実施する必要がありますが、2. データの前処理と3. モデルの学習は毎回実施せずに、一度構築したモデルを再利用すればいいはずです（定期的なモデルのアップデートは必要ですが）。ということで、その運用を実施してみましょう。

build.ipynb

import pickle

filename = 'model_sample.pickle'
pickle.dump(clf, open(filename, 'wb'))

このように、pickleというライブラリを使用することで、構築したモデルをシリアライズしてファイルに保存することができます。

そして、保存したモデルの復元方法がこちらです。

restore.ipynb

import pickle

filename = 'model_sample.pickle'
clf = pickle.load(open(filename, 'rb'))

# 予測
y_pred = clf.predict(予測対象レースの説明変数データ)

簡単にモデルを復元し、未来のレース予測に利用することができます。これでデータの前処理やモデルの学習を必要としない、効率的な運用が可能になります。

さいごに

以上で、環境構築からモデル構築まで、一連の作業を順を追って実施することができました。初心者による拙い説明にはなりますが、似たような境遇の方々の参考になれば幸いです。

次回は別のアルゴリズムを使って、今回作ったモデルとの比較検証や予測精度だけでなく、実際の収支はどうなのかという一歩踏み込んだ仕組み作りに挑戦したいと思います。

はじめに

Windows10上のIISでDjangoのチュートリアルを動かした手順を備忘録として残しておきます。

参考記事

はじめての Django アプリ作成、その 1
Windows7 + IIS + virtualenv + wfastcgiで、Djangoをホストする
Python(Django) をWindows+IISで動かす
IIS Web ページを開くときの HTTP エラー500.19

目次

• 環境
• Pythonのインストール
• PostgreSQLのインストール
• IIS(Internet Information Services)の有効化
• Djangoのプロジェクト作成
  • 開発環境の準備
  • プロジェクトの作成
• IISの設定
  • サイトの追加
  • Pythonのハンドラーマッピングを追加
  • wfastcgiの設定
  • IIS用権限の付与
• 動作確認
  • エラーが出た場合

環境

• Windows10 Pro
• IIS10
• Python 3.8.5
• Django 3.1.1

Pythonのインストール

公式サイトからインストーラーをダウンロードします。
インストールする際、すべてのユーザーにインストールをしてください。
個別ユーザーインストールだとIISのユーザーが利用できず動かすことが出来ません。

PostgreSQLのインストール

PostgrSQLを使っていきたいのでインストールします

公式サイトからインストーラーをダウンロードします。
今回はWindows x86-64のversion13をインストールしました。

IIS(Internet Information Services)の有効化

コントロールパネル>プログラム>Windowsの機能の有効化または無効化 から
インターネットインフォメーションサービスを有効化します。

コンピュータの管理>サービスとアプリケーションに
インターネットインフォメーションサービスが追加されていたら有効化出来ています。

Djangoのプロジェクト作成

1.開発環境の準備

C:\Users\ユーザー名配下に「web」ディレクトリを作成しそこで作業することにします。

コマンドプロンプト

C:\Users\ユーザー名> mkdir web

virtualenvのインストール

コマンドプロンプト

C:\Users\ユーザー名\web> pip install virtualenv

仮想環境(env)の作成

コマンドプロンプト

C:\Users\ユーザー名\web> virtualenv env

仮想環境の有効化

コマンドプロンプト

C:\Users\ユーザー名\web> env\Scripts\activate

Djangoのインストール

コマンドプロンプト

(env) C:\Users\ユーザー名\web> pip install Django

wfastcgiのインストール

コマンドプロンプト

(env) C:\Users\ユーザー名\web> pip install wfastcgi

psycopg2のインストール

コマンドプロンプト

(env) C:\Users\ユーザー名\web> pip install psycopg2

pip listの結果は以下です。

コマンドプロンプト

(env) C:\Users\ユーザー名\web>pip list
Package    Version
---------- -------
asgiref    3.2.10
Django     3.1.1
pip        20.2.3
psycopg2   2.8.6
pytz       2020.1
setuptools 49.6.0
sqlparse   0.3.1
wfastcgi   3.0.0
wheel      0.35.1

2.プロジェクトの作成

Djangoのチュートリアルに沿ってプロジェクトを作成していきます。

コマンドプロンプト

(env) C:\Users\ユーザー名\web> django-admin startproject mysite

ローカルで動くか確認

コマンドプロンプト

(env) C:\Users\ユーザー名\web>mysite> python manage.py runserver

http://127.0.0.1:8000/ にアクセスし、以下のページが表示されたらOKです。

IISの設定

サイトの追加

新規にサイトを追加します。
コンピュータの管理>インターネットインフォメーションサービス から
サイト>Webサイトの追加で物理パス等を設定します。

物理パスは、Djangoプロジェクトのフォルダ(manage.pyなどの親フォルダ)を設定します。

Pythonのハンドラーマッピングを追加

ハンドラーマッピング>スクリプトマップの追加から設定します。
実行可能ファイルは、env環境のpython.exeを指定します。

wfastcgiの設定

wfastcgiを利用するためロックを解除

(env) C:\Users\ユーザー名\web\mysite>%windir%\system32\inetsrv\appcmd unlock config -section:system.webServer/handlers
構成パス "MACHINE/WEBROOT/APPHOST" のセクション "system.webServer/handlers" のロックを解除しました。

wfastcgi enableを実行

(env) C:\Users\ユーザー名\web\mysite>wfastcgi-enable
構成変更を構成コミット パス "MACHINE/WEBROOT/APPHOST" の "MACHINE/WEBROOT/APPHOST" のセクション "system.webServer/fastCgi" に適用しました
"c:\users\ユーザー名\web\env\scripts\python.exe|c:\users\ユーザー名\web\env\lib\site-packages\wfastcgi.py" can now be used as a FastCGI script processor

web.configを作成

Djangoプロジェクト配下(manage.pyと同じディレクトリ)にweb.configを作成します。
scriptProcessorの値はwfastcgi-enableで表示された値を設定します。

web.config

<configuration>
  <appSettings>
    <add key="WSGI_HANDLER" value="django.core.wsgi.get_wsgi_application()" />
    <add key="PYTHONPATH" value="C:\Users\ユーザー名\web" />
    <add key="DJANGO_SETTINGS_MODULE" value="mysite.settings" />
  </appSettings>
  <system.webServer>
    <handlers>
        <add name="Python FastCGI" path="*" verb="*" modules="FastCgiModule" scriptProcessor="c:\users\ユーザー名\web\env\scripts\python.exe|c:\users\ユーザー名\web\env\lib\site-packages\wfastcgi.py" resourceType="Unspecified" />
    </handlers>
  </system.webServer>
</configuration>

IIS用権限の付与

コンピュータの管理>インターネットインフォメーションサービス の
MySite(新規に作成したサイト)からアクセス許可の編集をします。
セキュリティタブで[コンピュータ名\IIS_IUSRS]のユーザーを追加

また、ファイルエクスプローラーでC:\Users\ユーザー名\webのenvフォルダを右クリック>プロパティから
同じく[コンピュータ名\IIS_IUSRS]のユーザーを追加してください。

動作確認

コンピュータの管理>インターネットインフォメーションサービスからMySiteを選択しWebサイトの参照でロケットが飛んだらDjangoサイトが動作しています。

エラーが出た場合

以下のように0x800700005エラーや0x8007010bエラーになる場合は、
ファイルアクセスの権限やハンドラーマッピングで設定したPython.exeのパスが適切か確認してみて下さい。

原因　：サイトのディレクトリにコンピュータ名\IIS_IUSRSのアクセス権限がない場合に起こる
解決策：コンピュータ名\IIS_IUSRSの権限を追加する

原因　：使用しているPython.exeのディレクトリにコンピュータ名\IIS_IUSRSのアクセス権限がない場合に起こる
解決策：コンピュータ名\IIS_IUSRSの権限を追加する

次回はデータベースをPostgreSQLに変更する手順を書きます

はじめに

機械学習をしてみたいと思って、選ばれたのが『ポケモン』でした。
ポケモンは種族値がポケモンごとに決まっているので、データの宝石箱だと考えました。

しかし、今回はGoogleで『ポケモン　機械学習』で検索してトップに出てきた人のものを参考にした完全下位互換記事なので、真似したい方は是非元記事をご参照ください。
ポケモンで学ぶ機械学習

環境

OS:Win10 home
IDE:VScode
言語:python 3.7.3 64bit

やったこと

7世代までのポケモンのデータベースを元に、『ひこう』、『エスパー』のポケモンを抽出して、ロジスティック回帰で二値分類させてみました。
ちなみに、ポケモンにおける各タイプの数は以下（7世代まで）

タイプ	匹数
ノーマル	116匹
かくとう	63匹
どく	69匹
じめん	75匹
ひこう	113匹
むし	89匹
いわ	67匹
ゴースト	55匹
はがね	58匹
ほのお	72匹
みず	141匹
でんき	60匹
くさ	103匹
こおり	43匹
エスパー	100匹
ドラゴン	59匹
あく	59匹
フェアリー	54匹

みずが最多で、こおりが最小でしたね。フリーズドライで倍返しですね。

Codeは以下です。

lr_pokemon.py

import pandas as pd
import codecs
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt


# read data by pandas
with codecs.open("data/pokemon_status.csv", "r", "Shift-JIS", "ignore") as file:
    df = pd.read_table(file, delimiter=",")

# print(df.head(15))

p_type = ["ノーマル","かくとう","どく","じめん","ひこう","むし","いわ","ゴースト","はがね","ほのお","みず","でんき","くさ","こおり","エスパー","ドラゴン","あく","フェアリー"]
print(len(p_type))

# make functions
def count_type(p_type):
    list1 = df[df['タイプ１'] == p_type]
    list2 = df[df['タイプ２'] == p_type]
    lists = pd.concat([list1, list2])
    print(p_type + "のポケモン: %d匹" % len(lists))

def type_to_num(p_type):
    if p_type == "ひこう":
        return 1
    else:
        return 0

# count number of type in pokemons
for i in p_type:
    count_type(i)

# make sky_df
sky1 = df[df['タイプ１'] == "ひこう"]
sky2 = df[df['タイプ２'] == "ひこう"]
sky = pd.concat([sky1, sky2])

# make psycho_df
psycho1 = df[df['タイプ１'] == "エスパー"]
psycho2 = df[df['タイプ２'] == "エスパー"]
psycho = pd.concat([psycho1, psycho2])

df_s_p = pd.concat([sky, psycho], ignore_index=True)

type1 = df_s_p['タイプ１'].apply(type_to_num)
type2 = df_s_p['タイプ２'].apply(type_to_num)
df_s_p['type_num'] = type1 + type2

print(df_s_p)

X = df_s_p.iloc[:,7:13].values
y = df_s_p['type_num'].values

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

lr = LogisticRegression(C = 1.0)
lr.fit(X_train, y_train)
# show scores
print("train_score: %.3f" % lr.score(X_train, y_train))
print("test_score: %.3f" % lr.score(X_test, y_test))

i = 0
error1 = 0
success1 = 0
error2 = 0
success2 = 0
print("[ひこうタイプと判断したポケモン一覧]")
print("----------------------------------------")
print("")
while i < len(df_s_p):
    y_pred = lr.predict(X[i].reshape(1, -1))
    if y_pred == 1:
        print(df_s_p.loc[i, ["ポケモン名"]])
        if df_s_p.loc[i, ["type_num"]].values == 1:
            success1 += 1
            print("ひこうタイプですよね")
            print("")
        else:
            error1 += 1
            print("ひこうタイプやと思ってしまいました")
            print("")
    else:
        print(df_s_p.loc[i, ["ポケモン名"]])
        if df_s_p.loc[i, ["type_num"]].values == 0:
            error2 += 1
            print("エスパータイプですよね")
            print("")
        else:
            success2 += 1
            print("エスパータイプやと思ってしましました")
            print("")
    i += 1
print("----------------------------------------")
print("正しくひこうタイプと判断したポケモンの数: %d匹" % success1)
print("正しくエスパータイプと判断したポケモンの数: %d匹" % success2)
print("誤ってひこうタイプと判断したポケモンの数: %d匹" % error1)
print("誤ってエスパータイプと判断したポケモンの数: %d匹" % error2)
print("")

結果

結果は正答率75%でした。低いですね。機械学習では使えない数値でした。

私はもっと良い数字がでると思ったんですけどね。なぜなら『ひこう』なら物理アタッカー、『エスパー』なら特殊アタッカーと大まかに分けられるかなと思ったからです。現実はそんなに単純ではありませんね。
とはいえ、実際に誤検知されたポケモンを見ると私でも誤検知してしまうなーという理由が得られました。
例えば、ひこうなのにエスパーと間違えられた子として『サンダー』、『フリーザー』がいたのですが、とくこうが高いのでそりゃそうよな。俺でも初見なら間違えるわ、となりました。
逆に、エスパーなのにひこうと間違えられた子として『ケーシィ』、『ラルトス』がいたのですが、これは低種族値なので仕方ないかなと思いました。低種族値帯では数値に差がつきにくいので。
進化系の『フーディン』や『サーナイト』、『エルレイド』はばっこしエスパーに割り振られていたので安心です。

ん？？

エルレイドはんっ！
あんたはひこうタイプに間違われても良かったんちゃいまっか！！！

おわりに

やはり種族値だけでポケモンを判断するのは間違っている　完