概要

　Pythonのライブラリpyparsingを使うと、階層的な定義の箇条書きで、読み易く変更し易い文法を定義できる。if文など使わず記述出来る点に目を付け、pyparsingのクラスやメソッド、変数名に日本語を使って文法を書いてみた。同じ内容の英文記述に較べて、日本語によるコードは一目見た時に把握し易いと感じた。クラスやメソッドまで日本語にしたのはやりすぎかもしれないが、Pythonで日本語を使ってここまでできるとは思っていなかった。
Python3.7, pyparsing 2.4.6を使用。(Anacondaディストリビューション）

記述と実行例

　組織の3種類のメンバ名簿を想定して、それを読み込むパーサの文法を日本語で定義してみた。　Pythonの予約語以外の変数名（文法名、式名）、関数名、importしたクラス名や関数名、パース対象とも漢字を使っている。
　コードは、上から下に向かって文をボトムアップに積み上げた記述になる。最後に記述された以下の文の右辺式がトップレベルの文法で、組織のメンバに3種類あることがわかる。

　協会員 = 賛助会員 | 学生会員 | 個人会員

　ボトムアップに、と書いたが、記述の際はこの最後の定義をまず決め、次いで部品に相当する下位の定義を書いたら、この最後の文から細部に分解していく方法をとった。
　一番重要な3種類のメンバの分岐を行うために、名簿の各行の最初のトークンに一致する式を定義する。つまりパースする文字列の最初の一致が会社名か学校名かで分岐する。個人会員はそれ以外というわけだ。(以下にコードを抜き出し)

会社名 = 後方一致('会社')
賛助会員 = (会社名 + 代表者 + 会員番号)('賛助会員')

学校名 = 後方一致('大学') | 後方一致('高専') | 後方一致('大学校')
学生会員 = (学校名 + 姓名 + 姓名読み + 会員番号)('学生会員')

　尚、〇✖株式会社のように、区切り無の連続した文字列を想定した会社名、学校名の一致は上記のように正規表現の後方一致で行っている。 当初、以下の記述を考えていたのだが先行する式である漢字列(Word)に、例えば '株式会社' まで食われてしまういわゆる過食(greedy)問題でうまくいかなかった。最長一致も試したがうまくいかない。pyparsingではトークンを左から消費していくためで前方一致では問題が起きない。

"""後方一致は過食問題を起こす"""
会社名 = 結合(漢字列 + oneOf('株式会社 合同会社 有限会社'))('会社名')
"""前方一致は過食問題を起こさない"""
会社名前方 = 結合('株式会社' + 漢字列)

　正規表現を使って文の羅列という形式を保つために、後方一致のRegexを返す関数(lambda式)を設けている。後方一致関数には、'株式会社 合同会社' のように複数の文字列を渡せる定義とした方が効率は良いが、単一引数にして文法記述で複数記述する形態とした。
　pyparsingで文法を定義する際に、先ほどの過食問題を避けるには、正規表現での回避方法の他に、入力の文字種を前後で変える、区切り文字を入れるなどで、消費を止めることが考えられる。対症療法では解決に無駄に時間をかけることになる。（実際2日間をああでもないこうでもないと無駄にした）

　以下は全コードで、メイン部分でデータを与えてテストしており簡単な例外処理も入れている。但し、バックトラックによると思われるが、pe.locは正しく最初のエラー箇所を示してくれるとは限らないようだ。
　文法記述に最初はとまどうが、いくつか書くとコツがわかってくる。イメージではパース対象の文字列が、文法記述したコードに注入され、どれかの式にマッチしたものだけがフィルタされて抜けてくる、というように捉えている。

parse_OrgMemberRecordReg.py

#by T.Hayashi
#tested with Python3.7, pyparsing 2.4.6
#don't use full-width space as delimitter in this script.
from pyparsing import (
       Combine as 結合,
       Word as 列,
       nums as 数字,
       __version__ as 版数,
       Regex ,
       pyparsing_unicode as uni,
       ParseException)

#以下日本語
def 文法を定義():

    後方一致 = lambda s : Regex(r'.*'+s)

    整数 = 列(数字)
    漢字列 = 列(uni.Japanese.Kanji.alphas)
    かな列 = 列(uni.Japanese.Hiragana.alphas)

    会員番号 = 整数('会員番号')

    姓名 = 漢字列('姓名')
    姓名読み = かな列('姓名読み')

    会社名前方 = 結合('株式会社' + 漢字列)
    会社名 = 会社名前方 | 後方一致('会社')
    代表者 = 漢字列('代表者')
    賛助会員 = (会社名 + 代表者 + 会員番号)('賛助会員')

    学校名 = 後方一致('大学') | 後方一致('高専') | 後方一致('大学校')
    学生会員 = (学校名 + 姓名 + 姓名読み + 会員番号)('学生会員')

    個人会員 = (姓名 + 姓名読み + 会員番号)('個人会員')

    協会員 = 賛助会員 | 学生会員 | 個人会員
    return 協会員

def テスト(gram,instr):
    try:
        r=gram.parseString(instr)
        name=r.getName()
        print(name,r.get(name))
        print()
    except ParseException as pe:
        print(f'error at {pe.loc} of {instr}')
        print(instr)
        #loc : char position.
        print('　'*(pe.loc-2)+'^')
        #print('Explain:\n',ParseException.explain(pe))


print('pyparsing 版数:',版数)       
文法=文法を定義()

テスト(文法,'山田太郎 やまだたろう 3456')
テスト(文法,'架空東大学 川崎三郎 かわさきさぶろう 5127')
テスト(文法,'株式会社架空商事 東太郎 0015') #前方一致
テスト(文法,'架空商事株式会社 海山太郎 0010') #後方一致
テスト(文法,'北北西高専 伊藤一郎 いとういちろう 900')
#エラーの確認　高校は定義に無い
テスト(文法,'北北東高校 鈴木三郎 すずきさぶろう 1000')
#エラーの確認　会社が抜け
テスト(文法,'株式架空商事 東太郎 0015')
#エラーの確認　読みに漢字
テスト(文法,'山田一太郎 やまだ一太郎 3456')

　以下は実行結果。

pyparsing 版数: 2.4.6
個人会員 ['山田太郎', 'やまだたろう', '3456']

学生会員 ['架空東大学', '川崎三郎', 'かわさきさぶろう', '5127']

賛助会員 ['株式会社架空商事', '東太郎', '0015']

賛助会員 ['架空商事株式会社', '海山太郎', '0010']

学生会員 ['北北西高専', '伊藤一郎', 'いとういちろう', '900']

error at 6 of 北北東高校 鈴木三郎 すずきさぶろう 1000
北北東高校 鈴木三郎 すずきさぶろう 1000
　　　　^
error at 7 of 株式架空商事 東太郎 0015
株式架空商事 東太郎 0015
　　　　　^
error at 9 of 山田一太郎 やまだ一太郎 3456
山田一太郎 やまだ一太郎 3456
　　　　　　　^

終わりに

　BNF(Backus-Naur form)風の定義の羅列で、通常のプログラムに比べ理解し易い文法を定義できた。日本語を使ったら、いろいろ予期しないことが起きるのではと思っていたが、それもなく、Pythonでここまでできるとは意外だった。気を付けたのは、過食問題を持ち込まないようにすること、コード入力時見えない全角空白が入らないようにすることであった。
　より大きな規模の文法を正しく動作するように定義、デバッグするのはトレースが難しいこともあり、書き方によっては通常のPythonのプログラムより簡単ではないかもしれない。このため、作っては例外や想定外動作を見て修正することを繰り返す小生の場合は、通常のプログラムに較べて、始めからできるだけ正しいコードを書くことを強く心掛ける必要がある、と思う次第．．。
　注：過食問題と呼んだが一般的な用語ではなくここで仮にそう名付けた。

大量のデータ点で散布図を描くと、あまりに密集してしまって、ある領域にどの程度のデータが存在するのかよくわからなくなる。

例として、手書き数字画像データセット（MNIST）をUMAPで二次元に圧縮した次のようなデータを考える。

import pandas as pd

df = pd.read_csv('./mnist_embedding.csv', index_col=0)
display(df)

	x	y	class
0	1.273394	1.008444	5
1	12.570375	0.472456	0
2	-2.197421	8.652475	4
3	-5.642218	-4.971571	1
4	-3.874749	5.150311	9
...	...	...	...
69995	-0.502520	-7.309745	2
69996	3.264405	-0.887491	3
69997	-4.995078	8.153721	4
69998	-0.226225	-0.188836	5
69999	8.405535	-2.277809	6

70000 rows × 3 columns

xがX座標、yがY座標、classはそれぞれのラベル（0~9のどの数字を書いた画像か）。

普通にmatplotlibで散布図を描いてみる。ちなみに本筋ではないけど、最近追加されたlegend_elements関数によって、複数カテゴリの散布図はfor文をまわさずとも簡単に凡例が作れるようになった。

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(12, 12))

sc = ax.scatter(df['x'], df['y'], c=df['class'], cmap='Paired', s=6, alpha=1.0)

ax.add_artist(ax.legend(*sc.legend_elements(), loc="upper right", title="Classes"))
plt.axis('off')
plt.show()

7万個の点がプロットされている。それぞれの数字ごとにクラスタが別れているのはいいんだけど、これだけデータサイズが大きいと点があまりに密集して、オーバーラップして塗り潰されてしまい、それぞれのクラスの中の構造がほとんど見えない。これをなんとかしたい。

解決策1: sizeやalphaを調整してがんばる

オーバーラップを避けるために、点のサイズを小さくする、あるいは点の透明度を調整して密度をわかりやすくする。試行錯誤が必要だし、必ずしも見やすくなるとは限らない。

fig, ax = plt.subplots(figsize=(12, 12))

sc = ax.scatter(df['x'], df['y'], c=df['class'], cmap='Paired', s=3, alpha=0.1)

ax.add_artist(ax.legend(*sc.legend_elements(), loc="upper right", title="Classes"))
plt.axis('off')
plt.show()

解決策2: Hexagonal Binning

これもよくやる方法。キャンバスを六角形のグリッドで敷き詰めて、それぞれの中に入るデータ点の数を集計して色の濃さで表現する。Pandasのプロット関数を使うのが簡単。

fig, ax = plt.subplots(figsize=(12, 12))

df.plot.hexbin(x='x', y='y', gridsize=100, ax=ax)

plt.axis('off')
plt.show()

解決策3: Datashaderを使う

応用が効いて使いやすい。使い方に慣れさえすれば。

Datashaderは大規模なデータセットについて「ラスタライズされたプロット」を高速に生成するライブラリ。

最初に出力する図の解像度（ピクセル数）を決めてしまってから、各ピクセルにデータを集計して、画像として出力する、という3つのステップで描画する。それぞれのステップで細かく調整ができるので自由度が高い。

各ステップは後述するけど、全部デフォルト設定でちぢめて書くと次のようになる。

import datashader as ds
from datashader import transfer_functions as tf

tf.shade(ds.Canvas().points(df,'x','y'))

各ステップの設定

Datashaderでは、

1. キャンバスを設定

2. 集計関数の設定と計算

3. 画像へ変換

の三つのステップでプロットを作る。以下、それぞれ説明。

1. キャンバスを設定

datashader.Canvasでキャンバスのもろもろを設定する。縦と横の解像度（ピクセル）、対数軸か否か、数値のレンジ（matplotlibでいうxlim, ylim）など。

canvas = ds.Canvas(plot_width=600, plot_height=600, # 縦横600ピクセル
                   x_axis_type='linear', y_axis_type='linear', # 'linear' or 'log'
                   x_range=(-10,15), y_range=(-15,10))

2. 集計関数の設定と計算

上で(600 x 600)ピクセルのキャンバスを作った。このピクセルひとつひとつについて、データをどのように集計するかをここで設定する。たとえば、ピクセルに入るデータ点のカウントに応じて色の濃さを変える、データ点がひとつでも入るか否かの二値にする、など。

たとえば上で設定したcanvas変数に対して以下のように、データフレーム、x軸座標（のカラム名）、y軸座標、集計関数を入れて計算を実行する。datashader.reductions.count関数の場合は、ピクセルに入るデータ点の個数をカウントする。

canvas.points(df, 'x', 'y', agg=ds.count())

<xarray.DataArray (y: 600, x: 600)>
array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]], dtype=int32)
Coordinates:
  * x        (x) float64 -9.979 -9.938 -9.896 -9.854 ... 14.85 14.9 14.94 14.98
  * y        (y) float64 -14.98 -14.94 -14.9 -14.85 ... 9.854 9.896 9.938 9.979

このように、(600 x 600)のサイズの行列で、データ点の個数をカウントした描画用のデータが生成された。

カウントではなくデータ点が入るか否かの二値で集計したい場合は、datashader.reductions.any関数を使って次のようにすればいい。

canvas.points(df, 'x', 'y', agg=ds.any())

<xarray.DataArray (y: 600, x: 600)>
array([[False, False, False, ..., False, False, False],
       [False, False, False, ..., False, False, False],
       [False, False, False, ..., False, False, False],
       ...,
       [False, False, False, ..., False, False, False],
       [False, False, False, ..., False, False, False],
       [False, False, False, ..., False, False, False]])
Coordinates:
  * x        (x) float64 -9.979 -9.938 -9.896 -9.854 ... 14.85 14.9 14.94 14.98
  * y        (y) float64 -14.98 -14.94 -14.9 -14.85 ... 9.854 9.896 9.938 9.979

3. 画像への変換

画像への変換はdatashader.transfer_functionsのshade関数を使う。shade関数の引数に、上で計算した集計済みの行列データを渡せばいい。また他にも様々なtransfer_functionsが用意されていて、画像出力の微調整ができる。ここではカウント集計した結果をset_background関数で白背景にして画像化してみる。

