こんばんは、@0yanです。
先日、別の部署の課長から「毎月第1営業日に、Eラーニングの研修受講履歴を送って欲しいのだけど」と依頼を受け、「忘れそうだな・・・」と思ったため、早速、Seleniumで研修受講履歴をダウンロード＆Gmail送信するコードを書き、Windows上で自動実行することにしました（サーバを自由にたてる権限はないため）。
以下、WindowsでPythonファイルを自動実行するための備忘録です。

流れ

1.pythonファイルを作成する
2.batファイルを作成する
3.タスクスケジューラに登録する

batファイルを作成する

任意の場所にbatファイルを作成します。例えば、
- PC123というユーザー名で、PycharmProjects直下のtest.pyを自動実行したい
- Anaconda3フォルダ直下にpython.exeがある
という場合、以下のように記述します。
※batファイルでコメントアウトする際は、シングルクオーテーションを先頭につけます。

test.bat

'実行したいファイルが格納されているディレクトリの絶対パス
cd C:\Users\PC123\PycharmProjects

'python.exeの絶対パス 実行したいファイル名
C:\Users\PC123\Anaconda3\python.exe test.py

タスクスケジューラに登録する

@Richard_Roe さんの記事が分かり易かったので、そちらに譲ります。
（参考になりました。ありがとうございました！）

Windowsでbatファイルを自動実行したい時（タスクスケジューラの設定）

目的

https://dailyportalz.jp/kiji/shibuya-nobodify
ここの記事のプログラムを実装してみよう

準備

pythonで実装しようと思うので、anacondaにopencv3をインストール

アルゴリズム

定点撮影した写真を準備する。この写真を順番に読みだして、前のn個の写真と画素ごとに比較してもっとも頻度の高い画素に置き換える。
置き換え方法としては、平均、中央値、最頻などが考えられたが中央値を採用する

プログラム

激重プログラムなのでもっと改善が必要ですがなんとか動いたものができた

import cv2
import glob
import statistics
import numpy as np

class PHOTO_REMOVE():
    """description
    写真で背景のみ抽出する
    """
    output_file = "./output.mp4" 
    hist = 10
    is_First = True
    stack_index = 0
    read_img_count = 0
    def __init__(self,param=None):
        """
        初期化
        hist  : 背景判定を何フレームで行うか？
        path  : 写真があるフォルダのパス
        """
        if param != None:
            self.hist = param["hist"]
            self.set_photo_file(param["path"])
        else:
            self.set_photo_file("./sample")
        self.set_output_video(self.output_file)

        self.image_stack = [None for _ in range(self.hist)] 
        print(len(self.image_stack))

    def run(self):
        self.read_jpg_files(self.path)

    def main_analize(self,image):
        print("test")

    def set_photo_file(self,name):
        self.is_photo = True
        self.is_video = False
        self.path = glob.glob('{}/*.JPG'.format(name))
        self.file_num = len(self.path)
        #print(self.path)

    def read_jpg_files(self,files):
        self.fill_stack_data(files)
        self.img_height, self.img_width, self.img_channels = cv2.resize(cv2.imread(files[0]),(640,480)).shape[:3]
        print(self.img_height, self.img_width, self.img_channels)
        #for img in cv2.resize(cv2.imread(files[0]),(640,480)):
        #    for rgb in img:
        #        print(rgb)
        for f in files:
            img = cv2.imread(f)
            img = cv2.resize(img, (640,480))
            self.read_img_count = self.read_img_count + 1
            print("FRAME {0}番目".format(self.read_img_count))
            ret_img = self.photo_remove(img)
            cv2.imshow("frame",ret_img)
            self.make_output_video(ret_img)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        cv2.destroyAllWindows()  
        self.output_video.release()

    def set_output_video(self,name):
        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
        self.output_video = cv2.VideoWriter(name,fourcc, 2.0, (640,480))
    def make_output_video(self,img):
        self.output_video.write(img)

    def fill_stack_data(self,files):
        for i in range(self.hist-1):
            self.image_stack[i] = cv2.resize(cv2.imread(files[i]), (640,480))


    def photo_remove(self,img):
        ret_img = img
        self.image_stack[self.stack_index] = img
        if self.stack_index == self.hist-1:
            self.stack_index = 0
        else:
            self.stack_index = self.stack_index + 1

        for h in range(self.img_height-1):
            for w in range(self.img_width-1):
                tmp = []
                for i in range(self.hist-1):
                    tmp.append(np.linalg.norm(self.image_stack[i][h,w]))
                    #tmp.append(self.image_stack[i][h,w])
                median = statistics.median(tmp)
                for i in range(self.hist-1):
                    if median == tmp[i]:
                        ret_img[h,w] = self.image_stack[i][h,w]
                        break

        return ret_img


if __name__ == "__main__":
    test_obj = PHOTO_REMOVE()
    test_obj.run()

追記
中央値を採用するアルゴリズムだとじわじわ消すことはできないので件名に偽りあり。

はじめに

階層的クラスタリングを行うときに迷うのが、どの距離と方法を使うのがよいのかという点です。正解の用意されていないクラスタリングでは、特にです。
今回は、距離と方法ごとにコーフェン相関係数を計算して、クラスタリングの妥当性を調べてみます。この値が１に近いほど良いとされています。（詳しくはこちら）

データの準備

今回は、irisのデータセットを使いました。

# irisのデータセットを得る。
from sklearn import datasets
dataset = datasets.load_iris()
dataset_data = dataset.data
dataset_target = dataset.target
target_names = dataset.target_names
dataset_labels = target_names[dataset_target]

# データの標準化を行う。
from sklearn.preprocessing import scale
data = scale(dataset_data)

コーフェン相関係数の計算

まず、クラスタリングで使いそうな距離や方法をリストアップします。データの形に合うものをいくつか用意します。

METORICS = ['euclidean', 'minkowski', 'cityblock', 'seuclidean',
            'sqeuclidean', 'cosine', 'correlation', 'hamming',
            'jaccard', 'chebyshev', 'canberra', 'braycurtis',
            'mahalanobis']

METHODS = ['single', 'complete', 'average', 'weighted', 
           'centroid', 'median', 'ward']

# minkowski距離に使うノルム。デフォルトだと2で、ユークリッド距離となるので、とりあえず3。
P_NORM = 3

コーフェン相関係数の計算にはscipyのcophenetを使いました。（詳しくはこちら）

# 距離と方法を変えてコーフェン相関係数(CPCC）を計算する。
import itertools
from scipy.spatial.distance import pdist
from scipy.cluster.hierarchy import linkage, cophenet

result = []  
for metric, method in itertools.product(METORICS, METHODS):
    distance_matrix = pdist(X=data, metric=metric, p=P_NORM)
    linkage_matrix = linkage(y=distance_matrix, method=method)
    cpcc, _ = cophenet(linkage_matrix, distance_matrix)
    result.append([metric, method, cpcc])

データ処理のために、pandasのDataframeに計算結果を入れます。コーフェン相関係数が最大となった距離と方法を得ます。

import pandas as pd
cpcc_df = pd.DataFrame(result, columns=['metric', 'method', 'CPCC'])

# コーフェン相関係数が最大である距離と方法を得る
best_metoric = cpcc_df.loc[cpcc_df['CPCC'].idxmax(), 'metric']
best_method = cpcc_df.loc[cpcc_df['CPCC'].idxmax(), 'method']

print ("距離：{0}, 方法：{1} でコーフェン相関係数が最大。".format(best_metoric,best_method))

実行結果は、以下のとおり。

距離：correlation, 方法：average でコーフェン相関係数が最大。

これだけではよくわからないので、seabornのheatmapを使って、全体を見てみました。

# DataFrameを整形。
cpcc_df = cpcc_df.set_index(keys=['metric', 'method']).unstack()
cpcc_df.columns = cpcc_df.columns.droplevel()


# heatmapで表示。
import matplotlib.pyplot as plt
import seaborn as sns

fig, ax = plt.subplots(figsize=(8.5, 8))
ax = sns.heatmap(data=cpcc_df, annot=True)
fig.show()

heatmapを見てみると、方法よりも距離の方がコーフェン相関係数に影響している傾向があります。この傾向は、クラスタリングするデータによって変わってくるかもしれません。

デンドログラムの作図

計算結果から得たベストな距離と方法でデンドログラムを描いて完成です。

# コーフェン相関係数が最大である距離と方法でデンドログラムを描く。
from scipy.cluster.hierarchy import linkage, dendrogram

best_linkage = linkage(y=data, metric=best_metoric, method=best_method)

fig, ax = plt.subplots(figsize=(5,13))
ax = dendrogram(Z=best_linkage,
                orientation='right',
                labels=dataset_labels)
fig.show()

最後に

今回計算したコーフェン相関係数も、これだけで完璧なクラスタリングができるわけではなく、指標の一つでしかありません。複数の指標を使ったクラスタリングを目指して勉強していきたいと思います。最後までお付き合いいただき、ありがとうございました。

$$
\def\bra#1{\mathinner{\left\langle{#1}\right|}}
\def\ket#1{\mathinner{\left|{#1}\right\rangle}}
\def\braket#1#2{\mathinner{\left\langle{#1}\middle|#2\right\rangle}}
$$

はじめに

加算、剰余加算、制御-剰余乗算という具合に見てきましたが、それは「Shorのアルゴリズム」で重要な役割を果たす「べき剰余」を実行するための準備として、という位置づけでした。今回はその「べき剰余」について見ていきます。アルゴリズムを説明した後、自作の量子計算シミュレータqlazyで、動作を確認します。

参考にさせていただいた論文は以下です。

