ローカルにあったメモ書きをQiitaで供養します。
書いたのが去年なので古い情報もあるかもしれませんです。。

psycopg2 について

psycopg2はPythonでPostgreSQLを扱うライブラリです。

Refs.: 1, 2

psycopg2 で PostgreSQL DB に接続する

conn = psycopg2.connect({DB_URL(str)}) でDBコネクションを作成できます。

{DB_URL} は postgresql://{username}:{pass}@{IP Address or hostname}:{port}/{DB name} で指定されます。

または、conn = psycopg2.connect(host={IP Address or hostname(str)}, port={port number(int)}, dbname={DB name(str)}, user={username(str)}, password={pass(str)})でも指定できます。

コネクションは不要になったらclose()しますが、with 構文が使えるので使うといいと思います。

import psycopg2

with psycopg2.connect({DB URL}) as conn:
    # Processes you want to do

クエリを投げる

投げるために、カーソルを作ります。

カーソルは、conn.cursor()で作れます。これも不要になったらclose()しますが、wi（以下略）。

cursor.execute({query string})でクエリを実行できます。

引数を与えたいときは、cursor.execute('SELECT * FROM EXAMPLE_TABLE WHERE FOO = %s', (fooval, ))といったように第二引数にタプル(またはリスト)で与えます。

また、引数を辞書（Dictionary型）で与えることもできます。その際は%(key)sといったようにプレースホルダにキーを与えます。

cur.execute("""
     INSERT INTO some_table (an_int, a_date, another_date, a_string)
     VALUES (%(int)s, %(date)s, %(date)s, %(str)s);
     """,
     {'int': 10, 'str': "O'Reilly", 'date': datetime.date(2005, 11, 18)})

import psycopg2

with psycopg2.connect({DB URL}) as conn:
    with conn.cursor() as cur:
        cur.execute({query})

クエリの結果を受け取る

SELECTとかの結果をPythonオブジェクトで受け取ります。

cursor.fetchone(), cursor.fetchall(), cursor.fetchmany(size)で受け取れます。

cursor.fetchone()

結果（クエリのresultset）の次の行から1件だけ受け取ります。結果はタプルで返ってきます。

cursorが終端を指しているときに実行すると、Noneが返ってきます。

cursor.fetchall()

結果（クエリのresultset）の次の行から全件受け取ります。結果はタプルのリストで返ってきます。

cursorが終端を指しているときに実行すると、空のリストが返ってきます。

cursor.fetchmany(size)

結果（クエリのresultset）の次の行からsize件受け取ります。結果はタプルのリストで返ってきます。

cursorが終端を指しているときに実行すると、空のリストが返ってきます。

コミットする

デフォルトでトランザクションが有効になっているため、コミットしないと変更が反映されません。connect.commit()でコミットしましょう。

connect.autocommit = Trueを設定するとトランザクションが無効になります。

ロールバックする

connect.rollback()です。
コネクションをwith構文で作成している場合、withブロック内で例外が起きると自動的にロールバックされるようです。便利だね¹。

---

1. PEP249を満たしているかららしい ↩

1.はじめに

すごく今更ですが，Neural ODE実装ライブラリの使い方を紹介します．ちなみに，Neural ODE はNeurIPS 2018のbest paperに輝いた論文です．

このNeural ODE,著者らによってtorchdiffeqというライブラリ化された公式レポジトリが公開されています．

Neural ODEは理論や解釈を説明した記事は数多くあっても、このライブラリの実際の使い方を記述している日本語記事が少ないように思ったので、この記事で基礎的な使い方をまとめました．
ちなみにtorchdiffeqはPyTorch用のライブラリです．

この記事を読むことで、以下のことができるようになります．

• 一階常微分方程式の初期値問題をtorchdiffeqで解ける
• 二階常微分方程式の初期値問題をtorchdiffeqで解ける
• Neural ODEを構成する層であるODE Block層が実装できる

2.前提知識

torchdiffeqを使うに当たっての前提知識をおさらいします．

2.1 常微分方程式とは

微分方程式のうち，未知変数が本質的にただ一つのものを常微分方程式といいます．例えば，$\frac{dz}{dt}=f(z(t), t)$や,$m\ddot{x} = -kx$などの微分方程式は複数の変数が出てきますが，$z$や$x$は$t$の関数となるので，本質的に未知変数が$t$のただ一つしか存在せず，常微分方程式だと言えます．

2.2 Neural ODEとは

Neural ODEに関してはわかりやすい記事が他にたくさんあるので，そちらを参照していただきたいです．

一応，概要だけを簡単に説明すると，Neural ODEとは，「連続的な層をもつニューラルネットワーク」だと言えます．

「常微分方程式」というニューラルネット界隈では聞きなれない言葉があるせいでコンセプトが掴みにくくなっている説がありますが，重要な点は，「層を連続化した」したという点だと思っています．これにより従来のモデルでは不可能だった，例えば「0.5層目の出力を取り出す」といったことができるようになりました．

以下参考リンク：
- 連続ダイナミクスを表現可能なニューラルネットワーク
- 【NIPS 2018最優秀賞論文】トロント大学発 ： 中間層を微分可能な連続空間で連結させる、まったく新しいNeural Networkモデル

3. torchdiffeqの使い方

それでは早速，torchdiffeqの使い方を見ていきましょう．

3.1 インストール

インストールするには以下のコマンドを実行します．

pip install torchdiffeq

3.2 例：一階微分方程式

実際にNeural ODEの実装に入る前に，簡単な一階常微分方程式を例にして，torchdiffeqの簡単な使い方を見ていきましょう．

以下の式微分方程式を考えます．
$$
z(0) = 0, \\
\frac{dz(t)}{dt} = f(t) = t
$$

この解は$C$を積分定数として

$$
\int dz = \int tdt+C　\\
z(t) = \frac{t^2}{2} + C
$$

と書く下すことができ、$z(0) = 0$なので, この微分方程式の解は以下のようになることがわかります．
$$
z(t) = \frac{t^2}{2}
$$

torchdiffeqによる実装

この問題をtorchdiffeqで解くための最もシンプルな実装が以下になります．

first_order.py

from torchdiffeq import odeint

def func(t, z):
    return t

z0 = torch.Tensor([0])
t = torch.linspace(0,2,100)
out = odeint(func, z0, t)

以下，ポイントを箇条書きにします．

• 関数funcは上の微分方程式$\frac{dz}{dt}=f(t, z)$の$f$にあたります．引数は(t, z)の順番です．出力の次元はzに一致する必要があります．z,tのどちらかを用いなくても大丈夫です．
• 変数z0はダイナミクスの初期値になります．

• 変数tは時間を表し，tensor([0., 0.1, 0.2, ..., 0.9, 1.0])のように１次元テンソルである必要があります．t[0]は初期値に対応する時刻になります．

• 注意すべきは，tの要素は狭義単調増加（減少）する列でなくてはならないということです．t=tensor([0, 0, 1])のように，同じ値が含まれていてもエラーになります．

• odeint(func, z0, t)で微分方程式を解きます．引数は順番に関数func, 初期値y0，時刻tです．

• ソルバーはtで指定されている時刻でのzの値を返します．つまり，t=tensor([t0, t1, ..., tn])のとき，out = tensor([z0, z1,..., zn])となります．t[0]は初期時刻なので，出力out[0]は必ずz0に一致しています．

以上の結果をプロットします．

from matplotlib.pyplot as plt

plt.plot(t, out)
plt.axes().set_aspect('equal', 'datalim')  # 縦横比を1:1にする
plt.grid()
plt.xlim(0,2)
plt.show()

手計算で求めた微分方程式の解$z = \frac{t^2}{2}$と一致していることがわかります．

3.3 (参考)例２：二階微分方程式を解く

torchdiffeqを使うと二階微分方程式も解けてしまいます．例として，理系には馴染み深い（？）単振動の微分方程式をtorchdiffeqで解きます．単振動の微分方程式は以下になります．
$$
m\ddot{x} = -kx
$$
初期状態として，$t=0$のとき，$x=1$, $\dot{x}=\frac{dx}{dt}=0$とします．
二階微分方程式を解くコツは，二階微分方程式を２つの一階微分方程式に分解することです．具体的には，以下のようにします．

$$
\left[
\begin{array}{c}
\dot{x} \\
\ddot{x} \\
\end{array}
\right] =
\left[
\begin{array}{cc}
0 & 1\\
-\frac{k}{m} & 0\\
\end{array}
\right]
\left[
\begin{array}{c}
x \\
\dot{x} \\
\end{array}
\right]
$$

ここで，$\boldsymbol{y}= \left[
\begin{array}{c}
x \\
\dot{x} \\
\end{array}
\right]$とおけば，この二階微分方程式は以下の一階微分方程式に帰着します．

$$
\frac{d\boldsymbol{y}}{dt} = f(\boldsymbol{y})
$$

実装は以下になります．$k=1, m=1$としています．

oscillation.py

class Oscillation:
    def __init__(self, km):
        self.mat = torch.Tensor([[0, 1],
                                 [-km, 0]])

    def solve(self, t, x0, dx0):
        y0 = torch.cat([x0, dx0])
        out = odeint(self.func, y0, t)
        return out

    def func(self, t, y):
        # print(t)
        out = y @ self.mat  # @は行列積
        return out

if __name__=="__main__":
    x0 = torch.Tensor([1])
    dx0 = torch.Tensor([0])

    import numpy as np
    t = torch.linspace(0, 4 * np.pi, 1000)
    solver = Oscillation(1)
    out = solver.solve(t, x0, dx0)

描画すると，きちんと単振動の解が求まっていることがわかります．

4.ODE Blockの実装

torchdiffeqの使い方に慣れてきたところで，実際のODE Blockの実装の仕方について見ていきましょう．ODE Blockとは，$\frac{dz}{dt} = f(t, z)$のダイナミクスを形成する一つのモジュールです．実際のNeural ODEは，通常のFull-Connect層や畳み込み層と共にODE Blockが使われて構成されています．

以下の実装は簡潔さを重視したものであり，あくまで一例です．

from torchdiffeq import odeint_adjoint as odeint

class ODEfunc(nn.Module):
    def __init__(self, dim):
        super(ODEfunc, self).__init__()
        self.seq = nn.Sequential(nn.Linear(dim, 124),
                                 nn.ReLU(),
                                 nn.Linear(124, 124),
                                 nn.ReLU(),
                                 nn.Linear(124, dim),
                                 nn.Tanh())

    def forward(self, t, x):
        out = self.seq(x)
        return out


class ODEBlock(nn.Module):
    def __init__(self, odefunc):
        super(ODEBlock, self).__init__()
        self.odefunc = odefunc
        self.integration_time = torch.tensor([0, 1]).float()

    def forward(self, x):
        self.integration_time = self.integration_time.type_as(x)
        out = odeint(self.odefunc, x, self.integration_time)
        return out[1]  # out[0]には初期値が入っているので．