tf.set_background(tf.shade(canvas.points(df,'x','y', agg=ds.count())), 'white')

データ点の密度に応じて濃淡が表現されてだいぶ構造が見やすくなった。

同じようにデータ点が入るか否かの二値で集計した場合もやってみる。

tf.set_background(tf.shade(canvas.points(df,'x','y', agg=ds.any())), 'white')

他の補助データで集計する

これまではデータの座標情報だけ使って集計をしたけど、データ点それぞれになんらかのカテゴリのラベルがついていたり、連続値が割り振られていたりすることもよくある。

単にピクセルに入るデータ点を数えるだけだとそういった情報が反映されないので、それぞれに応じた特別な集計関数が存在する。

補助データがカテゴリカル変数の場合の集計

MNISTの場合は正解クラスのラベルがついているので、それでちゃんと色分けをしてプロットしたい。そのための集計関数として、datashader.reductions.count_catがある。この関数は、それぞれのラベルごとにピクセルに入るデータ点の個数をカウントする。つまりMNISTの場合は(600 x 600)の集計行列が10個できあがることになる。

count_catを使うためには、ラベルデータがPandasのcategory型である必要があるので(int型じゃダメ)、まずはデータフレームのラベル列をcategory型に変換する。

df['class'] = df['class'].astype('category')

count_catで集計する。countやanyの集計関数と違って、データフレームのどのカラムがラベルを表しているのか、カラム名を指定する必要がある。

agg = canvas.points(df, 'x', 'y', ds.count_cat('class'))

それぞれのラベルの色は、ラベルをキーとした辞書で定義しておく。冒頭で描画したときの図の色と合わせるためにmatplotlibから"Paired"の色を取り出す。辞書型のリスト内包を使うと簡単。

import matplotlib
color_key = {i:matplotlib.colors.rgb2hex(c[:3]) for i, c 
             in enumerate(matplotlib.cm.get_cmap('Paired', 10).colors)}
print(color_key)

{0: '#a6cee3', 1: '#1f78b4', 2: '#b2df8a', 3: '#fb9a99', 4: '#e31a1c', 5: '#fdbf6f', 6: '#cab2d6', 7: '#6a3d9a', 8: '#ffff99', 9: '#b15928'}

画像化してみる。各ピクセルの色は、ピクセルに入るデータ点のラベルの数に応じてそれぞれの色がミックスされて描画されるらしい。

tf.set_background(tf.shade(agg, color_key=color_key), 'white')

補助データが連続値の場合の集計

データ点のひとつひとつに、なんらかの連続値が紐づいていることがある。シングルセル解析とかで、数万の細胞の次元圧縮した図に関して、細胞ごとになんらかの遺伝子発現量で色の濃さを変える場合とか。

ピクセルには複数のデータ点が入るので、なんらかの方法で代表値を決めなくてはならない。そのための集計関数として、max, mean, modeなど簡単な統計量は一通り揃えてくれている。

MNISTは連続値補助データがないので、適当に作ってみる。わかりやすい量として、画像の中心のエリアの平均的な輝度を計算してみる。ゼロだと（画像の真ん中を線が走ることはあまりないから）暗くなり、1だと明るくなるはず。

data = pd.read_csv('./mnist.csv').values[:, :784]
data.shape

(70000, 784)

# 28 x 28のサイズの画像なので。
upper_left = 28 * 13 + 14
upper_right = 28 * 13 + 15
bottom_left = 28 * 14 + 14
bottom_right = 28 * 14 + 15

average_center_area = data[:, [upper_left, upper_right, 
                               bottom_left, bottom_right]].mean(axis=1)

まずは普通にmatplotlibで描いてみる。

fig, ax = plt.subplots(figsize=(12, 12))

sc = ax.scatter(df['x'], df['y'], c=average_center_area, cmap='viridis', 
                vmin=0, vmax=255, s=6, alpha=1.0)

plt.colorbar(sc)
plt.axis('off')
plt.show()

やはりつぶれてしまってよくわからない。

Datashaderに渡して、各ピクセルに入ったデータ点の「最大値」で塗り分けてみる。datashader.reductions.max関数で集計できる。

df['value'] = average_center_area
agg = canvas.points(df, 'x', 'y', agg=ds.max('value'))
tf.set_background(tf.shade(agg, cmap=matplotlib.cm.get_cmap('viridis')), 'white')

見やすくなった。matplotlibのscatterでサイズを小さく調整する場合とあまり変わらないかもしれないが、細かい試行錯誤なしでも綺麗に描画できるのが便利。

あとデータサイズが巨大でも高速なので、平均値で集計する場合はどうなるか、などいろいろと調整してみるのもストレスにならない。

agg = canvas.points(df, 'x', 'y', agg=ds.mean('value'))
tf.set_background(tf.shade(agg, cmap=matplotlib.cm.get_cmap('viridis')), 'white')

はじめに

PySparkでAUCを算出する際、BinaryClassificationEvaluatorクラスを利用すれば簡単に求めることが出来る。
ただし、そのままではモデル間の違いを把握するために、テストデータ全体ではなく、セグメントごとにAUCを算出したいというニーズに対応することが出来ない。

この対処法として、pandas_udfを使ってAUCを算出する集計関数を定義し、aggメソッドで算出することを行った。

　実装例

サンプルは以下の通り。

事前に正解ラベル(true)と予測スコア(pred)を算出の上、それを参照してAUCを算出する集計関数を定義している。

aggメソッドの中で、pandas_udfで定義した集計関数は、sparkで用意された集計関数と併用することはできないので注意。
(併用しようとすると、Cannot use a mixture of aggregate function and group aggregate pandas UDFというエラーが出る)

UDF定義

from sklearn.metrics import roc_auc_score
from pyspark.sql.types import DoubleType
from pyspark.sql.functions import pandas_udf, PandasUDFType


@pandas_udf(DoubleType(), functionType=PandasUDFType.GROUPED_AGG)
def auc_udf(true, pred):
    return roc_auc_score(true, pred)

算出方法

data.groupBy(key).agg(auc_udf('true', 'pred').alias('auc'))

参考

• Sparkでpandas UDFを利用する
• apache spark - Applying UDFs on GroupedData in PySpark (with functioning python example)

QRコードを生成しAPI等で返したり、メール送信する場合、
一度ファイルにセーブし、それを読み出ししたりする処理が入ります。
この処理の場合、I/Oでの速度的問題や、並列処理時に問題が生じます。

BytesIOモジュールを使えば、一度ファイルに吐き出すことなく、インメモリに画像を生成出来ます。

環境

• Python 3.7.4
• qrcode 6.1
• Pillow 7.0.0

qrcodeおよびPillowライブラリが必要です。

pip install qrcode pillow

生成

from io import BytesIO
import base64
import qrcode


class QRImage():

    @staticmethod
    def to_bytes(text: str) -> bytes:
        stream = BytesIO()
        img = qrcode.make(text)
        img.save(fp, "PNG")
        stream.seek(0)
        byte_img = stream.read()
        stream.close()
        return byte_img

    @classmethod
    def to_b64(cls, text: str) -> bytes:
        byte = cls.to_bytes(text)
        return base64.b64encode(byte).decode("utf-8")

if __name__ == "__main__":
    binary = QRImage.to_bytes(text="some_text")
    base64_encoded = QRImage.to_b64(text="some_text")

BytesIO()でバイナリストリームを生成、ファイルストリームのようにmakeやread、saveを行うだけです。

StringIO等も存在し、stringを格納することが出来ます。
また、with構文もサポートしています。

from io import StringIO

def main():
    with StringIO() as fp:
        fp.write("Hello")
        print(fp.closed)     # True
        print(fp.getvalue()) # Hello
    print(fp.closed)         # False

main()

これで中間ファイルとはおさらばしましょう。

LINEBOTで単純なオウム返しを、Heroku、Flask、line-bot-sdkで作成した。丸２日かかり詰まった点も多いのでメモも含めて共有。

・Mac
・Python

（１）環境整備、ディレクトリ構成

デスクトップに、ディレクトリtest_linebotを作成。
ディレクトリ内に仮想環境を構築して起動。

python3 -m venv .
source bin/activate

最終的なディレクトリ構成は以下の通り

test_linebot
├main.py
├runtime.txt
├Procfile
└requirements.txt

（２）必要なフレームワークをインストール

pip install flask
pip install gunicorn
pip install line-bot-sdk

（３）main.pyを作成

main.py

from flask import Flask, request, abort
from linebot import (
    LineBotApi, WebhookHandler
)
from linebot.exceptions import (
    InvalidSignatureError
)
from linebot.models import (
    MessageEvent, TextMessage, TextSendMessage,
)
import os

app = Flask(__name__)

#herokuの環境変数に設定された、LINE DevelopersのアクセストークンとChannelSecretを
#取得するコード
YOUR_CHANNEL_ACCESS_TOKEN = os.environ["YOUR_CHANNEL_ACCESS_TOKEN"]
YOUR_CHANNEL_SECRET = os.environ["YOUR_CHANNEL_SECRET"]
line_bot_api = LineBotApi(YOUR_CHANNEL_ACCESS_TOKEN)
handler = WebhookHandler(YOUR_CHANNEL_SECRET)

#herokuへのデプロイが成功したかどうかを確認するためのコード
@app.route("/")
def hello_world():
    return "hello world!"


#LINE DevelopersのWebhookにURLを指定してWebhookからURLにイベントが送られるようにする
@app.route("/callback", methods=['POST'])
def callback():
    # リクエストヘッダーから署名検証のための値を取得
    signature = request.headers['X-Line-Signature']

    # リクエストボディを取得
    body = request.get_data(as_text=True)
    app.logger.info("Request body: " + body)

    # 署名を検証し、問題なければhandleに定義されている関数を呼ぶ
    try:
        handler.handle(body, signature)
    except InvalidSignatureError:
        abort(400)
    return 'OK'


#以下でWebhookから送られてきたイベントをどのように処理するかを記述する
@handler.add(MessageEvent, message=TextMessage)
def handle_message(event):
    line_bot_api.reply_message(
        event.reply_token,
        TextSendMessage(text=event.message.text))

# ポート番号の設定
if __name__ == "__main__":
    port = int(os.getenv("PORT", 5000))
    app.run(host="0.0.0.0", port=port)

※上記コードの補足説明

try:〜

Webhookに関する記述。Webhookとはイベント（メッセージ送信、友達追加など）が起きた時にイベントを処理するサーバーへイベントを送る処理をするもの（サーバーへ送るためにはLINE DevelopersのWebhookにURLを指定が必要）。

@handler.add(MessageEvent, message=TextMessage)

1つ目の引数にはイベントの種類を入れる（今回はメッセージが送られてきた時に返信したいので、MessageEventとした）、２つ目の引数にはメッセージの種類を入れる（今回はテキストを返したいので、message=TextMessageとした）。

def handle_message(event):

イベント処理する関数handle_messageが呼び出され、reply_messageの第2引数の値がLINEの返信として返される。lineメッセージとして返すためにはlineb_bot_apiのreply_message関数を使う。reply_messageである第一引数のevent.reply_tokenはreply_tokenが入る。これはwebhookオブジェクトから取得できるもので、どのイベントに対して返信するのか識別するもの。イベントの応答トークンを意味する。第二引数にはlinebot.modelsに定義されている返信用のTextSendMessageという関数を入れ、この関数は引数に返すメッセージを入れる。
また、event.message.textはLINEから送られてきたメッセージが格納されている。例えば”おはよう”と送られてきたら、event.message.text="おはよう"が格納されている。仮に、TextSendMessage(text='おはよう'))とすれば、返信は全て"おはよう"と返す。
ちなみに、eventの中身は以下のようになっている。

{
  "message": {
    "id": "***************",
    "text": "おはよう",
    "type": "text"
  },
  "replyToken": "***********************",
  "source": {
    "type": "user",
    "userId": "************************"
  },
  "timestamp": *********************,
  "type": "message"
}

port = int(os.getenv("PORT", 5000))

Herokuは動的にポート番号を割り当てているようなので、os.environ.get()を使用して，以下のようにする。os.environ.get('PORT', 5000)は，環境変数'PORT'を取得を試みて、取得できた場合はその取得した値が返され、取得できない場合：5000が返される。5000はローカル環境で作業する場合を想定としたもの。

# ポート番号の設定
if __name__ == "__main__":
    port = int(os.getenv("PORT", 5000))
    app.run(host="0.0.0.0", port=port)

（４）LINE Developersに登録

LINE Developersへアクセスして、登録後、サービス提供者を表す「プロバイダー」を作成。プロバイダー内で新規チャネルを作成。チャネルの種類はMessage APIを選択。

（５）Herokuの環境変数を設定

Herokuにログインして、アプリを作成する。今回は、testlinebot0319という名前とした。

heroku login

heroku create testlinebot0319

初期化して、

git init

herokuのアプリとgitを紐つけて、

heroku git:remote -a testlinebot0319

herokuの環境変数に、Line developersの「アクセストークンの文字列」と「チャンネルシークレットの文字列」を設定する。
例えば、heroku config:set YOUR_CHANNEL_ACCESS_TOKEN="チャネルアクセストークンの文字列" -a （アプリ名）とする。

heroku config:set YOUR_CHANNEL_ACCESS_TOKEN="チャネルアクセストークンの文字列" -a testlinebot0319
heroku config:set YOUR_CHANNEL_SECRET="チャネルシークレットの文字列" -a testlinebot0319

heroku上に環境変数がちゃんとセットされたか確認。

heroku config

（６）その他、必要なファイルを揃える