• V. Vedral,A. Barenco,A. Ekert; "Quantum Networks for Elementary Arithmetic Operations" (arXiv:quant-ph/9511018)

べき剰余の実現方法

参考論文に全体の回路図が出ているので、まずそれを掲載します。

$a^x \space mod \space N$という「べき剰余」を実行する回路です(図には$x^a \space mod \space N$と書いてありますが、$a^x \space mod \space N$の間違いではないかと思われます)。

図を見てわかる通り、前回の記事で確認した「制御-剰余乗算(以下CMMと省略)」とスワップ(以下SWAPと表記)とCMMの逆演算(以下iCMMと表記)をセットにして繰り返し適用していくだけなので、考え方はそれほど難しくないです。

説明のため、レジスタに名前をつけます。図の左側の上にxと記載してあるレジスタを<x>、1と記載してあり最終結果が格納されるレジスタを<xx>、一番下の0と記載されている レジスタを<y>と名付けておきます。aを格納するレジスタが記載されていないですが、この量子計算を実現するために外から与えるパラメータのようなもので、あえて言うなら古典レジスタに格納されていると思えば良いと思います。その他、CMMを実現するために必要になるレジスタもありますが、詳細は前回の記事を参照してください。

では、左から順に、レジスタ<xx>とレジスタ<y>の状態変化を表にして示します。状態なのでケット記号を使って$\ket{A}$のように記載すべきなのですが、簡単のため$A$とのみ記載します。また、各段階での計算は$mod \space N$前提で実行しているものと思ってください。xの値によって、各段階のCMMやSWAPやiCMMがONになったりOFFになったりするので、場合分けをして表にしてみました。

• $x=0$ ($x_{0}=0,x_{1}=0$)の場合

レジスタ	初期状態	0番目のCMM	SWAP	0番目のiCMM	1番目のCMM	SWAP	1番目のiCMM
<xx>	$1$	$1$	$1$	$1$	$1$	$1$	$1$
<y>	$0$	$0$	$0$	$0$	$0$	$0$	$0$

• $x=1$ ($x_{0}=1,x_{1}=0$)の場合

レジスタ	初期状態	0番目のCMM	SWAP	0番目のiCMM	1番目のCMM	SWAP	1番目のiCMM
<xx>	$1$	$a$	$1$	$a$	$a$	$a$	$a$
<y>	$0$	$1$	$a$	$0$	$0$	$0$	$0$

• $x=2$ ($x_{0}=0,x_{1}=1$)の場合

レジスタ	初期状態	0番目のCMM	SWAP	0番目のiCMM	1番目のCMM	SWAP	1番目のiCMM
<xx>	$1$	$1$	$1$	$1$	$1$	$a^{2}$	$a^{2}$
<y>	$0$	$0$	$0$	$0$	$a^{2}$	$1$	$0$

• $x=3$ ($x_{0}=1,x_{1}=1$)の場合

レジスタ	初期状態	0番目のCMM	SWAP	0番目のiCMM	1番目のCMM	SWAP	1番目のiCMM
<xx>	$1$	$a$	$1$	$a$	$a$	$a^{3}$	$a^{3}$
<y>	$0$	$1$	$a$	$0$	$a^{3}$	$a$	$0$

というわけで、レジスタ<xx>に$a^{x} \space mod \space N$の値が入ることがわかります。ここで1点注意しておきたいのがSWAPの動作です。回路図のSWAPには制御ビットとつながる線が書かれていませんが、CMM-SWAP-iCMMが一体となって制御ビットとつながっていることを意味しています。つまり、SWAPは厳密に言うと、制御SWAP(正式名称は知りません。フレドキンゲートの拡張みたいですがちょっと違うかな?)です。

さて、"CMM-SWAP-iCMM"のセットを2回繰り返したところまで書けたので、あとはこれを延長すれば、任意のべき剰余が計算できるというわけです。

数式で説明すると、以下のような量子計算を$i=0,1,2,...$と繰り返していると思えば良いです。

\begin{align}
& \ket{a^{2^0 x_0 + 2^1 x_1 + \cdots 2^{i-1} x_{i-1}}, 0} \\
& \rightarrow \ket{a^{2^0 x_0 + 2^1 x_1 + \cdots 2^{i-1} x_{i-1}},a^{2^0 x_0 + 2^1 x_1 + \cdots 2^{i} x_{i}}} \\
& \rightarrow \ket{a^{2^0 x_0 + 2^1 x_1 + \cdots 2^{i} x_{i}},a^{2^0 x_0 + 2^1 x_1 + \cdots 2^{i-1} x_{i-1}}} \\
& \rightarrow \ket{a^{2^0 x_0 + 2^1 x_1 + \cdots 2^{i} x_{i}}, 0}
\end{align}

ここで、1行目から2行目はCMM、2行目から3行目はSWAP、3行目から4行目はiCMMの演算を表しています。これを$n$回繰り返すと、最大で$x=2^{n}-1$までのべき剰余$a^{x} \space mode \space N$が実行できることがわかります。

シミュレータで動作確認

それでは、シミュレータで動作確認をしていくのですが、その前に各レジスタに必要となるビット数を見積もってみます。上の図だけ見ると、とてもシンプルに見えるのですが、CMMやiCMMを実現するためには内部で「剰余加算」を実行していて、「剰余加算」を実行するために内部で「加算」を実行していて、各々を実行するために多くの補助レジスタが必要になります。シミュレータでの実行は限定されたメモリ範囲内でやるしかないため、今回はとても小さい数での動作確認になります。具体的には、$a=2,N=3,x=0,1,2$で動作させることを前提にします。

まず、$a=2$については外部パラメータということで量子レジスタとして割り当てることはしません。$x$については2ビットで十分なので、レジスタ<x>には2ビットを割り当てます。レジスタ<xx>には、$mod \space 3$の結果が格納されるので2ビット割り当てることにします。CMMを実行するために、内部で剰余加算を実行しますが、それへの入力レジスタが別途必要になり、今回レジスタ<xxx>と名付けることにします(前回の制御-剰余乗算の記事では<xx>と呼んでいました)。<xxx>には最大で$a^2=4$が入るので、3ビット割り当てます。<y>は、CMMの内部で剰余加算をするもう一方の入力レジスタなので、<xxx>よりも1つ多いビット数を用意しておく必要があるため、4ビットとします。加算を実行するためには桁上げ情報格納のためのレジスタ<c>がさらに必要になります。それには<y>と同じ数のビットを用意しておき、最上位の1ビットを<y>と共有するため、追加で3ビット必要になります。$N=3$を格納するためのレジスタも、上の回路図には書かれていないですが、必要です。剰余加算回路の内部で<xxx>とスワップするため同じビット数、すなわち3ビットを割り当てます。その他、剰余加算でアンダーフロー記述のための補助レジスタが1ビット必要になります。以上、すべてを合わせると「18量子ビット」となります。ちょっとややこしい説明になってしまいましたが、前回までの、加算、剰余加算、制御-剰余乗算の記事をよく見ればわかると思います(と言いつつ、間違っていたらすみません、汗)。

それではシミュレータで、「べき剰余」の動作を確認してみます。先程説明したように、$a=2,N=3,x=0,1,2$で動作させます。x=3の場合は、今回ビット数の関係で諦めましたので、xのすべての値に対して重ね合わせることはせず、$x=0,1,2$でforループを回して結果を逐一表示するようにしました。全体のPythonコードは以下の通りです。

from qlazypy import QState

def swap(self,id_0,id_1):

    dim = min(len(id_0),len(id_1))
    for i in range(dim):
        self.cx(id_0[i],id_1[i]).cx(id_1[i],id_0[i]).cx(id_0[i],id_1[i])
    return self

def ctr_swap(self,id_ctr,id_0,id_1):

    dim = min(len(id_0),len(id_1))
    for i in range(dim):
        self.ccx(id_ctr[0],id_0[i],id_1[i])
        self.ccx(id_ctr[0],id_1[i],id_0[i])
        self.ccx(id_ctr[0],id_0[i],id_1[i])
    return self

def sum(self,q0,q1,q2):

    self.cx(q1,q2).cx(q0,q2)
    return self

def i_sum(self,q0,q1,q2):

    self.cx(q0,q2).cx(q1,q2)
    return self

def carry(self,q0,q1,q2,q3):

    self.ccx(q1,q2,q3).cx(q1,q2).ccx(q0,q2,q3)
    return self

def i_carry(self,q0,q1,q2,q3):

    self.ccx(q0,q2,q3).cx(q1,q2).ccx(q1,q2,q3)
    return self

def plain_adder(self,id_a,id_b,id_c):

    depth = len(id_a)
    for i in range(depth):
        self.carry(id_c[i],id_a[i],id_b[i],id_c[i+1])
    self.cx(id_a[depth-1],id_b[depth-1])
    self.sum(id_c[depth-1],id_a[depth-1],id_b[depth-1])
    for i in reversed(range(depth-1)):
        self.i_carry(id_c[i],id_a[i],id_b[i],id_c[i+1])
        self.sum(id_c[i],id_a[i],id_b[i])
    return self

def arrow(self,N,q,id):

    for i in range(len(id)):
        if (N>>i)%2 == 1:
            self.cx(q,id[i])
    return self

def arrow2(self,i,a,id_ctr,id_x,id_xx):

    aa = a * 2**i
    for j in range(len(id_xx)):
        if (aa>>j)%2 == 1:
            self.ccx(id_ctr[0],id_x[i],id_xx[j])
    return self

def arrow3(self,id_ctr,id_x,id_y):

    for j in range(len(id_x)):
        self.ccx(id_ctr[0],id_x[j],id_y[j])
    return self