簡単に解説をすると，

• ODE Blockは受け取った入力xを微分方程式の初期値として扱います．
• ODEfuncが系のダイナミクスを記述する$f$となっています．
• ODE Blockの積分区間は0~1で固定となっています．そして$t=1$での層の出力を返します．

こうすることで，以下のように，ニューラルネットの一つのモジュールとしてODE Blockを使うことができます．

class ODEnet(nn.Module):
    def __init__(self, in_dim, mid_dim, out_dim):
        super(ODEnet, self).__init__()

        odefunc = ODEfunc(dim=mid_dim)

        self.fc1 = nn.Linear(in_dim, mid_dim)
        self.relu1 = nn.ReLU(inplace=True)
        self.norm1 = nn.BatchNorm1d(mid_dim)
        self.ode_block = ODEBlock(odefunc)  # ODE Blockを使用
        self.norm2 = nn.BatchNorm1d(mid_dim)
        self.fc2 = nn.Linear(mid_dim, out_dim)

    def forward(self, x):
        batch_size = x.shape[0]
        x = x.view(batch_size, -1)

        out = self.fc1(x)
        out = self.relu1(out)
        out = self.norm1(out)
        out = self.ode_block(out)
        out = self.norm2(out)
        out = self.fc2(out)

        return out

このモデルは計算速度が遅かったです．
しかし，torchdiffeqを使えば必ず遅くなるわけでもないようで，自分が試した限りでは公式レポジトリのNeural ODEモデルでは通常のニューラルネットワークと遜色ない速度が出ていました．（こっちのほうがモデル小さいはずなのに...）

5. まとめ

Neural ODEの実装に役立つtorchdiffeqの初歩的な使い方を紹介しました．実際にモデルを訓練しているプログラムを見たい方は，以下のtorchdiffeqの公式レポジトリか筆者の実装レポジトリを参照してください．

参考

torchdiffeq - GitHub
My 実装レポジトリ

1 この記事は？

テクニカル分析等を行う場合、各銘柄のまとまった期間の株価データが必要になります。米国株の場合、Pandas Readerを使い、専用APIにアクセスしてまとまった期間の株価データを取得することは容易ですが、日本株の場合無料で株価を取得できるAPIはありません。また、Webスクレイピングを行い株価データを取得することは定番ですが、日本株の取得、株価を掲載しているほとんどのサイトはスクレイピングを禁止しております。ちなみにYahoo ファイナンスはスクレイピング禁止です。日本株では、株式投資メモというサイトがWebスクレイピングOKとなっており、個別株の株価データを取得できます。ただし、株式投資メモは指数系(日経225)や米国株には対応していません。

よって、個別日本株の株価データは、株式投資メモで取得し、日経225などの指数系と米国株は、pandas_datareaderで取得するコードをPythonで作りました。

株式投資メモサイト

2 コードを掲載します。

下記は、個別日本株と指数系(日経225)と米国株の株価の取得を行うコードです。基準日に対して過去3年分の株価を取得できるようにしています。
個別日本株は、株式投資メモのサイトよりスクレイピングを行います。指数系と米国株はpandas_datareaderを使いAPIにアクセスし株価データを取得するようにしています。APIにアクセスするより、スクレイピングを行う方が処理に時間がかかります。そこで、日本株の株価データを取得する場合すでに株価を取得した銘柄であれば、スクレイピングする量を削減し、処理が早く終わるようにしております。

test.py

#-*- coding:utf-8 -*-
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.chrome.options import Options
import time
import pandas as pd
import datetime
from pyvirtualdisplay import Display
from selenium.webdriver.common.by import By
import os.path
import pandas_datareader.data as web #米国株データの取得ライブラリを読み込む


####(1)取得する株価番号,取得基準年を記載します。#######

STOCKNUMS=[4800,1570,7752,'^N225','VOOV','^DJI','JPY=X']   #取得する株価番号を入力します。
#STOCKNUMS=[1570]
YEAR=2020 #取得基準年を記入します。取得基準年から過去2年分の株価データを取得します。

####(2)chromedriverの設定を行います。#######

options = Options() 
options.add_argument('--headless')
options.add_argument('--disable-gpu')

####(3)X環境がない(コンソール上で実施)場合、以下のdisplayコマンドを有効にする。jupyterで実行する場合は、以下のdisplayコマンドは無効にする#######

#pyvirtualdisplayパッケージを使って仮想ディスプレイ（Xvfb）を起動させてSeleniumを使う方法
display = Display(visible=0, size=(1024, 1024))
display.start()


####(4) 各種フォルダの設定を行います ##############

EXECUTABLE_PATH="xxxxxxxxxxxxxxxxxx" #/chromedriver.exeのパスを指定する。
HOME_PATH="yyyyyyyyyyyyyyyyyy" #株価データを保存する場所を指定する。


#### (5)株価取得クラス GET_KABUDATA #####

class GET_KABUDATA():

    ### (5-1)コンストラクターを定義する ###
    def __init__(self,stocknum,year):

        stocknum=str(stocknum)


        try:
            print('銘柄番号' + str(stock)+'の株価データを取得します')

            #csvファイルが存在しない(今回初めてデータを取得する銘柄)場合
            if os.path.exists(HOME_PATH + str(stocknum)+'.csv')==False:
                #stocknum(銘柄名)が数値型ではない(=日本個別株ではない場合)
                if stocknum.isnumeric()==False:
                    self.get_PandasDR(stocknum) #pandas_readerを実行する

                #stocknum(銘柄名)が数値型の場合(=日本個別株の場合)
                else:
                    self.get_new_stockdat(stocknum,year) #株式投資メモから過去3年分のデータをスクレイピングする。

            #csvファイルが存在する場合(過去にデータを取得したことのある銘柄の場合)           
            else:
                #stocknum(銘柄名)が数値型ではない(=日本個別株ではない場合)
                if str(stocknum).isnumeric()==False:
                    self.get_PandasDR(stocknum) #pandas_readerを実行する

                #stocknum(銘柄名)が数値型の場合(=日本個別株の場合)
                else:
                    self.get_add_stockdat(stocknum,year) #現在保有していない日にちの株価データを株式投資メモから取得し、csvファイルに追記する。

            print('銘柄番号' + str(stock)+'の株価データ取得を完了しました')
            print('**********')

        #エラー処理(存在しない銘柄番号を指定した。株式投資メモのサイトがダウンしておりデータがスクレイピングできない) 
        except Exception as e:
            print(e)
            print('株価取得失敗')                


    ### (5-2)過去に株価を取得した銘柄の場合、サーバーにある株価データと、取得した株価データの差分比較を行い、差分のみを取得しcsvファイルに書き込みを行う            
    def get_add_stockdat(self,stocknum,year):


        #(5-2-1)各種変数を初期化する。
        s_date=[]
        s_open=[]
        s_high=[]
        s_low=[]
        s_close=[]
        s_volume=[]
        dfstock=[]
        add_s_date=[]
        add_s_open=[]
        add_s_high=[]
        add_s_low=[]
        add_s_close=[]
        add_s_volume=[]  
        add_s_stock=[] 
        add_dfstock=[]       

        #(5-2-2)株式投資メモに表示される個別株の株価表にアクセスする(スクレイピングを行う)。
        browser = webdriver.Chrome(options=options,executable_path=EXECUTABLE_PATH)
        url='https://kabuoji3.com/stock/'+ str(stocknum) + '/'+ str(year) + '/'
        browser.get(url)
        elem_tmp0 = browser.find_element_by_class_name('data_contents')
        elem_tmp1 = elem_tmp0.find_element_by_class_name('data_block')
        elem_tmp2 = elem_tmp1.find_element_by_class_name('data_block_in')
        elem_tmp3 = elem_tmp2.find_element_by_class_name('table_wrap')
        elem_table= elem_tmp3.find_element_by_class_name('stock_table.stock_data_table')
        elem_table_kabuka=elem_table.find_elements(By.TAG_NAME, "tbody")

        #(5-2-3)株価表の１行ずつ指定し、各日の株価を読み取る
        for i in range(0,len(elem_table_kabuka)):

            kabudat=elem_table_kabuka[i].text.split()   
            s_date.append(str(kabudat[0].split('-')[0]) +'/'+ str(kabudat[0].split('-')[1]) +'/'+ str(kabudat[0].split('-')[2])) #日付けを取得    
            s_open.append(kabudat[1]) #始値を取得する
            s_high.append(kabudat[2]) #高値を取得する。
            s_low.append(kabudat[3]) #低値を取得する。
            s_close.append(kabudat[4]) #終値を取得する。
            s_volume.append(kabudat[5]) #出来高を取得する。
            s_stock={'DATE':s_date,'CLOSE':s_close,'OPEN':s_open,'HIGH':s_high,'LOW':s_low,'VOL':s_volume} #始値,高値,低値,終値,出来高をリストに入れる      


        dfstock=pd.DataFrame(s_stock,columns=["DATE","CLOSE","OPEN","HIGH","LOW","VOL"]) #リストs_stockをDataFrame化する。
        dfstock.set_index("DATE",inplace=True)
        dfstock=dfstock.sort_index() #取得した株価データを日付順に並べる。
        dfstock.reset_index("DATE",inplace=True)


        dfstock_csv= pd.read_csv(HOME_PATH + str(stocknum)+'.csv', index_col=0) #サーバーに保存している株価データをcsvファイルから読み出す。
        dfstock_csv.reset_index("DATE",inplace=True)  #index指定を解除する


        #(5-2-4)サイトから新規にスクレイピングした株価データの最新の日付を取得する
        dfstock_latest = dfstock['DATE'].iloc[dfstock['DATE'].count()-1]
        dfstock_latest=datetime.datetime.strptime(dfstock_latest, '%Y/%m/%d') #日付けを文字型に設定する
        dfstock_latest_date=datetime.date(dfstock_latest.year, dfstock_latest.month, dfstock_latest.day) #日付けを文字型から日付け型に変更する


        #(5-2-5)サーバーに保存されている株価データの最新の日付を取得する。  
        dfstock_csv_latest = dfstock_csv['DATE'].iloc[dfstock_csv['DATE'].count()-1]
        dfstock_csv_latest=datetime.datetime.strptime(dfstock_csv_latest, '%Y/%m/%d') #日付けを文字型に設定する
        dfstock_csv_latest_date =datetime.date(dfstock_csv_latest.year, dfstock_csv_latest.month, dfstock_csv_latest.day) #日付けを文字型から日付け型に変更する

        #(5-2-6)サイトから新規にスクレイピングした株価データの最新の日付と、サーバーに保存されている株価データの最新の日付の差を算出する。
        difday=dfstock_latest_date - dfstock_csv_latest_date 



        #(5-2-7)サーバーに保存されている株価データに対し、不足分の株価データを加え最新の状態にする。
        for i in range(len(elem_table_kabuka)-difday.days,len(elem_table_kabuka)):


            kabudat=elem_table_kabuka[i].text.split()   
            add_s_date.append(str(kabudat[0].split('-')[0]) +'/'+ str(kabudat[0].split('-')[1]) +'/'+ str(kabudat[0].split('-')[2]))     
            add_s_open.append(kabudat[1])
            add_s_high.append(kabudat[2])
            add_s_low.append(kabudat[3])
            add_s_close.append(kabudat[4])
            add_s_volume.append(kabudat[5])
            add_s_stock={'DATE':add_s_date,'CLOSE':add_s_close,'OPEN':add_s_open,'HIGH':add_s_high,'LOW':add_s_low,'VOL':add_s_volume} 


        #不足分の株価データをリスト形式からDataFrame形式に変換する
        add_dfstock=pd.DataFrame(add_s_stock,columns=["DATE","CLOSE","OPEN","HIGH","LOW","VOL"])    

        #(5-2-8)サーバーに保存されている株価データに対し、不足分の株価データを加える。
        dfstock=pd.concat([dfstock_csv, add_dfstock])  

        #(5-2-9)更新分を追加した株価データをcsvに書き出しする        
        dfstock.set_index("DATE",inplace=True)
        dfstock.to_csv(HOME_PATH + str(stocknum)+'.csv')


        browser.close()#ブラウザを閉じる  for文の外に書かないとエラーになる         


     ### (5-3)新規に株価データを取得する。
    def get_new_stockdat(self,stocknum,year):

         #(5-3-1)各種変数を初期化する。       
        s_date=[]
        s_open=[]
        s_high=[]
        s_low=[]
        s_close=[]
        s_volume=[]
        dfstock=[]

        #(5-3-2)株式投資メモに表示される個別株の株価表にアクセスする(スクレイピングを行う)。
        browser = webdriver.Chrome(options=options,executable_path=EXECUTABLE_PATH)

        #(5-3-3)株式投資メモから過去３年分の株価データを取得する
        for j in range(0,3):
            url='https://kabuoji3.com/stock/'+ str(stocknum) + '/'+ str(year-j) + '/'
            browser.get(url)
            elem_tmp0 = browser.find_element_by_class_name('data_contents')
            elem_tmp1 = elem_tmp0.find_element_by_class_name('data_block')
            elem_tmp2 = elem_tmp1.find_element_by_class_name('data_block_in')
            elem_tmp3 = elem_tmp2.find_element_by_class_name('table_wrap')
            elem_table= elem_tmp3.find_element_by_class_name('stock_table.stock_data_table')
            elem_table_kabuka=elem_table.find_elements(By.TAG_NAME, "tbody")

             #(5-2-4)株価表の１行ずつ指定し、各日の株価を読み取る
            for i in range(0,len(elem_table_kabuka)):

                kabudat=elem_table_kabuka[i].text.split()   
                s_date.append(str(kabudat[0].split('-')[0]) +'/'+ str(kabudat[0].split('-')[1]) +'/'+ str(kabudat[0].split('-')[2]))     
                s_open.append(kabudat[1])
                s_high.append(kabudat[2])
                s_low.append(kabudat[3])
                s_close.append(kabudat[4])
                s_volume.append(kabudat[5])
                s_stock={'DATE':s_date,'CLOSE':s_close,'OPEN':s_open,'HIGH':s_high,'LOW':s_low,'VOL':s_volume}


        dfstock=pd.DataFrame(s_stock,columns=["DATE","CLOSE","OPEN","HIGH","LOW","VOL"]) #リスト -> DataFrameに変更
        dfstock.set_index("DATE",inplace=True)
        dfstock=dfstock.sort_index() #取得した株価データを日付順に並べる。
        dfstock.to_csv(HOME_PATH + str(stocknum)+'.csv') #株価データをCSVファイルに書き出す。

        browser.close()#ブラウザを閉じる  for文の外に書かないとエラーになる 




     ### 米国株や指数系の株価データを取得する。
    def get_PandasDR(self,stocknum):
        ed=datetime.datetime.now()
        st=datetime.datetime.now()- datetime.timedelta(days=600)        
        df=web.DataReader(stocknum, 'yahoo',st,ed) #日経225の株価データを取得する
        df=df.drop(columns='Adj Close') #列Aを削除する。
        df.reset_index("Date",inplace=True)
        df= df.rename(columns={'Date': 'DATE','High': 'HIGH', 'Low': 'LOW',  'Open': 'OPEN', 'Close': 'CLOSE',  'Volume': 'VOL' })#各列名を所望の列名に変更する。
        df = df[['DATE','CLOSE','HIGH','LOW','OPEN','VOL']]
        df.set_index("DATE",inplace=True)
        df.to_csv(HOME_PATH + str(stocknum)+'.csv') #dfを外部のcsvファイルに書き込む 