Procfile、runtime.txt、requirements.txtを作成する。

runtime.txtは、自身のpythonのバージョンを確認の上作成する。

runtime.txt

python-3.8.0

Procfileは以下を記述。

Prockfile

web: python main.py

requirements.txtは以下をターミナルで入力して記述。

pip freeze > requirements.txt

（７）Herokuへデプロイ

gitを再度初期化、紐つけて、addして、the-firstという名前でcommitする。
最後にHerokuにプッシュ。

git init
heroku git:remote -a testlinebot0319
git add .
git commit -m'the-first'
git push heroku master

heroku openして、

heroku open

ブラウザに以下が出れば成功。

（８）LINE DevelopersのWebhook設定

以下のように、自分のHeroku上のアプリ名をLINE DevelopersのWebhook欄に設定する。Heroku上のアプリ名＝testlinebot0319

この時、Webhookの利用をオンにしておく。
これで、LINE Developersの上記にあるQRコードを読み込み友達登録すればオウム返しのアプリの完成。
うまく、オウム返ししてくれないなどLINEBOTが機能しない場合は、Webhookの利用を、オン、オフを繰り返すとる場合がある（私の場合はそれでうまくいった）。

参考にしたサイト

1時間でWikipedia検索できるLINE BOTをサクッと作ってみよう！
Python + Flask + HerokuでLINE BOT
【Python初心者! -LINE Botでオウム返し編-】

ラズパイ4 + BU-353S4 + PythonでGPSトラッキング

ラズパイを用いて、GPS情報を取得する
Raspberry Pi 4Bを使いますが、別に3とかでも同じだと思います。

用意するもの

• GLOBALSAT BU-353S4 => USB接続のGPSセンサー
• Raspberry Pi 4

手順

必要なパッケージをインストール

sudo apt-get upgrade
sudo apt-get install gpsd gpsd-clients python-gps cu

USBにBU-353S4を差込み、以下のコマンドで接続を確認

lsusb
# Prolific Technology, Inc. PL2303 Serial Portがあればok
ls /dev/ttyUSB*
# => /dev/ttyUSB0
# 使用されているポートを確認（あとで使います）

USBの接続が確認できたら、以下のコマンドでgpsd設定ファイルを作成（既存の場合は下に追加）

vi /etc/default/gpsd
# vim /etc/default/gpsd

/etc/default/gpsd

# 以下の2行を追加（DEVICESには先ほどのデバイス番号）
DEVICES="/dev/ttyUSB0"
GPSD_OPTIONS="-n"

# 自動起動を設定して再起動
sudo systemctl enable gpsd.socket
sudo systemctl start gpsd.socket
sudo reboot

Pythonサンプルコード

gps3をインストール

pip3 install gps3

gps.py

from gps3 import gps3

gps_socket = gps3.GPSDSocket()
data_stream = gps3.DataStream()
gps_socket.connect()
gps_socket.watch()

for new_data in gps_socket:
  if new_data:
    data_stream.unpack(new_data)
    print('time : ', data_stream.TPV['time'])
    print('lat : ', data_stream.TPV['lat'])
    print('lon : ', data_stream.TPV['lon'])

python3 gps.py
# 以下のように出力されます。
# time :  2020-03-19T13:24:08.000Z
# lat :  35.633116667
# lon :  139.703893333
# alt :  17.1

まとめ

意外と簡単だったけど、まともな解説記事やサンプルコードを探すのに苦労した。

参考記事

https://qiita.com/t2hk/items/572c72fbe99362d92e32

はじめに

とあるOSSのコードを眺めてて、良さそうなのがあったのでそれの紹介をば。

コード

とあるOSSというのは、Apache Airflow。
この中で、airflow/utils/session.py がいい感じでした。

簡単な説明

まずは、 session.py から。

import contextlib
from functools import wraps

from airflow import settings

# contextlib.contextmanager を指定すると with を使って close を自動でやってくれる
@contextlib.contextmanager
def create_session():
    """
    Contextmanager that will create and teardown a session.
    """
    session = settings.Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Sessionを使いたい function で使うといい感じに Session を補完してくれる
def provide_session(func):
    """
    Function decorator that provides a session if it isn't provided.
    If you want to reuse a session or run the function as part of a
    database transaction, you pass it to the function, if not this wrapper
    will create one and close it for you.
    """
    @wraps(func)
    def wrapper(*args, **kwargs):
        arg_session = 'session'

        func_params = func.__code__.co_varnames
        session_in_args = arg_session in func_params and \
            func_params.index(arg_session) < len(args)
        session_in_kwargs = arg_session in kwargs
        # function の引数で session があるならそれを使い、なかったら作るという処理
        if session_in_kwargs or session_in_args:
            return func(*args, **kwargs)
        else:
            with create_session() as session:
                kwargs[arg_session] = session
                return func(*args, **kwargs)

    return wrapper

で、次に使う側のコード。
airflow/models/baseoperator.py の 940行目にある

@provide_session
def get_task_instances(self, start_date: Optional[datetime] = None,
                        end_date: Optional[datetime] = None,
                        session: Session = None) -> List[TaskInstance]:
    """
    Get a set of task instance related to this task for a specific date
    range.
    """
    end_date = end_date or timezone.utcnow()
    return session.query(TaskInstance)\
        .filter(TaskInstance.dag_id == self.dag_id)\
        .filter(TaskInstance.task_id == self.task_id)\
        .filter(TaskInstance.execution_date >= start_date)\
        .filter(TaskInstance.execution_date <= end_date)\
        .order_by(TaskInstance.execution_date)\
        .all()

のように session を使う function でデコレータとして指定すると
呼び出し元で session を設定していない場合は新規に作成され（且つ終了時にcloseされる）
session を設定している場合はそれをそのまま使うといういい感じなことが実現できる。

終わりに

この方法はDB接続以外にも色々応用ができそうだなと思う。

参考

• Pythonのデコレータにはwrapsをつけるべきという覚え書き
• with 文と @contextlib.contextmanager が便利

はじめに

皆さん、業務でAWSは使われているでしょうか。
AWS、インフラの構築から運用までいろいろサポートしてくれていて、とても便利ですよね。
それこそインフラ担当だけじゃなくて、CloudWatchやセッションマネージャーのような環境に接続するすべての関係者にとってメリットがある機能なんかもよくリリースされています。

ところで （問題提起）

これらの素晴らしいAWSの機能って、インフラ担当ばっかりメリットを享受していて、コンサルタントや製品開発者にはあまり届いてこないことが多いです。
何故かというと、「マネジメントコンソール」を使える人間が限られているからです。
AWSはどんどんいい機能を出してくれるのに、それを使える人間が限られているのはとてももったいないですよね。
かといって、それらをいろんな人が使えるようにインターフェースを実装するのは大変ですし、AWSが機能拡張するたびに対応する必要があるのも格好が悪いです。

だったら （解決案）

AWSのあらゆる機能にアクセスできる最強のインターフェース、「マネジメントコンソール」を「AWSユーザーが割り当てられていない人」にも使えるようにしたらいいんじゃないか。
これが、本記事の本題になります。

今回使うもの

1.Amazon Cognito

https://dev.classmethod.jp/cloud/aws/what-is-the-cognito/
Cognito は、2014年7月に発表された ユーザーのアイデンティティ をテーマにしたサービスです。「こぐにーと」と読みます。
簡単に言うと、AWS内のリソースをユーザーごとに分けて提供できる機能で、例えばAさん専用のファイルアップロード領域を作ったりできます。

2.カスタム ID ブローカーに対する AWS コンソールへのアクセスの許可

https://docs.aws.amazon.com/ja_jp/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html#STSConsoleLink_programPython
組織のネットワークにサインインするユーザーに対して AWS マネジメントコンソール への安全なアクセスを許可するには、そのための URL を生成するコードを記述して実行できます。この URL は、AWS から取得したサインイントークンを含み、それを使って AWS に対してユーザーを認証します。

3.Python(boto3)

boto3というモジュールを使って、pythonでAWSのAPIを操作します。

どう使うのか (概要)

「Amazon Cognito」のIDPoolを使用することで、アクセス権限を制限したポリシーを持つAWSユーザーを払い出すことができます。
これらはアクセスキーも持っているので、それを使って「カスタム ID ブローカーに対する AWS コンソールへのアクセスの許可」で提示されているログインURLを生成することができます。
これらを行うためにはAWSアカウント上にいくつかのリソースの準備が必要であるため、それらも説明していきます。

AWSリソースの準備

1.AWSリソース操作に使用するユーザーに、アクセス権限を追加

AmazonCognitoPowerUserポリシー、AmazonCognitoDeveloperAuthenticatedIdentitiesポリシーをアタッチしてください。

2.IDPoolの作成

以下のURLから、ユーザーの情報を保管しておくIDPoolという領域を作成してください。
https://ap-northeast-1.console.aws.amazon.com/cognito/create/?region=ap-northeast-1#
1.Identity Pool Name = 好きな名前を付けましょう。

2.Unauthenticated Identitiesで匿名IDを許可するために「Enable Access to Unauthenticated Identities」にチェックを入れてください。今回、認証ロジックについては解説しないため、未認証でアクセスキーを発行します。

3.未認証ユーザーを使用する場合、基本 (クラシック) フローを使用しないと管理コンソールの使用認可を行えないので、「基本 (クラシック) フローを許可する」にチェックを入れてください。

4.プールの作成を行ってください。

5.Identify the IAM roles to use with your new identity pool のページが表示されるので詳細の表示をしてください。（ちなみに、上が認証済みID、下がゲストIDの設定）

6.新しいロールの作成をします。認証済み、未認証それぞれで権限を変えることができるので、Unauth ・Authedそれぞれを作成しましょう。ちなみに、今回Authedは使う予定がないので中身は適当でも問題ありません。

7.Unauth にReadOnlyAccessと以下をアタッチしましょう。今回はセッションマネージャーを使用可能なゲスト用ロールにしてみます。

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Cognito",
            "Effect": "Allow",
            "Action": [
                "mobileanalytics:PutEvents",
                "cognito-sync:*",
                "sts:GetFederationToken"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Sid": "Ssm",
            "Effect": "Allow",
            "Action": [
                "ssmmessages:CreateDataChannel",
                "s3:GetEncryptionConfiguration",
                "ssm:UpdateInstanceInformation",
                "ssmmessages:OpenDataChannel",
                "ssmmessages:OpenControlChannel",
                "ssmmessages:CreateControlChannel",
                "ssm:StartSession"
            ],
            "Resource": "*"
        }
    ]
}

8.サンプルコードのところに書いてあるIDプールのIDをメモしておいてください。

3.以下のpythonのコードからcredentialの設定部分をcognitoに置き換えたlogin_test.pyを実装します。

https://docs.aws.amazon.com/ja_jp/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html#STSConsoleLink_programPython

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

#以下のように実行します。
#python3 login_test.py user_name

import urllib, json, sys
import requests
import boto3
import datetime

_args = sys.argv
_USER                       = _args[1]
_AWS_ACCOUNT                = "123456789012"
_CONV_AWS_ACCESS_KEY_ID     = "ASIA*******:"
_CONV_AWS_SECRET_ACCESS_KEY = "**********"
_CONV_AWS_SESSION_TOKEN     = "*********"
_REGION_NAME                = "ap-northeast-1"
_ID_POOL_ID                 = "手順8でメモしておいたものを使用します。"
_ARN                        = "arn:aws:cognito-identity:ap-northeast-1:123456789012:identitypool/ap-northeast-1:*******"
_ROLE_ARN                   = "arn:aws:iam::123456789012:role/Unauth"

class GetLoginUrl():
    def cognito_auth(self):
        try:
            #cognitを操作するためのclient作成
            cognito_client = boto3.client('cognito-identity',
                region_name           = _REGION_NAME,
                aws_access_key_id     = _CONV_AWS_ACCESS_KEY_ID,
                aws_secret_access_key = _CONV_AWS_SECRET_ACCESS_KEY,
                aws_session_token     = _CONV_AWS_SESSION_TOKEN #MFAを使用していないなら不要
            )
            #ID取得
            user_id = cognito_client.get_id(
                AccountId      = _AWS_ACCOUNT,
                IdentityPoolId = _ID_POOL_ID
            )["IdentityId"]
            print("Cognito ID:"+user_id)
        except:
            raise Exception("get id faild.")

        try:
            #Role設定確認
            roles = cognito_client.get_identity_pool_roles(IdentityPoolId=_ID_POOL_ID)["Roles"]["unauthenticated"]
            print("Use role:"+roles)

            # GetOpenIdToken + AssumeRoleWithWebIdenity
            token = cognito_client.get_open_id_token(
                IdentityId=user_id
            )

            sts_client = boto3.client('sts',
                region_name           = _REGION_NAME,
                aws_access_key_id     = _CONV_AWS_ACCESS_KEY_ID,
                aws_secret_access_key = _CONV_AWS_SECRET_ACCESS_KEY,
                aws_session_token     = _CONV_AWS_SESSION_TOKEN #MFAを使用していないなら不要
            )

            d_today = str(datetime.date.today())
            credentials_for_identity = sts_client.assume_role_with_web_identity(
                RoleArn = _ROLE_ARN,
                RoleSessionName = _USER + "-" + d_today,#ログの頭に付く文字列　誰のセッションか識別できる情報を入れよう。
                WebIdentityToken = token["Token"]
            )

            AccessKeyId = credentials_for_identity["Credentials"]["AccessKeyId"]
            SecretKey = credentials_for_identity["Credentials"]["SecretAccessKey"]
            SessionToken = credentials_for_identity["Credentials"]["SessionToken"]
        except:
            #id削除
            #失敗したときは無駄に作成したidは消しておこう。
            del_response = cognito_client.delete_identities(
                IdentityIdsToDelete=[
                user_id
                ]
            )
            raise Exception("cognito_auth faild.","delete id :"+str(del_response["ResponseMetadata"]["RequestId"]))

        url_credentials = {}
        url_credentials['sessionId'] = AccessKeyId
        url_credentials['sessionKey'] = SecretKey
        url_credentials['sessionToken'] = SessionToken
        json_string_with_temp_credentials = json.dumps(url_credentials)

        request_parameters = "?Action=getSigninToken"
        request_parameters += "&SessionDuration=43200"
        if sys.version_info[0] < 3:
            def quote_plus_function(s):
                return urllib.quote_plus(s)
        else:
            def quote_plus_function(s):
                return urllib.parse.quote_plus(s)
        request_parameters += "&Session=" + quote_plus_function(json_string_with_temp_credentials)
        request_url = "https://signin.aws.amazon.com/federation" + request_parameters
        r = requests.get(request_url)
        # Returns a JSON document with a single element named SigninToken.
        signin_token = json.loads(r.text)

        # Step 5: Create URL where users can use the sign-in token to sign in to
        # the console. This URL must be used within 15 minutes after the
        # sign-in token was issued.
        request_parameters = "?Action=login"
        request_parameters += "&Issuer=Example.org"
        request_parameters += "&Destination=" + quote_plus_function("https://console.aws.amazon.com/")
        request_parameters += "&SigninToken=" + signin_token["SigninToken"]
        request_url = "https://signin.aws.amazon.com/federation" + request_parameters

        # Send final URL to stdout
        print (request_url)

    def main(self):
        print("success login! welcome "+_USER)
        self.cognito_auth()