def i_plain_adder(self,id_a,id_b,id_c):

    depth = len(id_a)
    for i in range(depth-1):
        self.i_sum(id_c[i],id_a[i],id_b[i])
        self.carry(id_c[i],id_a[i],id_b[i],id_c[i+1])
    self.i_sum(id_c[depth-1],id_a[depth-1],id_b[depth-1])
    self.cx(id_a[depth-1],id_b[depth-1])
    for i in reversed(range(depth)):
        self.i_carry(id_c[i],id_a[i],id_b[i],id_c[i+1])
    return self

def modular_adder(self,N,id_a,id_b,id_c,id_N,id_t):

    self.plain_adder(id_a,id_b,id_c)
    self.swap(id_a,id_N)
    self.i_plain_adder(id_a,id_b,id_c)
    self.x(id_b[len(id_b)-1])
    self.cx(id_b[len(id_b)-1],id_t[0])
    self.x(id_b[len(id_b)-1])
    self.arrow(N,id_t[0],id_a)
    self.plain_adder(id_a,id_b,id_c)
    self.arrow(N,id_t[0],id_a)
    self.swap(id_a,id_N)
    self.i_plain_adder(id_a,id_b,id_c)
    self.cx(id_b[len(id_b)-1],id_t[0])
    self.plain_adder(id_a,id_b,id_c)
    return self

def i_modular_adder(self,N,id_a,id_b,id_c,id_N,id_t):

    self.i_plain_adder(id_a,id_b,id_c)
    self.cx(id_b[len(id_b)-1],id_t[0])
    self.plain_adder(id_a,id_b,id_c)
    self.swap(id_a,id_N)
    self.arrow(N,id_t[0],id_a)
    self.i_plain_adder(id_a,id_b,id_c)
    self.arrow(N,id_t[0],id_a)
    self.x(id_b[len(id_b)-1])
    self.cx(id_b[len(id_b)-1],id_t[0])
    self.x(id_b[len(id_b)-1])
    self.plain_adder(id_a,id_b,id_c)
    self.swap(id_a,id_N)
    self.i_plain_adder(id_a,id_b,id_c)

    return self

def ctr_modular_multiplier(self,a,N,id_ctr,id_x,id_xx,id_y,id_c,id_N,id_t):

    depth = len(id_x)
    for i in range(depth):
        self.arrow2(i,a,id_ctr,id_x,id_xx)
        self.modular_adder(N,id_xx,id_y,id_c,id_N,id_t)
        self.arrow2(i,a,id_ctr,id_x,id_xx)
    self.x(id_ctr[0])
    self.arrow3(id_ctr,id_x,id_y)
    self.x(id_ctr[0])
    return self

def i_ctr_modular_multiplier(self,a,N,id_ctr,id_x,id_xx,id_y,id_c,id_N,id_t):

    depth = len(id_x)
    self.x(id_ctr[0])
    self.arrow3(id_ctr,id_x,id_y)
    self.x(id_ctr[0])
    for i in reversed(range(depth)):
        self.arrow2(i,a,id_ctr,id_x,id_xx)
        self.i_modular_adder(N,id_xx,id_y,id_c,id_N,id_t)
        self.arrow2(i,a,id_ctr,id_x,id_xx)
    return self

def modular_exponentiation(self,a,N,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t):

    depth = len(id_x)
    id_ctr = [0]
    for i in range(depth):
        aa = a**(2**i)
        id_ctr[0] = id_x[i]
        self.ctr_modular_multiplier(aa,N,id_ctr,id_xx,id_xxx,id_y,id_c,id_N,id_t)
        self.ctr_swap(id_ctr,id_xx,id_y)
        self.i_ctr_modular_multiplier(aa,N,id_ctr,id_xx,id_xxx,id_y,id_c,id_N,id_t)
    return self

def encode(self,decimal,id):

    for i in range(len(id)):
        if (decimal>>i)%2 == 1:
            self.x(id[i])
    return self

def decode(self,id):

    iid = id[::-1]
    return self.m(id=iid,shots=1).lst

def create_register():

    num = 0
    id_x = [i for i in range(2)]
    num += len(id_x)
    id_xx = [i+num for i in range(2)]
    num += len(id_xx)
    id_xxx = [i+num for i in range(3)]
    num += len(id_xxx)
    id_y = [i+num for i in range(4)]
    num += len(id_y)
    id_c = [i+num for i in range(4)]
    id_c[len(id_c)-1] = id_y[len(id_y)-1]
    num += (len(id_c)-1)
    id_N = [i+num for i in range(3)]
    num += len(id_N)
    id_t = [i+num for i in range(1)]
    num += len(id_t)
    id_r = id_xx

    return (num,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t,id_r)

if __name__ == '__main__':

    # add methods
    QState.swap = swap
    QState.ctr_swap = ctr_swap
    QState.sum = sum
    QState.i_sum = i_sum
    QState.carry = carry
    QState.i_carry = i_carry
    QState.arrow = arrow
    QState.arrow2 = arrow2
    QState.arrow3 = arrow3
    QState.plain_adder = plain_adder
    QState.i_plain_adder = i_plain_adder
    QState.modular_adder = modular_adder
    QState.i_modular_adder = i_modular_adder
    QState.ctr_modular_multiplier = ctr_modular_multiplier
    QState.i_ctr_modular_multiplier = i_ctr_modular_multiplier
    QState.modular_exponentiation = modular_exponentiation
    QState.encode = encode
    QState.decode = decode

    # set input numbers
    a = 2
    N = 3
    x_list = [0,1,2]

    # create registers
    num,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t,id_r = create_register()

    for x in x_list:

        # initialize quantum state
        qs = QState(num)
        qs.encode(x,id_x)
        qs.encode(N,id_N)
        qs.encode(1,id_xx)

        # execute controlled modular multiplier
        qs.modular_exponentiation(a,N,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t)
        res = qs.decode(id_r)
        print("{0:}^{1:} mod {2:} -> {3:}".format(a,x,N,res))

        qs.free()

前回までの記事(加算、剰余加算、制御-剰余乗算)で、大半の関数は説明済なので、今回の差分だけを説明します。

def ctr_swap(self,id_ctr,id_0,id_1):

    dim = min(len(id_0),len(id_1))
    for i in range(dim):
        self.ccx(id_ctr[0],id_0[i],id_1[i])
        self.ccx(id_ctr[0],id_1[i],id_0[i])
        self.ccx(id_ctr[0],id_0[i],id_1[i])
    return self

で、制御ビットつきのスワップを定義しています。通常のスワップは制御NOTを3つ組み合わせますが、さらに別の制御ビットによってON/OFF制御するため、制御-制御NOT、つまりToffoliゲート3つに置き換えています。

def modular_exponentiation(self,a,N,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t):

    depth = len(id_x)
    id_ctr = [0]
    for i in range(depth):
        aa = a**(2**i)
        id_ctr[0] = id_x[i]
        self.ctr_modular_multiplier(aa,N,id_ctr,id_xx,id_xxx,id_y,id_c,id_N,id_t)
        self.ctr_swap(id_ctr,id_xx,id_y)
        self.i_ctr_modular_multiplier(aa,N,id_ctr,id_xx,id_xxx,id_y,id_c,id_N,id_t)
    return self

で、べき剰余を定義しています。上で示した回路図をそのまま実行しています。

def create_register():

    num = 0
    id_x = [i for i in range(2)]
    num += len(id_x)
    id_xx = [i+num for i in range(2)]
    num += len(id_xx)
    id_xxx = [i+num for i in range(3)]
    num += len(id_xxx)
    id_y = [i+num for i in range(4)]
    num += len(id_y)
    id_c = [i+num for i in range(4)]
    id_c[len(id_c)-1] = id_y[len(id_y)-1]
    num += (len(id_c)-1)
    id_N = [i+num for i in range(3)]
    num += len(id_N)
    id_t = [i+num for i in range(1)]
    num += len(id_t)
    id_r = id_xx

    return (num,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t,id_r)

で、各レジスタに割り当てる量子ビット番号と全体の量子ビット数を計算してリターンする関数を定義しています。

というわけで、プログラム本体の説明です。

# set input numbers
a = 2
N = 3
x_list = [0,1,2]

# create registers
num,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t,id_r = create_register()

$a,N$の値と$x$の値を入れるリストを設定して、各レジスタおよび必要となる全体量子ビット数を適当な変数に格納します。

for x in x_list:

    # initialize quantum state
    qs = QState(num)
    qs.encode(x,id_x)
    qs.encode(N,id_N)
    qs.encode(1,id_xx)

    # execute controlled modular multiplier
    qs.modular_exponentiation(a,N,id_x,id_xx,id_xxx,id_y,id_c,id_N,id_t)
    res = qs.decode(id_r)
    print("{0:}^{1:} mod {2:} -> {3:}".format(a,x,N,res))

xの値を変えながら、べき剰余の計算を実行し、その結果を逐次表示します。

実行結果は、以下の通りです。

2^0 mod 3 -> 1
2^1 mod 3 -> 2
2^2 mod 3 -> 1

というわけで、べき剰余が正しく計算できることが確認できました。

おわりに

結局、とても小さい数でしか実行できませんでしたが、とりあえず確認できたことにします。今回18量子ビットという見積りのもとで実行しましたが、参考論文には$N$のビット数$n$に対して、$7n+1$量子ビットで良いという記載があります。だとすると、本当は15量子ビットで実行可能なはず、ということでしょうか？ちょっとわかりませんが、もしかすると何らかの誤まった解釈から余分な量子ビットを使ってしまっているのかもしれません(が、すみません。今回はここまでとします。みなさま、お使いのシミュレータで実行してみて、量子ビット削減できたよ！ということが、もしあれば、後で教えて下さい)。