############# メインプログラム ##################

#指定した銘柄の株価を取得する。
if __name__ == '__main__':        

    for stock in STOCKNUMS:
        GET_KABUDATA(stock,YEAR)

    print('株価取得終了しました。')

3 コードを実行する上での注意点

3-1 取得する銘柄の設定

取得する株価の銘柄番号を変数STOCKNUMSに記入します。

STOCKNUMS=[4800,1570,7752,'^N225','VOOV','^DJI','JPY=X']   #取得する株価番号を入力します。
#STOCKNUMS=[1570]
YEAR=2020 #取得基準年を記入します。取得基準年から過去2年分の株価データを取得します。

^N225:日経平均 , VOOV:バンガードS&P500バリューETF , ^DJI:NYダウ, JPY=X:円米ドル

3-2 スクレイピングの設定

ブラウザが立ち上がらない環境(console環境)で、コードを実行する場合、下記のコードを有効にします。
逆にjupyterなど、ブラウザが立ち上がる環境であれば下記を無効にしてください。

display = Display(visible=0, size=(1024, 1024))
display.start()

3-3 PATHの設定

chromeドライバーのchromedriver.exeが配置されているパス(EXECUTABLE_PATH)と株価データを保存するパス(HOME_PATH)を設定してください。

EXECUTABLE_PATH="xxxxxxxxxxxxxxxxxx" #/chromedriver.exeのパスを指定する。
HOME_PATH="yyyyyyyyyyyyyyyyyy" #株価データを保存する場所を指定する。

概要

海外ではエンジニアの面接においてコーディングテストというものが行われるらしく、多くの場合、特定の関数やクラスをお題に沿って実装するという物がメインである。

どうやら多くのエンジニアはその対策としてLeetCodeなるサイトで対策を行うようだ。

早い話が本場でも行われているようなコーディングテストに耐えうるようなアルゴリズム力を鍛えるサイトであり、海外のテックカンパニーでのキャリアを積みたい方にとっては避けては通れない道である。

と、仰々しく書いてみましたが、私は今のところそういった面接を受ける予定はありません。

ただ、ITエンジニアとして人並みのアルゴリズム力くらいは持っておいた方がいいだろうということで不定期に問題を解いてその時に考えたやり方をメモ的に書いていこうかと思います。

Leetcode

Python3で解いています。

ゼロから始めるLeetCode 目次

前回
ゼロから始めるLeetCode Day85 「6. ZigZag Conversion」

Twitterやってます。

技術ブログ始めました！！
技術はLeetCode、Django、Nuxt、あたりについて書くと思います。こちらの方が更新は早いので、よければブクマよろしくお願いいたします！

問題

33. Search in Rotated Sorted Array

難易度はMedium。
問題としては、昇順にソートされた配列を，あらかじめ知らないピボットで回転させたとします（[0,1,2,4,5,6,7]が[4,5,6,7,0,1,2]になるかもしれません。）
(例えば，[0,1,2,4,5,6,7]は[4,5,6,7,0,1,2]になるかもしれません。)
検索対象の値が与えられます。配列の中に見つかった場合はそのインデックスを返し、そうでない場合は-1を返します。
配列の中に重複したものが存在しないと仮定しても構いません。
なお、アルゴリズムの実行時の複雑さは，O(log n)のオーダーでなければなりません。

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1

解法

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if nums.count(target) == 0:
            return -1
        else:
            ans = nums.index(target)
        return ans
# Runtime: 36 ms, faster than 92.59% of Python3 online submissions for Search in Rotated Sorted Array.
# Memory Usage: 14 MB, less than 61.16% of Python3 online submissions for Search in Rotated Sorted Array.

仮にcountが0ならば-1を返し、そうでない場合にindexを返します。

・・・
書くことがなぁい！！！

では今回はここまで。
お疲れ様でした。

感想

土曜日のABC級のコンテストの悔しさをバネに頑張ります。
また、今週はいくつかライブラリを整理できればと思っています。

18日目

ABC138-E Strings of Impurity

かかった時間

考察10分,実装10分

考察

考察を綺麗にまとめられたので、実装もスムーズに終わりました。また、以下では、$t$の$i$文字目を$t_i$、$s$の$i$文字目を$s_i$と表します。