if __name__ == "__main__":
    GLU = GetLoginUrl()
    GLU.main()

4.login_test.pyを実行します。

login_test.pyは、実行されるまでにユーザーが認証を通したという前提で実装されています。
なので、これ単体でたたくとそれだけでアカウントが発行され、とても長いログイン用のURLが発行されます。
そのURLにアクセスすると、マネジメントコンソールの画面にリダイレクトされ、フェデレーテッドログインに成功します。
権限はReadOnlyに加え、セッションマネージャーも許可しているので、EC2からどのインスタンスが立っているか確認したり、セッションマネージャーを使用して環境にアクセスしたりすることができます。

おわりに

今回は、AWSマネジメントコンソールに対してAWSユーザーを発行されていないユーザーがログインできるようにしました。
この仕組みを使えば、IAMで個別にアカウントを管理して、退職者が出たりするたびにメンテナンスする必要もなく、お手軽にマネジメントコンソールを提供することができます。
マネジメントコンソールはAWSが勝手に強化してくれるので、我々の開発工数をかけずに業務効率化を継続して行えるようにもなります。
とても便利ですので、ぜひ一度お試しください。

私もAWS初心者（クラウドプラクティショナー程度）であるため、ご指摘・ご質問・ご感想はどのようなものでもありがたくいただく所存です。
何かございましたら、ぜひコメントを頂ければと存じます。

以上、お疲れ様でした。

はじめに

機械学習もデータ見える化が重要ですよね。それについても様々な先人の知恵がありました。

• 機械学習に関する個人的なメモとリンク集①
• 機械学習に関する個人的なメモとリンク集②

Python

PythonのグラフといえばMatplotlibがよく使われますが、もうちょっとカッコいいグラフにしたいというニーズで記事がまとまっています。

seaborn

-pythonでデータを可視化したいならseabornを使おう！

Yellowbrick

• 【Python】 機械学習の可視化が捗るライブラリ「Yellowbrick」

pandas-profiling

• pandas-profilingが探索的データ解析にめちゃめちゃ便利だった件 - GoogleColab編
• チュートリアル

BI

BIと言えば、最近はTableauやLookerが有名ですが、Google Data Portalが色々とできて好きです。

DataPortal

• データポータル

• 初心者がData Portal (旧Data Studio) 入門するときに見るリンク集

• データポータル ✕ コミュニティビジュアライゼーションまとめ

Tableau

• Tableauから始めるデータサイエンス

$$
\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}}
$$

はじめに

前回の記事で古典線形符号について理解できたので、今回はそれをベースとした量子誤り訂正のクラスである「CSS符号(Calderbank-Shor-Steane code)」について勉強します。さらに、その具体的な符号方式として「Steane符号」についても見ていきます。一通り理解できたところで、量子計算シミュレータqlazyを使って、その「Steane符号」の動作を確認してみます。

ちなみに、「CSS符号」は、より一般的な量子誤り訂正のクラスである「スタビライザー符号(Stabilizer code)」の部分クラスに相当するとのことです。今回の記事は、それへの布石という位置づけでもあります。

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

1. ニールセン、チャン「量子コンピュータと量子通信（３）」オーム社（2005年）

理論の説明

CSS符号の定義

$C_1$と$C_2$は古典線形符号$[n,k_1]$と$[n,k_2]$であり、$C_2 \subset C_1$とします。また、$C_1$と$C_{2}^{\perp}$はともに$t$個の誤りに対応可能であるとします。このとき$t$個の誤りに対応できる、$[n, k_1 - k_2]$の量子符号として、CSS符号$CSS(C_1,C_2)$を構築することができます。$x \in C_1$を符号$C_1$における任意の符号語であるとします。このとき量子状態$\ket{x + C_2}$を、

\ket{x+C_2} \equiv \frac{1}{\sqrt{|C_{2}|}} \sum_{y \in C_2} \ket{x+y}  \tag{1}

のように定義します。ここで、右辺の$+$は2を法とするビットごとの和を表すものとします（以下同様）。この$\ket{x+C_2}$たちの重ね合わせによって表現される符号がCSS符号です。

イキナリなんのことかわかりません。噛み砕きます。

$x$は$[n,k_1]$符号$C_1$の要素なので、$k_1$次元のすべてのバイナリ・ベクトル（$0$または$1$を要素とするベクトル）から生成される$n$次元のバイナリ・ベクトルです。したがって、$x$の総数$|C_1|$は$2^{k_1}$個です。一方、$y$は$[n,k_2]$符号$C_2$の要素なので、$k_2$次元のすべてのバイナリ・ベクトルから生成される$n$次元のバイナリ・ベクトルです。したがって、$y$の総数$|C_2|$は$2^{k_2}$個です。また、$C_2 \subset C_1$ということなので、$k_2 < k_1$です。前回の記事で「古典線形符号」が理解できていれば、ここまでは全然難しくないですね。

さて、式(1)の右辺は、$C_1$の要素$x$と$C_2$の要素$y$との和を指標とする状態ベクトル$\ket{x+y}$を、すべての$y \in C_2$について足しあげる格好になっています。それを$\ket{x+C_2}$という記号で定義しています。少し別の言い方をすると、$\ket{x+C_2}$は、ある$\ket{x} \space (x \in C_1)$を種にして、それに対してすべての$y \in C_2$を総動員して行った変換（ケットの中身に$y$を加える）を全部を合わせた重ね合わせ状態です。

ここで、線形符号の要素同士を足し合わせても、その同じ線形符号の要素になるので¹、右辺のすべてのケットの中身は$C_1$の要素であることに注意しておきましょう。つまり、種になる$x \in C_1$にすべての$y \in C_2 \subset C_1$を加えた結果の各々は、すべて$C_1$に属する符号になります。別の$x^{\prime} \in C_1$を種にしてすべての$y \in C_2$を加えた結果の各々も、すべて$C_1$に属する符号になります。ここで質問です。$x$と$x^{\prime}$を種にして生成された2つの符号の集まり（各々$2^{k_2}$個の集まりですが）に何か関係はありますでしょうか？実は、「全部同じ」または「全部違う」のどちらかであって、部分的に重なっているということはありません。

どういうことでしょうか？

いま考えている集合とは正確には違うのですが、一旦感覚を掴むために、類似した例を上げてみます。$0$から$99$までの整数の集合をイメージしてください。これを集合$C_1$とします。次に、$C_1$の中から$3$の倍数を取り出します。それを$C_2$とします。いま$C_1$の中から、ある特定の整数を取り出し$x$とします。これを種にして、すべての$y \in C_2$を総動員して、その各々を$x$に加えます（ただし$100$を法とした加算にします）。得られた結果は全部$0$から$99$までの整数になるので、$C_1$の要素になっています。例えば、$x=6$としてみましょう。このとき、$y$を加えてできあがった整数は全部$3$の倍数になります。$x^{\prime}=15$を考えて、同じように$y \in C_2$を使って、整数の集合を生成してみます。簡単にわかると思いますが、これも全部$3$の倍数です。つまり、$x=6,x^{\prime}=15$を種にして生成された整数の集合は完全に一致しているということです。別の例として、$x=7,x^{\prime}=31$だとどうでしょうか。生成される整数は、どっちも$3$で割ったら余りが$1$になる集合です。ということで、この場合も両者は完全に一致します。さらに別の例として、$x=11,x^{\prime}=52$だとどうでしょうか。この場合、$x=11$から生成されるのは、$3$で割った余りが$2$の整数集合、$x^{\prime}=52$から生成されるのは、$3$で割った余りが$1$の整数集合です。ということで、両者は完全不一致です。つまり、$x \in C_1$を種に集合$C_2$を使って生成した集合を、$3$で割った余りがいくつになるかで分類することができるということです。もっと言うと、$C_2$によって$x \in C_1$を3つのグループに分類することができます。この分類のことを「剰余類」と呼びます（例えば、「$7$と$31$は同じ剰余類に属している」という言い方をします）。同じ剰余類に属しているかどうかは、いちいち全部生成してみなくても、引き算をしてみればわかります。いまの例でやってみます。$15-6$は$9$、$31-7$は$24$となり、どっちも$3$の倍数です。一方、$52-11$は$41$となり、$3$の倍数ではありません。このように同じ剰余類に属しているかどうかは、引き算をしてみて、それが$C_2$に属しているかどうかで判断できます。

さて、アナロジーはこの辺までにしておきます。前段の$C_1,C_2$の定義は忘れてください。で、改めて、式(1)の定義を見ると、これに類似したことが成り立ちそうな気がしてきます。気がするだけでなく、実際にもそうであるということを以下で示してみます。

まず、同じ剰余類に属している場合、すなわち、$x, x^{\prime} \in C_1$で、$x-x^{\prime} \in C_2$だったとすると、

\ket{x + C_2} = \ket{x^{\prime} + C_2}  \tag{2}

が成り立ちます。では、証明してみます。

【証明】

$\ket{x+C_2} - \ket{x^{\prime}+C_2}$が$0$になることを証明します。

\ket{x+C_2} - \ket{x^{\prime}+C_2} = \frac{1}{|C_2|} (\sum_{y \in C_2} \ket{x+y} - \sum_{y \in C_2} \ket{x^{\prime}+y})  \tag{3}

$x-x^{\prime}=y^{\prime} \in C_2$とおきます。

\ket{x+C_2} - \ket{x^{\prime}+C_2} = \frac{1}{|C_2|} (\sum_{y \in C_2} \ket{x^{\prime}+y^{\prime}+y} - \sum_{y \in C_2} \ket{x^{\prime}+y})  \tag{4}

$y^{\prime\prime} = y^{\prime}+y$とおきます。$y^{\prime}$と$y$は同じ符号$C_2$の要素なので$y^{\prime\prime} \in C_2$であることに注意すると、

\ket{x+C_2} - \ket{x^{\prime}+C_2} = \frac{1}{|C_2|} (\sum_{y^{\prime\prime} \in C_2} \ket{x^{\prime}+y^{\prime\prime}} - \sum_{y \in C_2} \ket{x^{\prime}+y}) = 0 \tag{5}

となります。（証明終）

次に、異なる剰余類に属している場合、すなわち、$x, x^{\prime} \in C_1$で、$x-x^{\prime} \notin C_2$だったとすると、

\braket{x + C_2}{x^{\prime} + C_2} = 0 \tag{6}

が成り立ちます。では、証明してみます。

【証明】

まず、いかなる2つの$y,y^{\prime} \in C_2$をもってきても、$x+y = x^{\prime}+y^{\prime}$にすることはできません。つまり、

x+y \neq x^{\prime} + y^{\prime}  \tag{7}

です。なぜなら、等号が成り立つとすると、$x-x^{\prime} = y^{\prime}-y \in C_2$となり²、前提を否定することになります。したがって、式(7)が成り立ちます。とすると、

\begin{align}
\ket{x+C_2} &= \frac{1}{|C_2|} \sum_{y \in C_2} \ket{x+y} \\
\ket{x^{\prime}+C_2} &= \frac{1}{|C_2|} \sum_{y^{\prime} \in C_2} \ket{x^{\prime}+y^{\prime}} \tag{8}
\end{align}

という2つの状態は、互いに全く重なることのない状態の重ね合わせということになるので、

\braket{x+C_2}{x^{\prime}+C_2} = 0 \tag{9}

が成り立ちます。（証明終）

$\ket{x+C_2}$の$x$は$C_1$の要素なので、その総数は$2^{k_1}$なのですが、上に示した性質があるので、ケットとしての総数はそれより少なくなります。簡単にわかると思いますが、$y \in C_2$の総数で割り算すれば良いです。つまり、$\ket{x+C_2}$の総数は、$|C_1|/|C_2|=2^{k_1}/2^{k_2}=2^{k_1 - k_2}$です。ということで、このCSS符号は、量子ビット長$k_1 - k_2$の状態から生成される$[n, k_1 - k_2]$符号ということになります。

ビット反転と位相反転

それでは、このように定義された量子符号で、なぜどのように誤り訂正ができるのかを見ていきます。が、まず、ビット反転と位相反転が加わった状態がどうなるかを確認しておきます。