「べき剰余」のアルゴリズムについては、今回参考にした論文が発表された1990年代半ば以降、研究の進展がとてもあるようなので、今後余裕があれば見ておこうと思います。

次回は、予定では「Shorのアルゴリズム」なのですが、べき剰余の部分をどうしようか、考え中です。

以上

Seleniumを使って、気象データのダウンロード自動化を目指したいと、思います。

1.　経緯

▶任意の地点である一定期間の気象データ(気温・降水量など)が欲しい場合、気象庁のアメダス（AMeDAS：Automated Meteorological Data Acquisition System：自動気象データ収集システム)をよく利用している。
▶手軽にダウンロードできる反面、一度に取得できるデータ量には上限がある。
▶仮に長期間の1時間間隔のデータを取得しようとした場合、期間を区切りながら手動でダウンロードするのはめんどう。地点が増えればなおさらである。
⇒ある地点を選択してダウンロードして、また地点を変えてダウンロードして、、、この作業を全部自動化できないのか。

2.　Seleniumによるブラウザ自動操作

2.1　Chromedriverの導入

Chromedriver導入に関しては、多くの参考記事があると思うのでここでは省略します。

https://sites.google.com/a/chromium.org/chromedriver/downloads

2.2　ダウンロードするアメダス地点の選定

①まず目的のダウンロードサイトから、地域を選択する操作をしなければならないので、各地域の場所情報をリスト化する。
今回は各地域のid属性値(id=pr××)を取得した（=計61地域）

②各地域の観測地点を1地点ずつ選択するための情報をリスト化する。
今回はname="stname"のvalue="××"を取得した（=計1300地点）

get_list.py

# -*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time

options = Options()
options.add_argument('--headless')
driver = webdriver.Chrome('C:/selenium/chromedriver', options=options)
html = driver.get("https://www.data.jma.go.jp/gmd/risk/obsdl/index.php")
time.sleep(1)


#各地域のid属性取得==========================================================
pr_list = []
prefecture = driver.find_elements_by_class_name("prefecture")
for pr in prefecture:
    pr = pr.get_attribute("id")
    pr_list.append(pr)
#==========================================================================

#各地域の観測地点名取得==========================================================
stname_list = []
for i in pr_list:
    #順番に各地域へアクセス
    driver.find_element_by_xpath('//*[@id="{}"]'.format(i)).click()
    time.sleep(1)
    #その地域の観測地点情報の取得
    stations = driver.find_elements_by_xpath('//*[@class="station"]')
    for station in stations:
        station.click() #地点選択
        time.sleep(1)
        #地点名取得
        stname = station.find_element_by_name("stname").get_attribute("value")
        stname_list.append(stname)
    #全部選択し終わったらその地域から離れ、別の地域へ 
    driver.find_element_by_css_selector("#buttonSelectStation").click()
    time.sleep(1)
#==============================================================================

各地域・地点情報のリストは以下の通り。稼働中の地点は1300ヶ所、この中から各自ダウンロードしたい地点を選定する。
※リスト化のプログラムは時間かかります。

2.3　AMeDASデータダウンロード

実際にデータをダウンロードするには物理量や期間などを選択する必要があります。
以下のプログラムでは2017年12月1日から2019年3月31日の冬季期間における時間降雪量を取得しています。
各要素をクリックするためのidやxpathを丁寧に指定してあげてください。

get_amedas.py

# -*- coding: utf-8 -*-
from selenium import webdriver
import time

driver = webdriver.Chrome('C:/selenium/chromedriver')
html = driver.get("https://www.data.jma.go.jp/gmd/risk/obsdl/index.php")
time.sleep(1)

#ダウンロードするデータの詳細設定==============================================================================
#項目を選ぶ
driver.find_element_by_id('elementButton').click()
time.sleep(1)
#時間降雪量を選択
driver.find_element_by_xpath('//*[@id="aggrgPeriod"]/div/div[1]/div[1]/label/input').click()
time.sleep(1)
driver.find_element_by_xpath('//*[@id="降雪の深さ"]').click()
time.sleep(1)
#期間を選ぶ
driver.find_element_by_id('periodButton').click()
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectPeriod"]/div/div[2]/div[1]/label/span').click()
time.sleep(1)
driver.find_element_by_xpath( '//*[@id="selectPeriod"]/div/div[2]/div[2]/div[2]/select[1]/option[3]').click()  # 2017年
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectPeriod"]/div/div[2]/div[2]/div[1]/select[1]/option[12]').click() #12月
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectPeriod"]/div/div[2]/div[2]/div[1]/select[2]/option[1]').click() #1日
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectPeriod"]/div/div[2]/div[2]/div[2]/select[2]/option[1]').click() #2018年    
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectPeriod"]/div/div[2]/div[2]/div[1]/select[3]/option[3]').click() #3月
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectPeriod"]/div/div[2]/div[2]/div[1]/select[4]/option[31]').click() #31日
time.sleep(1)
#表示オプションを選ぶ
driver.find_element_by_id('optionButton').click()
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectOp"]/div[1]/div/div[2]/p/label/input').click()
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectOp"]/div[2]/div/div[2]/p/label/input').click()
time.sleep(1)
driver.find_element_by_xpath('//*[@id="selectOp"]/div[3]/p[3]/label/input').click()
time.sleep(1)
driver.find_element_by_xpath('// *[@id="selectOp"]/div[4]/div/div[2]/label/input').click()
time.sleep(1)
#==================================================================================================

#地点を選ぶ
driver.find_element_by_id('stationButton').click()
time.sleep(1)

#今回は試しに以下のリストに示した観測地点のデータをダウンロードする
select_list = ['稚内', '北見枝幸', '歌登', '中頓別', '豊富', '沼川', '浜鬼志別']
for i in pr_list:
    driver.find_element_by_xpath('//*[@id="{}"]'.format(i)).click()
    time.sleep(1)
    stations = driver.find_elements_by_xpath('//*[@class="station"]')
    time.sleep(1)
    for station in stations:
        station.click() 
        time.sleep(1)
        stname = station.find_element_by_name("stname").get_attribute("value")
        #選択中の地点がselect_listになければ、その地点をスキップする
        if not stname in select_list:
            print(stname + " skip")
        else:
            driver.find_element_by_xpath('//*[@id="csvdl"]/img').click()
            time.sleep(5) #ダウンロードには多少時間がかかる
            print(stname + " DL")
        #選択した地点を解除する   
        driver.find_element_by_id("deleteAllStPref").click()
        time.sleep(1)

    driver.find_element_by_css_selector("#buttonSelectStation").click()
    time.sleep(1)

$ python get_amedas.py
稚内　DL
沓形　skip
浜頓別　skip
北見枝幸　DL
歌登　DL
中頓別　skip
豊富　DL
沼川　DL
宗谷岬　skip
浜鬼志別　DL
本泊　skip
：
：

上記プログラム実行すると、ダウンロードフォルダなどに保存されます。
あとは、ループしつつも、同時にデータ整形して別フォルダに保存し、元のファイルは削除しておくようなプログラムを組み込むといいと思います。
ではでは。

はじめに

Pythonで書くWebアプリケーションフレームワークFlaskの練習として、簡単なToDoリストを作成しました。

概要

• ルートページ(index.html)にはToDoリストの一覧を表示
• それぞれの項目に詳細ページ(show.html)
• 他に、項目編集ページ(edit.html)と新規項目追加フォームページ(new.html)
• 見た目はBootstrapを使いました

環境

OS	macOS mojave
Python	3.7.3
Flask	1.0.3

ソースコード

https://github.com/TaroNoguchi/flask-app-practice

アプリの作成

まずはアプリの根幹になるファイルapp.pyを作成します。

モジュールのインポートなど

app.py

from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///todo.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
db.create_all()

作業ディレクトリを整理

以下は完成したディレクトリ構造。
*はbootstrapのファイルです。
その他ページの見た目をhtmlでtemplatesに、cssでstaticに作成しました。

.
├── Procfile
├── app.py
├── requirements.txt
├── static
│   ├── css
│   │   └── bootstrap.css *
│   └── js
│       ├── bootstrap.js *
│       └── jquery-3.4.1.js *
├── templates
│   ├── edit.html
│   ├── favicon.png
│   ├── index.html
│   ├── layout.html
│   ├── new.html
│   └── show.html
└── todo.db

データベースの作成

SQLAlchemyというモジュールを用いて、SQL文を書かずとも操作ができるスタイルで作ります。
まずはtouch todo.dbでデータベースファイルを作り、以下のクラスに対応するようにテーブルを作成します。

app.py

class Post(db.Model):

    __tablename__ = "posts"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    date = db.Column(db.Text())
    title = db.Column(db.Text())
    content = db.Column(db.Text())
    commit = db.Column(db.Integer)

このクラスを外部から呼び出すことでデータベースへの操作を行うことができます。

ルートページの作成

app.py

app.py

@app.route('/') # ルート(/)ページURLにリクエストが送られた時の処理
def index():

    posts = Post.query.all()
    return render_template("index.html", posts = posts)

• 変数postsにPostクラスの全てのクエリを代入
• index.htmlのテンプレートを呼び出してレンダリングし、表示。

index.html

続いてindex.htmlを編集します。
layout.htmlで共通部分を作成し、{% block content %}と{% endblock %}で挟み込んだ所のみを記述することで余計にコードを書かないようにします。

index.html