まず、$s$に含まれる文字のみで構成されるなら$t$を作ることができ、$t$のそれぞれの文字ができるだけ早く$s^{'}$に出てくるように貪欲に選んでいきます。ここで、$t_i$として$s_j$が選ばれるとして$t_{i+1}$がどの$s_k$に対応するか考えます。

$t_{i+1}=s_k(k>j)$が成り立つ時は最小の$k$となる$s_k$(✳︎)を$t_{i+1}$として選べば良いですが、$t_{i+1}=s_k(k>j)$が成り立たない時は次に現れる$s$の中で最小の$k$となる$s_k$を$t_{i+1}$として選べば良いです。これを任意の$t_i$について繰り返していけば正答にたどり着くことができます。

上記では$s$に現れるアルファベットのインデックスをすぐに検索できる必要があるので、アルファベットごとにどのインデックスが存在するかを(昇順の)配列で保存しておきます。昇順の配列で保存しておけば、(✳︎)における最小の$k(>j)$をbisect_rightで求めることができます。また、最後の文字をみる時は場合分けが少し異なるので、実装で少し注意が必要です(詳しくはコードを参照してください。)。

Pythonのコード

abc138E.py

from bisect import bisect_right
s=input()
t=input()
ns=len(s)
nt=len(t)
alp=[[] for i in range(26)]
for i in range(ns):
    alp[ord(s[i])-97].append(i)
alpl=[len(alp[i]) for i in range(26)]
ans=0
now=-1
for i in range(nt):
    if alpl[ord(t[i])-97]==0:
        exit(print(-1))
    b=bisect_right(alp[ord(t[i])-97],now)
    if b==alpl[ord(t[i])-97]:
        now=alp[ord(t[i])-97][0]
        ans+=ns
        if i==nt-1:
            ans+=(now+1)
    else:
        now=alp[ord(t[i])-97][b]
        if i==nt-1:
            ans+=(now+1)
print(ans)

ABC139-E League

かかった時間

30分かけて一つだけTLE→1時間以上デバッグして定数倍高速化

間違えた原因

最大$n=1000$の元での$O(n^3)$が通ると勘違いしていたことが原因。
→計算量の確認を怠らない

考察

原因にもある通り計算量の確認を怠って無限に時間を溶かしました…。
結果的に$O(N^3)$の愚直解で無駄に計算しているところを削れば良いだけだったので、反省しています。

まず、順序に制限があるので、愚直に決めていく(対戦できる人から順に対戦させていく)ことができるのではないかと考え、愚直に決めていくよりも良いケースがないのでこの方針が間違ってないとかります。

この元で対戦できる人をサンプルケースを用いて考えると、以下のように対戦する人をpairにして保存すれば対戦する人を順に決めることができます。

ここで、$i$日目に対戦可能な組み合わせを辞書dに保存すると、valueが2となる組み合わせは対戦可能なので、その対戦可能な組み合わせに含まれる人それぞれの次に対戦する人(今対戦している人をbに保存しておきます。)をpairで新しく辞書に格納することを繰り返せば、全ての対戦を見終わった時点での日にちが求める最小の日数となります。

またある日においてvalueが2となる組み合わせが一つも存在しない場合は条件を満たすような試合の組み合わせが存在しないことと同値なので-1を出力します。

さらに、valueが2となる組み合わせをdから削除して次に対戦する人の組をdに追加する操作をvalueが2となる組み合わせのチェックと同時に行うとfor文の中で要素を削除及び追加することによりイテレータが壊れるので、チェックが全て終わってから行うようにします。

ちなみに、この方針だと$O(N^3)$になりますが、$i+1$日目にvalueが2となる組み合わせは$i$日目に更新されたvalueしかあり得ません。したがって、$i+1$日目にdに含まれる全組み合わせを見ずに$i$日目に更新された人changeable1のみを見れば、全試合$\frac{N(N-1)}{2}$通りをチェックするだけでよく、$O(N^2)$まで計算量を落として十分高速に計算することができます。

別解

今回は軽く触れるだけですが、それぞれの試合に順序が決められていることを利用すれば、試合の集合は半順序集合となっています。
半順序集合は必ず閉路のないDAG(Directed acyclic graph,有向無閉路グラフ)で表現できるので、深さ優先探索を用いてこの問題を解くことができます。

別解について詳しくは、こちらの記事を参照してください。

C++のコード(非想定)

abc139e.cc

//コンパイラ最適化用
#pragma GCC optimize("Ofast")
//インクルード(アルファベット順)
#include<bits/stdc++.h>
using namespace std;
typedef int ll;

#define REP(i,n) for(ll i=0;i<n;i++)
//xにはvectorなどのコンテナ
#define SIZE(x) ll(x.size())
#define PB push_back //vectorヘの挿入
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素
#define Umap unordered_map

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    ll n;cin>>n;
    vector<vector<ll>> a(n,vector<ll>(n-1));
    REP(i,n){
        REP(j,n-1){
            ll c;cin>>c;
            if(c-1<i)a[i][j]=c-1+n*i;
            else a[i][j]=i+n*(c-1);
        }
    }
    Umap<ll,ll> d;
    REP(i,n)d[a[i][0]]++;
    vector<ll> b(n,0);
    ll ans=0;
    deque<ll> nextd;
    deque<ll> cleard;
    while(!d.empty()){
        ans++;
        bool g=true;
        for(const auto& i : d){
            if(i.S==2){
                g=false;
                ll e=(i.F)/n;ll f=(i.F)%n;
                cleard.insert(cleard.begin(),i.F);
                b[e]++;b[f]++;
                if(b[e]<n-1)nextd.insert(nextd.begin(),a[e][b[e]]);
                if(b[f]<n-1)nextd.insert(nextd.begin(),a[f][b[f]]);
            }
        }
        if(g){
            cout<<-1<<endl;
            return 0;
        }
        ll ln,lc;ln=SIZE(nextd);lc=SIZE(cleard);
        REP(i,ln){
            d[*--nextd.end()]++;
            nextd.pop_back();
        }
        REP(i,lc){
            d.erase(*--cleard.end());
            cleard.pop_back();
        }
    }
    cout<<ans<<endl;
    return 0;
}

Pythonのコード(想定)

abc139e.py

from collections import deque
n=int(input())
#それぞれ長さはn-1
a=[[j-1+n*i if j-1<i else i+n*(j-1) for j in list(map(int,input().split()))] for i in range(n)]
#試合の候補をいれる
d=dict()
for i in range(n):
    if a[i][0] in d:
        d[a[i][0]]+=1
    else:
        d[a[i][0]]=1
#どこまで見たか
b=[0]*n
#最大n(n-1)/2回
ans=0
nextd=deque()
cleard=deque()
changeable1=deque(set([a[i][0] for i in range(n)]))
while len(d):
    ans+=1
    #一個も同じのなかったらむり
    g=True
    changeable2=deque()
    for i in changeable1:
        if d[i]==2:
            g=False
            e,f=i//n,i%n
            cleard.append(i)
            b[e]+=1
            b[f]+=1
            if b[e]<n-1:
                nextd.append(a[e][b[e]])
                changeable2.append(a[e][b[e]])
            if b[f]<n-1:
                nextd.append(a[f][b[f]])
                changeable2.append(a[f][b[f]])
    if g:
        exit(print(-1))
    ln,lc=len(nextd),len(cleard)  
    for _ in range(ln):
        i=nextd.popleft()
        if i in d:
            d[i]+=1
        else:
            d[i]=1
    for _ in range(lc):
        i=cleard.popleft()
        d.pop(i)
    changeable1=set(changeable2)
print(ans)

19日目

ABC140-E Second Sum

かかった時間

30分くらい使ってわからず→解説AC

間違えた原因

自分の解法に自信がなかった。
解法を単純化できなかった。

考察

まず、このような和の計算で全ての候補を数え上げると間に合わないかつその値の候補が数え上げられる範囲内である場合、値の候補がその和の計算で何回現れるか考えることで高速化することができます。

この問題では、$1 \leqq X_{L,R} \leqq N-1$の$N-1$通りしかないので値の候補で数え上げることができそうであることがわかります。

次に、問題文の条件を見ると$L,R(1 \leqq L <R \leqq N)$の時、$P_L,P_{L+1},…,P_R$の中で二番目の数が$X_{L,R}$です。したがって、$P_i$が$X_{L,R}$となる時$P_L,P_{L+1},…,P_R$の中には$P_i$よりも大きい数が一つだけ存在します。したがって、このように$L,R$が選ぶ方法がないか探すには$P_i$よりも大きい数に注目すれば良いので、そのような数を赤丸で$P_i$を青丸で表して下図のようになります。($P_i$よりも大きいかどうかという二値化をしていることになります。)

上図の①または②の間で赤丸と青丸を含むように$L,R$はそれぞれ選ぶことができる(✳︎)ので、$P_i$よりも大きい数のうち左側で最も近い要素二つと右側で最も近い要素二つがそれぞれわかれば良いことが言えます。

ここで、それぞれの$P_i$についてそれより大きい要素を$P_1,P_2,…,P_N$から毎回探そうとすると合計で$O(N^2)$だけの探索をすることになり間に合いませんが、探索範囲が被っていて無駄なことと$P_i$より大きい数のインデックスのみがわかっていれば良いことに注目すると問題の見通しが良くなります。つまり、その数より大きい数のみを保存するコンテナsを用意しておけば、大きい数から順にそのインデックスを確かめてsに保存することで高速に計算できることがわかります。また、左側と右側で$i$に最も近いそれぞれ二つのインデックスを調べられるようにsは順序付きでなければならず、ここではsetを用いることにしました。

上記の方針をまとめると以下のようになります。

大きい数から順にそのインデックスをsに挿入していきます。こ子で、今見ている数$P_i$のインデックス$i$をs中に挿入する際に右側にくる最小の二つの数のインデックス(r1<r2)と左側にくる最小の二つの数のインデックス(l1>l2)を求めて$X_{L,R}=P_i$となる場合の数を求めます。また、このままだとr1,r2,l1,l2が存在しない可能性があるので、番兵用のインデックスとして-2,-1,n,n+1をsに先に格納しておきます。このもとで、$X_{L,R}=P_i$を満たす場合の数は(✳︎)によって下図のように求めることができます。

また、l1<0の場合は①を満たす場合が存在せず、r1>n-1の場合は②を満たす場合が存在しないので、これらのパターンを除くようにして計算する必要があり、以上の計算を任意の$P_i$について行えば$O(N \log{N})$のプログラムを書くことができます。

C++のコード

abc141e.cc

//コンパイラ最適化用
#pragma GCC optimize("O3")
//インクルード(アルファベット順)
#include<algorithm>//sort,二分探索,など
#include<bitset>//固定長bit集合
#include<cmath>//pow,logなど
#include<complex>//複素数
#include<deque>//両端アクセスのキュー
#include<functional>//sortのgreater
#include<iomanip>//setprecision(浮動小数点の出力の誤差)
#include<iostream>//入出力
#include<iterator>//集合演算(積集合,和集合,差集合など)
#include<map>//map(辞書)
#include<numeric>//iota(整数列の生成),gcdとlcm(c++17)
#include<queue>//キュー
#include<set>//集合
#include<stack>//スタック
#include<string>//文字列
#include<unordered_map>//イテレータあるけど順序保持しないmap
#include<unordered_set>//イテレータあるけど順序保持しないset
#include<utility>//pair
#include<vector>//可変長配列

using namespace std;
typedef long long ll;

//マクロ
//forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
//Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i,n) for(ll i=0;i<ll(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=ll(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=ll(b);i--)
//xにはvectorなどのコンテナ
#define ALL(x) x.begin(),x.end() //sortなどの引数を省略したい
#define SIZE(x) ll(x.size()) //sizeをsize_tからllに直しておく
//定数
#define INF 1000000000000 //10^12:極めて大きい値,∞
#define MOD 1000000007 //10^9+7:合同式の法
#define MAXR 100000 //10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define PB push_back //vectorヘの挿入
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素
#define Umap unordered_map
#define Uset unordered_set
//.lower_boundはO(√n)
signed main(){
    //入力の高速化用のコード
    //ios::sync_with_stdio(false);
    //cin.tie(nullptr);
    ll n;cin>>n;
    vector<ll> p(n);vector<ll> p_num(n);
    REP(i,n){cin>>p[i];p[i]--;p_num[p[i]]=i;}
    //番兵を入れておくと良い
    //p[i]よりも大きい数のインデックスを保存しておく
    set<ll> s;
    s.insert(-2);s.insert(-1);
    s.insert(n);s.insert(n+1);
    ll ans=0;
    //大きい数から処理
    REPD(i,n){
        //pでのインデックス
        ll j=p_num[i];
        ll l1,l2,r1,r2;
        r1=*(s.upper_bound(j));
        r2=*(++s.upper_bound(j));
        l1=*(--s.lower_bound(j));
        l2=*(--(--s.lower_bound(j)));
        //cout<<l2<<" "<<l1<<" "<<r1<<" "<<r2<<endl;
        if(l1>-1)ans+=((i+1)*(l1-l2)*(r1-j));
        if(r1<n)ans+=((i+1)*(r2-r1)*(j-l1));
        s.insert(j);
    }
    cout<<ans<<endl;
}