いま、ビット反転の誤りを表すベクトルをバイナリ値を要素とする、以下のようなベクトルで表すことにします。

e_1 = (0, \cdots , 0,1,0, \cdots, 0,1,0, \cdots, 0)^T  \tag{10}

ここで、ベクトルの次元は$n$で、誤りが加わる量子ビット番号に相当した要素のみが$1$で、その他が$0$となっているものと思ってください。また、位相反転の誤りを表すベクトルも同様に、

e_2 = (0, \cdots , 0,1,0, \cdots, 0,1,0, \cdots, 0)^T  \tag{11}

と表すことにします。このような誤りによって、先程のCSS符号はどう変化するかと言うと、

\ket{x+C_2} = \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \tag{12}

となります。ビット反転の効果が、右辺のケットの中身に$e_1$が加えられることによって表現されるのは良いですよね。ちょっとわかりにくいのは位相反転の効果が、$(-1)^{(x+y)e_2}$になっているところかと思いますので、若干説明を加えます。

$x+y$は$n$次元のバイナリ・ベクトルでした。それがケットの中に入っているということなので、

x+y = (q_1, q_2, \cdots , q_n)^{T}  \tag{13}

とおいてみると、$\ket{x+y}$は、

\ket{x+y} = \ket{q_1}\ket{q_2} \cdots \ket{q_n}  \tag{14}

と書けます。ここで、$\ket{q_i}$は$\ket{0}$か$\ket{1}$のどちらかです。位相反転は$\ket{0}$をそのままにして、$\ket{1}$を$-\ket{1}$にする変換だったので、式(11)の$n$個の成分の中で$1$となっている場所の$q_i$が$1$になっているときに、式(14)の符号が反転します。つまり、$x+y$と$e_2$の内積分だけ$-1$がかかるということなので、式(12)で示されているように、係数$(-1)^{(x+y)e_2}$が状態の前にかかることになります。

ビット反転誤りの訂正

このように誤りが入った状態をどうやって訂正していくかについて説明します。まず、ビット反転誤りの訂正についてです。式(12)の右辺の$\ket{x+y+e_1}$に注目します。$x+y \in C_1$だったので、$C_1$のパリティ検査行列を$H_1$として、それをケットの中身に適用して誤りシンドロームの計算ができれば、そこにビット反転があった量子ビット番号についての情報が入っているはずです。これを実行するためには、量子誤りシンドロームの結果を格納するためのアンシラが必要になります。すなわち、

\ket{x+y+e_1}\ket{0} \rightarrow \ket{x+y+e_1}\ket{H_1(x+y+e_1)} = \ket{x+y+e_1}\ket{H_1 e_1}  \tag{15}

という変換が実現できれば、右辺のアンシラ$\ket{H_1 e_1}$に、誤りビット番号に関する情報が入ることになります。

では、式(15)の変換は、どんな量子回路で実現できるでしょうか。

いきなり一般的に説明するは難しいので、簡単な例で考えてみます。$\ket{x}\ket{0} \rightarrow \ket{x}\ket{Hx}$という変換を実現したいとします。具体的には、$\ket{x}$は3量子ビットの符号語、$H$はパリティ検査行列、

H =
\begin{pmatrix}
1 & 1 & 0 \\
0 & 1 & 1
\end{pmatrix}  \tag{16}

とします。このとき、生成行列$G$は、

G =
\begin{pmatrix}
1\\
1\\
1
\end{pmatrix}  \tag{17}

です。ということで、これは、1量子ビットを3量子ビットに冗長化する繰り返し符号に他なりません。つまり、$\ket{0} \rightarrow \ket{000}, \ket{1} \rightarrow \ket{111}$のような符号化を実現します。入力ベクトル$x=(x_1, x_2, x_3)^{T}$に$H$を演算した結果が、アンシラに転写されれば良いので、量子回路は以下のようになります。

     [1行目]  [2行目]
|x1> --*-------------
|x2> --|--*----*-----
|x3> --|--|----|--*--
       |  |    |  |
 |0> --X--X----|--|--
 |0> ----------X--X--

[1行目]と書かれている箇所は$H$の1行目に対応した計算です。1列目と2列目の行列要素が1になっているので、1番目のアンシラが$\ket{x_1+x_2}$となるようにしています。[2行目]と書かれている箇所は$H$の2行目に対応した計算です。2列目と3列目の行列要素が1になっているので、今度は、2番目のアンシラが$\ket{x_2 + x_3}$となるようにしています。

任意の$\ket{x}$に対して任意の$H$が定義されたときも、この考え方は一般化できます。$H$の第$i$行の第$j$列が$1$だったとき、$j$番目の符号量子ビットを制御ビット、$i$番目のアンシラ量子ビットを標的ビットにしたCNOTゲートを配備します。これを行列要素が$1$になっている数分繰り返せば良いです。というわけで、式(15)の変換を実現する量子回路をどう作れば良いかわかったと思います³。

元の誤りありの状態は式(12)だったので、量子誤りシンドロームを通した結果は、

\begin{align}
\ket{x+C_2} &= \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \ket{0} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \ket{H_1(x+y+e_1)} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y+e_1} \ket{H_1 e_1} \tag{18}
\end{align}

となります。誤りが1量子ビットに限定されている場合は、最後の$\ket{H_1 e_1}$の中で$\ket{0}$となっていないものは1種類しかありません。それを$\ket{z_1}$とします。アンシラが$\ket{z_1}$となっている右辺の項についてのみ、$z_1$に対応した量子ビット番号（つまり、パリティ検査行列の列ベクトルが$z_1$になっていう列番号）を反転させれば、誤り訂正ができます。2量子ビットの誤りがある場合は、$\ket{0}$以外のアンシラ状態が2種類あるということになります。それを$\ket{z_1},\ket{z_2}$とすると、アンシラが$\ket{z_1}$または$\ket{z_2}$になっている右辺の項についてのみ、$z_1$と$z_2$に対応した量子ビット番号を反転するようにすれば、誤り訂正ができます。3量子ビット以上の誤りがあった場合も同様にして誤り訂正ができます。というわけで、ビット反転誤りの訂正が完了します⁴。ただし、$C_1$は$t$個までの誤りを訂正できる符号だったので、対応できる量子ビット数は$t$個までです。

ビット反転誤りを訂正した結果、状態は以下のようになります。

\frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y} \tag{19}

位相反転誤りの訂正

次に、位相反転誤りの訂正について考えます。ヒントはアダマール変換です。

\begin{align}
\ket{+} \rightarrow \ket{-}  \\
\ket{-} \rightarrow \ket{+}  \tag{20}
\end{align}

という位相反転は、アダマール変換した世界で考えると

\begin{align}
\ket{0} \rightarrow \ket{1}  \\
\ket{1} \rightarrow \ket{0}  \tag{21}
\end{align}

というビット反転となります。ここから、何となくアダマール変換して、ビット反転誤りの訂正をやって、再びアダマール変換をやると、うまく行くような気がします。実際にもそれは正しくて、以下のように、きちんと数式で示すことができます。

まず、$n$量子ビット状態に対するアダマール変換$H^{\otimes n}$は、

H^{\otimes n} \ket{x} = \frac{1}{\sqrt{2^{n}}} \sum_{z} (-1)^{xz} \ket{z}  \tag{22}

となります⁵。これを使うと、式(19)に対するアダマール変換は、

\begin{align}
& \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} \ket{x+y} \\
& \rightarrow \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{(x+y)e_2} H^{\otimes n} \ket{x+y} \\
&= \frac{1}{\sqrt{|C_2| 2^{n}}} \sum_{z} \sum_{y \in C_2} (-1)^{(x+y)e_2} (-1)^{(x+y)z} \ket{z} \\
&= \frac{1}{\sqrt{|C_2| 2^{n}}} \sum_{z} \sum_{y \in C_2} (-1)^{(x+y)(e_2+z)} \ket{z} \tag{23}
\end{align}

$z^{\prime}=z+e_2$とおくと、上の式は、

\begin{align}
& \frac{1}{\sqrt{|C2| 2^{n}}} \sum_{z^{\prime}} \sum_{y \in C_2} (-1)^{(x+y)z^{\prime}} \ket{z^{\prime} + e_2} \\
&= \frac{1}{\sqrt{|C2| 2^{n}}} \sum_{z^{\prime}} (-1)^{xz^{\prime}} \sum_{y \in C_2} (-1)^{yz^{\prime}} \ket{z^{\prime} + e_2} \tag{24}
\end{align}

と変形できます。ここで、$\sum_{y \in C_2} (-1)^{yz^{\prime}}$に注目して、前回の記事の式(46)のあたりで説明した双対符号の性質を使います。いまの状況に焼き直すと、その性質は、

\begin{align}
& z^{\prime} \in C_{2}^{\perp} \Rightarrow \sum_{y \in C_2} (-1)^{yz^{\prime}} = |C_2| \\
& z^{\prime} \notin C_{2}^{\perp} \Rightarrow \sum_{y \in C_2} (-1)^{yz^{\prime}} = 0 \tag{25}
\end{align}

と表されます。これを式(24)に当てはめると、

\sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime} + e_2}  \tag{26}

となります。つまり、アダマール変換を実行した結果、位相反転$e_2$の効果はケットの中の加算として現れることになります。こうなれば、後は先程と同様、ビット反転の誤り訂正の手続きで$e_2$の効果を消去することができます。結果、

\sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime}}  \tag{27}

ということになります。再度アダマール変換を実行すると、完全に元に戻るはずです。やってみます。

\begin{align}
& \sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \ket{z^{\prime}} \\
& \rightarrow \sqrt{\frac{|C_2|}{2^{n}}} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{xz^{\prime}} \frac{1}{\sqrt{2^{n}}} \sum_{w} (-1)^{z^{\prime} w} \ket{w} \\
&= \frac{\sqrt{|C_2|}}{2^{n}} \sum_{w} \sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{(x+w)z^{\prime}} \ket{w} \tag{28}
\end{align}

再び、$\sum_{z^{\prime} \in C_{2}^{\perp}} (-1)^{(x+w)z^{\prime}}$に対して、双対符号の性質を使います。$x+w \in C_2$のときのみ$|C_2|$となり、その他は$0$なので、以下のように変形できます。

\frac{\sqrt{|C_2|}}{2^{n}} \sum_{w,x+w \in C_2} |C_{2}^{\perp}| \ket{w} \tag{29}

ここで、

\begin{align}
& |C_2| = 2^{k_2}, |C_{2}^{\perp}| = 2^{n-k_2} \\
& |C_2| |C_{2}^{\perp}| = 2^{n} \tag{30}
\end{align}

が成り立つので、式(29)は、

\frac{1}{\sqrt{|C_2|}} \sum_{w,x+w \in C_2} \ket{w} \tag{31}

となります。ここで、$x+w=x-w=y \in C_2$とおくと、結局、

\frac{1}{\sqrt{|C_2|}} \sum_{y \in C_2} \ket{x+y} \tag{32}

とできるので、これで元の状態が完全に復元されることになります。

ビット反転や位相反転以外の連続的な誤りがあったときも、これだけで対応できることは、前々回の記事で説明していました。ということで、CSS符号がどう構築されて、どんな量子回路を通せば、誤り訂正ができるかの説明は一応完了です。

が、最後にもう一言。

CSS符号には、パラメータ$u,v$をもったバリエーションがあります。

\ket{x+C_2} \equiv \frac{1}{|C_2|} \sum_{y \in C_2} (-1)^{uy} \ket{x+y+v}  \tag{33}

で定義され、$CSS_{u,v}(C_1,C_2)$符号と呼ばれています。余計なパラメータが入っているのですが、先程の$CSS(C_1,C_2)$符号と同じ量子回路で誤り訂正ができます。量子鍵配送で有用になるとのことなので、ここで定義だけ掲載し、証明は省略します⁶。

Steane符号

CSS符号の一般論がわかったので、具体例を上げて、さらに理解を確実にしたいと思います。「Steane符号」というものがあります。これは、$C_1=C, C_2=C^{\perp}$として、$C$をHamming符号にしたCSS符号です。$C_1$のパリティ検査行列を$H_1$、生成行列を$G_1$とします。いま簡単のため、$[7,3]$Hamming符号とすると、$H_1,G_1$は各々、

H_1 =
\begin{pmatrix}
0 & 1 & 1 & 1 & 1 & 0 & 0 \\
1 & 0 & 1 & 1 & 0 & 1 & 0 \\
1 & 1 & 0 & 1 & 0 & 0 & 1
\end{pmatrix}  \tag{34}

G_1 =
\begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & 0 & 1 \\
0 & 1 & 1 & 1 \\
1 & 0 & 1 & 1 \\
1 & 1 & 0 & 1
\end{pmatrix}  \tag{35}

と表せます（標準形で書きました）。一方、$C_2$は、その双対符号ですので、定義から、

H_2 = G_{1}^{T} =
\begin{pmatrix}
1 & 0 & 0 & 0 & 0 & 1 & 1 \\
0 & 1 & 0 & 0 & 1 & 0 & 1 \\
0 & 0 & 1 & 0 & 1 & 1 & 0 \\
0 & 0 & 0 & 1 & 1 & 1 & 1
\end{pmatrix}  \tag{36}

G_2 = H_{1}^{T} =
\begin{pmatrix}
0 & 1 & 1 \\
1 & 0 & 1 \\
1 & 1 & 0 \\
1 & 1 & 1 \\
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{pmatrix}  \tag{37}

と書き表せます。