{% extends "layout.html" %}
{% block content %}
    <div class="container">
        <h1>ToDo</h1>

        <table class="table table-hover table-responsive">
            <tr><th>Last Update</th><th>Title</th><th></th><th></th><th></th></tr>
            {% for post in posts %}    
            <div class="row">
                <tr>
                    <td>{{ post.date }}</td>
                    {% if post.commit == 1 %}
                        <td><del>{{ post.title }}</del></td>
                    {% else %}
                        <td>{{ post.title }}</td>
                    {% endif %}
                    <td><a href="/show/{{ post.id }}" class="btn btn-success far fa-file-alt"> 詳細 </a></td>
                    <td><a href="/done/{{ post.id }}" class="btn btn-info fas fa-check-circle"> Done </a></td>
                    <td><a href="/undone/{{ post.id }}" class="btn btn-success fas fa-undo-alt"> Undone </a></td>
                </tr>
            </div> 
            {% endfor %}
        </table>
        <p>
            <a href="/new" class="btn btn-primary far fa-file"> 新規 </a>
            <a href="/destroy/alldone" class="btn btn-danger fas fa-trash" onclick="return confirm('完了済みの項目を全て削除します。よろしいですか？')"> 完了済みをすべて削除 </a>
        </p>
    </div>
{% endblock %}

• forループとtableタグを使ってクエリの一覧表示
• Postクラス変数commitが1の時完了を、0の時未完了を表し、1の時は横線を入れるよう条件分岐で記述
• 各種ボタンを作成

詳細ページの作成

app.py

/show/(Postクラスのインスタンスのid)にアクセスした時の振る舞いをapp.pyに記述します。

app.py

@app.route('/show/<int:id>')
def show(id):
    post = Post.query.get(id)
    return render_template("show.html", post = post)

• /showの後に記述されたint型の値を変数idに格納
• この変数idとDBのidカラムのデータを変数postに代入
• show.htmlをテンプレートとしてれ呼び出し、レンダリング

show.html

show.html

{% extends "layout.html" %}
{% block content %}
<div class="container">

    <div class="card bg-light">
        <div class="card-header">
            <h2>{{ post.title }}</h2>
        </div>
        <div class="card-body">
            <blockquote class="blockquote mb-0">
                <p>{{ post.content }}</p>
                <footer class="blockquote-footer"><cite title="Source Title">(Last Update: {{ post.date }})</cite></footer>
            </blockquote>
        {% if post.commit == 1 %}
            <div class="alert alert-success" role="alert">
                完了しています
            </div>
        {% endif %}
        </div>
    </div>

    <br>
    <div>
        <a href="/edit/{{ post.id }}" class="btn btn-warning far fa-edit"> 編集 </a>
        <a href="/destroy/{{ post.id }}" class="btn btn-danger fas fa-trash-alt" onclick="return confirm('この項目を削除します。よろしいですか？')"> 削除 </a>
        <a href="/done/{{ post.id }}" class="btn btn-info fas fa-check-circle"> Done </a>
        <a href="/undone/{{ post.id }}" class="btn btn-success fas fa-undo-alt"> Undone </a>        
    </div>

    <br>
    <p><a href="/" class="btn btn-default">一覧に戻る</a></p>

</div>
{% endblock %}

• タイトルと、さらに詳しく情報が表示されます
• 完了しているもの(commit == 1)にはブロックが表示されます

新規追加・編集ページの作成

新規追加・編集ページのレイアウトと、そこに記述された内容をPOSTメソッドで送るロジックを組みます。

new.html

先にテンプレートを作ります。

new.html

{% extends "layout.html" %}
{% block content %}
<div class="container">
    <form action="/create" method="POST">
        <div class="form-group">

            <label for="title">ToDo</label>
            <input type="text" name="title" value="" class="form-control" placeholder="What do you do next?">

        </div>
        <div class="form-group">

            <label for="content">備考</label>
            <textarea class="form-control" name="content" cols="40" rows="10" placeholder="If you have options, write down here."></textarea>

        </div>

        <button type="submit" class="btn btn-primary">保存</button>
        <button type="button" class="btn btn-danger" onclick="history.back()">キャンセル</button>

    </form>
</div>
{% endblock %}

• /createへPOSTリクエストを送ります
• 送り先ではname属性で指定した値で取り出せます

app.py

app.py

@app.route('/new')
def new_post():

    return render_template("new.html")

このメソッドに/newにアクセスされた時の動きを記述します。
といってもnew.htmlのテンプレートをレンダリングするだけです。

app.py

@app.route('/create', methods=["POST"])
def create_post():

    new_post = Post()
    new_post.title = request.form["title"]
    new_post.content = request.form["content"]
    new_post.date = str(datetime.today().year) + "-" + str(datetime.today().month) + "-" + str(datetime.today().day)
    new_post.commit = 0
    db.session.add(new_post)
    db.session.commit()

    return redirect(url_for('.index'))

こちらで、実際にnew.htmlで入力された値をDBに格納します。

• 変数new_postをPostクラスでインスタンス化
• title, contentにPOSTリクエストで送られてきた値を格納
• dateは今日の日付
• 未完了なのでcommitは0に
• session.addでデータベースへ値を追加
• session.commitでデータベースの変更を実行します
• 編集後にわざわざレンダリングせずindex.htmlを表示させます。こうすることでリロードした時に同じものが登録されてしまうのを防げます

edit.html

edit.html

{% extends "layout.html" %}
{% block content %}
<div class="container">
    <form action="/update/{{ post.id }}" method="POST">
        <div class="form-group">

            <label for="title">ToDo</label><br>
            <input type="text" name="title" value="{{ post.title }}" class="form-control">

        </div>
        <div class="form-group">

            <label for="content">詳細</label><br>
            <textarea name="content" cols="40" rows="10" class="form-control">{{ post.content }}</textarea>

        </div>
        <button type="submit" class="btn btn-primary">保存</button>
        <button type="button" class="btn btn-danger" onclick="history.back()">キャンセル</button>

    </form>
</div>
{% endblock %}

こちらもnew.htmlと見た目は一緒ですが、一緒にレンダリングした変数postを使って現在のデータを入力ボックス内に表示してあげないといけません。

• /update/{{ post.id }}へリクエストを送ります

app.py

app.py

@app.route('/edit/<int:id>')
def edit_post(id):

    post = Post.query.get(id)

    return render_template("edit.html", post = post)

こちらは編集ページなので指定したデータも一緒にレンダリングしてあげないといけません。

app.py

@app.route('/update/<int:id>', methods=["POST"])
def update_post(id):

    post = Post.query.get(id)
    post.title = request.form["title"]
    post.content = request.form["content"]
    post.date = str(datetime.today().year) + "-" + str(datetime.today().month) + "-" + str(datetime.today().day)
    db.session.commit()

    return redirect(url_for('.index'))

• /createの時と同じような要領で記述します
• 今回も編集後にわざわざレンダリングせずindex.htmlを表示します

項目の完了(make item done)・削除のロジック

リクエストがdestroy, done, undoneに送られた時の動きをapp.pyに記述します。これらに関するURLにリクエストが送られた時の「動き」を記述すれば良いだけなので、とくに新たなhtmlファイルを書く必要はありません。

Done, Undone

app.py

@app.route('/done/<int:id>')
def done_post(id):

    post = Post.query.get(id)
    post.commit = 1
    post.date = str(datetime.today().year) + "-" + str(datetime.today().month) + "-" + str(datetime.today().day)
    db.session.commit()
    posts = Post.query.all()

    return redirect(url_for('.index'))

@app.route('/undone/<int:id>')
def undone_post(id):

    post = Post.query.get(id)
    post.commit = 0
    post.date = str(datetime.today().year) + "-" + str(datetime.today().month) + "-" + str(datetime.today().day)
    db.session.commit()
    posts = Post.query.all()

    return redirect(url_for('.index'))

• 変数commitが0か1かで、完了・未完了を分けているのでそれをリクエストによって変更する記述をします

削除

一件のみの削除

app.py

@app.route('/destroy/<int:id>')
def destroy(id):

    post = Post.query.get(id)
    db.session.delete(post)
    db.session.commit()
    posts = Post.query.all()

    return redirect(url_for('.index'))

• 新規追加や編集の時と記述の仕方はほとんど一緒です
• session.deleteで削除してコミットします

完了済みを全削除

app.py

@app.route('/destroy/alldone')  
def destroy_alldone():

    posts_done = Post.query.filter_by(commit=1).all()
    for i in posts_done:
        db.session.delete(i)
    db.session.commit()
    posts = Post.query.all()

    return redirect(url_for('.index'))

• ルートページにこのボタンがあります
• Post.query.filter_byで変数commitが1のもの(完了しているもの)をとりだし
• 削除してコミットします
• 最後にルートページに飛んで終了

最後に

GitHubではHerokuに公開したURLも記述していますがユーザー管理を導入していないので完全に一人用です。
Herokuの使い方はRailsのチュートリアルドキュメントを参考にしました。

What is this?

備忘録的なあれです。
Golangを書いている後、Pythonを書き始めるとエラーをどうあつかったらいいかわからなくなりました。

Golangは基本的に、なにかメソッドを書く際には、必ずといっていい程、エラーも同時に返り値として設定します。そのおかげで、「このエラーはraiseさせよう」とか、「ここはpanicでええやろ」とか、「ここは例外的に処理させねばとか」、逐一考える機会が与えらえて良いなあという印象を受けました。

一方で、Pythonはコード上にて明示的吐き出されません。プログラムを実行した際に、ようやく「ああ、ここはこういうエラーが吐き出されのね、ふーん」みたいなことが多々ありました。