ABC146-D Coloring Edges on Tree

かかった時間

25分くらい

考察

緑色、水色前半の問題は安定して10分くらいで方針を間違えずに解けると嬉しいです…。

各頂点についてその頂点を端点に持つ辺の色を全て異なるように塗れば良いので、BFSやDFSなどで直前に通った辺以外の色を全て使って塗ることを繰り返せば全ての辺を塗ることができます。ただ、直前に通った判定の実装が面倒かと思って違う解法を選択しました(結局DFSやBFSと変わりませんが)。

それぞれの頂点から伸びる辺をそれぞれ保存しておき、番号の小さい点と繋がっている辺から順に色を塗っていきます。この時、それぞれの辺ですでに色が塗られている場合はその色は塗れないのでcand1にその色の番号を保存します。逆にまだ塗られていない辺は塗りたいのでcand2に保存します。このもとでcand2の全要素にアクセスし、cand1に含まれない色のみで小さい番号の色からそれぞれの辺を順に塗っていけば良いです。

Pythonのコード

abc146d.py

n=int(input())
paths=[[] for i in range(n)]
colors=[0]*(n-1)
for i in range(n-1):
    a,b=map(int,input().split())
    paths[a-1].append(i)
    paths[b-1].append(i)
m=0
for i in range(n):
    m=max(m,len(paths[i]))
print(m)
for i in range(n):
    cand1,cand2=set(),[]
    for j in paths[i]:
        if colors[j]!=0:
            cand1.add(colors[j])
        else:
            cand2.append(j)
    now=1
    for j in cand2:
        while now in cand1:
            now+=1
        colors[j]=now
        now+=1
for i in range(n-1):
    print(colors[i])

はじめに

はじめまして！初めての投稿です。
投稿練習、自分用メモとして書きます。

環境

macOS Catalina 10.15.5

内容

macには標準でpythonが入っていて、Terminalから使うことができます。
起動の仕方と終了の仕方を記します。

手順

-はじめ方
terminalを立ち上げて、"python"と入力するだけです。
none
~$ python

-終わり方
ctrl + Dと入力するとpythonから抜けられます。
または、exit()と入力してもOKです。

GoogleDriveのデータを@gmailアカウントから@G-Suiteアカウントに移動した際の備忘録です。

同じドメイン間(AAA@gmail.com→BBB@gmail.com)は共有機能を使えば一括で移動ができますが[1]、異なるドメイン間(AAA@gmail.com→BBB@nulpo-ga.com)へは一括で移動するツールやサービスがありません。(2020年06月現在)

注意点
・今回は@gmail.comのデータのリンクを保ったまま移動する必要がありました。
・ファイルのオーナーを変更する必要があります
　（共有機能を使ったり、ダウンロードしてしまうとリンクが切れてしまいます）

---

方法
1.Google同期とDriveFileStreemの活用
2.Pythonでコーディング

1.Google同期とDriveFileStreemの活用

https://www.google.com/intl/ja_ALL/drive/download/
にて公式アプリをダウンロード・インストールします。設定は順々に行えばできます。
移動元：Google同期と移動先：DriveFileStreemがエクスプローラーのナビゲーションウィンドウに表示されます。
まず、Google同期のフォルダから移動したいフォルダ/ファイルを一度ローカルに移動します。ローカルに移動したフォルダー/ファイルをDriveFileStreemに移動します。

Google同期からDriveFileStreemへはファイルの移動しかできませんが、ローカルを挟むことでフォルダの移動が可能になります。

2.Pythonでコーディング

こちらもGoogle同期とDriveFileStreemを使います。

import shutil
FROM='G:/マイドライブ/対象元フォルダー'
TO='G:/共有ドライブ/自宅用/対象先フォルダー'
new_path = shutil.move(FROM, TO)

一度実行すれば放置でいいのですが、1の方法より時間がかかります。エラーが発生する場合もあるので自己責任でお願いします。

---

他にいい方法やご意見がありましたら、ご気軽にご連絡ください。
殴り書きで書いたのでいずれ分かりやすい記事に直します。

参考
[1] https://codeaid.jp/blog/gdrive-move/

Python学習コースⅣで理解が追い付かなかったので
復習しながら学習メモを残します。
同じコードだとつまらないし覚えられないので
大好きな「CLOCK ZERO～終焉の一秒～」のゲームネタを交えながら書いていきます。
ネタバレ注意。

---

クラスを作成する

クラスは「class クラス名:」で定義する
クラス名は大文字で始める

class CZmember:

クラスで何も処理がないときはpassと書く
インデントをそろえる

class CZmember:
  pass

処理がない、つまりはまだ2010年の秋より前ってことでしょうねー。

クラスからインスタンスを生成する

「クラス()」とそのクラスを呼び出すことで新しくインスタンスを生成できる
「変数名=クラス()」で生成したクラスを変数に代入できる

空のクラスを生成

class CZmember:
   pass

cz_member1 = CZmember()

インスタンスに情報を追加
今回はCZメンバーの名前と年齢にしましょう。

class CZmember:
   pass

#インスタンスを作成
cz_member1 = CZmember()

#インスタンスに情報を追加
cz_member1.name = 'Takato'
cz_member1.age  = 12

print(cz_member1.name + 'は' + str(cz_member1.age) + 歳です)

Takatoは12歳です

この「name」や「age」の部分をインスタンス変数という
攻略対象が小学生のゲームってなんなんですかねー。

メンバーもさくっと追加しちゃいましょー

class CZmember:
   pass

cz_member0 = CZmember()
cz_member0.name = 'Nadeshiko'
cz_member0.age  = 12

cz_member1 = CZmember()
cz_member1.name = 'Takato'
cz_member1.age  = 12

cz_member2 = CZmember()
cz_member2.name = 'Riichiro'
cz_member2.age  = 11

メンバー7人いるのにわざわざこんなに書くのめんどくさいな。
なのであとで出てくる項目で追加しましょう。

クラスの中に処理を追加する

（続きは随時更新）

---

「CLOCK ZERO～終焉の一秒～」
Switchでも発売されているゲームでめっちゃ泣けるので
気になる方はぜひプレイしてみてください。

はじめに

前回の失敗から手法を変えてチャットボットの作成を試みました。
今度はうまくいきましたが、ほぼ公式ドキュメント通りの内容なのであまり面白味はありません。

前回の失敗はこちらから
全体のコードはこちらから

作成方法

今回はGoogle Brain チームが提供しているTensor2Tensor(t2t)を使うことにしました。
t2tは既に用意されているデータセットで学習するだけならコードを書くことなく(コマンドのみ)実行できる手軽さが特徴です。
自前のデータセットを実行する際にも、ほぼ公式ドキュメントに書かれている数行のコードと形式の整ったデータセットさえあれば実行できるので非常に楽です。

今回は前回作成した名大会話コーパスから抽出したinput_corpus.txtとoutput_corpus.txtをデータセットとして学習・推論をさせてみます。実行環境はGoogle Colabです。

なお公式ドキュメント¹やこちら²、こちら³などの内容に沿って進めます。

データセットの準備

上記参考ページの通りに進めますと必要なことは以下の二つです。

• データセットを参照するためのコード(myproblem.py)
• myproblem.pyをt2tに認識させるためのコード(__init__.py)

作り方の詳細については参考ページにお任せします。とりあえずコードだけ載せておきます

myproblem.py

from tensor2tensor.data_generators import problem
from tensor2tensor.data_generators import text_problems
from tensor2tensor.utils import registry


@registry.register_problem
class chat_bot(text_problems.Text2TextProblem):
    @property
    def approx_vocab_size(self):
        return 2**13

    @property
    def is_generate_per_split(self):
        return False

    @property
    def dataset_splits(self):
        return [{
            "split": problem.DatasetSplit.TRAIN,
            "shards": 9,
        }, {
            "split": problem.DatasetSplit.EVAL,
            "shards": 1,
        }]

    def generate_samples(self, data_dir, tmp_dir, dataset_split):
        filename_input = '/content/drive/My Drive/Colab Notebooks/input_corpus.txt'
        filename_output = '/content/drive/My Drive/Colab Notebooks/output_corpus.txt'

        with open(filename_input) as f_in, open(filename_output) as f_out:
            for src, tgt in zip(f_in, f_out):
                src = src.strip()
                tgt = tgt.strip()
                if not src or not tgt:
                    continue
                yield {'inputs': src, 'targets': tgt}

公式ドキュメントから変更した点はクラス名とgenerate_samples関数の必要箇所になります。
なおクラス名はキャメルケースで書くのが通例ですが、なぜかこのあとのことを考慮するとスネークケースで書かざるを得ませんでした。本来ならキャメルケースでも動くはずですなのが、ちょっと謎です。

__init__.py

from . import myproblem

こちらについては上記の内容のみを書いてmyproblem.pyと同じディレクトリに置けばOKです。

データの前処理

t2tはデータの前処理もほぼ自動でやってくれます。便利ですね。(下記コードはnotebook形式から.py形式に変換しています)

ChatBot_with_t2t.py

#Tensorflowのバージョンを1,xにする
"""

# Commented out IPython magic to ensure Python compatibility.
# %tensorflow_version 1.x

"""#機械学習モデル(Transformer)をインストールする"""

!pip install tensor2tensor

"""#Google Driveのマウント"""

from google.colab import drive
drive.mount('/content/drive')

"""#作業ディレクトリの変更"""

cd /content/drive/My Drive/Colab Notebooks

"""#学習データの前処理"""

!t2t-datagen \
  --data_dir=. \
  --tmp_dir=./t2t \
  --problem=chat_bot \
  --t2t_usr_dir=./t2t

今回はmyproblem.pyと__init__.pyをChatBot_with_t2t.ipynbの一階層下にあるt2tディレクトリに置きます。また、今回はinput_corpus.txtとoutput_corpus.txtは.ipynbと同じディレクトリに置きましたが、実行後に生成されるファイルがあるため、別フォルダに保存しておいたほうが良いかもしれません。