ところで、このように定義した線形符号をベースにした量子符号が確かにCSS符号であるということを言うためには、$C_1$と$C_{2}^{\perp}$が同じ$t$個の誤りに対応できる、つまり符号の距離（最小距離）が等しいということと、$C_2 \subset C_1$であることが必要です。

前者は、定義より$C_1$も$C_{2}^{\perp}$もともに$C$なので自明です。後者は、前回の記事の式(45)あたりで説明したことを使えばわかります。再掲します。

G^{T} G = 0 \Leftrightarrow C \subseteq C^{\perp}  \tag{38}

つまり、$G_{2}^{T} G_2 = 0$が示せれば、$C_2 \subseteq C_{2}^{\perp}$、すなわち、$C_2 \subseteq C_1$が証明できたことになります。やってみます。

G_{2}^{T} G_2 =
\begin{pmatrix}
0 & 1 & 1 & 1 & 1 & 0 & 0 \\
1 & 0 & 1 & 1 & 0 & 1 & 0 \\
1 & 1 & 0 & 1 & 0 & 0 & 1
\end{pmatrix}
\begin{pmatrix}
0 & 1 & 1 \\
1 & 0 & 1 \\
1 & 1 & 0 \\
1 & 1 & 1 \\
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{pmatrix} =
\begin{pmatrix}
0 & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}  \tag{39}

ということで、$C_2 \subseteq C_{2}^{\perp}$であることが確認できました⁷。

それでは、ベースとなる古典線形符号がわかったので、これからCSS符号を構築してみます。式(1)を改めて見てみます。

\ket{x+C_2} \equiv \frac{1}{\sqrt{|C_{2}|}} \sum_{y \in C_2} \ket{x+y}  \tag{1}

これに従って符号を構築すれば良いです。

いま$C_1$は[7,4]符号、$C_2$は[7,3]符号です。したがって、できあがるCSS符号は[7,1]符号です。1量子ビットを7量子ビットに冗長化する量子符号ということなので、2つの$x$を持ってきて、式(1)の右辺のようにすべての$y$を総動員して重ね合わせれば良いです。$y$の方は[7,3]符号なので、すべての3次元のバイナリ・ベクトルを持ってきて、式(35)の生成行列$G_2$を演算してやれば良いです。さて、問題はどんな$x$を持ってくれば良いかです。同じ剰余類に属する2つのの$x$を持ってきたとすると、右辺は全く同じになるので、意味がありません。違う剰余類に属する2つの$x$を持ってくる必要があります。2つの$x$の差分が$C_2$に属していないようにすれば良いので、エイヤで$x=(0,0,0,0,0,0,0)^{T}$と$x^{\prime} = (1,1,1,1,1,1,1)^{T}$という2つを持ってきます。こうすれば差分が$C_2$の要素になっていなさそうです。$x$を種にして生成される状態を$\ket{0_L}$、$x^{\prime}$を種にして生成される状態を$\ket{1_L}$とすると、

\begin{align}
\ket{0_L} &= \frac{1}{\sqrt{8}} (\ket{0000000} + \ket{1101001} + \ket{1011010} + \ket{0110011} + \ket{0111100} + \ket{1010101} + \ket{1100110} + \ket{0001111}) \\
\ket{1_L} &= \frac{1}{\sqrt{8}} (\ket{1111111} + \ket{0010110} + \ket{0100101} + \ket{1001100} + \ket{1000011} + \ket{0101010} + \ket{0011001} + \ket{1110000}) \tag{40}
\end{align}

となり、これで量子符号ができました。実際に、$\ket{\psi} = \alpha \ket{0} + \beta \ket{1}$という1量子ビット状態を符号化する際には、

\ket{\psi}　\rightarrow \ket{\psi_{L}} = \alpha \ket{0_L} + \beta \ket{1_L} \tag{41}

を実現するように適当な量子回路を構築します。

次に、この状態に対して誤りが加わる想定で、先程説明したような誤りシンドロームを計算する回路を実行します。つまり、アンシラを追加して、各状態に対して、

\ket{x} \ket{0} \rightarrow \ket{x} \ket{H_1 x}  \tag{42}

を実現する量子回路を実行すれば、アンシラに$H_1 e_1$というビット反転誤りの効果が移るのでした。いまの場合、3量子ビット分のアンシラを用意します。先程説明したように、パリティ検査行列の各行に含まれる$1$の場所に注意しながら、CNOTゲートを並べます。

|x1> -----------*--------*-------- ...
|x2> --*--------|--------|-*------ ...
|x3> --|-*------|-*------|-|------ ...
|x4> --|-|-*----|-|-*----|-|-*---- ...
|x5> --|-|-|-*--|-|-|----|-|-|---- ...
|x6> --|-|-|-|--|-|-|-*--|-|-|---- ...
|x7> --|-|-|-|--|-|-|-|--|-|-|-*-- ...
       | | | |  | | | |  | | | |       
 |0> --X-X-X-X--|-|-|-|--|-|-|-|-- ...
 |0> -----------X-X-X-X--|-|-|-|-- ...
 |0> --------------------X-X-X-X-- ...

次に、アンシラの状態に応じて、ビット反転をします。アンシラの状態がパリティ検査行列$H_1$の列ベクトルの値と一致しているところに対応したビットを反転します。つまり、アンシラが$\ket{011}$なら第1量子ビット、$\ket{101}$なら第2量子ビット、$\ket{110}$なら第3量子ビット…という具合にビット反転すれば、ビット反転誤りは訂正できます。先程の回路に続けて、以下のようにします。

|x1> ... ----X--------------------------------------------- ...
|x2> ... ----|------X-------------------------------------- ...
|x3> ... ----|------|------X------------------------------- ...
|x4> ... ----|------|------|------X------------------------ ...
|x5> ... ----|------|------|------|------X----------------- ...
|x6> ... ----|------|------|------|------|------X---------- ...
|x7> ... ----|------|------|------|------|------|------X--- ...
             |      |      |      |      |      |      |
 |0> ... --X-*-X----*------*------*------*----X-*-X--X-*-X-
 |0> ... ----*----X-*-X----*------*----X-*-X----*----X-*-X-
 |0> ... ----*------*----X-*-X----*----X-*-X--X-*-X----*---

これで、ビット反転誤りが訂正できたので、次に位相反転誤りに対応します。まず、アダマール変換を使います。同時に、ビット反転誤り訂正用のアンシラは役目が終わったので初期化します。上の回路に続けて、以下を実行します。

|x1> ... --H-------------*--------*-------- ...
|x2> ... --H----*--------|--------|-*------ ...
|x3> ... --H----|-*------|-*------|-|------ ...
|x4> ... --H----|-|-*----|-|-*----|-|-*---- ...
|x5> ... --H----|-|-|-*--|-|-|----|-|-|---- ...
|x6> ... --H----|-|-|-|--|-|-|-*--|-|-|---- ...
|x7> ... --H----|-|-|-|--|-|-|-|--|-|-|-*-- ...
                | | | |  | | | |  | | | |       
 |0> ... -------X-X-X-X--|-|-|-|--|-|-|-|-- ...
 |0> ... ----------------X-X-X-X--|-|-|-|-- ...
 |0> ... -------------------------X-X-X-X-- ...

誤りシンドロームの計算ができたので、位相反転誤りを訂正して（実際にはビット反転誤りを訂正して）、最後にアダマール変換を実行して、元に戻します。

|x1> ... ----X---------------------------------------------H--
|x2> ... ----|------X--------------------------------------H--
|x3> ... ----|------|------X-------------------------------H--
|x4> ... ----|------|------|------X------------------------H--
|x5> ... ----|------|------|------|------X-----------------H--
|x6> ... ----|------|------|------|------|------X----------H--
|x7> ... ----|------|------|------|------|------|------X---H--
             |      |      |      |      |      |      |
 |0> ... --X-*-X----*------*------*------*----X-*-X--X-*-X----
 |0> ... ----*----X-*-X----*------*----X-*-X----*----X-*-X----
 |0> ... ----*------*----X-*-X----*----X-*-X--X-*-X----*------

これで、誤り訂正は完了です⁸。

シミュレーション

実装

それでは、上で説明したSteane符号を実装してみます。qlazyでは、量子回路の計算は、量子状態または密度演算子に相当するクラスのインスタンスを作って、ゲート演算することで実行します。量子状態でも密度演算子でもどちらでも良いのですが、雑音付加に量子チャネル（分極解消とか、振幅ダンピングとか）を利用できる密度演算子の方でやってみます⁹。

全体のコードは以下です。

import numpy as np
from qlazypy import QState, DensOp

Hamming   = np.array([[0,1,1,1,1,0,0], [1,0,1,1,0,1,0], [1,1,0,1,0,0,1]])
Hamming_T = Hamming.T

Steane_0 = ['0000000', '1101001', '1011010', '0110011',
            '0111100', '1010101', '1100110', '0001111']
Steane_1 = ['1111111', '0010110', '0100101', '1001100',
            '1000011', '0101010', '0011001', '1110000']

def generate_qstate(qid_C, qid_S):

    a = np.random.rand() + np.random.rand() * 1.j
    b = np.random.rand() + np.random.rand() * 1.j

    print("== quantum state (a |0L> + b |1L>) ==")
    print("- a = {:.4f}".format(a))
    print("- b = {:.4f}".format(b))

    qvec = np.full(2**len(qid_C), 0.+0.j)
    for s in Steane_0: qvec[int(s, 2)] = a
    for s in Steane_1: qvec[int(s, 2)] = b

    norm = np.linalg.norm(qvec)
    qvec = qvec / norm

    qs_C = QState(vector=qvec)
    qs_S = QState(len(qid_S))
    qs = qs_C.tenspro(qs_S)
    de_ini = DensOp(qstate=[qs])
    de_fin = de_ini.clone()

    QState.free_all(qs_C, qs_S, qs)
    return de_ini, de_fin

def noise(self, kind='', prob=0.0, qid=[]):

    print("== noise ({:}) ==".format(kind))
    print("- qubit = {:}".format(qid))
    print("- prob  = {:}".format(prob))

    qchannel = {'bit_flip':self.bit_flip, 'phase_flip':self.phase_flip,
                'bit_phase_flip':self.bit_phase_flip,
                'depolarize':self.depolarize, 'amp_dump':self.amp_dump,
                'phase_dump':self.phase_dump}
    [qchannel[kind](i, prob=prob) for i in qid]
    return self

def correct(self, kind, qid_C, qid_S):

    self.reset(qid=qid_S)

    if kind == 'phase_flip': [self.h(q) for q in qid_C]

    # syndrome
    for i, row in enumerate(Hamming):
        [self.cx(qid_C[j], qid_S[i]) if row[j] == 1 else False for j in range(len(row))]

    # correction
    for i, row in enumerate(Hamming_T):
        [self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]
        self.mcx(qid=qid_S+[qid_C[i]])
        [self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]

    if kind == 'phase_flip': [self.h(q) for q in qid_C]

    return self

if __name__ == '__main__':

    # add custom gates
    DensOp.add_method(noise)
    DensOp.add_method(correct)

    # set registers
    qid_C = DensOp.create_register(7) # registers for code space
    qid_S = DensOp.create_register(3) # registers for error syndrome
    DensOp.init_register(qid_C, qid_S)

    # generate initial quantum state (density operator)
    de_ini, de_fin = generate_qstate(qid_C, qid_S)

    # add noise
    de_fin.noise(kind='depolarize', qid=[qid_C[3]], prob=1.0)

    # error correction
    de_fin.correct('bit_flip', qid_C, qid_S)
    de_fin.correct('phase_flip', qid_C, qid_S)

    # print result
    print("== result ==")
    print("- fidelity = {:.6f}".format(de_fin.fidelity(de_ini, qid=qid_C)))

    DensOp.free_all(de_ini, de_fin)

何をやっているか、簡単に説明します。基本的には、上で説明したSteane符号による誤り訂正を実行しているだけです。では、メイン処理部を見てください。

# add custom gates
DensOp.add_method(noise)
DensOp.add_method(correct)

で、雑音付加と誤り訂正を各々一つのかたまりとしてカスタムゲートを定義して、メソッドとして設定しています。処理内容は上の方で関数定義されています。

# set registers
qid_C = DensOp.create_register(7) # registers for code space
qid_S = DensOp.create_register(3) # registers for error syndrome
DensOp.init_register(qid_C, qid_S)

で、使用する量子レジスタを定義しています。この程度であれば、こんなクラスメソッドを使わなくても手で書いてしまった方が早いかもしれません。これで、qid_Cは[0,1,2,3,4,5,6]というリストになり、qid_Sは[7,8,9]というリストになります。

# generate initial quantum state (density operator)
de_ini, de_fin = generate_qstate(qid_C, qid_S)

Steane符号を使った量子状態（密度演算子）をランダムに用意します。関数定義を見ていただければわかると思いますが、$a,b$という複素数をランダムに設定して、7量子ビットの量子状態$a \ket{0_L} + b \ket{1_L}$を作成し、3量子ビットのアンシラとのテンソル積を実行することによって10量子ビットの状態を作成します。それに基づき密度演算子を作成してリターンします。複製して２つ全く同じものを作っていますが、これはプログラムの最後で、初期状態と演算結果の状態を比較評価するためです。

# add noise
de_fin.noise(kind='depolarize', qid=[qid_C[3]], prob=1.0)

で、雑音を加えます。qlazyに標準搭載されている雑音（量子チャネル）は、「ビット反転(bit_flip)」「位相反転(phase_flip)」「ビット位相反転(bit_phasee_flip)」「分極解消(depolarize)」「振幅ダンピング(amp_dump)」「位相ダンピング(phase_dump)」の6種類であり、各々、適用する量子ビット番号リストと雑音の強度を表す確率を引数に与えるようになっています。関数（カスタムゲート）noiseは、引数にその量子チャネルの種別を表す文字列と量子ビット番号リストと確率を指定して、密度演算子に適用するものです。詳細は関数定義をご覧ください。

# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
de_fin.correct('phase_flip', qid_C, qid_S)

で、ビット反転誤り訂正と位相反転誤り訂正を実行しています。関数（カスタムゲート）correctは、引数にビット反転対応なのか位相反転対応なのかを表す文字列と、符号空間とアンシラに対応した量子ビット番号リストを指定します。correectの中身を見てみます。

self.reset(qid=qid_S)

で、アンシラを初期化します。誤りシンドローム計算のために、まず初期化が必要です。

if kind == 'phase_flip': [self.h(q) for q in qid_C]

位相反転に対応したい場合、アダマールをまず実行しないといけないので、ここでやっています。

# syndrome
for i, row in enumerate(Hamming):
    [self.cx(qid_C[j], qid_S[i]) if row[j] == 1 else False for j in range(len(row))]

で、誤りシンドロームの計算を実行します。上で説明した回路を実行するため、Hamming符号のパリティ検査行列の各行ごとにCNOTを適切にかけるようなループを回しています。

# correction
for i, row in enumerate(Hamming_T):
    [self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]
    self.mcx(qid=qid_S+[qid_C[i]])
    [self.x(qid_S[j]) if row[j] == 0 else False for j in range(len(row))]

で、誤りシンドロームの結果に応じて、ビット反転して元に戻します。Hamming符号のパリティ検査行列の各列に応じて、マルチ制御NOT（mcxメソッド）を適切にかけるようなループを回しています。

if kind == 'phase_flip': [self.h(q) for q in qid_C]

で、位相反転対応の場合、最後にアダマールをかけて、元に戻すようにします。以上で誤り訂正が完了します。

再度、メイン処理部に戻ります。

# print result
print("== result ==")
print("- fidelity = {:.6f}".format(de_fin.fidelity(de_ini, qid=qid_C)))

で、最初の密度演算子と誤り訂正処理を実行した後の密度演算子とを比較評価するため、fidelityメソッドで両者の忠実度を計算して表示します。引数qidに関心のある量子ビット番号リストを指定することで、該当部分のみの忠実度を計算することができます。

DensOp.free_all(de_ini, de_fin)

で、使用したメモリを開放します。クラスメソッドfree_allに引数として複数のDensOpインスタンスを指定すれば、1行で複数インスタンスのメモリを開放できます（引数に何個インスタンスを指定しても大丈夫です）。

動作の確認

実行結果を示します。3番目の量子ビットに対して分極解消チャネルを確率1.0で適用した結果です。

== quantum state (a |0L> + b |1L>) ==
- a = 0.4835+0.0654j
- b = 0.2558+0.9664j
== noise (depolarize) ==
- qubit = [3]
- prob  = 1.0
== result ==
- fidelity = 1.000000

忠実度が1.0になっているので、誤り訂正は無事成功しました。量子ビット番号や量子チャンネルや確率をいろいろ変えてみましたが、どんな場合でも忠実度は1.0となり、誤り訂正できることがわかりました。

ところが、当然ですが、2つの量子ビットに雑音が入るとダメでした。以下の通りです。

== quantum state (a |0L> + b |1L>) ==
- a = 0.4749+0.4393j
- b = 0.5424+0.6672j
== noise (depolarize) ==
- qubit = [3, 4]
- prob  = 1.0
== result ==
- fidelity = 0.864784

それから、これも当然ですが、位相反転の誤り訂正を省略した場合もダメでした。

# error correction
de_fin.correct('bit_flip', qid_C, qid_S)
# de_fin.correct('phase_flip', qid_C, qid_S)

という具合に位相反転対応部分をコメントアウトすると、

== quantum state (a |0L> + b |1L>) ==
- a = 0.2903+0.1936j
- b = 0.8322+0.4586j
== noise (depolarize) ==
- qubit = [3]
- prob  = 1.0
== result ==
- fidelity = 0.707107

となり、これも誤り訂正は失敗します。

というわけで、予想通りの動作が確認できました。

おわりに

ある条件を満たした古典線形符号を2つ持ってくれば、そこから量子符号を1つ必ず構築できるということがわかりました。つまり、いろんな量子符号を具体的に構築できる強力なツールの一つを手に入れたということになります。しかも、「Steane符号」は7量子ビットで実行できます。「Shorの符号」は9量子ビット必要だったので、2量子ビット削減することができました（3量子ビットのアンシラも必要でしたが）！

「はじめに」で述べたように「CSS符号」は、さらに、より一般的な「スタビライザー符号」の部分クラスに相当するとのことです。次回は、この「スタビライザー符号」について勉強してみたいと思います（予定です）。

以上

---

1. $[n,k]$符号$C$を考え、その生成行列を$G$とします。任意の$x_1,x_2 \in \{ 0,1 \}^{k}$に対して、$y_1 = Gx_1, y_2 = Gx_2$とすると、$y_1, y_2 \in C$です。2つの式を足すと、$y_1 + y_2 = G(x_1 + x_2)$となり、$x_1 + x_2 \in \{ 0,1 \}^{k}$なので、$y_1+y_2 \in C$が成立ちます。 ↩

2. 2を法とするビットごとの加算は減算に等しいことにご注意。$y^{\prime}-y=y{\prime}+y$となり同じ符号に属するもの同士を足しても同じ符号に属するという線形符号の性質から$y^{\prime}-y \in C_2$が言えます。 ↩

3. ニールセン、チャンの「演習問題10.26」です。 ↩

4. $z_1,z_2, \cdots$の値を得るために測定して、それに応じて符号量子ビットを反転するような回路を組むことは可能です。その場合、条件つきXゲート（測定結果を古典レジスタに格納しておいて、その値が0か1かに応じてオンオフするXゲート）を使う感じになると思います。が、誤り量子ビットが1個以上ある場合は、複数$z_1,z_2, \cdots$を得るために、複数回の測定をしないといけないと思います。というわけで、あまり嬉しくないです。測定をする代わりに$\ket{z_i}$のみに反応するようにXゲートとCNOTゲートを組み合わせて、同じことを実現する回路も可能であって、その場合、量子回路を1回通すだけで、複数量子ビットの誤り訂正ができると思います。記事の後半で示すシミュレーションはこの方向で実装しました。 ↩

5. 公式として覚えておくと良いと思います。 ↩

6. これについて、私は驚くべき証明を見つけたのですが、この余白はそれを書くには狭すぎます、というのは嘘です（笑、一度言ってみたかった。出典ご存知ない方はこちらをどうぞ）。ニールセン、チャンの「演習問題10.27」です。上でやったのとほぼ同じ式変形を愚直にやる感じだったので、省略しました。 ↩

7. [7,3]Hamming符号の場合は確認できましたが、一般のHamming符号についても成り立っているかどうかは、まだ言えてないです（多分成り立っているのだと思いますが）。一瞬、$HG=0$が使えるかと思ったのですが、勘違いでした。 ↩

8. もっと効率の良い回路構成はあるのかもしれませんが、とりあえず初心者コースなので、ご容赦ください。少なくとも連続しているXゲートは消去できます。それから、本当は、7量子ビットのSteane符号を1量子ビット状態から作成したかったのですが、良さげな回路を思いつかなかったので、今回の記事では、それも省略しました。もっと勉強を進めればスッキリしたカッコいい回路が書けるのだと思いますが。 ↩

9. 10量子ビットの密度演算子の計算で、かつ、マルチ制御NOT（制御ビットが複数あるCNOT）をふんだんに使っているので、量子状態で実行するのと比べ、処理時間はかかります。 ↩

Seaborn

matplotlibで描くにはちょっと面倒なグラフでも、seabornを使えば割と簡単にかけてしまうことに感動した。

matplotlibでこれを描こうとすると、だいたいこんな感じになるとおもう。超適当だから間違ってるかもしれんが、

import itertools
fig, axes = plt.subplots(2, 3)
col_f = 'Pclass'
col_f_domain = [1, 2, 3]
row_f = 'Sex'
row_f_domain = ['male', 'female']
for i, (r, c) in enumerate(itertools.product(row_f_domain, row_f_domain)):
    row_i = i // 3
    col_i = i % 3
    ax = axes[row_i][col_i]
    # (以下略)

そうそう、forループ回すよな。
これ、seabornだと１行なんだぜ・・・

sns.relplot(x='Age', y='Fare', hue='Survived', col='Pclass', row='Sex', data=train_data)

最後に

EDA(Exploratory Data Analysis, 探索的データ探索)をするときは、比較対象とする特徴量や水準を変えながらたくさんグラフを書くことになるから、このように複雑なプロットもサクッとかけてしまうツールは重宝する。
逆に、matplotlibは、こう言ったハイレベルなツールでは手の届かない痒いところまでできるのが良いところ。Seabornじゃ描けなそうなプロットはmatplotlibで描こう、って感じかなと。

要約

タイトル通り。やろうとしたらなかなか方法が見つからなかったので。
結論だけ読みたい人は 結論Axesを用いた方法 へ
調べてたらちゃんとした方法が見つかったので更新しました 2020/03/19/21:29

前フリ

Pythonのグラフ描画ライブラリmatplotlibで散布図を描くとき、すごく細かい点をブワーッと並べたいときがありますよね。
plt.scatterのマーカーはmarkerパラメーターで指定でき、細かい点を打つときはmarker='.'とします。 ( ※matplotlib.pyplot.scatter )
しかしこの'.'のマーカー(ドキュメントのdescriptionでは「point」と呼ばれています)、これでもまだちょっと大きい気がします。

rand = lambda n:[np.random.rand() for _ in range(n)]
xy = (rand(100), rand(100))

plt.scatter(*xy, marker=".")

マーカーの枠線を消してみましょう。

plt.scatter(*xy, marker=".", linewidth=0)

若干小さくなった気がしますがこれでもまだ大きい気がします。もっとゴミみたいな点が打ちたい。

matplotlib.markers の説明を読んでみると「","：：pixel」というのがあります。そうそう、ピクセル単位レベルの点が打ちたかったのです。

plt.scatter(*xy, marker=",")

どうしてこうなった……
どうやらサイズが規格化されているらしく、形を指定するとこのサイズいっぱいになるように拡大縮小されるようです。

結論 めんどくさい例

マーカーサイズの規格化を無効にするパラメーターが見つからなかったので姑息的に「規格化されても小さく見えるマーカー」を作ってみます。(直接マーカーサイズを指定できる方法をご存知のかたは教えて下さいm(_ _)m)(Axesを使った例へ)
markerパラメーターに「2次元座標のタプルの配列」を与えることで任意の多角形を描かせることができます。
これを利用して幅ゼロの対角線を引いてサイズを確保してから中心に小さく四角を作ります。

(こんなん)

t = 0.1
plt.scatter(*xy, marker=[(0,0), (-1,-1), (1,1), (0,0), (t,t), (-t,t), (-t,-t), (t,-t), (t,t), (0,0)], linewidths=0)

ゴミみたいな点を打つことに成功しました！

マーカーオブジェクトを作って0~1倍の任意のサイズの点を打てるようにしてみました。

from matplotlib.markers import MarkerStyle
dot = lambda t: MarkerStyle([(0,0), (-1,-1), (1,1), (0,0), (t,t), (-t,t), (-t,-t), (t,-t), (t,t), (0,0)])
plt.scatter(*xy, marker=dot(0.2), linewidths=0)

正直もっとまともな方法あるやろ……と思われるので、まっとうな方法で小さい点を打つ方法をご存じの方はぜひご一報ください。よろしくお願いします。

Axesを用いた方法

Axes.plotではLine2Dのパラメーターを指定でき、ここにmarkersizeが存在することに気づきました。

fig, ax = plt.subplots()
ax.plot(*xy, linestyle='none', marker=',', markersize=1)

これが一番まともな方法だと思います。

ちょっとややこしいことをしようとするならやはりオブジェクト指向インターフェースを使うべきですね。
こちらの記事が参考になります。早く知っておきたかったmatplotlibの基礎知識、あるいは見た目の調整が捗るArtistの話 @skotaro さん

※小さい点でやりたかったこと

こうやって濃淡を点の密度で表現してみたかったのです。

func = lambda x,y:np.sin(x*np.pi)**2 * np.exp(-y**2/2)
n = 100
dx = 0.02
xlin = np.arange(-2,2,dx)
ylin = np.arange(-2,2,dx)
xx, yy = np.meshgrid(xlin, ylin)
pltx, plty = [], []
for x, y in zip(xx.flatten(), yy.flatten()):
    dense = func(x+dx/2, y+dx/2)
    pltx += [x+np.random.rand()*dx for _ in range(int(dense*n))]
    plty += [y+np.random.rand()*dx for _ in range(int(dense*n))]

fig, ax = plt.subplots(figsize=(6,6))
ax.plot(pltx, plty, linestyle='none', marker='.', markersize=0.1, alpha=0.1)
plt.xlim(-2,2)
plt.ylim(-2,2)
plt.show()

（無駄にめっちゃ重いのでカラーマップにしたほうが良いと思います。）

概要

ツイッターに投稿している謎の生物についてまとめました。
https://twitter.com/graph_gorilla

仕組み

1．乱数を出力
　　謎の生物は正規乱数で作っています。全体に分布させるときは一様乱数を使っています。
　　謎の生物の座標を指定して生成する場合はrand_norm関数、
　　全体をうにょうにょさせる場合はrand_uni関数、
　　ランダムに動かすにはmove_random関数を使用します。

2. 配列に格納
　　x座標用の配列dfxとy座標用の配列dfxを用意します。
　　出力する乱数は全てこの配列に格納します。