Golangから改めてPythonを触った自分は、エラー出た場合に、try except で例外処理として、エラーを吐き出すべきなのか、そのままエラーをシステムに吐かせればいいのか、わからなくなりました。

そこで、今回では、どのような場合にエラーをtry exceptでログを吐き出すべきなのか、備忘録的に記載していきます。

エラーを例外処理する場合

結論からいうと、
「エラーログに付加要素を付け加えたい場合に例外処理をするべき」
です。

どういうこっちゃかというと、例えばデータベースに接続して検索するケースを挙げます。
下記のような、Mysqlに接続するとします。

import mysql.connector

class DataBaseRepository:
    def  __init__(self):
        self.conn = mysql.connector.connect(
            database=MYSQL_DATABASE,
            host=MYSQL_HOST,
            user=MYSQL_USER,
            password=MYSQL_PASS,
            charset='utf8mb4',
            autocommit=True,
            connection_timeout=60,
        )

    def get_users(self, user_id: int, group_id: int) -> [str]:
        """
        get username
        :return list of username
        """
        cursor = self.conn.cursor
        sql = 
        f"""
        SELECT name
        FROM users
        WHERE user_id = {user_id}
          AND group_id = {group_id}
        """
        cursor.execute(sql)
        return cursor.fetchall()

    def close(self):
        self.conn.close()

    def __del__(self):
        self.close()

DataBaseに接続して、get_users　で user_id と group_id が一致するuserの name を取得します。(そのほかのメソッドは、説明は省きます)

このコードを用いた下記のような2種類実行のコードがあるとします。

• 例外処理を書く場合

from logging import getLogger

if __name__ == '__main__':
    logger = getLogger(__name__)

    repo = DataBaseRepository()
    user_id = 100
    group_id = 1
    try:
        user_names = repo.get_users(group_id, gender_id)
    except:
        """
        ここにどうような処理を書くべき？
        """

    if len(user_names) == 0 {
        logger.warn('user_name size is zero!')
    }

• 例外処理を書かない場合

from logging import getLogger

if __name__ == '__main__':
    repo = DataBaseRepository()
    user_id = 100
    group_id = 1
    user_names = repo.get_users(group_id, gender_id)
    if len(user_names) == 0 {
        logger.warn('user_name size is zero!')
    }

どっちがいいと思いますか？
どっちでも、エラーがでるときは十分ありうるコードなのです。DataBaseのカラムが存在しないかもしれないし、Connectionが確立されてないかもしれないし、そもそもレコードがないこともありえますね。

その場合、より多くの情報があった方が不足の事態に対処しやすいです。
この情報が 付加要素　となるわけです。

例えば、今回の場合だと、group_id　と gender_idがあった方が、断然エラー対応しやすいです。
なので、エラーがでる部分を例外処理でくくって、付加要素を加えます。

• 例外処理を書く場合

from logging import getLogger

if __name__ == '__main__':
    logger = getLogger(__name__)

    repo = DataBaseRepository()
    user_id = 100
    group_id = 1
    try:
        user_names = repo.get_users(group_id, gender_id)
    except Exception as e:
        """
        ここにどうような処理を書くべき？
        """
        logger.error(f'Failed to get user_name of group_id:{group_id} and gender_id:{gender_id}')
        raise(e)

    if len(user_names) == 0 {
        logger.warn('user_name size is zero!')
    }

これで、エラー対応が楽になるはず。。。

まとめ

要約すると
「エラー対応がしやすいように、付加要素的なエラーログを意識しましょう」
以上。

何か、ご意見やご指摘あれば、何卒コメント欄にご記入いただけますと幸いです。

TL;DR

''.join(traceback.TracebackException.from_exception(exc).format())

従来の方法

tracebackを文字列で取得する方法として traceback.format_exception() がよく紹介されています。

import traceback

try:
    1/0
except Exception as e:
    t = traceback.format_exception(type(e), e, e.__traceback__)
    print(t)

# ['Traceback (most recent call last):\n',
# '  File "/path/to/script.py", line 4, in <module>\n    1/0\n',
# 'ZeroDivisionError: division by zero\n']

この書き方は冗長です。エラーひとつに対して etype, value, tb の３つの引数を与えなくてはなりません。
(実は引数 e_type は Python3.5 からは無視される仕様となっているため、 None などで代用できます)

より単純な書き方

Python3.5 から TracebackException が導入され、より単純に同じことを実現できるようになりました。

import traceback

try:
    1/0
except Exception as e:
    t = list(traceback.TracebackException.from_exception(e).format())
    print(t)

# ['Traceback (most recent call last):\n',
# '  File "/path/to/script.py", line 4, in <module>\n    1/0\n',
# 'ZeroDivisionError: division by zero\n']

TracebackException.format() は文字列のジェネレータを返すという点に注意してください。

TL;DR

''.join(traceback.TracebackException.from_exception(exc).format())

従来の方法

tracebackを文字列で取得する方法として traceback.format_exception() がよく紹介されています。

import traceback

try:
    1/0
except Exception as e:
    t = traceback.format_exception(type(e), e, e.__traceback__)
    print(t)

# ['Traceback (most recent call last):\n',
#  '  File "/path/to/script.py", line 4, in <module>\n    1/0\n',
#  'ZeroDivisionError: division by zero\n']

この書き方は冗長です。エラーひとつに対して etype, value, tb の３つの引数を与えなくてはなりません。
(引数 e_type は Python3.5 からは無視される仕様となったため、 None で代用できます)

より単純な書き方

Python3.5 から TracebackException が導入され、より単純に同じことを実現できるようになりました。

import traceback

try:
    1/0
except Exception as e:
    t = list(traceback.TracebackException.from_exception(e).format())
    print(t)

# ['Traceback (most recent call last):\n',
#  '  File "/path/to/script.py", line 4, in <module>\n    1/0\n',
#  'ZeroDivisionError: division by zero\n']

TracebackException.format() は文字列のジェネレータを返す点に注意してください。

謝辞

TracebackException について教えてくださった python.jp の atsuoishimoto さんに感謝申し上げます。
の

はじめに

これは筆者の勉強まとめページですので、指摘しまくってい頂けると幸いです

ロジスティック回帰

線形回帰を二値分類に使用する方法で、とある閾値を超えたものを1クラス、その他のクラスを0クラスとして分類していく手法で、今回は0.5を閾値として、損失関数が以下のように設定される。

$$ y = w・x + b $$

$$ sigmoid(x) = \frac{1}{1 + \exp(-x)} $$

$$ loss = \sum^{n}_{k = 1}{(t・log(sigmoid(y) + (1 - t)・log(1 - sigmoid(y))} $$

これを用いて2クラス分類をしていきます

import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
from sklearn import datasets

sess = tf.Session()

# [setosa, versicolor] と [virginica] の分類を行う

iris = datasets.load_iris()
x_vals = iris.data
target = iris.target

y1 = [0 for i in target if i != 2]
y2 = [1 for i in target if i == 2]

y_vals = np.array(y1+y2)

learning_rate = 0.05
batch_size = 25

x_data = tf.placeholder(shape = [None, 4], dtype = tf.float32)
y_target = tf.placeholder(shape = [None, 1], dtype = tf.float32)

A = tf.Variable(tf.random_normal(shape = [4, 1]))
b = tf.Variable(tf.random_normal(shape = [1, 1]))

model_output = tf.add(tf.matmul(x_data, A), b)

loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = model_output, labels = y_target))

init = tf.global_variables_initializer()
sess.run(init)

optimizer = tf.train.GradientDescentOptimizer(learning_rate)
train = optimizer.minimize(loss)

prediction = tf.round(tf.sigmoid(model_output))
prediction_correct = tf.cast(tf.equal(prediction, y_target), tf.float32)
accuracy = tf.reduce_mean(prediction_correct)

loss_vec = []
accuracy_vec = []

for i in range(1000):

    rand_index = np.random.choice(len(x_vals), size = batch_size)
    rand_x = x_vals[rand_index]
    rand_y = np.transpose([y_vals[rand_index]])

    sess.run(train, feed_dict = {x_data: rand_x, y_target: rand_y})

    tmp_accuracy, temp_loss = sess.run([accuracy, loss], feed_dict = {x_data: rand_x, y_target: rand_y})

    loss_vec.append(temp_loss)
    accuracy_vec.append(tmp_accuracy)

    if (i + 1) % 25 == 0:

        print("Step #" + str(i + 1) + " A = " + str(sess.run(A)) + " b = " + str(sess.run(b)))
        print("Loss = " + str(temp_loss))
        print("Acc = " + str(tmp_accuracy))

plt.plot(loss_vec, "k-")
plt.title("L2 Loss per Generation")
plt.xlabel("Generation")
plt.ylabel("L2 Loss")
plt.show()

plt.plot(accuracy_vec, "k-")
plt.title("L2 accuracy per Generation")
plt.xlabel("Generation")
plt.ylabel("L2 accuracy")
plt.show()

こんな感じで学習が進んでいれば成功
うまく分類できている模様(テストデータで検証してないけど...)
ロジスティック回帰で他クラスにする手法とかないかな(ボソッ)

環境

ubuntu 16.04 LTS
python 3.7.3

やること

Python機械学習プログラミング(第一版)の「第8章 | 機械学習の適用1-感情分析」を参考に、2人のユーザーによるツイートを正解ラベルありで学習させ、ツイートからどちらのユーザーがツイートしたかを判定します。ちなみにこの本は第二版が出ているので買う場合はそっちを選んでください。特に深層学習のトピックが増えているらしいです。

学習するツイートについて

ともにライターで、ツイッターを利用していれば1度は見たことがあるであろうARuFaさんとヨッピーさんのツイートを使います。