なお、コマンドラインオプションのproblem=にはmyproblem.pyで変更したクラス名(本来ならキャメルケースからスネークケースに自動変換されるがうまくいきませんでした)を指定します。

学習させる

ChatBot_with_t2t.py

"""#学習の実行"""

!t2t-trainer \
  --data_dir=/content/drive/My\ Drive/Colab\ Notebooks \
  --problem=chat_bot \
  --model=transformer \
  --hparams_set=transformer_base_single_gpu \
  --output_dir=/content/drive/My\ Drive/Colab\ Notebooks/t2t \
  --t2t_usr_dir=/content/drive/My\ Drive/Colab\ Notebooks/t2t

前処理は相対パスでディレクトリを指定しましたが、絶対パスでの記述ももちろん可能です。
今回はパス内に空白を含むので\でエスケープしました。
今回も学習モデルはtransformerで行います。今回の学習には大体3時間~4時間かかりました。
なお、90分制限をクリアするためにChorme拡張機能で自動再読み込みさせています。

ひとつ注意すべき点がありまして、学習を実行すると中間生成物が多く作られます。自環境だとGoogle Drive内のゴミ箱が一杯になってしまい、実行途中に空にする必要に迫られました。
まだ実行後に生成される学習ファイルも結構容量を食うので、必要がなくなったら都度削除する必要があるかもしれません。

推論させる

ChatBot_with_t2t.py

"""#推論する"""

!t2t-decoder \
   --data_dir=./ \
   --problem=chat_bot \
   --model=transformer \
   --hparams_set=transformer_base_single_gpu \
   --output_dir=./t2t \
   --decode_hparams="beam_size=4,alpha=0.6" \
   --decode_interactive=true \
   --t2t_usr_dir=./t2t

上記コマンドで対話的に実行させることができます。

実行結果

decodeコマンドを打つとボットと会話できます。以下、入力と出力内容の抜粋です。

入力：こんにちは
出力：っていう意味なの？

入力：いやおはようって言ってるでしょ
出力：大丈夫。

入力：なにが大丈夫なんだよ(笑)
出力：うん。

入力：うんちゃうわ
出力：性格？

入力：そういう性格です
出力：うーん、そうなんですよ。

入力：納得したわ
出力：テレフォン、テレフォンカード、ふつう、ありがとうっていうお礼にね、あげるのはあたりまえよね。

入力：突然暴れだしたぞ
出力：＜笑い＞突き刺したら、お前。

入力：えっいきなり怖っ
出力：怖いじゃん。

入力：もうやめさしてもらうわ
出力：さしぶりってなんだよー。

最後にqと入力すれば対話モードを終了させることができます。

不自然さは拭えないうえにたまに暴走することもありますが、概ね上手くいっているのではないでしょうか
今回のデータセットは砕けた会話が中心のものなので、堅苦しい文章などは難しいかもしれません。

まとめ

前回は大いに失敗しましたが、今回はt2tを使うことで雑談チャットボットを作ることができました。
会話というより質問に対して応答しているだけではありますが、ある程度はうまくいっていると思います。

チャットボットを簡単に作れますし、ほかの機械学習タスクにも対応しているので皆さんが作りたいものも簡単に作れるかもしれません。

参考文献

---

1. 公式ドキュメント 自前データセットの作り方 ↩

2. おいでませ！Chatbot whywaitaくん！ ↩

3. tensor2tensorで和英翻訳 ↩

リストの中に特定の要素がいくつあるかを数える

リストの要素に、ある要素がいくつあるかを数えたいとき、count()が使えます。
また、これは文字列に対しても使えます。

count()

l = [1, 2, 2, 3, 3, 3]
print(l.count(2)) 

# 出力結果: 2

s = 'hello world!'
print(s.count('o'))

# 出力結果: 2

その他

l = [1, 2, 2, 3, 3, 3]
print(len([a for a in l if a == 2]))  # 2

l = [1, 2, 2, 3, 3, 3]
print(sum([a == 2 for a in l]))  # 2

条件にあてはまる要素の数え上げにはこちらで対応できます。

はじめに

これは自然言語処理の機械学習を初めてやってみたら躓いた話。製作までの過程を適当に書き記しておきます。
記事投稿時点では上手くいっていないので反面教師ぐらいにしかならないでしょう。
うまくできる方法を知りたい方はこちらをご覧ください。

著者のスペック

• 大学(正しくは高専専攻科)在学に画像処理と機械学習(多層パーセプトロン)を使った研究をしていた
• 機械学習の知識はほぼ独学に近い(授業での経験は皆無、ほぼ研究活動時の自学自習のみ)
• 機械学習をお仕事にしたくて求職中
• 自然言語処理の経験は皆無、知識もあまりない

そんなペーペーエンジニア見習いの記事になります。あまり参考になりそうにないなと思ったらブラウザバックをおすすめします。

自然言語処理界隈の機械学習を調べる

元々機械学習そのものには触れていた私。しかしながら、自然言語処理の経験は全くないのでとりあえず情報や知見を収集することにした。

最初に飛び込んできたのはgoogleのBERTがすごいということ。なのでその構造や学習の仕組みなども調べてみたが全くの「？？？？？？？」状態であった。

とにかくBERTがすごいらしい。ならそれを使ってなにか作ってみようと思うに至り、チャットボットを作ろうと思った。

後発のXLNetやALBERTを使ってみようかとも検討した。ただ自分向けに改造がしやすそうなものはBERTを含め無かった。

特にGoogleが非公式に提供しているGithubのBERTリポジトリ、文章分類などは簡単にできそうだったがそれ以外の想定していなそうなタスクをするにはハードルが高そうだった。そのため別の方策を探した。

第1章 2節 右も左もわからないがとりあえずチャットボットを作ってみよう

色々調べてみてtransformerで日英翻訳をやっている方やtransformerでチャットボットを作っている方に行き着いた。

じゃあtransformerでチャットボットを作ってみればいいのでは？と考えついたので、それを実践してみることにした。

今回使用した材料はこちら

• 日本語自然会話書き起こしコーパス(旧名大会話コーパス)
  • コーパスのデータ整形ツール
• sentencepiece
• keras向けのtrasnformerラッパー

下準備

それでは作り方に移ります。
今回はGoogle colab上で実行するので、notebook形式を前提とします。
コードの全文はこちらから

まずtransformerのインストールから

!pip install keras-transformer

続いてトーカナイザーとして使うsentencepieceのインストール

!pip install sentencepiece

ここでGoogleドライブをマウントしておきます(やり方は略)

続いてコーパスをダウンロードして、整形していきます。

!git clone https://github.com/knok/make-meidai-dialogue.git

リポジトリのあるディレクトリに移動します。

cd "/content/drive/My Drive/Colab Notebooks/make-meidai-dialogue"

makefileを実行して

!make all

元のディレクトリに戻ります。

cd "/content/drive/My Drive/Colab Notebooks"

コーパスをダウンロードしてmakefileを実行するとsequence.txtが生成されます。
この中には
input:~~~~
output:~~~~
の形式で会話文が書かれているので、今後使いやすいように整形していきます。

input_corpus = []
output_corpus = []
for_spm_corpus = []
with open('/content/drive/My Drive/Colab Notebooks/make-meidai-dialogue/sequence.txt') as f:
  for s_line in f:

    if s_line.startswith('input: '):
      input_corpus.append(s_line[6:])
      for_spm_corpus.append(s_line[6:])

    elif s_line.startswith('output: '):
      output_corpus.append(s_line[7:])
      for_spm_corpus.append(s_line[7:])

with open('/content/drive/My Drive/Colab Notebooks/input_corpus.txt', 'w') as f:
  f.writelines(input_corpus)

with open('/content/drive/My Drive/Colab Notebooks/output_corpus.txt', 'w') as f:
  f.writelines(output_corpus)

with open('/content/drive/My Drive/Colab Notebooks/spm_corpus.txt', 'w') as f:
  f.writelines(for_spm_corpus)

transformerに入力するためのテキストと出力用テキスト、sentencepieceに学習させるためにinput:とoutput:部分を除した学習用テキストに分割しました。

前準備

続いてsentencepieceで会話文を分かち書きにします。
spm_corpus.txtを使って学習させてみましょう。

import sentencepiece as spm

# train sentence piece
spm.SentencePieceTrainer.Train("--input=spm_corpus.txt --model_prefix=trained_model --vocab_size=8000 --bos_id=1 --eos_id=2 --pad_id=0 --unk_id=5")

詳細はsentencepieceの公式リポジトリにやり方が書かれているので省略します。

それでは一度sentencepieceで文章を分かち書きしてみます。

sp = spm.SentencePieceProcessor()
sp.Load("trained_model.model")

#test
print(sp.EncodeAsPieces("ああそういうことね"))
print(sp.EncodeAsPieces("なるほどわかった"))
print(sp.EncodeAsPieces("つまり、そのあなたの言いたいことはそういうことですか？"))
print(sp.DecodeIds([0,1,2,3,4,5]))

実行結果です。

['▁ああ', 'そういうこと', 'ね']
['▁なるほど', 'わかった']
['▁', 'つまり', '、', 'その', 'あなた', 'の', '言い', 'たい', 'ことは', 'そういうこと', 'ですか', '?']
、。 ⁇ 

以上のように分割されることがわかりました。

ここからの内容はKeras TransformerのREADME.mdに書かれている内容を一部改変したものになります。

それではパディングとtransformerに適した形式にコーパスを整形させていきます。

import numpy as np

# Generate toy data
encoder_inputs_no_padding = []
encoder_inputs, decoder_inputs, decoder_outputs = [], [], []
max_token_size = 168

with open('/content/drive/My Drive/Colab Notebooks/input_corpus.txt') as input_tokens, open('/content/drive/My Drive/Colab Notebooks/output_corpus.txt') as output_tokens:
  #コーパスから一行ずつ読み込む
  input_tokens = input_tokens.readlines()
  output_tokens = output_tokens.readlines()

  for input_token, output_token in zip(input_tokens, output_tokens):
    if input_token or output_token:
      encode_tokens, decode_tokens = sp.EncodeAsPieces(input_token), sp.EncodeAsPieces(output_token)
      #パディングする
      encode_tokens = ['<s>'] + encode_tokens + ['</s>'] + ['<pad>'] * (max_token_size - len(encode_tokens))
      output_tokens = decode_tokens + ['</s>', '<pad>'] + ['<pad>'] * (max_token_size - len(decode_tokens))
      decode_tokens = ['<s>'] + decode_tokens + ['</s>']  + ['<pad>'] * (max_token_size - len(decode_tokens))


      encode_tokens = list(map(lambda x: sp.piece_to_id(x), encode_tokens))
      decode_tokens = list(map(lambda x: sp.piece_to_id(x), decode_tokens))
      output_tokens = list(map(lambda x: [sp.piece_to_id(x)], output_tokens))

      encoder_inputs_no_padding.append(input_token)
      encoder_inputs.append(encode_tokens)
      decoder_inputs.append(decode_tokens)
      decoder_outputs.append(output_tokens)
    else:
      break