3．seabornのkdeplotでプロット
　　2で格納した配列を少しずつスライドさせながらプロットしていきます。
　　変数sが配列の最初の位置です。s~s+1000の区間がプロットに使用するデータになります。
　　プロットするたびに100ずつ足すことで、配列を読み込む位置が100ずつずれていきます。　　

4．gif画像として保存
　　下のリンクのやり方を参考にしました。imagemagickというパッケージが必要らしいです。

test.py

import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import seaborn as sns

#ロジスティック関数
def logi(x,a):
    return 1 / (1 + np.exp(-x+a))

#反転ロジスティック関数
def revlogi(x,a):
    return 1-(1 / (1 + np.exp(-x+a)))

#壁
def wall(x,r):
    lx9=logi(x,90)
    lr9=logi(r,0)
    lx1=revlogi(x,10)
    lr1=revlogi(r,0)
    result=lx9*lr9+lx1*lr1
    return 1-result

frame_count=0   #フレームカウント用変数
colname="Blues"     #ヒートマップの色

#初期設定
fig=plt.figure(figsize=(7,7))
sns.set_style({"axes.facecolor": plt.get_cmap(colname)(15)})

#乱数格納用配列
dfx = []
dfy = []

x=20    #xの位置
y=20    #yの位置

#正規乱数生成（謎の生物）
def rand_norm(xx,yy,sdx,sdy,n): # (x座標, y座標 , x方向の標準偏差, y方向の標準偏差, 繰り返し数)
    global frame_count,x,y
    for i in range(n):
        dfx.append(random.normalvariate(x,sdx))
        dfy.append(random.normalvariate(y,sdy))
        x=xx
        y=yy
        frame_count+=1

#一様乱数生成（全体のうにょうにょ）
def rand_uni(n):  # n: 繰り返し数
    global frame_count
    for i in range(n):
        dfx.append(random.uniform(0,100))
        dfy.append(random.uniform(0,100))
        frame_count+=1

#ランダムな動き
def move_random(n,t): #  (繰り返し数,　速さ)
    global x,y
    for i in range(n):
        rand_norm(x, y, 5, 5, t)
        randx = random.uniform(-10, 10)
        randy = random.uniform(-10, 10)
        randxx = wall(x, randx) * randx
        randyy = wall(y, randy) * randy
        x += randxx
        y += randyy

#乱数生成
#---------------------------------------------------------
#rand_norm(x座標, y座標 , x方向の標準偏差, y方向の標準偏差, 繰り返し数)
#rand_uni(繰り返し数)
#繰り返し数1000で1秒だと思います。

#move_random(繰り返し数,　速さ)
#こっちは何となくで書いているのでよくわかりません。

rand_norm(20,20,5,5,3000)
rand_norm(30,30,5,5,1000)
rand_norm(40,40,5,5,1000)
rand_norm(40,40,10,5,1000)
rand_norm(40,40,5,10,1000)
move_random(50,100)
rand_uni(3000)
rand_norm(20,20,5,5,1000)
#---------------------------------------------------------

df = pd.DataFrame({'X':dfx,'Y':dfy})    #データフレーム作成
s=0     #プロットするデータの開始位置

#プロット
def plot(data):
    global s
    plt.cla()
    plt.xlim([0, 100])
    plt.ylim([0, 100])
    plt.title(str(int(s/100))+" / "+str(int(frame_count/1000-1)*10))
    sns.kdeplot(df[s:s+1000].X,df[s:s+1000].Y,shade=True,cmap=colname)
    s+=100
    print("\b"*20,s," / ",int(frame_count/1000-1)*1000+100,end="")

#アニメーション
ani_frame_num=int(frame_count/1000-1)*10
ani = animation.FuncAnimation(fig, plot, interval=1, frames=ani_frame_num)
print("Please wait")
ani.save("plot.gif", writer="imagemagick")
print("\nFinished")

参考文献

matplotlib でアニメーションを作る
https://qiita.com/yubais/items/c95ba9ff1b23dd33fde2

はじめに

kivyでは様々なボタンがあります。普通に使えるものから、ちょっとよくわからないものまで。
そこで今回は、特に使えそうなものをピックアップして紹介したいと思います。細かいところまでは、言及しません。今までのように、kivyのuiを用いて何か作って紹介するといった感じではないです。この記事では、簡単な使い方の例だけを示します。ソースは公式のリファレンスの受け売りです。詳しい使い方はリファレンスを参照していただきたいです！

※今回のボタンの定義は、押したらなんかなる奴です。細かいことは抜きにします！
https://www.weblio.jp/content/button

普通のボタンたち

kivy.uix.Button

紹介するまでもないと思いますが、普通のボタンです。

button_sample.py

from kivy.app import App
from kivy.lang import Builder
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.togglebutton import ToggleButton
from kivy.uix.behaviors import ToggleButtonBehavior

class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        # ラベルの定義
        self.label = Label(text="OFF")
        self.add_widget(self.label)

        # ボタンの定義、押した時と話した時の処理
        self.button = Button(on_press=self.press, on_release=self.release, text="Press!")
        self.add_widget(self.button)

    #押した時
    def press(self, btn):
        self.label.text = "This is Button!"

    #話した時
    def release(self, btn):
        self.label.text = "OFF"


class Sample(App):

    def build(self):
        return Test()

Sample().run()

kivy.uix.togglebutton

押したらON状態、OFF状態が確認できるボタンです。
押されているかどうかは、トグルボタンのstateという変数のdownとnormalで判別できます。また、groupを設定することで、ラジオボタン的な使い方もできるようです。

画像にトグルボックス的な挙動を付与できたりもするらしいです。（未検証）
https://kivy.org/doc/stable/api-kivy.uix.behaviors.togglebutton.html#kivy.uix.behaviors.togglebutton.ToggleButtonBehavior

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.togglebutton import ToggleButton

class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        # ラベルの定義、
        self.label = Label(text="OFF")
        self.add_widget(self.label)

        # トグルボタンの定義
        self.toggle = ToggleButton(on_press=self.t_press, text="Press!")
        self.add_widget(self.toggle)

        # チェックボックスとして扱うトグルボタンを別で用意したボックスレイアウトに貼り付ける
        self.toggle_box = BoxLayout()
        self.t1 = ToggleButton(group="g1", on_release=self.toggle_check,  text="toggle 1")
        self.t2 = ToggleButton(group="g1", on_release=self.toggle_check, text="toggle 2")
        self.t3 = ToggleButton(group="g1", on_release=self.toggle_check, text="toggle 3")
        self.toggle_box.add_widget(self.t1)
        self.toggle_box.add_widget(self.t2)
        self.toggle_box.add_widget(self.t3)
        self.add_widget(self.toggle_box)

    def t_press(self, btn):
        if btn.state == "down":
            self.label.text = "This is Toggle Button!"
        if btn.state == "normal":
            self.label.text = "OFF"

    def toggle_check(self, btn):
        self.label.text = btn.text

class Sample(App):

    def build(self):
        return Test()

Sample().run()

kivy.uix.checkbox

ラジオボタンとチェックボックスです。 トグルボタンと似たような挙動をしています。
groupを設定すると、ラジオボタンになり、設定しないと、チェックボックスになります。（下記ソースのコメント部を外してもらうと確認できると思います。）
トグルボタンとは違い押されているかどうかは、activeという変数からTrue Falseで確認できます。

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.checkbox import CheckBox


class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        self.orientation = "vertical"
        # ラベルの定義、スクリーンに貼り付け
        self.label = Label(text="OFF")
        self.add_widget(self.label)

        # チェックボックスとして扱うトグルボタンを別で用意したボックスレイアウトに貼り付ける
        self.checkbox_box = BoxLayout(orientation="horizontal")

        # チェックボックスを定義
        self.t1 = CheckBox()
        self.t2 = CheckBox()
        self.t3 = CheckBox()

        # ラジオボタンを定義
        # self.t1 = CheckBox(group="g1")
        # self.t2 = CheckBox(group="g1")
        # self.t3 = CheckBox(group="g1")

        self.checkbox_box.add_widget(self.t1)
        self.checkbox_box.add_widget(self.t2)
        self.checkbox_box.add_widget(self.t3)

        #チェックボックを押した時の処理
        self.t1.bind(active=self.on_checkbox_active)
        self.t2.bind(active=self.on_checkbox_active)
        self.t3.bind(active=self.on_checkbox_active)

        self.add_widget(self.checkbox_box)

    def on_checkbox_active(self, instance, value):
        self.label.text = "Left      : {}\n" \
                          "Center : {}\n" \
                          "Right    : {}\n".format(self.t1.state, self.t2.state, self.t3.state)

class Sample(App):

    def build(self):
        return Test()

Sample().run()

ボタンっぽいもの

上で紹介したものは、ちゃんとボタンでしたが、下記で紹介するのは、ボタンを使って何かしてるものだと認識だと思います。

kivy.uix.spinner

コンボボックスです。上下どちらかにスペースを開けてあげないと、リストが開けないことに注意してください。

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.dropdown import DropDown

class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        self.label = Label(text="test")
        self.add_widget(self.label)

        self.dropdown = DropDown()
        for index in range(10):

            btn = Button(text='Value %d' % index, size_hint_y=None, height=44)

            # 定義したボタンを押した時の処理
            btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))

            # dropdownにボタンを載せる
            self.dropdown.add_widget(btn)

        self.mainbutton = Button(text="main", size_hint=(1, 0.1), pos_hint={"y": 0.9})
        self.mainbutton.bind(on_release=self.dropdown.open)

        self.add_widget(self.mainbutton)
        self.dropdown.bind(on_select=self.press)

    def press(self, instance, x):
        self.mainbutton.text = x
        self.label.text = "Press : {}".format(x)

class Sample(App):

    def build(self):
        return Test()

Sample().run()

kivy.uix.dropdown

押したらドロップダウンリストが出てくるやつです。
コンボボックスと似てますが、こっちの方が開いたボタンに機能が付けることができるため、自由度が高いと思います。僕はうまく使えませんでしたが。。。

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.dropdown import DropDown

class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        self.label = Label(text="test")
        self.add_widget(self.label)

        self.dropdown = DropDown()
        for index in range(10):

            btn = Button(text='Value %d' % index, size_hint_y=None, height=44)

            # 定義したボタンを押した時の処理
            btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))

            # dropdownにボタンを載せる
            self.dropdown.add_widget(btn)

        self.mainbutton = Button(text="main", size_hint=(1, 0.1), pos_hint={"y": 0.9})
        self.mainbutton.bind(on_release=self.dropdown.open)

        self.add_widget(self.mainbutton)
        self.dropdown.bind(on_select=self.press)

    def press(self, instance, x):
        self.mainbutton.text = x
        self.label.text = "Press : {}".format(x)

class Sample(App):

    def build(self):
        return Test()

Sample().run()![button.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/421817/d0665bf7-f6e7-0a4b-fb6d-bce3683092ae.gif)

kivy.uix.switch

スイッチです。使ったことはありません。
挙動自体はチェックボックスとほぼ同じだと思います。ボタンを持ってスライドさせることもできるので、ちょっと面白いと思いましたw

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.switch import Switch


class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        self.label = Label(text="test")
        self.add_widget(self.label)

        self.switch = Switch()
        self.switch.bind(active=self.switch_check)
        self.add_widget(self.switch)

    def switch_check(self, instance, value):
        if value:
            self.label.text = "ON"
        else:
            self.label.text = "OFF"


class Sample(App):

    def build(self):
        return Test()

Sample().run()

kivy.uix.accordion

ビロ〜んと出てくる、リストです。これも使ったことありません。
リストの中に何か処理とか入れたい場合には、Accordionの子要素であるAccordionImemsの宣言時にidsを入れるか、配列とかで保持しとけばできるかもしれないですね。(未検証)

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.accordion import Accordion, AccordionItem

class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        self.label = Label(text="test")
        self.add_widget(self.label)

        self.accordion = Accordion(orientation='vertical')
        #Accodionの中身を定義
        for x in range(5):
            item = AccordionItem(title='Title %d' % x)
            item.add_widget(Label(text='Very big content\n' * 10))
            self.accordion.add_widget(item)

        self.add_widget(self.accordion)


class Sample(App):

    def build(self):
        return Test()

Sample().run()

kivy.uix.tabbedpanel

タブを切り替えるボタンです。というよりもうこれボタンじゃないと思います。これはパネルですね。画面繊維を実装せずに画面の切り替えが簡単にできるので、便利なクラスだと思います。

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.tabbedpanel import TabbedPanel, TabbedPanelItem

class Test(BoxLayout):
    def __init__(self, **kwargs):
        super(Test, self).__init__(**kwargs)

        self.tabbedPanel = TabbedPanel(do_default_tab=False)

        #TabbedPanelに載せるパネルの定義
        self.panel1 = TabbedPanelItem(text="tab 1")
        self.panel1.add_widget(Label(text="This is Panel 1"))

        #TabbedPanelに載せるパネルの定義
        self.panel2 = TabbedPanelItem(text="tab 2")
        self.panel2.add_widget(Label(text="This is Panel 2"))

        #TabbedPanelに載せる
        self.tabbedPanel.add_widget(self.panel1)
        self.tabbedPanel.add_widget(self.panel2)

        #Appに載せる
        self.add_widget(self.tabbedPanel)


class Sample(App):

    def build(self):
        return Test()

Sample().run()

まとめ

紹介といっておきながら今まで触ったことのないボタン(？)に触れることのできる良い機会となりました。細々した内容については全く触れず簡単に紹介いたしましたが今回の紹介したボタンを別の機会で使える日が来るようもう少し勉強しておきたいと感じました。

参考文献

公式リファレンス