服屋で店員さんに声をかけられるのが怖いので、同じ根暗たちを集めて『店員に声をかけられる前に爆速で服を買い、その服だけでコーディネートをする大会』をした記事を書きました。緊張感すごい

【挑戦】店員に声をかけられる前に服を買え！「即買いコーディネート選手権」！https://t.co/ZuNp1vvNy7 pic.twitter.com/ZtFcRXQ5za

— ARuFa (@ARuFa_FARu) 2019年7月1日

笹のコスプレ pic.twitter.com/vIsbRdAyWT

— ヨッピー (@yoppymodel) 2019年7月7日

Twitter APIのstatuses/user_timelineでそれぞれツイートを取得し、ツイート内のユーザーIDとURLはここで取り除きます。ツイート、ユーザー(正解ラベル：0，1)のDataFrameにしてCSVで保存します。

ここでstatuses/user_timelineについて、指定したユーザーのツイートを新しい順に3200個取得するのですが、それにはRTも含まれます。include_rts=FalseでRTは除いているのですが、カウント時には含まれるので、例えばRTが200個あればレスポンスとして取得できるツイートは3000個になります。さらにその後の処理でリプライも除いているので、RTやリプライ数により結果として取得できるツイートは3200から大きく減る場合があります。

Twitter APIの概要やsearch/tweetsの使い方等はこちら

import urllib
import io
from requests_oauthlib import OAuth1Session, OAuth1
import requests
import sys
import re
import pandas as pd


def main():
    # APIの認証キー
    CK = 'xxxxxxxxxxxxxxxx'
    CKS = 'xxxxxxxxxxxxxxxx'
    AT = 'xxxxxxxxxxxxxxxx'
    ATS = 'xxxxxxxxxxxxxxxx'
    # ユーザーID
    user_id = 'ARuFa_FARu' # 正確にはscree_nameのこと。本来のuser_idは数字だけで表現される
    # 取得時のパラメーター
    range = 200 # 検索回数の上限値(最大200)
    # インスタンス作成
    get = Get_User_Timeline()
    save = Save_Data()
    # タイムライン取得
    tweets = get.get_tl(CK, CKS, AT, ATS, user_id, range)
    # 前処理
    tweets = get.preprocess(tweets)
    # DataFrameの作成
    user_label = 0 # ユーザーラベル
    df = save.to_DF(tweets, user_label)
    # CSVとして保存
    path = "ARuFa.csv"
    save.save_as_csv(df, path)


class Get_User_Timeline:

    def get_tl(self, CK, CKS, AT, ATS, user_id, range):
        user_id = urllib.parse.quote_plus(user_id)
        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
        url = "https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name="+user_id+"&include_rts=False&tweet_mode=extended"
        auth = OAuth1(CK, CKS, AT, ATS)
        response = requests.get(url, auth=auth)
        data = response.json()
        cnt = 0
        tweets = []
        count_tweets = 0
        while True:
            if len(data) == 0:
                break
            if cnt > range:
                break
            cnt +=  1
            for tweet in data:
                if tweet['in_reply_to_status_id'] == None:
                    tweets.append(tweet['full_text'])
                    count_tweets += 1
                max_id = int(tweet["id"]) - 1
            url = "https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name="+user_id+"&include_rts=False&tweet_mode=extended&max_id="+str(max_id)
            response = requests.get(url, auth=auth)
            try:
                data = response.json()
            except KeyError:
                print('上限まで検索しました')
                break
        print('取得したツイート数 :', count_tweets)
        return tweets

    def preprocess(self, tweets):
        for i in range(len(tweets)):
            tweets[i] = re.sub(r'@\w+', '', tweets[i])
            tweets[i] = re.sub(r'https?://[\w/:%#\$&\?\(\)~\.=\+\-]+', '', tweets[i])
        return tweets


class Save_Data():

    def to_DF(self, tweets, user_label):
        cols = ['tweet', 'user']
        df = pd.DataFrame(index=[], columns=cols)
        for tweet in tweets:
            record = pd.Series([tweet, user_label], index=df.columns)
            df = df.append(record, ignore_index=True)
        return df

    def save_as_csv(self, df, path):
        df.to_csv(path, index=False)


if __name__ == '__main__':
    main()

テキストデータのベクトル化について

BoWというモデルでテキストをベクトル化し,さらにTF-IDFが適用されるsklearnのTfidfVectorizerを使用します。同じくsklearnのCountVectorizerのようなシンプルなBoWモデルでは、各テキストにおける単語の出現頻度をそのままベクトルに反映し、その出現頻度を

tf(t,d)

で表します。dは各テキストで、tはその中の各単語の出現回数です。ここで、「が」「は」といったような助詞など多くのテキストに頻繁に出現するような単語は判断材料として乏しいので過剰な重みを与えないようにしたいと考え、IDFを次にように定義します。

idf(t, d) = log\frac{n_d}{1 + df(t, d)}

nはテキストの総数です。単語の出現頻度が大きいほど重みが抑えられます。また、出現頻度が低い単語にも過剰な重みが与えられることを防ぐために対数をとっています。そして、TF-IDFはdfとidfの積で定義されます。

tfｰidf(t, d) = tf(t, d) × idf(t, d)

さらにこの後の学習では、ベクトルを正規化するべきかの検証も行われます。詳しいことは参考文献を読んでください。

データの前処理

さきほど作成したCSVをそれぞれ読み込み、欠損値のある列を削除します。ここからは全てjupyter-notebookで実行しています。

import pandas as pd

df_y = pd.read_csv('Yoppi.csv')
df_a = pd.read_csv('ARuFa.csv')
df_y = df_y[~df_y['tweet'].isnull()]
df_a = df_a[~df_a['tweet'].isnull()]

ここでデータをチェックしてみます。

print('ヨッピー')
print(df_y.info())
print(df_y.head(5))

ヨッピー
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1198 entries, 0 to 1205
Data columns (total 2 columns):
tweet    1198 non-null object
user     1198 non-null int64
dtypes: int64(1), object(1)
memory usage: 28.1+ KB
None
                                               tweet  user
0  【定期】ヨッピーが書いた記事が全部届くLINE@（スマホから）はこっち→ 　たまにダラダラ長...     0
1  坦坦担麺\n\n元RADWIMPSの斉木さん、ギターを置いてなぜ汁なし担々麺屋になったんですか？      0
2  Twitterで見かけたあの件、マジだったのか……！\n\nお悔やみ欄見て遺族に虚偽請求の手...     0
3  「ハイヒール履いてみた」って動画が話題だけど、自分でやってみて当事者のしんどさを知るっていう...     0
4  【定期】ヨッピーが書いた記事が全部届くLINE@（スマホから）はこっち→ 　たまにダラダラ長...     0

print('ARuFa')
print(df_a.info())
print(df_a.head())

ARuFa
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1952 entries, 0 to 1971
Data columns (total 2 columns):
tweet    1952 non-null object
user     1952 non-null int64
dtypes: int64(1), object(1)
memory usage: 45.8+ KB
None
                                               tweet  user
0  服屋で店員さんに声をかけられるのが怖いので、同じ根暗たちを集めて『店員に声をかけられる前に爆...     1
1  周りのタピオカユーザーに差をつけたいので、クッソでかいタピオカを吸ってるように見えるストロー...     1
2                             ムチャクチャな理由で会社が休みになりました      1
3  最近カレーばっかりで飽きてきたので、カレーを構成する『カレールー』『白米』『スプーン』の位置...     1
4                                    ？？？？？？？？？？？？？？      1

ヨッピーさんのツイート数が1198に対してARuFaさんは1952です。前述の通り、statuses/user_timelineの仕様及びリプライを除いていることからRT数やリプライ数が多いほどここでのツイート数は少なくなります。この差に関する検証は後ほどやっていきたいと思います。
またヨッピーさんの方は定期ツイートが設定されているのでこれも除きます。

df_y = df_y[df_y['tweet']!='【定期】ヨッピーが書いた記事が全部届くLINE@（スマホから）はこっち→ 　たまにダラダラ長文を投下するFB（5000人到達したからフォローしてね）はこっち→']
df_y.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 898 entries, 1 to 1205
Data columns (total 2 columns):
tweet    898 non-null object
user     898 non-null int64
dtypes: int64(1), object(1)
memory usage: 21.0+ KB

さらに300ほど少なくなりました。

最後に、2つのDataFrameを縦に結合し、学習・テストデータに分割します。

df = pd.concat([df_y, df_a])
X_train, X_test, Y_train, Y_test = train_test_split(df.tweet, df.user, test_size=0.3, random_state=0)

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

Pipelineでパラメータの比較をまとめて行い、先ほど触れたベクトルの正規化についても検証します。基本的に元のプログラムと同じですが、TfidfVectorizerのtokenizerとstop_wordsは変えています。

①tokenizerについて、これはテキストをトークンごとに分割する処理です。英語の場合は素直に単語を空白で区切ればOKですが、日本語ではMeCabの分かち書きで分割する場合が多く、ここでもそうしています。また元のプログラムでは単純な単語の分割に加えて単語を原形に変換した場合（例:runnner, running, run → run）も検証していますが、ここでそのような処理は行いません。

②stop_wordsについて、これはどんなテキストにも出現しうるありふれた単語のことで、英語の場合isやandなどのことを指します。これを除く処理はNLTKというライブラリを使えば簡単に実装できるのですが、日本語は用意されていません。ただし、TF-IDFを適用した段階でストップワードのような単語の重みはあらかじめ抑えられているので、ストップワードを除く必要性はあまりないと参考文献でも言及されています。これについては後で検証しますので、ここではストップワードを除かずそのまま学習させます。