#学習モデルへの入力用に変換する
X = [np.asarray(encoder_inputs), np.asarray(decoder_inputs)]
Y = np.asarray(decoder_outputs)

学習させる

それではtransformerに学習させていきます。

from keras_transformer import get_model

# Build the model
model = get_model(
    token_num=sp.GetPieceSize(),
    embed_dim=32,
    encoder_num=2,
    decoder_num=2,
    head_num=4,
    hidden_dim=128,
    dropout_rate=0.05,
    use_same_embed=True,  # Use different embeddings for different languages
)

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
)
model.summary()

# Train the model
model.fit(
    x=X,
    y=Y,
    epochs=10,
    batch_size=32,
)

実行結果です。

Epoch 1/10
33361/33361 [==============================] - 68s 2ms/step - loss: 0.2818
Epoch 2/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2410
Epoch 3/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2331
Epoch 4/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2274
Epoch 5/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2230
Epoch 6/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2193
Epoch 7/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2163
Epoch 8/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2137
Epoch 9/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2114
Epoch 10/10
33361/33361 [==============================] - 66s 2ms/step - loss: 0.2094

損失は悪くなさそうですね。

推論させる

学習したモデルで推論を行ってみます。

from keras_transformer import decode

input = "今日はいい天気ですね"
encode = sp.EncodeAsIds(input)

decoded = decode(
    model,
    encode,
    start_token=sp.bos_id(),
    end_token=sp.eos_id(),
    pad_token=sp.pad_id(),
    max_len=170
)

decoded = np.array(decoded,dtype=int)
decoded = decoded.tolist()
print(sp.decode(decoded))

実行結果です。

ね、でも、あの、あの、あの、あの、あの、あの、あの、あの、あの、あの

あれ…全然結果が芳しくありません。これじゃコミュ障です。

ここまでの考察

うまくいかなかった原因はなんでしょうか？

• 一文の長さが長すぎてうまく学習できていない？
• コーパスが足りない(今回は質問と回答それぞれ3万文ずつ)
• パラメータの設定がよくない

などが最初にあげられるでしょうか？

モデルの性能改善に向けて

そこでOptunaを使ってチューニングをしようと試みましたが次の理由でうまくいきませんでした。

• チューニングにかかる時間が長すぎる(最後までやっていませんが1日は余裕でかかりそう)
• 上記の理由からColabでの実行は難しい(12時間制限に引っかかるため)
• Colabではできないので自分のPC内の環境で試す(GPUは使えない)がもっと時間がかかるので断念
• ではクラウド上ではやるかと考えAWSを試すもGPU付きインスタンスの作成が許可されない(次記事の方法を試している間に許可されましたが…)
• そもそも途中までやってみた結果もあまり芳しくない(ほぼ精度に変化なしか)

ということで別の方法を試すことにしました。
うまくいった方法はこちら

個人的な備忘録として残します。
手早くファイルを得られるよう、なるべく簡潔に書きたいと思います。

完成予想図

Wikipediaのリダイレクトを収集して以下のようなファイルを作ります。

redirects.json

{"src": "COVID-19", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "COVID-2019", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "Covid-19", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "Covid-2019", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "新型コロナウイルス感染症", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "コビッド19", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "COVID19", "dst": "新型コロナウイルス感染症_(2019年)"}
{"src": "2019新型コロナウイルス感染症", "dst": "新型コロナウイルス感染症_(2019年)"}

リダイレクトとは

以下参照
Wikipedia:リダイレクト

リダイレクト例

https://ja.wikipedia.org/wiki/COVID-19 にアクセスしようとすると、
自動的にhttps://ja.wikipedia.org/wiki/新型コロナウイルス感染症_(2019年) に飛ばされます。

実装等

0. 必要な色々

• MySQL
• Python3
  • mysqlclient
    pip install mysqlclient

1. Wikidumpのリストア

必要データのダウンロード

以下から必要なデータをダウンロードしてください。

https://dumps.wikimedia.org/jawiki/

• jawiki-[dump取得日]-redirect.sql.gz
• jawiki-[dump取得日]-page.sql.gz

解凍

$ gunzip jawiki-[dump取得日]-redirect.sql.gz
$ gunzip jawiki-[dump取得日]-page.sql.gz

MySQLデータベースへリストア

$ mysql -u [ユーザー名] -p [DB名] < jawiki-[dump取得日]-page.sql
$ mysql -u [ユーザー名] -p [DB名] < jawiki-[dump取得日]-redirect.sql

2. リダイレクト抽出

Pythonコード

データベースを叩いてリダイレクトを抽出しJSONで保存するコードです。

extract_redirects.py

import json
import MySQLdb

USERNAME = "[MySQLユーザー名]"
PASSWORD = "[パスワード]"
DB_NAME = "[DB名]"
OUTPUT = "./redirects.json"

def save_jsonl(file_path, data):
    json_dumps = lambda d:json.dumps(d, ensure_ascii=False)
    dumps = map(json_dumps, data)
    with open(file_path, "w") as f:
        f.write("\n".join(dumps))

if __name__ == '__main__':
    # データベースに接続
    conn = MySQLdb.connect(
        user=USERNAME,
        passwd=PASSWORD,
        host='localhost',
        db=DB_NAME
    )

    # Cursorを作成しクエリを実行
    cur = conn.cursor(MySQLdb.cursors.DictCursor)
    sql = "select page.page_title, redirect.rd_title from page, redirect where redirect.rd_from=page.page_id"
    cur.execute(sql)
    rows = cur.fetchall()

    # 実行結果を整理
    redirects = []
    for row in rows:
        row = {key:cell.decode() if type(cell) is bytes else cell for key, cell in row.items()}
        redirects.append({
            "src":row["page_title"],
            "dst":row["rd_title"]
        })

    # 保存
    save_jsonl(OUTPUT, redirects)

    cur.close()
    conn.close()

実行

python extract_redirects.py

以上です!

α. 軽い解説等

※事前知識:Wikipediaのページにはtitleの他にpage_idが個別に割り振られています。

jawiki-[dump取得日]-redirect.sql.gzでは、リダイレクト元のpage_idとリダイレクト先のtitleがレコードで紐づけられています。
jawiki-[dump取得日]-page.sql.gzでは、page_idとtitleがレコードで紐づけられています。

この2つのダンプを組み合わせることで、リダイレクト元titleとリダイレクト先titleを紐づけています。

特定の事柄に対して値を持たせる場合に、定数って使いたいじゃないですか。
Pythonで定数を扱う場合って個人的にはEnum（列挙型）を使うのがいいと思うんです。

そもそもPythonって定数なくない？

そうなんです。
どんな値でもやりようによっては上書きできてしまうので、厳密な意味での定数は存在しません。
でも公式ドキュメント にそう書いてあるんだもん。

列挙型の記法

from enum import Enum
class Hoge(Enum):
    ONE = 1
    TWO = 2
    THREE = 3

列挙型とループ処理

列挙型は識別子の集合なので、識別子に持たせた値そのものに意味があるケースが少ないのではないかなと。
リスト型であればfor文で簡単に出力できるのですが、列挙型では書き方に工夫が要ります。

リスト型

>>> lst = [1, 2, 3]
>>> [l for l in lst]
[1, 2, 3]

列挙型

>>> from enum import Enum
>>> class Hoge(Enum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
...
>>> [v.value for n, v in Hoge.__members__.items()]
[1, 2, 3]

ここまで来れば書けそう

>>> from enum import Enum
>>> class Hoge(Enum):
...     ONE = 1
...     TWO = 2
...     THREE = 3
...
>>> [v.value for n, v in Hoge.__members__.items()]
[1, 2, 3]
>>> 1 in [v.value for n, v in Hoge.__members__.items()]
True

できました。使い所は知りません。

おまけ

列挙型の__members__の中身ってどうなっているんだろう？

>>> Hoge.__members__
mappingproxy({
    'ONE': <Hoge.ONE: 1>,
    'TWO': <Hoge.TWO: 2>,
    'THREE': <Hoge.THREE: 3>
})

MappingProxyTypeってなんだろう？
公式ドキュメントによると

読み出し専用のマッピングのプロキシです。マッピングのエントリーに関する動的なビューを提供します。
つまり、マッピングが変わった場合にビューがこれらの変更を反映するということです。

なるほど（？）
このプロキシの中にitems()があるわけですね。
さらっと見た感じだと辞書型にも似てますね。

追記

@shiracamus様よりもっと簡素的な書き方があると教えていただきました。

>>> 1 in [e.value for e in Hoge]
True

あるいは

>>> any(e.value == 1 for e in Hoge)
True

と書けるようです。ありがとうございます！！
一つ目の方はなぜ気付かなかったのだろうかというレベルです・・・

記事を書くことでアドバイスをいただけるので、やはりアウトプットって大切だなぁと思いました。

はじめに

もっといい方法はないだろうか..と模索しつつも、ひとまずこの方法でまとめておく。（もっといい方法ご存知の方、教えてください！！）

やりたいこと

①基本
下図のように３次元の座標点が格納されているエクセルがあり、同じ座標を持つ番号をリンクさせたい。下図の例ではS/N-2の座標とS/N-3の座標（水色でハイライトした箇所）は完全一致しているので、これらは「同じ座標です！」と判定させる。

②応用
私が今回取り組んでいる対象の仕様として、完全に座標が一致することはなかなか起こらない。そのため、ある程度のMarginをもって一致していると判定したい。例えば、S/N-8の座標とS/N-9の座標（黄色でハイライトした箇所）は概ね一致しているので、これらも「同じ座標です」と判定して欲しい。

今回、この”応用”のグッドアイデアが今一つ思い浮かばなかった。。
完全一致のみを抽出する場合はX座標、Y座標、Ｚ座標を文字列として結合して、一致するか判断していけばいいのかなと思いました。

できたコードがこのような感じ

まずはmarginを含んで判定できるような関数を作成。以下の場合誤差±100は無視され、３つの座標がmargin込みで一致した場合、Trueが返ります。

def coordinates_check(ax,ay,az,bx,by,bz):
    margin=100
    flag = 0
    result=False

    if ax-margin < bx < ax+margin:
        flag = flag +1
    if ay-margin < by < ay+margin:
        flag = flag +1
    if az-margin < bz < az+margin:
        flag = flag +1

    if flag >2:
        result = True

    return result

この関数を使用して、エクセルファイルの行を上から読み取っていきます。
読み取りが重複しないように、２つ目のfor文の開始番号を工夫しています。

df_test = pd.read_excel('sample.xlsx')

for i in range(len(df_test)):
    ax= df_test.loc[i,"X座標"]
    ay= df_test.loc[i,"Y座標"]
    az= df_test.loc[i,"Z座標"]
    k = i+1
    for j in range(k,len(df_test)):
        bx = df_test.loc[j,"X座標"]
        by = df_test.loc[j,"Y座標"]
        bz = df_test.loc[j,"Z座標"]
        if coordinates_check(ax,ay,az,bx,by,bz):
            print("一致しました：",df_test.loc[i,"S/N"],"-->",df_test.loc[j,"S/N"])

結果、うまくできている。

少ないデータならいいのだけど..

私が今回使いたいデータは1万行超えで、上記のコードを実行すると３時間くらいかかってしまったんですよね..。もっといい方法があるはずだよなぁと思った今日この頃でした。いい方法をご存知の方、助けてください！

スマホで書類を撮影して使うことが多くなった。手軽だけどスキャナで取り込んだものより鮮明さに欠ける。スマホで撮影したようなコントラストの鈍い画像を読みやすくするには、文字を黒く残したまま背景の明度を上げるのがいいだろう。背景を白く飛ばす処理の都合で、画像の文字部分とただの白地部分を区別する必要がでてきたが、画像の局所ごとの画素の統計をとり画素値の標準偏差の大小で判定するとうまくいった。

例として次の画像を加工して行くことにする。各画像をクリックすると拡大して見ることができるはず。

波田野 直樹 著「多良間島幻視行」p.36

ヒストグラム平坦化

画像の鮮明化をするときによく行われるのはヒストグラムの平坦化処理である。画像の画素の明度が狭い範囲に収まっているとき、それを画像フォーマットのレンジ全体、グレースケール画像なら0～255の範囲に広げてやれば、画素同士の違いが大きくなり画像がはっきりする。OpenCVには専用の関数が用意されており、以下のリンク先に詳しい説明がある。
OpenCVでのヒストグラム>ヒストグラム その2: ヒストグラム平坦化
これを利用して元画像をグレースケール化してからヒストグラム平坦化したのが以下の画像である。プログラムとともに示す。

 bookimg = cv2.imread('tarama36p.jpg')
 img_gray = cv2.cvtColor(bookimg, cv2.COLOR_BGR2GRAY)

 equ = cv2.equalizeHist(img_gray)
 cv2.imwrite('tarama36pcv2.jpg', equ )

結果は特に文字が鮮明になった感じはしない。元画像では分からなかったが、左より右ページの方が明るいようだ。上部の金属片の反射が強調されている。実はこの画像のヒストグラムは以下のようになっていて、赤線が画素の明るさの最大最小値を表しているが、既に最大最小値が画像レンジいっぱいまで広がっているので、単純なヒストグラム平坦化の効果は少ない。

OpenCVには適用的ヒストグラム平坦化という、画像を細かいブロックに分けブロックごとにヒストグラム平坦化するという関数も用意されている。それによる処理結果が以下の画像である。

 bookimg = cv2.imread('tarama36p.jpg')
 img_gray = cv2.cvtColor(bookimg, cv2.COLOR_BGR2GRAY)

 equ = cv2.equalizeHist(img_gray)
 cv2.imwrite('tarama36pcv2.jpg', equ )

cv2.equalizeHist()よりは見やすくなったがスキャナほどではない。

白画素をすべて真っ白に

汎用のコントラスト強化処理は、白い部分の画素値の違いもある程度残そうとする。テキスト画像の場合、背景白地の細かな情報は不要なので、ある閾値より上の画素はは全部真っ白、画素値としてすべて255に書き換えてもいいだろう。黒い方は文字形状の情報が入っているので、元の画素値に1より小さい値をかけて、値としては黒い方に寄せるが元の傾向は残すようにした。閾値はヒストグラムの中央値あたりの値から、仮に140としてみた。プログラムと処理結果は以下のとおり。

    for y in range(img_gray.shape[0]):
         for x in range(img_gray.shape[1]):
             if img_gray[y][x] > 140:
                 img_gray[y][x] = 255
             else:
                 img_gray[y][x] = img_gray[y][x] * 0.5

    cv2.imwrite('tarama36p140.jpg', img_gray )

右側は狙い通り背景が白くつぶれ文字がクッキリとした。金属片の余計な映り込みも消えている。しかしながら左下は全体として暗めだったので、背景部分まで黒と認識されて強調されてしまった。かといって左下に閾値を合わせると、今度は右側で文字部分が白く飛んでしまう。つまり適切な閾値は画像の場所によって違う。

画像をブロックに分けて処理する

適用的ヒストグラム平坦化同様、元画像を縦横64ドットのブロックに分け、それぞれ適切な閾値を求め処理する。閾値をどう決めるかが重要だが、ここでは閾値の値は各ブロックの画素の中央値の下半分のさらに中央値、つまりブロック画素全体の1/4を黒とみなすような値とした。ブロック画像imgを引数として閾値を返す関数をPythonで書くと、以下のようになる。使ってみると大雑把だがまあまあ適切な値を返してくれるようだ。ただし黒字に白のテキストだとうまくいかないだろう。

 import numpy as np
 def getBWThrsh(img):
     med = np.median(img)
     fild = img[img < med]
     return np.median(fild) 

処理した結果が以下の画像である。なお、各ブロックごとにヒストグラム平均化処理も合わせて行い、白く飛ばすところは単純に255を代入するのではなく、元の画素に大多数の背景が256を越えるような係数をかけて代入している。ほとんどは白く飛ばすが、それよりちょっと暗い文字の部分は残すためだ。

文字部分はうまく背景が白く抜けているが、改行して文字のないただの白地の部分は、薄っすらと裏のページの文字が透けている。拡大したのが以下の画像である。

裏ページが透けた部分には非常に微かな濃淡の差しかないが、ヒストグラム平均化処理をすることで、見事に裏文字が浮き上がってきたわけである。

文字と白地の区別をつける

裏ページが透けるので白地部分はヒストグラム平均化処理をしないようにしたい。文字部分と白地部分を見分けるにはどうすればいいだろうか。これまでブロックごとにnumpyで統計処理を行い画素の中央値などを求めてきたが、文字と白地の区別に画素値の標準偏差が使えるのではないかと思いついた。白地は画素値のバラツキが少なく標準偏差が小さい、文字部分はそれより大きい値になるだろう。ともかく各ブロックの画素の標準偏差を求め、どういう値が多いのかヒストグラムを作成して傾向を調べてみた。

左側の小さい値に突出してピークになっているところがあるが、これか白地のブロックだろう。このピークを含むような値に標準偏差の閾値を設定すれば白地を判定できる。閾値をあまり小さくすると白地のゴミが残るし、大きくすると白地に小さい文字の一部が含まれていても白地とみなされて欠けてしまうので、適切な閾値を設定するのは実は難しいのだが、ともかくこれで文字と白地の区別をつけ、白地は完全に白く飛ばす処理を行ったのが以下の画像である。

周辺のテキストでないところに、いろいろとゴミが残ったが、テキスト部分は綺麗に処理できたと思う。ブロック単位で白地とそうでない部分の区別がつくようになったので、白地ブロックが連続していると周りの余白部分であるとか、余白部にぽつりと文字が入ってるとノンブルだろうとか、いろいろな判定に応用ができるような気がする。

以上のソースは以下のとおり。一番下の行にあるsharpenImg()の引数に変換したいファイル名を書くと背景を白飛びさせたファイルを作成する。今のところ変換に数十秒の時間がかかるが、Cなどで書き換えれば実用な処理速度になると思う。

import cv2
from matplotlib import pyplot as plt
import numpy as np

def getStdThrsh(img, Blocksize):
    stds = []
    for y in range( 0, img.shape[0], Blocksize ):
        for x in range( 0, img.shape[0], Blocksize ):
            pimg = img[y:y+Blocksize, x:x+Blocksize]
            std = np.std( pimg )
            minv = np.min( pimg )
            maxv = np.max( pimg )
            stds.append(std)

    hist = np.histogram( stds, bins=64 )
    peaki = np.argmax(hist[0])   

    #plt.hist( stds, bins=64 )
    #plt.show()

    slim = 6.0
    for n in range(peaki,len(hist[0])-1):
        if hist[0][n] < hist[0][n+1]:
            slim = hist[1][n+1]
            break

    if slim > 6.0:
        slim = 6.0

    return slim

def getBWThrsh(img):
    med = np.median(img)
    fild = img[img < med]
    return np.median(fild)

def getWbias( img, bwthr ):
    wimg = img[ img > bwthr ]
    hist = np.histogram( wimg, bins=16 )
    agm = np.argmax(hist[0])
    return hist[1][agm]

def getOutputName( title, slim ):
    return title + "_s{:04.2f}.jpg".format( slim )

def sharpenImg(imgfile):
    Testimagefile = imgfile
    TestimageTitle = Testimagefile.split('.')[0]
    Blocksize = 64
    Bbias = 0.2

    bookimg = cv2.imread( Testimagefile )
    img_gray = cv2.cvtColor(bookimg, cv2.COLOR_BGR2GRAY)

    slim = getStdThrsh(img_gray, Blocksize)

    for y in range( 0, img_gray.shape[0], Blocksize ):
        s = ""
        for x in range( 0, img_gray.shape[1], Blocksize ):
            pimg = img_gray[y:y+Blocksize, x:x+Blocksize]
            std = np.std( pimg )
            minv = np.min( pimg )
            maxv = np.max( pimg )
            pimg -= minv

            cimg = pimg.copy()
            if maxv != minv:
                for sy in range (cimg.shape[0]):
                    for sx in range( cimg.shape[1] ):
                        cimg[sy][sx] = (cimg[sy][sx]*255.0)/(maxv - minv)

            bwthrsh = getBWThrsh( pimg )
            wb = getWbias( cimg, bwthrsh )
            wbias = 256 / wb

            if std < slim:
                s = s + "B"
                for sy in range (pimg.shape[0]):
                    for sx in range( pimg.shape[1] ):
                        img_gray[y+sy][x+sx] = 255
            else:
                s = s + "_"
                for sy in range (cimg.shape[0]):
                    for sx in range( cimg.shape[1] ):
                        if maxv != minv:
                            img_gray[y+sy][x+sx] = (img_gray[y+sy][x+sx]*255.0)/(maxv - minv)
                        if pimg[sy][sx] > bwthrsh:
                            v = img_gray[y+sy][x+sx]
                            v = v * wbias
                            if v > 255:
                                v = 255
                            img_gray[y+sy][x+sx] = v
                        else:
                            img_gray[y+sy][x+sx] = pimg[sy][sx] * Bbias
        print( "{:4d} {:s}".format( y, s ) )

    cv2.imwrite(getOutputName(TestimageTitle, slim), img_gray )

if __name__ =='__main__':
    sharpenImg('tarama36p.jpg')

https://github.com/pie-xx/TextImageViewer