import MeCab
import sys
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import TfidfVectorizer

def tokenizer(text):
    m = MeCab.Tagger('-Owakati')
    wakati_text = m.parse(text)
    return wakati_text.split()

tfidf = TfidfVectorizer(strip_accents=None,
                        lowercase=False,
                        preprocessor=None)
param_grid = [{'vect__ngram_range': [(1, 1)],
               'vect__stop_words': [None]
               'vect__tokenizer': [tokenizer],
               'clf__penalty': ['l1', 'l2'],
               'clf__C': [1.0, 10.0, 100.0]},
             {'vect__ngram_range': [(1, 1)],
               'vect__stop_words': [None]
               'vect__tokenizer': [tokenizer],
               'vect__use_idf': [False],
               'vect__norm': [None],
               'clf__penalty': ['l1', 'l2'],
               'clf__C': [1.0, 10.0, 100.0]}
             ]
lr_tfidf = Pipeline([('vect', tfidf),
                     ('clf', LogisticRegression(random_state=0))])
gs_lr_tfidf = GridSearchCV(lr_tfidf, param_grid,
                           scoring='accuracy',
                           cv=5, verbose=1, n_jobs=-1)

gs_lr_tfidf.fit(X_train, Y_train)

実行結果

gs_lr_tfidf.best_params_
# {'clf__C': 100.0,
# 'clf__penalty': 'l2',
# 'vect__ngram_range': (1, 1),
# 'vect__stop_words': None,
# 'vect__tokenizer': <function __main__.tokenizer(text)>}

gs_lr_tfidf.best_score_
# 0.8751879699248121

clf = gs_lr_tfidf.best_estimator_
clf.score(X_test, Y_test)
# 0.8783625730994152

best_params_で最適なパラメータが見れます。まずTfidfVectorizerについて、TF−IDFが適用され、ベクトルにはL2正則化(デフォルト)が適用されています。次にLogisticRegressionについて、L2正則化が適用され、その正則化項のパラメータCは100.0となっています。下の3つは共通です。

学習データでの正解率は約87.5%、テストデータでは約87.8%です。参考文献では学習・テストデータがそれぞれ25000個あったので足りるかなと思ったのですが、割といい感じになりました。

参考文献の内容としてはここまでですが、以降はこれまでに触れた今回の分析で気になる2つの点について検証していきます。

データの偏りについて

前処理後のデータ数は、ヨッピーさんが898、ARuFaさんが1952と倍近い偏りがあります。一般的にこの場合はARuFaさんと判定される確率の方が高くなると考えられ、実際に先ほどの学習結果についてテストデータをヨッピーさんとARuFaさんで分けて検証してみると、

X_y_test = X_test[Y_test==0]
Y_y_test = Y_test[Y_test==0]
X_a_test = X_test[Y_test==1]
Y_a_test = Y_test[Y_test==1]

clf.score(X_y_test, Y_y_test)
# 0.7509157509157509

clf.score(X_a_test, Y_a_test)
# 0.9381443298969072

ヨッピーさんのツイート正しく判定できる確率は約75.1％、ARuFaさんのツイートを正しく判定できる確率は約93.8％と、20％近い差がありました。

このような偏りを前処理の段階で抑えるには、基本的にデータを削るか補うかの2択になると思います。数値データであれば平均値などで補えますが、テキストデータでは難しく、今回は少ない方でも約900個あるのでそれに合わせて大きい方のデータを削ります。

df_a2 = df_a.sample(n=len(df_y), random_state=0)
df = pd.concat([df_y, df_a2])
X_train, X_test, Y_train, Y_test = train_test_split(df.tweet, df.user, test_size=0.3, random_state=0)

ヨッピーさんのデータの数だけARuFaさんのデータからランダムに抽出し、それを結合して学習・テストデータに分割しています。

あとは先程と同じように学習させるので、コードは省略します。

実行結果

gs_lr_tfidf.best_params_
# {'clf__C': 100.0,
# 'clf__penalty': 'l2',
# 'vect__ngram_range': (1, 1),
# 'vect__stop_words': None,
# 'vect__tokenizer': <function __main__.tokenizer(text)>}

gs_lr_tfidf.best_score_
# 0.8480509148766905

clf = gs_lr_tfidf.best_estimator_
clf.score(X_test, Y_test)
# 0.862708719851577

データ数を減らしたためか、学習データでは約2.7％・テストデータでは約1.6％正解率が下がっています。

続いて、テストデータをヨッピーさんとARuFaさんで分けて検証してみましょう。

X_y_test = X_test[Y_test==0]
Y_y_test = Y_test[Y_test==0]
X_a_test = X_test[Y_test==1]
Y_a_test = Y_test[Y_test==1]

clf.score(X_y_test, Y_y_test)
# 0.8717948717948718

clf.score(X_a_test, Y_a_test)
# 0.8533834586466166

2つの正解率の差を約1.8％まで縮めることができました。どのような課題かにもよるとは思いますが、データ数の偏りは抑えるべきだと確認できましたね。次の検証でも同じようにデータ数は揃えます。

ストップワードについて

元のプログラムと今回のプログラムの違いとして、stop_wordsを除くかどうかの検証について説明しました。

stop_wordsについて、これはどんなテキストにも出現しうるありふれた単語のことで、英語の場合isやandなどのことを指します。これを除く処理はNLTKというライブラリを使えば簡単に実装できるのですが、日本語は用意されていません。ただし、TF-IDFを適用した段階でストップワードのような単語の重みはあらかじめ抑えられているので、ストップワードを除く必要性はあまりないと参考文献でも言及されています。これについては後で検証しますので、ここではストップワードを除かずそのまま学習させます。

ということで、ここではストップワードを除く場合も検証してみます。前述のようにNLTKのストップワードには日本語のものはないので、
http://svn.sourceforge.jp/svnroot/slothlib/CSharp/Version1/SlothLib/NLP/Filter/StopWord/word/Japanese.txt
をstopwords.txtとしてダウンロード（コピペ）します。これは京都大学が作成したSlothLibというライブラリに登録されている単語ベースによるストップワードです。分かち書きで分割された単語のうちこのストップワードに含まれるものを除きます。今回はTfidfVectorizerのパラメータstop_wordsはNoneのままで、tokenizerにストップワードを除くものを追加します。

with open('stopwords.txt', 'r') as f:
    stopwords = []
    line = f.readline()
    while line:
        if line != '\n':
            stopwords.append(line.strip())
        line = f.readline()

def tokenizer(text):
    m = MeCab.Tagger('-Owakati')
    wakati_text = m.parse(text)
    return wakati_text.split()

def tokenizer_not_stopwords(text):
    m = MeCab.Tagger('-Owakati')
    wakati_text = m.parse(text)
    wakati_list = wakati_text.split()
    drop_words = set(wakati_list) & set(stopwords)
    return list(set(wakati_list) - drop_words)

また、tokenizerとtokenizer_not_stopwordsをまとめて検証するためparam_gridを以下のように変更します。

param_grid = [{'vect__ngram_range': [(1, 1)],
               'vect__stop_words': [None],
               'vect__tokenizer': [tokenizer, tokenizer_not_stopwords], # 追加
               'clf__penalty': ['l1', 'l2'],
               'clf__C': [1.0, 10.0, 100.0]},
             {'vect__ngram_range': [(1, 1)],
               'vect__stop_words': [None],
               'vect__tokenizer': [tokenizer, tokenizer_not_stopwords], # 追加
               'vect__use_idf': [False],
               'vect__norm': [None],
               'clf__penalty': ['l1', 'l2'],
               'clf__C': [1.0, 10.0, 100.0]}
             ]

実行結果

gs_lr_tfidf.best_params_
# {'clf__C': 10.0,
#  'clf__penalty': 'l2',
#  'vect__ngram_range': (1, 1),
#  'vect__stop_words': None,
#  'vect__tokenizer': <function __main__.tokenizer_not_stopwords(text)>}

gs_lr_tfidf.best_score_
# 0.863961813842482

clf = gs_lr_tfidf.best_estimator_
clf.score(X_test, Y_test)
# 0.8589981447124304

パラメータはtokenizer_not_stopwordsの方になっていますが、正解率には最初と比べて有意な差は見られません（先ほどの検証を踏まえARuFaさんのデータ数を削っているので若干下がっています）。TF-IDFを適用する場合、やはりストップワードを除く必要性は低そうですね。

以上で終わりです。ありがとうございました！

概要

この記事はPythonの計算結果をsiloファイルとして出力し、それをVisItで可視化しようと奮闘したときに生まれた副産物です。

インストール

pyvisfile

pip install pyvisfile

でpyvisfileをインストールします。これがsiloファイルを作成するために必要なモジュールです。

その他もろもろをインストール、と思いきや...

pyvisfileを動作させるにはboost-pythonとPyUbrasというモジュールも必要らしいことがわかりました。

brew install boost-python

の後に

pip install pyublas

とするとboost/python.hppがありませんとエラー。そんなはずはない、と思いネットサーフィンをしていると...同じくpyublasのインストールができないとの報告を発見。

NumPy・SciPyを用いた数値計算の高速化 : 落ち穂拾いのBoost/Pythonの章にて、「boostやPyUblasのビルドがPython3ではできなかった」と書かれています。

そのほかにも、こんなStackOverFlowの記事を発見。

結言

PyUblasやBoostの開発がPython3で行われてないっぽい？なんともモヤっとした終わり方ですが、Pythonからsiloファイルを書き出して、それをVisItで描画するという方法はあまり推奨できないのかなぁという感じでした。それでもmatPlotlibやMayaviがありますから、まぁ困らないんですけどね。