はじめに...

タイトル長くてスミマセン!!!!!
書きたいことの要約って難しいですよね...
誰か、要約案を私にお恵みください...
(ちなみに、この後も長いです。目次をご活用ください。)
あと、執筆途中であることに十分ご留意ください。

Python/Tkinterとは?

出典: フリー百科事典『ウィキペディア（Wikipedia）』

Tkinter は Python からGUIを構築・操作するための標準ライブラリ（ウィジェット・ツールキット）である。

Tcl/Tk の Tk 部分を Python で利用できるようにしたもので、使い方も可能な限り Tcl/Tk にあわせられるように作られている。
これにより、スクリプト言語である Python から簡単にGUI画面をもったアプリケーションを作ることが可能になる。

(以下略) 

ってWikipediaに書いてありますが、まあ、カンタンに言うと

Pythonに標準で付属している、GUI作成用ライブラリ

である。
大事なのは"標準"というところ。
(他のライブラリを使わなければ)pythonをインストール(またはPyinstallerとかを使う)だけでアプリケーションが作れる。
なんなら、Pyarmorを使えばソースコードを保護できる。

Tkinterリファレンス

ウィンドウ

まずはモジュールのインポートから...

#Python2なら...
import Tkinter #tkinter 本体
import ttk #tkinter 拡張(?)
#Python3なら...
import tkinter #tkinter 本体
from tkinter import ttk #tkinter 拡張(?)

Python2と3でモジュール名が違うので注意。
ちなみに、次のように書くと2,3両対応できる。

try:
    import Tkinter as tkinter
    import ttk
except:
    import tkinter
    from tkinter import ttk

ちなみに、先程からちょこちょこ登場している"ttk"はtkinterの拡張(?)で、
これを使うと、スタイル(テーマ)を変えることができます。

メインウィンドウ

次に、メインウィンドウを作る。

root = tkinter.Tk()#この後をよく読むこと

ただし、このままだとUbuntu等のOSでタスクバーのアプリケーション名が"Tk"と表示されダサいので、

root = tkinter.Tk(className="[アプリ名]")

とする。

サブウィンドウ

sub = tkinter.TopLevel()

とする。

全画面表示

root.attributes("-fullscreen", True)

戻すときは、

root.attributes("-fullscreen", False)

ウィジェット

ボタン

def callback():
    print("Hello!!")

button = ttk.Button(root, text="[表示するテキスト]",command=callback)

commandには、ボタンが押されたときに実行する関数の名前を指定する。
もし、引数を指定したい場合は、

def callback(hogehoge):
    print(hogehoge)

button = ttk.Button(root, text="[表示するテキスト]",command=lambda: callback("Hello!!!"))

フレーム(枠)

frame = ttk.Frame(root)

えーっと...　frameはウィンドウと他のウィジェットのrootの部分に入れて使います。
なんなら、色やら形を変えることもできます。(後で追記します。)
下に活用例を示します。

def callback(hogehoge):
    print(hogehoge)

frame = ttk.Frame(root)
button = ttk.Button(frame, text="[表示するテキスト]",command=lambda: callback("Hello!!!"))

ラベル(一行の選択できないテキスト)

label = ttk.Label(root, text="[表示するテキスト]")

ウィジェットの配置

tkinterではウィジェットを定義したあとに配置する必要があります。
配置方法は3つあります。

詰め込み方式(pack)

詰め込み方式(pack)では、ウィンドウの空いているところにウィジェットをツメコミマス。(語彙力...)

[ウィジェット].pack([オプション])

[ウィジェット]はウィジェットのインスタンス、
(インスタンスやら関数などがワケワカメな人はぜひ他のPython入門記事をご覧ください。)
[オプション]には次が指定できます(何も指定しなくても問題ない。):
・side
　どの方向に配置するか設定できます。
　設定可能値:
　　"right"右,"left"左,"bottom"下,"top"上
・fill
　どの方向に対して埋め立てるか設定できます。
　設定可能値:
　　"both"-両方向
　　"x"-x方向(縦?)
　　"y"-y方向(横?)
　　(正直、不安なので実験して教えていただけると幸いです。)
・anchor
　どこに配置するか設定できます。(sideに似ていますが、より具体的)
　設定可能値:
　　えーっと...こんな感じです。(ここより引用)
　　nw --- n --- ne
　　|　　　　　　|
　　w　　c　　　e
　　|　　　　　　|
　　sw --- s --- se
・expand
　空白が生まれたとき(ウィンドウのサイズが変わったときなど)に埋めるかどうか設定できます
　設定可能値:
　　True or False
　　(面倒臭さが表立っているのは気のせいですからね...本当ですよ......)

参考文献など

http://www.nct9.ne.jp/m_hiroi/light/python3.html#python3_tkinter

@stachibana さんのこちらのアプリを試した際の備忘録
https://github.com/stachibana/line-pay-v3-python-sdk-sample

紆余曲折ありましたが、これをForkしてLINE Pay の一般決済（単発決済）だけを実装するためのスターターアプリができました。
https://github.com/maztak/line-pay-v3-python-starter

LINE Pay 概要

オーソリってなに？

ユーザーが決済を承認した後の売上確定待ち状態。これをCaputureすることで売上確定となる。

Captureとは何？

Captureとは売上確定のことらしい。RequestAPIの利用時のrequest_optionsの値の中でoptions.payment.captureをFalseにすると、オーソリ状態（売上確定待ち状態）で止めることができる。それがどんなときに嬉しいかは知らん。

売上確定するにはCaptureAPIを使うことになるのだが、加盟店MyPageの売上管理＞売上対象照会からも手動で売上確定することが可能（なお以下はテストアカウントで本番決済したときの画面。Sandbox環境で模擬決済した場合はナビメニューの「Sandbox」から模擬決済の管理画面に入れる）。

Checkoutとは何？

一般用語としてや他の決済サービス（StripeとかPayjpとか）では、決済することそのもの、もしくは決済を簡単に実装できるライブラリのことを言うらしい。しかし、LINE Pay における Checkout は、ユーザーの住所とか送料を含めた決済機能のことを指すらしい。つまりECで商品の送付先を入力する作業を Checkoutを使えば省けるっぽい。

LINE Pay API v2 と v3 の違い

公式リファレンス Migration V3
https://pay.line.me/documents/online_v3_ja.html#migration-api-v3

Developers.I.O さんの記事
https://dev.classmethod.jp/articles/devio-cafe-line/

LINE Pay 加盟店アカウントを取得

正式なアカウントは法人または個人事業主でしか取得できないので、以下からSandboxアカウントを取得します
https://pay.line.me/jp/developers/techsupport/sandbox/testflow?locale=ja_JP

取得後のログイン画面
https://pay.line.me/portal/jp/auth/login

Sandboxについて

LINE Pay にはテストができるSandbox環境が用意されているが、用語がごちゃごちゃしていて混乱しやすいので注意。

Sandbox環境とproduction環境

Sandboxアカウントのチャネル情報（Channel ID, Channel Secret Key）を使っている環境のこと。
Sandbox環境で使用できるチャネル情報をテストチャネル情報という。

Sandobxシミュレーター

これは LIEN Pay の決済シミュレーターのことで、Sandbox環境がTrueの時に決済しようとするとこれが起動する。

加盟店MyPageの取引内訳

SandboxアカウントでSandboxシミュレーターを使って模擬決済した場合、加盟店MyPageに入ってナビバーにある「Sandbox」をクリックしたページで取引内訳が確認できる。

しかしSandbox環境でもLINE_PAY_IS_SANDBOX = Falseにしていると実際のお金が決済できてしまう（本サンプルアプリ特有のものかもしれない）。この場合は加盟店MyPageの「Sandbox」ページではなく、加盟店MyPageのホーム画面に取引内訳が記録される。

app.py

LINE_PAY_IS_SANDBOX = False

さらに、Sandboxアカウントと正式な加盟店アカウントでは加盟店MyPageの表示が違う。Sandboxアカウントでは取引の一覧が見れるだけだが、正式な加盟店アカウントのMyPageではグラフが見れる。

Herokuにデプロイしてみる

Webサービスとして運用することを想定したとき、当然どこかのサーバーにデプロイする必要があるので、今回は定番のHerokuを使います（LINE PAY API v2では決済サーバIPのホワイトリスト登録が必要だったので、固定IPではないHerokuは不向きでしたが、v3からはホワイトリスト登録不要になった）。

Herokuで動かすにはgunicornが必要

Herokuにデプロイしてapp.pyをRunした状態にしておきたい。今回はFlaskを使っている関係で実行命令ファイルProcfileにgunicornというフレームワーク？ライブラリ？が起動するように記述する。

Flaskってなに

Pythonのミニマムフレームワーク。Rubyでいう Ruby on Rails のちっさい版。

Procfileってなに

HeorkuデプロイしたPythonアプリの実行命令を書くファイル。

gunicornってなに

Flaskを始めとする多くのPythonフレームワークではWSGIサーバーというものでアプリを動かすらしい。このWSGIサーバーとのやり取りをいい感じにしてくれるライブラリがgunicornっぽい。普通にプロジェクトフォルダ直下にProcfileって名前のファイル作成すればよかったはず‥。

web: gunicorn app:app

Gitコミットして Heroku に push

$git init
$git add .
$git commit -m "initial commit"

$ heroku login --interactive
$ heroku create my-app-name #任意のアプリ名を付けてください
$ git push heroku master

環境変数の設定

.gitignoreで.envファイルをgit管理から無視するようにしているため当然Herokuにpushされません（僕は知らなかった）。そのためHeroku側でheroku config:setで環境編集をセットしてやる必要があります。

$heroku config:set LINE_PAY_CHANNEL_ID="xxx"
$heroku config:set LINE_PAY_CHANNEL_SECRET="xxx"

$heroku config #一応、環境変数が間違いなくセットされてるか確認しよう

トップページがエラーになるときは、この環境変数のセットし忘れであることが多い。

つまづきポイント

line-payがアップデート

LINE Pay のライブラリである line-pay が 0.0.1 -> 0.1.0 にアップデートしていた。requirements.txtでline-payライブラリのバージョンをあげましょう。

requirements.txt

line-pay==0.1.0

ちなみに僕のrequirements.txtは、なんかの理由でpip freezeというコマンドを使ったらしく以下のようになってました。これをHerokuにデプロイして動いているので、何か必要なことがあったのかも‥。

requirements.txt

certifi==2020.4.5.1
chardet==3.0.4
click==7.1.2
dominate==2.5.1
Flask==1.1.2
Flask-Bootstrap==3.3.7.1
gunicorn==20.0.4
idna==2.8
itsdangerous==1.1.0
Jinja2==2.11.2
line-pay==0.1.0
MarkupSafe==1.1.1
pykintone==0.3.10
python-dotenv==0.10.3
pytz==2020.1
PyYAML==5.3.1
requests==2.22.0
tzlocal==2.1
urllib3==1.25.9
visitor==0.1.3
Werkzeug==1.0.1

Request後のリダイレクトエラー

リダイレクト先がhttpssになるエラーが起きた。以下はGitコミットの差分ですが、replace()でhttpsに統一しようとしている部分を消したらちゃんと動きました。ただ決済時にhttp通信をすること自体がやばいので、あくまで応急処置です。

app.py

         "redirectUrls": {
-            "confirmUrl": request.host_url.replace('http', 'https') + "confirm",
-            "cancelUrl": request.host_url.replace('http', 'https') + "cancel"
+            "confirmUrl": request.host_url + "confirm",
+            "cancelUrl": request.host_url + "cancel"
         }

kintoneのアプリ名は一意に

kintoneアプリは過去に一度でも使ったことがあるアプリ名を使用すると動かない。今回kintoneアプリ名には「linepay」が設定されています。例えばこのアプリを一度削除し、もう一度テンプレートからアプリ作成したとしても本サンプルアプリは動いてくれません（トップページの表示や決済はできる）。そのためkintoneアプリの設定画面からアプリ名を過去に使用していないものに変更してやる必要があります。

その他のつまづきポイント

• account.ymlのドメイン名はサブドメインだけでよかった
• Herokuデプロイ前に一度ローカルで試す場合はPythonのバージョンが3.6以下だと動かない
• デプロイ直後（もしくは初回）に決済しようとすると Internal Server Error となる。原因不明。
• line pay sandbox 申請が最初数回エラーになった。何回かやってれば直った。

役立ちそうなコマンド

Herokuとのgit紐付け

# herokuからのクローン
heroku git:clone APPNAME

# herokuとローカルの紐付け
heroku git:remote --app APPNAME
# こっちでもOK
git remote add heroku https://git.heroku.com/AppName.git

Herokuの再起動方法

$ heroku ps:scale web=0
# 再びスタートするときは↓
$ heroku ps:scale web=1

Herokuのキャッシュ削除方法

間違ってるかも。

$ heroku plugins:install heroku-repo
$ heroku repo:purge_cache -a appname

$ git commit --allow-empty -m "Purge cache"
$ git push heroku master

https://help.heroku.com/18PI5RSY/how-do-i-clear-the-build-cache

LINE Pay v2 の実装サンプル

• Pythonによるv2の実装（Python+Heroku+Docker）
  https://qiita.com/sumihiro3/items/7a8f3a59e79e8d9b7a9c

• Node.jsによるv2の実装（Node.js+Heroku）
  https://qiita.com/nkjm/items/b4f70b4daaf343a2bedc

  • リッチメニューのLIFFから決済させる https://qiita.com/ufoo68/items/a6d036d143fe4950aea3
  • Python版 https://qiita.com/keigohtr/items/161c9fb1584758ae3e35

参考

• ngrokが便利すぎる
• pythonでローカルwebサーバを立ち上げる
• https://qiita.com/suzu_D/items/aaa568933e89ee029e00

TL;DR

Jupyter Notebook で分析を進める際、バージョン管理をしたいと思いGitで管理をしてみましたが、普通に進めるとNotebook のメタデータによって差分がとても見づらかったので、JupyterLab の jupyterlab-gitと nbdimeエクステンションを利用し、差分を見やすく表示できるようにしてみました。

JupyterLab 環境を構築

今回の記事では、下記の環境を利用します。

• docker-compose を使用
  • docker-compose のインストールは こちら を参照
• コンテナイメージのベースは kaggle-images を利用

Jupyter notebook のバージョンコントロールに必要な JupyterLab エクステンションは下記になります。

• jupyterlab-git
• nbdime
  • こちらは jupyterlab-git をインストールすると一緒にインストールされる

環境構築

下記２ファイルを作成します。

• Dockerfile
• docker-compose.yml

Dockerfile

FROM gcr.io/kaggle-images/python:v74

RUN apt-get update && \
    apt-get install -y git \
    curl

RUN curl -sL https://deb.nodesource.com/setup_12.x | bash - &&\
    apt-get install -y nodejs

RUN pip install -U pip \
    jupyterlab && \
    pip install jupyterlab-git

RUN jupyter lab build

docker-compose.yml

version: "3"
services:
  jupyter:
    build: .
    volumes:
      - $PWD:/tmp/work
    working_dir: /tmp/work
    ports:
      - 8888:8888
    command: jupyter lab --ip=0.0.0.0 --allow-root --no-browser

Docker イメージのビルド

上記２ファイルを作成後、同ディレクトリにてビルドします。

$ docker-compose build

コンテナを起動

ビルド後コンテナを起動します。

$ docker-compose up

起動後は http://localhost:8888/ にアクセスし、token を入力して JupyterLab にアクセスできます。
token とは起動後に出力される、例：http://acb729d0c5ce:8888/?token=45d10c660d2e85f0c8d59995a04667c154542ae79f27f65d の 45d10c660d2e85f0c8d59995a04667c154542ae79f27f65d にあたる箇所です。

Extension Manager を Enable

起動後は Exxtension Manager を Enable します。

２つのエクステンションがインストールされています。

Notebook を Git でバージョン管理をする

Git リポジトリ を Clone

必要なリポジトリをクローンします。すでに Notebook などがある場合は git init などをします。

リポジトリの URL を入力

Notebook (test.ipynb) を作成して first commit します。

$ git config --global user.email "you@example.com"
$ git config --global user.name "Your Name"
$ git add test.ipynb
$ git commit -m "first commit"

first commit 後、 Notebook で分析を進めたとします。例えば df.head() というコードを追加したとします。

git diff での差分表示

まず、git diff コマンドで確認した場合は、下記のように Notebook のメタデータなどの差分が表示されてしまいとてもわかりづらいです。

# git diff
diff --git a/test.ipynb b/test.ipynb
index f6c1f17..5af6074 100644
--- a/test.ipynb
+++ b/test.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -30,12 +30,164 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
     "df = pd.read_csv(data_dir + \"train.csv\")"
    ]
+  },
+  {
+   "cell_type": "code",
:

JupyterLab nbdime での差分表示

JupyterLab にて nbdime を利用して diff を確認した場合は下記になります。ピンクの左側は変更前、緑の右側は変更後になります。

とても見やすく差分が表示されていると思います。

参考

• Jupyter Notebook Manifesto: Best practices that can improve the life of any developer using Jupyter notebooks

はじめに

おひさしぶりです。学校の課題に追われてなかなか精進できませんでした(言い訳)
A,Bの二完でした。しかも、それぞれ1ペナずつ生やした。

A問題

問題

考えたこと
$m1>m2$のときはそのまま引き算できないので、$h1$から1取ってくる。

h1, m1, h2, m2, k = map(int,input().split())

if m1 > m2:
    m2 += 60
    h2 -=1
    ans_m = m2 - m1
else:
    ans_m = m2 - m1

ans_h = h2 - h1
ans = 60 * ans_h + ans_m

print(ans-k)

引き算の順序を間違えて1WAした。もったいない

B問題

問題

考えたこと
ヒタチコンの悪夢再来、こういう系の問題は苦手。
全てDにするのが最適ですが、私は気付かなかったので、if文でごり押ししてます。

t = list(input())
n = len(t)

if t[0] == '?':
    if n > 1:
        if t[1] == '?':
            t[0] = 'P'
        else:
            t[0] = 'D'
    else:
        t[0] = 'D'
if t[-1] == '?':
    t[-1] = 'D'
for i in range(1,n-1):
    if t[i] == '?':
        if t[i-1] == 'P':
            t[i] = 'D'
        else:
            if t[i+1] == '?' or t[i+1] == 'D':
                t[i] = 'P'
            else:
                t[i] = 'D'

ans = ''.join(t)
print(ans)

まとめ

C解けたらかっこよかった。
明日のABCが不安です。ではまた、おやすみなさい。

はじめに???

kaggleのデータセットでこれを見つけてしまって、試さずにはいられませんでした。
データセットはこちらです。
? https://www.kaggle.com/jessicali9530/animal-crossing-new-horizons-nookplaza-dataset

あつまれどうぶつの森（以下、あつ森）のマスターデータといった感じのデータセットです。
家具やむし、さかな、などはもちろん村人（どうぶつ）のデータも入っています。

AutoMLで分析?

今回は無料で使えるAutoMLツールのVARISTAを利用していきます。
? https://www.varista.ai/

さっそく分析開始?

まずはデータをアップロードして中身を確認してみましょう。
「housewares.csv」を利用します。
3,275行 x 32列 897.56 KBの家具の情報が入ってるデータです。

予測する列は売却価格の「Sell」です?
なお、答え合わせように１０行ほどランダムにピックアップした行を抽出しておきます。

学習に利用しない列を選んでいきましょう。

学習に利用しない列?

ユニークな値の列を削除

削除列	理由
Name	完全ユニークではないが売却金額が予想できるほぼ固有の値なので削除
Source	家具の入手方法、個を特定できるため削除
Source Notes	同上
Filename	ゲーム内で参照するファイル名、意味のない文字列のため削除
Internal ID	NameとOneToOneで紐づくIDなので削除
Unique Entry ID	意味のないID列

データリークの可能性があるため削除

削除列	理由
Buy	購入価格、売却価格と比例しているため、計算できてしまいデータリークになるから削除
Kit Cost	制作コスト、同上
Miles Price	マイルでの購入額、同上

実際に学習してみた?

?学習結果はこんな感じです。

スコア92と高いスコアを叩き出しました。
誤差の平均が5180ベルくらいで予測ができるモデルになりました！
（データの詳細設定から単位をつけることができます。ベルってなってるとなんかかわいい?）

細かく見ていきましょう。

特徴の重要度

重要な指標第1位は「Tag毎の平均売却額」

Tag列は家具の種類を示した列です。内容は以下のようになっています。

テーブル、椅子、ベッドなど家具の種類が入っているのが分かります。
売却価格との関係性を見てみましょう。

そこまではっきりとカテゴリごとに差が出ているわけではありませんが、最大値、最小値などのばらつきが見てとれます。

重要な指標第２位は「Size毎の平均売却額」

サイズはその家具が何x何マスのアイテムなのかを表しています。

1x1より2x1、2x1より2x2のアイテムが高いのが分かります。
3x3のものが異様に高級だったりするのもわかります。

重要な指標第3位は「HHA Concept 2毎の平均売却額」

「HHA Concept 2」は家具のコンセプトを表します。いわゆる家具のシリーズというやつですね。

Noneはコンセプトなしですが、リビングルームシリーズや、和室、ラグジュアリーシリーズだったりがあります。

たしかにシリーズによって金額に大きな差が見られます。
「expensive」コンセプトは高く、「living room」コンセプト、「office」コンセプトなどはリーズナブルなのがわかります。
これらの値を考慮して、予測値を出している模様

検証データによる予測結果

答え合わせ?

今回答え合わせ用に５つの家具をピックアップしておきました。
VARISTAで予測をし、それぞれ答え合わせをしていきます。
予測のフォーマットを整数にして、予測実行！

ダブルソファ

タグ	サイズ	コンセプト
Sofa	2x1	living room

売却価格: 1300ベル
予想売却価格: 1115ベル
誤差: -285ベル

キャンディマシン

タグ	サイズ	コンセプト
Shop	1x1	shop

売却価格: 700ベル
予想売却価格: 916ベル
誤差: +216ベル

ハンモック

タグ	サイズ	コンセプト
Bed	2x1	outdoors

売却価格: 325ベル
予想売却価格: 318ベル
誤差: -7ベル
ほぼぴったり！！?

DJブース

タグ	サイズ	コンセプト
Musical Instrument	2x1	party

売却価格: 2325ベル
予想売却価格: 2501ベル
誤差: +176ベル

くまのトクダイちゃん

タグ	サイズ	コンセプト
Animal	3x3	fancy

売却価格: 6300ベル
予想売却価格: 6008ベル
誤差: -292ベル

おわり?

結構な精度が出せましたが、ゲームのマスターデータはもともと、一定のルールのもと金額などが決められているため、予測がしやすかったのかもしれません。（それかどっかでリークしてる？確認します。）
このように、自分に親しみのあるデータで分析を行うとやっぱり楽しいですよね?
みなさんも是非遊んでみてください！

.NET Framework で bzip2 をサポートするライブラリについて調べます。Python や bzcat と処理速度を比較します。

ライブラリ

bzip2 をサポートする 3 種類のライブラリを見付けました。

1. SharpZipLib: マネージドコードによる再実装
2. SharpCompress: マネージドコードによる再実装
3. AR.Compression.BZip2 ネイティブライブラリのラッパー

これらのライブラリでのマルチストリームの扱いと伸張の所要時間を確認します。

マルチストリーム

個別に bzip2 で圧縮して連結したデータをマルチストリームと呼びます。

作成例

$ echo -n hello | bzip2 > a.bz2
$ echo -n world | bzip2 > b.bz2
$ cat a.bz2 b.bz2 > ab.bz2
$ hd ab.bz2
00000000  42 5a 68 39 31 41 59 26  53 59 19 31 65 3d 00 00  |BZh91AY&SY.1e=..|
00000010  00 81 00 02 44 a0 00 21  9a 68 33 4d 07 33 8b b9  |....D..!.h3M.3..|
00000020  22 9c 28 48 0c 98 b2 9e  80 42 5a 68 39 31 41 59  |".(H.....BZh91AY|
00000030  26 53 59 59 ce 7b cb 00  00 02 01 80 04 04 90 80  |&SYY.{..........|
00000040  20 00 30 cd 00 c1 a4 c0  71 77 24 53 85 09 05 9c  | .0.....qw$S....|
00000050  e7 bc b0                                          |...|
00000053

SharpZipLib

複数の圧縮アルゴリズムをサポートしています。

bzip2 の実装は以下にあります。

• src/ICSharpCode.SharpZipLib/BZip2

最小構成

bzip2 の伸張は、以下の 6 ファイルだけで行えることを確認しました。

• src/ICSharpCode.SharpZipLib/BZip2/BZip2Constants.cs
• src/ICSharpCode.SharpZipLib/BZip2/BZip2Exception.cs
• src/ICSharpCode.SharpZipLib/BZip2/BZip2InputStream.cs
• src/ICSharpCode.SharpZipLib/Checksum/BZip2Crc.cs
• src/ICSharpCode.SharpZipLib/Checksum/IChecksum.cs
• src/ICSharpCode.SharpZipLib/Core/Exceptions/SharpZipBaseException.cs

テスト

最小構成ではなく、NuGet で取得したライブラリを使用します。

• https://www.nuget.org/packages/SharpZipLib/

nuget install SharpZipLib
cp SharpZipLib.1.2.0/lib/net45/ICSharpCode.SharpZipLib.dll .

マルチストリームの例として作った ab.bz2 の伸張を試みます。

※ Mono には古いバージョンの ICSharpCode.SharpZipLib.dll が取り込まれています。パスを書かないとそちらが参照されるため、NuGet で取得した方の DLL をパス付きで参照します。

#r "SharpZipLib.1.2.0/lib/net45/ICSharpCode.SharpZipLib.dll"
open System.IO
open ICSharpCode.SharpZipLib.BZip2
do
    use fs = new FileStream("ab.bz2", FileMode.Open)
    use bz = new BZip2InputStream(fs)
    use sr = new StreamReader(bz)
    printfn "%s" (sr.ReadToEnd())

hello

最初のストリームしか処理されません。

BZip2InputStream.cs を眺めてもマルチストリームに対応した作りにはなっていないようなので、逐次的に読み込む必要があります。

※ IsStreamOwner が true の場合、処理の完了後に渡したストリーム fs が閉じられます。デフォルトでは true のため false を指定します。

#r "SharpZipLib.1.2.0/lib/net45/ICSharpCode.SharpZipLib.dll"
open System.IO
open ICSharpCode.SharpZipLib.BZip2
do
    use fs = new FileStream("ab.bz2", FileMode.Open)
    while fs.Position < fs.Length do
        use bz = new BZip2InputStream(fs, IsStreamOwner = false)
        use sr = new StreamReader(bz)
        printfn "%s" (sr.ReadToEnd())

hello
world

SharpCompress

複数の圧縮アルゴリズムをサポートしています。

bzip2 の実装は以下にあります。

• src/SharpCompress/Compressors/BZip2

このディレクトリは単独で抜き出して使えます。ただ一点、独自に定義している CompressionMode が不足しますが、既存のもので代用できました。

BZip2Stream.cs（追加）

using System.IO.Compression;

最小構成

bzip2 の伸張は、以下の 3 ファイルだけで行えることを確認しました。

• src/SharpCompress/Compressors/BZip2/BZip2Constants.cs
• src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs
• src/SharpCompress/Compressors/BZip2/CRC.cs

ただし class CBZip2InputStream は internal になっているため、public にする必要があります。

テスト

最小構成ではなく、NuGet で取得したライブラリを使用します。

• https://www.nuget.org/packages/SharpCompress/

nuget install sharpcompress
cp SharpCompress.0.25.1/lib/net46/SharpCompress.dll .

マルチストリームの例として作った ab.bz2 の伸張を試みます。

※ BZip2Stream のコンストラクターの最後の引数は、マルチストリームを読み進めるかどうかのフラグです。

#r "SharpCompress.dll"
open System.IO
open SharpCompress.Compressors
do
    use fs = new FileStream("ab.bz2", FileMode.Open)
    use bz = new BZip2.BZip2Stream(fs, CompressionMode.Decompress, true)
    use sr = new StreamReader(bz)
    printfn "%s" (sr.ReadToEnd())

実行結果

helloworld

マルチストリームに対するサポートがあるため、一気に最後まで読み進めることができました。

マルチストリームのフラグを false にすると、1 つのストリームの終端に達した時点で fs が閉じられてしまいます。CBZip2InputStream.cs を見ても、開いたままにすることは想定されていないようです。そのため逐次的に読み進めるには Dispose を無視するような小細工をするしかなさそうです。

#r "SharpCompress.dll"
open System.IO
open SharpCompress.Compressors
do
    let mutable ignore = true
    use fs = { new FileStream("ab.bz2", FileMode.Open) with
        override __.Dispose disposing = if not ignore then base.Dispose disposing }
    while fs.Position < fs.Length do
        use bz = new BZip2.BZip2Stream(fs, CompressionMode.Decompress, false)
        use sr = new StreamReader(bz)
        printfn "%s" (sr.ReadToEnd())
    ignore <- false

実行結果

hello
world

AR.Compression.BZip2

他のライブラリとは違って bzip2 に特化しています。伸長と圧縮は 1 つのクラスで実装されているため、分離して最小構成を調べるのは省略します。

NuGet に登録されています。

• https://www.nuget.org/packages/AR.Compression.BZip2/

ビルド

ライブラリを Mono と共用するには少し手を入れる必要があるため、今回は NuGet は使わずに自分でビルドします。

P/Invoke で指定する DLL のファイル名を変更します。

• sources/AR.BZip2/BZip2Stream_Interop.cs

10:        private const string DllName = "libbz2";

こうすれば Windows では libbz2.dll、WSL では libbz2.so が使用されます。WSL ではカレントディレクトリになくても /usr/lib/libbz2.so が参照されます。

DLL をビルドします。

csc -o -out:AR.Compression.BZip2.dll -t:library -unsafe sources/AR.BZip2/*.cs

Windows 用の bzip2 は以下で配布されているバイナリを利用します。

• Releases · philr/bzip2-windows
  DLL only (libbz2.dll) | 64-bit (x64)

テスト

マルチストリームの例として作った ab.bz2 の伸張を試みます。

※ BZip2Stream のコンストラクターの最後の引数が true の場合、処理の完了後に渡したストリーム fs は開いたままになります。デフォルトでは false のため true を指定します。SharpZipLib の IsStreamOwner と用途は同じですが指定方法が逆です。マルチストリームとは関係ありません。

#r "AR.Compression.BZip2.dll"
open System.IO
open System.IO.Compression
do
    use fs = new FileStream("ab.bz2", FileMode.Open)
    use bz = new BZip2Stream(fs, CompressionMode.Decompress, false)
    use sr = new StreamReader(bz)
    printfn "%s" (sr.ReadToEnd())

実行結果

helloworld

すべてのストリームが一括で処理されました。BZip2Stream.cs を見ても、逐次的に読み進めることは想定されていないようです。次で見るベースストリームの扱いと合わせて考えても、改造なしで対応することはできないようです。

ベースストリームの読み込み

それぞれのライブラリで、渡されたベースストリームの読み込み個所を確認します。

※ .NET での Stream のことをベースストリームと呼んで、bzip2 の意味でのストリームと区別します。

• SharpZipLib: src/ICSharpCode.SharpZipLib/BZip2/BZip2InputStream.cs

417:                            thech = baseStream.ReadByte();

• SharpCompress: src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs

231:            int magic0 = bsStream.ReadByte();
232:            int magic1 = bsStream.ReadByte();
233:            int magic2 = bsStream.ReadByte();
242:            int magic3 = bsStream.ReadByte();
378:                    thech = (char)bsStream.ReadByte();
649:                                    thech = (char)bsStream.ReadByte();
717:                                                thech = (char)bsStream.ReadByte();
814:                                            thech = (char)bsStream.ReadByte();

• AR.Compression.BZip2: sources/AR.BZip2/BZip2Stream.cs

  9:             private const int BufferSize = 128 * 1024;
 14:             private readonly byte[] _buffer = new byte[BufferSize];
368:                                             _data.avail_in = _stream.Read(_buffer, 0, ufferSize);

SharpZipLib と SharpCompress では必要に応じて ReadByte で 1 バイトずつ読み進めています。そのため bzip2 のストリームの区切りで抜けても、オーバーランすることはないようです。thech (the character?) という変数名が共通していることから、何か共通の元ネタがあるのかもしれません。（libbz2 にはこの変数名は見当たりません）

AR.Compression.BZip2 では固定長でバッファに読み込んでいます。自前で伸張していないため、バイト単位で読み進めることはできないのでしょう。もし bzip2 のストリームごとに処理を区切るとしてもオーバーランしてしまうため、何らかの対策が必要です。

バイトごとに読み進めるのはベースストリームの位置に関して正確ではありますが、処理速度的には不利です。

計測

巨大なファイルの伸張に掛かる時間を比較します。

Wikipedia 日本語版のダンプデータを使用します。このファイルはマルチストリーム構成です。

• https://dumps.wikimedia.org/jawiki/
  jawiki-20200501-pages-articles-multistream.xml.bz2 3.0 GB

逐次読み込み

SharpZipLib と SharpCompress でストリームを逐次的に読み込みます。

test1.fsx

#r "SharpZipLib.1.2.0/lib/net45/ICSharpCode.SharpZipLib.dll"
open System
open System.IO
open ICSharpCode.SharpZipLib.BZip2
let target = "jawiki-20200501-pages-articles-multistream.xml.bz2"
do
    use fs = new FileStream(target, FileMode.Open)
    let buffer = Array.zeroCreate<byte>(1024 * 1024)
    let mutable streams, bytes = 0, 0L
    while fs.Position < fs.Length do
        use bz = new BZip2InputStream(fs, IsStreamOwner = false)
        let mutable len = 1
        while len > 0 do
            len <- bz.Read(buffer, 0, buffer.Length)
            bytes <- bytes + int64 len
        streams <- streams + 1
    Console.WriteLine("streams: {0:#,0}, bytes: {1:#,0}", streams, bytes)

test2.fsx

#r "SharpCompress.dll"
open System
open System.IO
open SharpCompress.Compressors
let target = "jawiki-20200501-pages-articles-multistream.xml.bz2"
do
    let mutable ignore = true
    use fs = { new FileStream(target, FileMode.Open) with
        override __.Dispose disposing = if not ignore then base.Dispose disposing }
    let buffer = Array.zeroCreate<byte>(1024 * 1024)
    let mutable streams, bytes = 0, 0L
    while fs.Position < fs.Length do
        use bz = new BZip2.BZip2Stream(fs, CompressionMode.Decompress, false)
        let mutable len = 1
        while len > 0 do
            len <- bz.Read(buffer, 0, buffer.Length)
            bytes <- bytes + int64 len
        streams <- streams + 1
    ignore <- false
    Console.WriteLine("streams: {0:#,0}, bytes: {1:#,0}", streams, bytes)

実行結果

$ time ./test1.exe  # SharpZipLib
streams: 24,957, bytes: 13,023,068,290

real    16m2.849s

$ time ./test2.exe  # SharpCompress
streams: 24,957, bytes: 13,023,068,290

real    18m26.520s

SharpZipLib の方が速いようです。

一括読み込み

SharpCompress と AR.Compression.BZip2 で全ストリームを一括で読み込みます。

test3.fsx

#r "SharpCompress.dll"
open System
open System.IO
open SharpCompress.Compressors
let target = "jawiki-20200501-pages-articles-multistream.xml.bz2"
do
    use fs = new FileStream(target, FileMode.Open)
    use bz = new BZip2.BZip2Stream(fs, CompressionMode.Decompress, true)
    let buffer = Array.zeroCreate<byte>(1024 * 1024)
    let mutable bytes, len = 0L, 1
    while len > 0 do
        len <- bz.Read(buffer, 0, buffer.Length)
        bytes <- bytes + int64 len
    Console.WriteLine("bytes: {0:#,0}", bytes)

test4.fsx

#r "AR.Compression.BZip2.dll"
open System
open System.IO
open System.IO.Compression
let target = "jawiki-20200501-pages-articles-multistream.xml.bz2"
do
    use fs = new FileStream(target, FileMode.Open)
    use bz = new BZip2Stream(fs, CompressionMode.Decompress, false)
    let buffer = Array.zeroCreate<byte>(1024 * 1024)
    let mutable bytes, len = 0L, 1
    while len > 0 do
        len <- bz.Read(buffer, 0, buffer.Length)
        bytes <- bytes + int64 len
    Console.WriteLine("bytes: {0:#,0}", bytes)

実行結果

$ time ./test3.exe  # SharpCompress
bytes: 13,023,068,290

real    17m36.925s

$ time ./test4.exe  # AR.Compression.BZip2
bytes: 13,023,068,290

real    7m50.165s

AR.Compression.BZip2 はネイティブライブラリを呼び出しているだけあって速いです。

Python

Python の bz2 モジュールと比較します。こちらもネイティブのラッパーです。

test5.py（逐次）

import bz2
target  = "jawiki-20200501-pages-articles-multistream.xml.bz2"
streams = 0
bytes   = 0
size    = 1024 * 1024  # 1MB
with open(target, "rb") as f:
    bz2d = bz2.BZ2Decompressor()
    data = []
    while data or (data := f.read(size)):
        bytes += len(bz2d.decompress(data))
        data = bz2d.unused_data
        if bz2d.eof:
            bz2d = bz2.BZ2Decompressor()
            streams += 1
print("streams: {:,}, bytes: {:,}".format(streams, bytes))

test6.py（一括）

import bz2
target = "jawiki-20200501-pages-articles-multistream.xml.bz2"
bytes  = 0
size   = 1024 * 1024  # 1MB
with bz2.open(target, "rb") as f:
    while (data := f.read(size)):
        bytes += len(data)
print("bytes: {:,}".format(bytes))

実行結果

$ time py.exe test5.py  # 逐次
streams: 24,957, bytes: 13,023,068,290

real    8m12.155s

$ time py.exe test6.py  # 一括
bytes: 13,023,068,290

real    8m1.476s

処理の大半が libbz2 で行われているため、それ以外のオーバーヘッドは少ないようです。.NET との主な違いはバッファを使い回していない点です。

bzcat

WSL1 の bzcat コマンドも計測します。

$ time bzcat jawiki-20200501-pages-articles-multistream.xml.bz2 > /dev/null

real    8m21.056s
user    8m5.563s
sys     0m15.422s

次で見ますが Mono の AR.Compression.BZip2 より遅いです。WSL1 のリダイレクトにオーバーヘッドがあるためでしょうか。

まとめ

結果をまとめます。WSL1 (Mono) での計測結果を加えます。

	逐次 (Win)	逐次 (WSL1)	一括 (Win)	一括 (WSL1)
SharpZipLib	16m02.849s	22m49.375s
SharpCompress	18m26.520s	23m56.694s	17m36.925s	22m54.247s
AR.Compression.BZip2			7m50.165s	7m41.580s
Python (bz2)	8m12.155s	8m45.590s	8m01.476s	8m28.749s
bzcat				8m21.056s

マネージドコードで実装されたライブラリは倍以上の時間が掛かりました。マネージド縛りがなければ AR.Compression.BZip2 を使った方が無難です。

※ System.IO.Compression.GZipStream が利用している DeflateStream は、独自実装からネイティブのラッパーに切り替えたようです。

• GZipStream クラス (System.IO.Compression) | Microsoft Docs

.NET Framework 4.5以降では、DeflateStream クラスは、圧縮のために zlib ライブラリを使用します。

関連記事

Wikipedia のダンプについては以下の記事を参照してください。

• Wikipediaのダンプからページを取り出す

参考

SharpZipLib で bzip2 を扱っている記事です。

• C#で bzip2 の圧縮、展開を行う方法 - 備忘録

SharpCompress に言及している記事です。

• つぼやきver2 続SharpCompress

Matplotlib

• グラフ描画ライブラリ
• 公式サイト
• 基本Python + Numpy + matplotlib + SciPy + etc.の組み合わせて使用

インストール

pip install matplotlib

最初の例

import matplotlib.pyplot as plt # 呪い

squares = [1, 4, 9, 16, 25]
plt.plot(squares) # defalutは点同士が直線で結びついている
plt.show() # 上の指示に従い、描画し、見せる

日本語表示

デフォルトは日本語使用できないため、ちょっとした設定が必要になります。
要は、matplotlibのフォント設定を日本語対応のフォントを変更する。

1. https://ipafont.ipa.go.jp/node17#jp からIPAexフォントをダウンロード、現時点は「IPAexフォント Ver.004.01」が最新
2. ダウンロードしたファイルを解凍し、中のipaexg.ttfファイルを${オブジェクトパス}\venv\Lib\site-packages\matplotlib\mpl-data\fonts\ttfにコピーする
3. ${オブジェクトパス}\venv\Lib\site-packages\matplotlib\mpl-dataは以下にあるmatplotlibrcを開き
4. font.familyで検索
5. #font.family : sans-serifの下にfont.family : IPAexGothicを追記する
6. matplotlibのキャッシュの保存先の内容を全部削除する

下記のコードでフォントパスとキャッシュの保存先を調べることができる

print(matplotlib.matplotlib_fname())   # フォントパス
print(matplotlib.get_cachedir())       # キャッシュの保存先

もう一つ方法は、設定ファイルを修正しないが、毎回下記のコードを追記しないといけない

plt.rcParams['font.sans-serif']=['IPAexGothic']

もしくは

plt.rcParams["font.family"] = "IPAexGothic"

飾り

import matplotlib.pyplot as plt

squares = [1, 4, 9, 16, 25]
plt.plot(squares, linewidth = 5)  # 線をちょっと太くする

plt.title("平方", fontsize = 24)
plt.xlabel("値", fontsize = 14)
plt.ylabel("値の二乗", fontsize = 14)

# 軸の目盛りの表示設定
plt.tick_params(axis = 'both', labelsize = 14)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 0から5を0.2刻みの点を作成することにより、線が滑らかに見える
x = np.arange(0., 5., 0.2)
plt.plot(x, x * x)

plt.title("平方", fontsize = 24)
plt.xlabel("値", fontsize = 14)
plt.ylabel("値の二乗", fontsize = 14)

# 目盛りの文字サイズをちょっと大きめに設定
plt.tick_params(labelsize = 30)

plt.show()

目盛りのサイズが大きくすると、X軸やY軸のラベルがはみ出して、見えなくなるが、もちろん画面のサイズを調整して、見えるようにすればいいが、plt.tight_layout()をplt.show()前に入れれば、自動的に収める状態で表示してくれる。

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0., 5., 0.2)
plt.plot(x, x * x)

plt.title("平方", fontsize = 24)
plt.xlabel("値", fontsize = 14)
plt.ylabel("値の二乗", fontsize = 14)

plt.tick_params(labelsize = 30)

plt.tight_layout()
plt.show()

点で表示したい(散布図)

scatter()を使用する。

import matplotlib.pyplot as plt

x_values = [1, 2, 3, 4, 5]
y_values = [1, 4, 9, 16, 25]
plt.scatter(x_values, y_values, s=100)  # sは点のサイズを指定

plt.show()

データは自動計算から取得する

import matplotlib.pyplot as plt

x_values = list(range(1, 1001))
y_values = [x**2 for x in x_values]
plt.scatter(x_values, y_values, s=4)

plt.axis([0, 1100, 0, 1100000])  # 軸の範囲
plt.show()

custom_graident を使用する場合の通常の書き方

@tf.custom_gradient
def gradient_reversal(x):
  y = x
  def grad(dy):
    return - dy
  return y, grad

# model 内で使用する場合
class MyModel(tf.keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()

    def call(self, x):
        return gradient_reversal(x)

custom_gradient 内でスコープ外の変数(self等)を使用したい場合

class MyModel2(tf.keras.Model):
    def __init__(self):
        super(MyModel2, self).__init__()
        self.alpha = self.add_weight(name="alpha", initializer=tf.keras.initializers.Ones())

    @tf.custom_gradient
    def forward(self, x):
        y = self.alpha * x

        def backward(w, variables=None):
            with tf.GradientTape() as tape:
                tape.watch(w)
                z = - self.alpha * w

            grads = tape.gradient(z, [w])
            return z, grads

        return y, backward

    def call(self, x):
        return self.forward(x)

• ドキュメント 内での引数が dy になっているので計算済みのものが渡ってくるかと思いきや、Backpropagation 時の実行関数として指定できる (上記の backward メソッド)

• bakward メソッド外のスコープの変数を使用する場合は、 variables=None を受け取るようにしないと以下のようなエラーが発生する (ドキュメントのArgs内でも説明されている)

TypeError: If using @custom_gradient with a function that uses variables, then grad_fn must accept a keyword argument 'variables'.

検証用コード

import tensorflow as tf


optimizer = tf.keras.optimizers.Adam(learning_rate=0.1)


class MyModel(tf.keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.alpha = self.add_weight(name="alpha", initializer=tf.keras.initializers.Ones())

    @tf.custom_gradient
    def forward(self, x):
        y = self.alpha * x
        tf.print("forward")
        tf.print("  y: ", y)

        def backward(w, variables=None):
            z = self.alpha * w
            tf.print("backward")
            tf.print("  z: ", z)
            tf.print("  variables: ", variables)
            return z, variables

        return y, backward

    def call(self, x):
        return self.forward(x)


class MyModel2(tf.keras.Model):
    def __init__(self):
        super(MyModel2, self).__init__()
        self.alpha = self.add_weight(name="alpha", initializer=tf.keras.initializers.Ones())

    @tf.custom_gradient
    def forward(self, x):
        y = self.alpha * x
        tf.print("forward")
        tf.print("  y: ", y)

        def backward(w, variables=None):
            with tf.GradientTape() as tape:
                tape.watch(w)
                z = - self.alpha * w

            grads = tape.gradient(z, [w])

            tf.print("backward")
            tf.print("  z: ", z)
            tf.print("  variables: ", variables)
            tf.print("  alpha: ", self.alpha)
            tf.print("  grads: ", grads)
            return z, grads

        return y, backward

    def call(self, x):
        return self.forward(x)


for model in [MyModel(), MyModel2()]:
    print()
    print()
    print()
    print(model.name)
    for i in range(10):
        with tf.GradientTape() as tape:
            x = tf.Variable(1.0, tf.float32)
            y = model(x)

        grads = tape.gradient(y, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        tf.print("step")
        tf.print("  y:", y)
        tf.print("  grads:", grads)
        print()

はじめに

Django REST frameworkを使うと、簡単にAPIを作成することができます。
ここでは、Django REST frameworkについて、最低限知っておきたいことにしぼって解説します。

settings.pyへの追記

INSTALLED_APPSにrest_frameworkを追記します。

settings.py

INSTALLED_APPS = [
    'rest_framework', # 追加
]

serializerの作成

次に、serializerを作成していきます。

serializers.py

from rest_framework import serializers


class SampleSerializer(serializers.ModelSerializer):

    class Meta:
        model = 対象モデル
        fields = 含めるフィールド（全部の場合は'__all__'） # または、exclude = (除外したいフィールド)

viewの作成

serializerを作成したら、views.pyに追記します。

views.py

from rest_framework import generics


class SampleListAPI(generics.ListAPIView):
    queryset = 対象モデル.objects.all()
    serializer_class = シリアライザー


class SampleDetailAPI(generics.ListAPIView):
    queryset = 対象モデル.objects.all()
    serializer_class = シリアライザー

urls.pyの設定

最後に、ルーティングの設定をして一通り完了です。

urls.py

from django.urls import path

from . import views


urlpatterns = [
    path('api/sample/list', views.SampleListAPI.as_view(), name='api_sample_list'),
    path('api/sample/detail/<int:pk>/', views.SampleDetailAPI.as_view(), name='api_sample_detail'),
]

まとめ

ここでは、Django REST frameworkを用いたAPI作成方法について解説しました。

ここで書くこと

この記事では「Djangoを用いてWebページからサーバ上に用意したPythonファイルを実行し、htmlから渡したデータをcsvファイルに出力する方法」について書いています。

また、執筆環境は
OS：macOS Catalina バージョン 10.15.4
Python：3.7.6
Django：3.0.3
となっています。

Djangoについて

前回の記事にてDjangoのインストール→htmlの表示までの流れについて書かせていただきましたので、Djangoの導入等についてはそちらをご参考ください。

Pythonファイルの準備

Pythonファイルの作成

まず、実行したいPythonファイルをDjangoのサーバ上に用意します。説明のために今回は以下のようなPythonファイルを用意します。

write_data.py

# coding:utf-8
import os
import csv

# htmlからのデータをcsvファイルに記録
def write_csv(data):
    datas = [data]
    with open(os.getcwd()+'/myapp/application/'+'data.csv','a') as f:
        writer = csv.writer(f, lineterminator='\n')
        writer.writerow(datas)

これにより、write_csv()の引数にデータを渡して呼び出すことでdata.csvにそのデータが書き込まれます。なおここでは<アプリ名>/applicationフォルダ内にPythonファイルを配置＆csvファイルを出力することを想定しているためos.getcwd()+'/myapp/application/'+'data.csv'としていますが、この部分は環境に応じて適宜読み替えてください。

Pythonファイルの配置

用意したPythonファイルをDjangoのサーバ上に配置します。Pythonファイルを<アプリ名>/applicationフォルダ内に置く場合、アプリ内のディレクトリは以下のようになるかと思います。

<プロジェクト名>
- db.sqlite3
- manage.py
- <プロジェクト名>
  - __init__.py
  - asgi.py
  - settings.py
  - urls.py
  - wsgi.py
  - __pycashe__
    - (.pycファイルが複数)
- <アプリ名>
  - __init__.py
  - admin.py
  - apps.py
  - models.py
  - tests.py
  - urls.py
  - views.py
  - migrations
    - __init__.py
  - application  # 作成したフォルダ
    - write_data.py  # 用意したPythonファイル
- templates
- static

もちろん、ここに置かないといけないという訳ではないのでファイルの配置場所は任意の場所で大丈夫です。

htmlからPythonファイルを実行できるようにする

ファイルの用意と配置が完了しましたら、実際にhtmlからそのPythonファイルを実行させてcsvファイルを作成してみます。その前に、データの流れがどのようになっているかを把握してから実装した方が作業しやすいと思いますので、今回想定するデータの流れを書いてみたいと思います。

パワポで作ってみました、ガサツな図で申し訳ありません、、
簡略化の為にプログラムと異なる部分も多々ありますが、csvファイルへの書き込みまでのデータの流れとしてはこんな感じです。何となくでもイメージが伝われば嬉しいです。

html(index.html)
　→myapp/views.pyのcall_write_data()にデータを送信
　→call_write_data()内でapplication/write_data.pyのwrite_csv()メソッドを実行
　→それにより渡したデータがcsvファイルに書き込まれる

言葉で表すとこんな感じです。これを踏まえ、次から実際にhtmlからPythonファイルを実行できるよう各ファイルを編集していきます。

html：ajaxを用いてviews.pyにデータを送信する

views.py内のcall_write_data()メソッドにデータを渡す為に、html上でajaxを用いてデータを送信してみたいと思います。ここに関しては色々な方法があるかと思いますので、アプリケーションに合う方法を用いていただければと思います。

index.html

{% load static %}
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>HTML</title>
    <link rel='stylesheet' type='text/css' href="{% static 'style.css' %}"/>
    <script type="text/javascript" src="{% static 'script.js' %}"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
  </head>

  <body>
      <span>文字を入力した後にボタンを押してください</span>
      <br>
      <input type="text" size="50" id="input_form">
      <button type="button" onclick="clickBtn()">送信</button>

      <script>
        function clickBtn() {
          var txt = document.getElementById("input_form").value;

          $.ajax({
            url: "{% url 'myapp:call_write_data' %}",
            method: 'GET',
            data: {"input_data": txt},
            dataType: "text",
            contentType: "application/json",
            beforeSend: function(xhr, settings) {
              if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                xhr.setRequestHeader("X-CSRFToken", csrf_token);
              }
            },
            error: function(xhr, status, error) {
              console.log("error")
            }
          })
          .done(function(data) {
            console.log("Success"); 
          });

          // csrf_tokenの取得に使う
          function getCookie(name) {
            var cookieValue = null;
            if (document.cookie && document.cookie !== '') {
              var cookies = document.cookie.split(';');
              for (var i = 0; i < cookies.length; i++) {
                var cookie = jQuery.trim(cookies[i]);
                // Does this cookie string begin with the name we want?
                if (cookie.substring(0, name.length + 1) === (name + '=')) {
                  cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                  break;
                }
              }
            }
            return cookieValue;
          }

          // ヘッダにcsrf_tokenを付与する関数
          function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
          };
        }

      </script>
  </body>
</html>

送信ボタンを押すとclickBtn()が実行され、ajaxによりデータが送信されるようになっています。urlの部分はmyapp: call_write_dataとなっており、これによりviews.pyに記述したcall_write_data()というメソッドにデータが送信されます。

データ部分はdata: {"input_data": txt}となっており、データを受け取る側では"input_data"と指定することで目的のデータを取得することができます。ここでは一つだけにしていますが、data: {"data1": txt1, "data2": txt2}のようにデータの個数や型などデータの形式については自由に設定できます。

myapp/views.py：実行したいPythonファイルとメソッドを指定して実行する

myapp/views.py

from django.shortcuts import render
from django.http import HttpResponse
# application/write_data.pyをインポートする
from .application import write_data

# Create your views here.
def index(req):
    return render(req, 'index.html')

# ajaxでurl指定したメソッド
def call_write_data(req):
    if req.method == 'GET':
        # write_data.pyのwrite_csv()メソッドを呼び出す。
        # ajaxで送信したデータのうち"input_data"を指定して取得する。
        write_data.write_csv(req.GET.get("input_data"))
        return HttpResponse()

ここではajaxで送信されたデータを取得し、実行したいPythonファイルのメソッドにそのデータを渡して呼び出しています。

myapp/urls.py：htmlからviews.pyのcall_write_data()にデータを送信できるようにする

myapp/urls.py

from django.urls import path
from . import views

app_name = 'myapp'
urlpatterns = [
    path(r'', views.index, name='index'),
    # 以下を追記(views.pyのcall_write_data()にデータを送信できるようにする)
    path("ajax/", views.call_write_data, name="call_write_data"),
]

パスを通すことで、html上からajax通信を用いてviews.pyの指定したメソッドにデータを送信できるようになります。

実際にcsvファイルに書き込まれるかを確認する

以上で必要な編集は完了です。

$ python manage.py runserver

でサーバを立ち上げ、表示されたアドレスにアクセス(htmlを表示)し入力フォームに適当な文字を入力してから送信ボタンを押してみてください。

- <アプリ名>
  - __init__.py
  ...
  - application
    - write_data.py
    - data.csv  # 生成されたcsvファイル

このようにアプリ内に作成したapplicationフォルダの中にcsvファイルが生成され、入力した文字列がファイルに記録されていれば問題なくデータが送信されている＆Pythonファイルが実行されています。

補足

今回はhtmlからPythonファイルを実行し、送信されたデータをcsvファイルに書き込む方法についてご説明しましたがその逆も可能です。

説明の簡略化の為に、”write_data.pyから渡されたデータをviews.pyで取得しそれをhtmlに渡して表示する”ことを行ってみたいと思います。変更箇所のあるファイルだけ以下に載せていきます。

myapp/application/write_data.py

return_text()というメソッドを追記する。

myapp/application/write_data.py

   # coding:utf-8

   import os
   import csv

   # htmlからのデータをcsvファイルに記録
   def write_csv(data):
       datas = [data]
       with open(os.getcwd()+'/myapp/application/'+'data.csv','a') as f:
           writer = csv.writer(f, lineterminator='\n')
           writer.writerow(datas)

   # 以下を追記(return_text()を呼び出すと"Hello!!"が返される)        
+  def return_text():
+      return "Hello!!"

myapp/views.py

write_data.pyにて追記したreturn_text()を呼び出し、返ってきた文字列を取得する(dataに格納する)。そのデータをHttpResponse()を用いてhtmlに渡す。

myapp/views.py

  from django.shortcuts import render
  from django.http import HttpResponse
  # application/write_data.pyをインポートする
  from .application import write_data

  # Create your views here.
  def index(req):
      return render(req, 'index.html')

  # ajaxでurl指定したメソッド
  def call_write_data(req):
      if req.method == 'GET':
          # write_data.pyのwrite_csvメソッドを呼び出す。
          # ajaxで送信したデータのうち"input_data"を指定して取得する。
          write_data.write_csv(req.GET.get("input_data"))

          # write_data.pyの中に新たに記述したメソッド(return_text())を呼び出す。
+         data = write_data.return_text()
          # 受け取ったデータをhtmlに渡す。
+         return HttpResponse(data)

index.html

ajax通信が成功するとHttpResponse()で渡した引数が.done(function(data) {の部分に渡されるので、そのデータをページに表示する。

index.html

  {% load static %}
  <!DOCTYPE html>
  <html>
    <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <title>HTML</title>
      <link rel='stylesheet' type='text/css' href="{% static 'style.css' %}"/>
      <script type="text/javascript" src="{% static 'script.js' %}"></script>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
    </head>

    <body>
      <span>文字を入力した後にボタンを押してください</span>
      <br>
      <input type="text" size="50" id="input_form">
      <button type="button" onclick="clickBtn()">送信</button>

      <!-- views.pyから渡された文字列を表示する。 -->
+     <br>
+     <span id="text"></span>

      <script>
        function clickBtn() {
          var txt = document.getElementById("input_form").value;

          $.ajax({
            url: "{% url 'myapp:call_write_data' %}",
            method: 'GET',
            data: {"input_data": txt},
            dataType: "text",
            contentType: "application/json",
            beforeSend: function(xhr, settings) {
              if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                xhr.setRequestHeader("X-CSRFToken", csrf_token);
              }
            },
            error: function(xhr, status, error) {
              console.log("error")
            }
          })
          .done(function(data) {
            // views.pyのcall_write_data()にてreturnしたHttpResponse(data)のデータはここで取得できる。
            // フォームの下部に追記したspan部分の内容を書き換える。
+           document.getElementById("text").textContent = data;
            console.log("Success"); 
          });

          // csrf_tokenの取得に使う
          function getCookie(name) {
            var cookieValue = null;
            if (document.cookie && document.cookie !== '') {
              var cookies = document.cookie.split(';');
              for (var i = 0; i < cookies.length; i++) {
                var cookie = jQuery.trim(cookies[i]);
                // Does this cookie string begin with the name we want?
                if (cookie.substring(0, name.length + 1) === (name + '=')) {
                  cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                  break;
                }
              }
            }
            return cookieValue;
          }

          // ヘッダにcsrf_tokenを付与する関数
          function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
          };
        }

      </script>
    </body>
  </html>

これにより、送信ボタンを押して正しくPythonファイルが実行されると"Hello!!"という文字列がhtmlに渡され、入力フォームの下の部分に渡されたHello!!という文字列が表示されると思います。

これを応用することで、サーバ上のPythonファイルを実行しサーバ上のファイルのデータを読み書きしたり、そのデータをhtml上に反映させることが可能になります。

0.初めに

生産現場で不良解析をしていると、CUM_plotなるものをよく用いる。正規分布だと直線になり、外れ値や複数の正規分布が混じっているかなどが分かりやすい。ふとpythonで作成しようと思ったらどうしても図1のCUMが出てくるが、図2のCUMが出てこない。。。どうやら通常はCUMというと図1を示すよう。

という事で、図2のCUM作成にチャレンジしてみました。正しいか不明なので、誤り等あればご指摘いただけると助かります。

1.CUM plotとは？

累積分布関数(cumulative distribution)の略。ただしこれでググると図1しか出てこない。。。
https://ja.wikipedia.org/wiki/%E7%B4%AF%E7%A9%8D%E5%88%86%E5%B8%83%E9%96%A2%E6%95%B0
図1のCUMの作成方法は下記URL参照
https://matplotlib.org/3.1.1/gallery/statistics/histogram_cumulative.html

2.CUMの作り方

図2のCUMをよく見るとy軸が正規分布を写像しているように見える。ただしそんなスケールはmatplotlibにないので、無理やりスケール変換し割り当てて見ました。

#宣言
from scipy.stats import norm
import numpy as np
import matplotlib.pyplot as plt

#dataの作成
np.random.seed(19680803)
mu = 200
sigma = 3
x = np.random.normal(mu, sigma, size=100)

#累積分布関数の逆関数をxに割り当てる
norm_arr = list()
for no in range(1,len(x)+1):
   norm_arr.append(norm.ppf((no)/(len(x)+1))-norm.ppf(1/(len(x)+1)))
norm_arr=norm_arr/max(norm_arr)#正規化
x.sort()#xを小さい順にソート

#y軸表示の変更
scale =[]
list_axis =[0.0001,0.001,0.01,0.05,0.1,0.2,0.3,0.5,0.7,0.8,0.9,0.95,0.99,0.999,0.9999]
for no in list_axis:
   scale.append(norm.ppf(no)-norm.ppf(0.0001))
scale=scale/max(scale)

#描画
fig, ax = plt.subplots(figsize=(8, 4))
linestyles = '-'
ax.grid(True)
ax.legend(loc='right')
ax.set_title('Cumulative step histograms')
ax.set_xlabel('data')
ax.set_ylabel('Percentage')
plt.yticks(scale,list_axis)
ax.plot(x,norm_arr,label='linear',marker='o',markersize=1.0,linewidth=0.1,linestyle=linestyles)

plt.show()

実行すると上記図2がそのまま出力されます。

動機

先日M5STICKCを使ってLINE Beaconを試してみた際に、
Webhook先を今まで使ったことないGASにしてみたところ、
どこでハマってしまっているのかよくわからない状態になってしまった。

知らない機能同士をまとめてためしたのが原因なので、Webhook先は毎回固定にしておいた方がいいのかもしれない

作ってみたもの

ということで、作ってみたのが個人的にWebhook先として汎用的に使える環境。

環境は一番慣れ親しんだものとしてAWSのLambda（とAPI Gateway）とする。

Lambda関数の中身は以下で、POSTで受けてもGETで受けてもログに出力できるようにする。

import json

def lambda_handler(event, context):
    # 引数：eventの内容を表示
    print("Received event: " + json.dumps(event))
    # rawQueryString
    rawQueryString = event['rawQueryString']
    if(len(rawQueryString) != 0):
        queryStringParameters = event['queryStringParameters']
        print(queryStringParameters)

    # body
    body = event.get('body')
    if(not body is None):
        json_body = json.dumps(body)
        print(json_body)

    return {
        'isBase64Encoded': False,
        'statusCode': 200,
        'headers': {},
        'body': json.dumps('Hello from Lambda!')
    }

• API Gatewayの作成については割愛。久々に作ってみたら前とかなり雰囲気が違っていてかなり戸惑った。

昨日までのはこちら

100日後にエンジニアになるキミ - 70日目 - プログラミング - スクレイピングについて

100日後にエンジニアになるキミ - 66日目 - プログラミング - 自然言語処理について

100日後にエンジニアになるキミ - 63日目 - プログラミング - 確率について1

100日後にエンジニアになるキミ - 59日目 - プログラミング - アルゴリズムについて

100日後にエンジニアになるキミ - 53日目 - Git - Gitについて

100日後にエンジニアになるキミ - 42日目 - クラウド - クラウドサービスについて

100日後にエンジニアになるキミ - 36日目 - データベース - データベースについて

100日後にエンジニアになるキミ - 24日目 - Python - Python言語の基礎1

100日後にエンジニアになるキミ - 18日目 - Javascript - JavaScriptの基礎1

100日後にエンジニアになるキミ - 14日目 - CSS - CSSの基礎1

100日後にエンジニアになるキミ - 6日目 - HTML - HTMLの基礎1

今回はスクレイピングの続きです。

通信について

Python言語でスクレイピングを行なっていきます。
スクレイピングでは通信を伴いますので
通信の仕組みを知っておく必要があります。

WEBサイトは世界中のサーバー上に置かれています。
WEBにおいて基本的にサーバとのやりとりはHTTP（HyperText Transfer Protocol)というプロトコル(通信規約)を用いて行い

ブラウザからサーバへの要求をリクエスト
サーバからブラウザへの応答をレスポンスと呼んでいます。

WEB上での基本的なやりとりはリクエスト/レスポンス(R/R)で成立しており
基本的にはテキストメッセージを交換することにより、実現されています

サイト検索の例
ブラウザから検索ツールで検索を実行リクエスト
サーバは要求に対して結果を返答レスポンス
レスポンスを元にブラウザは検索結果を表示

HTTP通信には、いくつかの仕様があり、リクエストの送り方が複数あります。

GET通信

GETはURLにパラメータを付加してリクエストします

例：
http://otupy.com?p=abc&u=u123
?以降はパラメータでパラメータはキー=値を&つなぎにしたものです。

POST通信

POSTはBodyに含めてリクエストします

http://otupy.com

リクエストBody
param:p:ab,u:u123

POSTとGETの使い分け
通信自体はブラウザーでは適切な通信方法を選んで行うが
プログラムでは通信方法を指定する必要があります。

リクエスト

ブラウザーなどからWEBサイトのサーバーへの要求をリクエストと言っています。

ブラウザでWebページを開く際、ブラウザはサーバに下記のような要求メッセージを送信します。

GETの例：

リクエストヘッダ
GET http://www.otupy.com/ex/http.htm HTTP/1.1
Host: www.otupy.com
Proxy-Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8
Referer: https://www.google.co.jp/
Accept-Encoding: gzip, deflate
Accept-Language: ja,en-US;q=0.9,en;q=0.8

POSTの例：

リクエストヘッダ：
POST /hoge/ HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Content-Length: 22
Cache-Control: max-age=0
Origin: http://localhost:8080
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.98 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,/;q=0.8
Referer: http://localhost:8080/hoge/
Accept-Encoding: gzip, deflate, br
Accept-Language: ja,en-US;q=0.8,en;q=0.6

リクエストボディ：
name=hoge&comment=hoge

リクエストはヘッダとボディ部があり、通信方法によってどのような情報を詰めて送信しているのかが変わります。

そのため、プログラムでアクセスする際にも適切な情報を詰めてリクエストをしてあげる必要があります。

プログラムでのアクセス

早速スクレイピングを試してみましょう。

Pythonではrequestsと言うライブラリで通信を行うことができます。

import requests

アクセス先のWEBサイトが必要なのでそれを指定してGETで通信を行います。
requests.get(URL)

url = 'http://www.otupy.net/'
res = requests.get(url)
print(res)

通信の結果レスポンスが返ってきます。
通信に成功していれば、アクセス先の情報が取得できます。

当然通信ですので失敗することもあります。

通信結果(レスポンス)

通信の結果レスポンスはいくつかのステータスコードに別れます。
200番台は通信が成功していますが、400,500番台は
通信に失敗をしているので、URLの打ち間違いや、相手型のサーバーにアクセスできる状況であるのかを確認する必要があります。

分類	番号	メッセージ	説明
情報	100	Continue	処理を継続しています。続きのリクエストを送信してください。
情報	101	Sitching Protocols	Upgrade ヘッダで指定したプロトコルに変更して再要求してください。
成功	200	OK	成功しました。
成功	201	Created	Location ヘッダで指定した場所に新しいコンテンツが作成されました。
成功	202	Accepted	要求は受理されました。ただし処理は完了していません。
成功	203	Non-Authoritative Information	応答ヘッダはオリジナルサーバーが返したものとは異なりますが、処理は成功です。
成功	204	No Content	コンテンツはありませんが、処理は成功しました。
成功	205	Reset Content	要求を受理したので、現在のコンテンツ（画面）を破棄してください。。
成功	206	Partial Content	コンテンツを一部のみ返却します。
転送	300	Multiple Choices	コンテンツ入手方法について複数の選択肢があります。
転送	301	Moved Permanently	Location ヘッダで指定された別の場所に移動しました。
転送	302	Found	Location ヘッダで指定された別の場所に見つかりました。そちらを見てください。
転送	303	See Other	Location ヘッダで指定された他の場所を見てください。
転送	304	Not Modified	更新されていません。If-Modified-Since ヘッダを用いた場合に返却されます。
転送	305	Use Proxy	Location ヘッダで指定したプロキシを使用してください。
転送	306	(Unused)	未使用。
転送	307	Temporary Redirect	別の場所に一時的に移動しています。
クライアントエラー	400	Bad Request	要求が不正です。
クライアントエラー	401	Unauthorized	認証されていません。
クライアントエラー	402	Payment Required	支払いが必要です。
クライアントエラー	403	Forbidden	アクセスが認められていません。
クライアントエラー	404	Not Found	見つかりません。
クライアントエラー	405	Method Not Allowed	指定したメソッドはサポートされていません。
クライアントエラー	406	Not Acceptable	許可されていません。
クライアントエラー	407	Proxy Authentication Required	プロキシ認証が必要です。
クライアントエラー	408	Request Timeout	リクエストがタイムアウトしました。
クライアントエラー	409	Conflict	リクエストがコンフリクト（衝突・矛盾）しました。
クライアントエラー	410	Gone	要求されたコンテンツは無くなってしまいました。
クライアントエラー	411	Length Required	Content-Length ヘッダを付加して要求してください。
クライアントエラー	412	Precondition Failed	If-... ヘッダで指定された条件に合致しませんでした。
クライアントエラー	413	Request Entity Too Large	要求されたエンティティが大きすぎます。
クライアントエラー	414	Request-URI Too Long	要求された URI が長すぎます。
クライアントエラー	415	Unsupported Media Type	サポートされていないメディアタイプです。
クライアントエラー	416	Requested Range Not Satisfiable	要求されたレンジが不正です。
クライアントエラー	417	Expectation Failed	Expect ヘッダで指定された拡張要求は失敗しました。
サーバーエラー	500	Internal Server Error	サーバーで予期しないエラーが発生しました。
サーバーエラー	501	Not Implemented	実装されていません。
サーバーエラー	502	Bad Gateway	ゲートウェイが不正です。
サーバーエラー	503	Service Unavailable	サービスは利用可能ではありません。
サーバーエラー	504	Gateway Timeout	ゲートウェイがタイムアウトしました。
サーバーエラー	505	HTTP Version Not Supported	このHTTPバージョンはサポートされていません。

プログラムでの通信結果の確認

さてプログラムで通信の結果を確認してみましょう。

レスポンス変数.status_code
でステータスコードを確認できます。

url = 'http://www.otupy.net/'
res = requests.get(url)
print(res.status_code)

200

もし200番でなければ通信が失敗しているのでWEBサイトの情報取得は出来ていないことになります。

200番の場合は通信が成功しているのでWEBサイトから取得した情報を見ることができます。

通信の結果を変数に格納しているので、様々な内容を見ることが出来ます。

リクエストURL
レスポンス変数.url

ステータスコード
レスポンス変数.status_code

レスポンスボディをテキスト形式で取得
レスポンス変数.text

レスポンスボディをバイナリ形式で取得
レスポンス変数.content

クッキー
レスポンス変数.cookies

エンコーディング情報を取得
レスポンス変数.encoding

ここから先は取得したテキスト情報を使って必要な情報に切り分けていきます。

# レスポンスをバイナリ形式で取得して文字に変換して表示(1000文字分)
print(res.content[0:1000].decode('utf-8'))

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "" class="autolink">http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
....

カスタムヘッダー

リクエストを行う際にはリクエストヘッダとボディ部に情報を詰めてリクエストすることができます。

GET通信でヘッダを指定してリクエストするには下記のように行います。

requests.get(url, headers=辞書型のヘッダデータ)

ヘッダ情報としてユーザーエージェントを変更してアクセスするにはこのように指定します。

headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36 '}
res = requests.get(url, headers=headers)

GET通信でパラメータを変更して通信する場合は以下のように指定します。

requests.get(url, params=辞書型のパラメータデータ)

params = {'key1': 'value1', 'key2': 'value2'}
res = requests.get(url, params=params)

POST通信でリクエストボディ部に情報を詰めてリクエストするには下記のように行います。

requests.get(url, data=辞書型のボディデータ)

payload = {'send': 'data'}
res = requests.post(url, data=payload)

まとめ

スクレイピングに必要な通信の仕組みを抑えておき情報取得が出来るようになっておこう。明日はこの続きで取得した情報から必要な情報を抜き出すところに入っていきます。

君がエンジニアになるまであと29日

作者の情報

乙pyのHP：
http://www.otupy.net/

Youtube：
https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw

Twitter：
https://twitter.com/otupython

とあるコンペをするにあたって、国名コードが必要になった。
これからも使う機会があるのかなと思って、作ってみました。

関数で作成しました。
スクレイピング元

Python jupyterCode

country_code.ipynb

def country_code(output,file_name):
    '''
    ***help***
    output : 現状csvのみ
    file_name : 任意のファイルネームを取得
    今回使用しているpandas.read_htmlは、lxml、html5lib、
    beautifulsoup4が必要なので、pipでインストールしておく
    '''
    import pandas as pd
    url = "https://www-yousei.jsps.go.jp/yousei1/kuniList.do"
    dfs = pd.read_html(url,header = 0)
    if output == "csv":
        dfs[0].to_csv(file_name + ".csv")
    return dfs[0]

Gitにもupしているので、気になった方、他のコード類を取得するコードを上げていただけると助かります。
GitHub Link

なお、私はGitHub初心者でわからないことだらけなので、何かありましたらコメントで教えていただけると幸いです。

GCIデータサイエンティスト育成講座

「GCIデータサイエンティスト育成講座」は、東京大学(松尾研究室)が開講している"実践型のデータサイエンティスト育成講座およびDeep Learning講座"で、演習パートのコンテンツがJupyterNoteBook形式で公開(CC-BY-NC-ND)されています。
Chapter5は「Pythonによる科学計算の基礎（NumpyとScipy）」で、科学計算を行うためのライブラリーNumpyとScipyの基礎知識を習得していきます。
日本語で学べる貴重で素晴らしい教材を公開いただいていることへの「いいね！」ボタンの代わりに、解いてみた解答を載せてみます。間違っているところがあったらご指摘ください。

5章3節は理解の追いつかない内容が多く、演習はほぼコピペでした。後で必要に応じて復習必要かも…。

5 Pythonによる科学計算の基礎（NumpyとScipy）

5.1 概要

5.1.1 この章の概要について

5.2 Numpy

5.2.1 インデックス参照

<練習問題 1>
上記データのsample_namesのbに該当するdataを抽出してください。

data[sample_names == 'b']

> array([[-0.977,  0.95 , -0.151, -0.103,  0.411]])

<練習問題 2>
上記データのsample_namesのc以外に該当するdataを抽出してください。

data[sample_names != 'c']

> array([[ 1.764,  0.4  ,  0.979,  2.241,  1.868],
>        [-0.977,  0.95 , -0.151, -0.103,  0.411],
>        [ 0.334,  1.494, -0.205,  0.313, -0.854],
>        [-2.553,  0.654,  0.864, -0.742,  2.27 ]])

<練習問題 3>
上記のcond_dataを変更して、x_arrayの3番目と4番目、y_arrayの1番、2番、5番目を出すように、条件制御を実施してください。

cond_data = np.array([False,False,True,True,False])
print(np.where(cond_data,x_array,y_array))

> [ 6  7  3  4 10]

5.2.2 Numpyの演算処理

<練習問題 1>
以下のデータに対して、すべての要素の平方根を計算した行列を表示してください。

sample_multi_array_data2 = np.arange(16).reshape(4,4)
print(sample_multi_array_data2)
print(sample_multi_array_data2 ** 0.5)

> [[ 0  1  2  3]
>  [ 4  5  6  7]
>  [ 8  9 10 11]
>  [12 13 14 15]]
> [[0.    1.    1.414 1.732]
>  [2.    2.236 2.449 2.646]
>  [2.828 3.    3.162 3.317]
>  [3.464 3.606 3.742 3.873]]

<練習問題 2>
上記のデータsample_multi_array_data2の最大値、最小値、合計値、平均値を求めてください。

print(sample_multi_array_data2.max())
print(sample_multi_array_data2.min())
print(sample_multi_array_data2.sum())
print(sample_multi_array_data2.mean())

> 15
> 0
> 120
> 7.5

<練習問題 3>
上記のデータsample_multi_array_data2の対角成分の和を求めてください。

np.trace(sample_multi_array_data2)

> 30

5.2.3 配列操作とブロードキャスト

<練習問題 1>
次の2つの配列に対して、縦に結合してみましょう。

np.concatenate([sample_array1, sample_array1], axis=0)
# データの準備
sample_array1 = np.arange(12).reshape(3,4)
sample_array2 = np.arange(12).reshape(3,4)

np.concatenate([sample_array1, sample_array1], axis=0)

> array([[ 0,  1,  2,  3],
>        [ 4,  5,  6,  7],
>        [ 8,  9, 10, 11],
>        [ 0,  1,  2,  3],
>        [ 4,  5,  6,  7],
>        [ 8,  9, 10, 11]])

<練習問題 2>
上記の2つの配列に対して、横に結合してみましょう。

np.concatenate([sample_array1, sample_array1], axis=1)

> array([[ 0,  1,  2,  3,  0,  1,  2,  3],
>        [ 4,  5,  6,  7,  4,  5,  6,  7],
>        [ 8,  9, 10, 11,  8,  9, 10, 11]])

<練習問題 3>
普通の以下のリストの各要素に3を加えるためにはどうすればよいでしょうか。Numpyのブロードキャスト機能を使ってください。

sample_list = [1,2,3,4,5]
np.array(sample_list) + 3

> array([4, 5, 6, 7, 8])

5.3 Scipy

5.3.1 補間

<練習問題 1>
以下のデータに対して、線形補間の計算をして、グラフを描いてください。

x = np.linspace(0, 10, num=11, endpoint=True)
x_ = np.linspace(0, 10, num=30, endpoint=True)
y = np.sin(x**2/5.0)
plt.plot(x,y,'o')
plt.grid(True)

f_1 = interpolate.interp1d(x, y,'linear')
plt.plot(x_, f_1(x_), '-')

<練習問題 2>
2次元のスプライン補間をして上記のグラフに書き込んでください(2次元のスプライン補間はパラメタをquadraticとします。)

f_2 = interpolate.interp1d(x, y,'quadratic')
plt.plot(x, y, 'o', x_, f_1(x_), '-', x_, f_2(x_), '--')
plt.grid(True)

<練習問題 3>
3次元スプライン補間も加えてみましょう。

f_3 = interpolate.interp1d(x, y,'cubic')
plt.plot(x, y, 'o', x_, f_1(x_), '-', x_, f_2(x_), '--', x_, f_3(x_), '-.')
plt.grid(True)

5.3.2 線形代数：行列の分解

<練習問題 1>
以下の行列に対して、特異値分解をしてください。

B = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(B)

> [[ 1  2  3]
>  [ 4  5  6]
>  [ 7  8  9]
>  [10 11 12]]

# 特異値分解の関数linalg.svd
U, s, Vs = sp.linalg.svd(B)
m, n = B.shape

S = sp.linalg.diagsvd(s,m,n)

print("U.S.V* = \n",U@S@Vs)

> U.S.V* = 
>  [[ 1.  2.  3.]
>  [ 4.  5.  6.]
>  [ 7.  8.  9.]
>  [10. 11. 12.]]

<練習問題 2>
以下の行列に対して、LU分解をして、 ??=? の方程式を解いてください。

#データの準備
A = np.identity(3)
print(A)
A[0,:] = 1
A[:,0] = 1
A[0,0] = 3
b = np.ones(3)
print(A)
print(b)

> [[1. 0. 0.]
>  [0. 1. 0.]
>  [0. 0. 1.]]
> [[3. 1. 1.]
>  [1. 1. 0.]
>  [1. 0. 1.]]
> [1. 1. 1.]

# 正方行列をLU分解する
(LU,piv) = sp.linalg.lu_factor(A)

L = np.identity(3) + np.tril(LU,-1)
U = np.triu(LU)
P = np.identity(3)[piv]

# 解を求める
x = sp.linalg.lu_solve((LU,piv),b)
print(x)

> [-1.  2.  2.]

5.3.3 積分と微分方程式

<練習問題 1>
以下の積分を求めてみましょう。

  \int_0^2 (x+1)^2 dx

integrate.quad(lambda x: (x+1)**2, 0, 2)

> (8.667, 0.000)

<練習問題 2>
cos関数の範囲 (0,?) の積分を求めてみましょう。

from numpy import cos
integrate.quad(cos, 0, math.pi)

(0.000, 0.000)

5.3.4 最適化

<練習問題 1>
以下の関数が0となる解を求めましょう。

\ f(x) = 5x -10

from scipy.optimize import fsolve

def f1(x):
    return 5 * x - 10

x = np.linspace(-100,100)
plt.plot(x,f1(x))
plt.plot(x,np.zeros(len(x)))
plt.grid(True)
plt.show()

x1 = fsolve(f1,0)
print(x1)

> [2.]

<練習問題 2>
以下の関数が0となる解を求めましょう。

\ f(x) = x^3 - 2x^2 - 11x +12

from scipy.optimize import fsolve

def f2(x):
    return x**3 - 2 * x**2 - 11 * x + 12

x = np.linspace(-5,5)
plt.plot(x,f2(x))
plt.plot(x,np.zeros(len(x)))
plt.grid(True)
plt.show()

x1 = fsolve(f2,-99999)
x2 = fsolve(f2,0)
x3 = fsolve(f2,99999)
print(x1, x2, x3)

> [-3.] [1.] [4.]

5.4 総合問題

5.4.1 総合問題1
以下の行列に対して、コレスキー分解を活用して、??=?の方程式を解いてください。

A = np.array([[5, 1, 0, 1],
              [1, 9, -5, 7],
              [0, -5, 8, -3],
              [1, 7, -3, 10]])
b = np.array([2, 10, 5, 10])

L = sp.linalg.cholesky(A)

t = sp.linalg.solve(L.T.conj(), b)
x = sp.linalg.solve(L, t)

# 解答
print(x)

> [-0.051  2.157  2.01   0.098]

5.4.2 総合問題2
0≤?≤1、0≤y≤1−x の三角領域で定義される以下の関数の積分値を求めてみましょう。

\int_0^1 \int_0^{1-x} 1/(\sqrt{(x+y)}(1+x+y)^2) dy dx 

from scipy import integrate

integrate.dblquad(lambda y, x:  1 / ((x + y)**(1/2) * (1 + x + y)**2), 0, 1, lambda x: 0, lambda x: 1-x)

# 関数をf(x, y)とした場合はどうすれば良いんだろう…
# def f(x,y):
#     1 / ((x + y)**(1/2) * (1 + x + y)**2)
# integrate.dblquad(f, 0, 1, lambda x: 0, lambda x: 1-x)

(0.285, 0.000)

5.4.3 総合問題3
以下の最適化問題をSicpyを使って解いてみましょう。

\ min \ f(x) = x^2+1
\\  s.t. x \ge -1

from scipy.optimize import minimize

def f(x):
    return x**2 + 1

def constraint(x):
    return x+1

x0 = -1
con = {'type':'ineq','fun':constraint}
sol = minimize(f,x0,method='SLSQP',constraints=con)

print("x = " + str(sol.x) + " のとき、f(x)は最小値 " + str(sol.fun) + " を取る")

# memo
# conの"'type': 'eq'"は=0, "'type': 'ineq'"は=>0

> x = [2.22e-16] のとき、f(x)は最小値 1.0 を取る

はじめに

同じ内容の記事を先日投稿しましたが，寝ぼけて削除してしまいました．申し訳ないです．

今回は量子ボルツマンマシンをQiskitを用いて実装を行ってみました．
参考とした論文はこちらです．
A quantum algorithm to train neural networks using low-depth circuits
また，量子アニーリングマシンを用いたボルツマンマシンはminatoさんの記事で紹介しているのでそちらにお任せしたいと思います．
D-Waveから量子ゲートマシンまでのRBMのボルツマン学習

制限ボルツマンマシンはニューラルネットワークの最小単位と言われています．
ちなみに，著者は機械学習の専門家ではないので詳しい説明は他の方にお任せします．

QABoM

この論文ではQuantum Approximate Boltzmann Machine (QABoM) Algorithmとして紹介しています．
細かい内容まで踏み込む時間はないので，Appendixで紹介されているQABoMの流れを紹介したいと思います．

なお，使用するindexは以下の通りです．
・v: visible層
・h: hidden層
・u: visible+hidden層

step 0

Define the full and partial initial Hamiltonians.

H_I = \sum_{j \in u} Z_j \\
H_{\tilde{I}} = \sum_{j \in h} Z_j 

式を見ると，fullはvisible+hiddenについて，partialはhiddenについてですね．次に
Define the full and partial mixer Hamiltonians.

H_M = \sum_{j \in u} X_j \\
H_{\tilde{M}} = \sum_{j \in h} X_j 

ボルツマンマシンの変数である，weight$J_{jk}^0$とbias$B_j^0$を定義．
epoch 1以上について次に示すstep 1からstep　5を繰り返します．

step 1

epoch nにおいてfull cost Hamiltonianとpartial cost Hamiltonianを定義します．

\hat{H}_C^n = \sum_{j,k \in u} J_{jk}^n \hat{Z}_j \hat{Z}_k + \sum_{j \in u} B_j^n \hat{Z}_j \\
\hat{H}_{\tilde{C}}^n = \sum_{j,k \in u} J_{jk}^n \hat{Z}_j \hat{Z}_k + \sum_{j \in h} B_j^n \hat{Z}_j

step 2 Unclamped Thermalization

step 0, step 1で定義した式を用いてQAOAを実行していきます．

a

pulse parametersを初期化 -> $\gamma, \beta$

b

$H_M$と$H_C$を使ってQAOAを実行
(QAOAの解説については他のサイトを見てください...）
最適化parameterを求めます．
ここでは$\hat{H}_C^n$で期待値を求めています．

c

最適なparameterを入力したパラメータcircuitを実行し，期待値$ <Z_j Z_k> $と$ <Z_j> $を求める.

step 3 Clamped thermalization

各data string $x$について

a

pulse parametersを初期化 -> $\gamma, \beta$

b

visible層に$x$をencodeする．

c

$H_M$と$H_C$を使ってQAOAを実行
(QAOAの解説については他のサイトを見てください...）
最適化parameterを求めます．
ここでは$\hat{H}_{\tilde{C}}^n$で期待値を取っています．

d

最適なparameterを入力したパラメータcircuitを実行し，期待値$ <Z_j Z_k> $と$ <Z_j> $を求める.

step 4

パラメータを更新していきます．
ここで$ <\bar{\cdots}>_D $はstep 3の結果の平均です．

\delta J_{jk}^n = <\bar{Z_j Z_k}>_D -< Z_j Z_k> \\
\delta B_j^n = < \bar{Z_j}> - <Z_j>_D \\
J_j^{n+1} = J_j^n + \delta J_j^n \\
B_j^{n+1} = B_j^n + \delta B_j^n

step 5

epoch = n+1 back to step 1

code

import とclassの初期化

# coding: utf-8

from qiskit.aqua.utils import tensorproduct
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info.analysis import average_data

import numpy as np
from copy import deepcopy

from QAOA import QAOA
from my_functions import sigmoid

class QBM:

    def __init__(self, num_visible=2, num_hidden=1, steps=3,
                 tmep=1.0, quant_meas_num=None, bias=False, reduced=False):
        self.visible_units = num_visible  # v
        self.hidden_units = num_hidden  # h
        self.total_units = self.visible_units + self.hidden_units
        self.quant_meas_num = quant_meas_num
        self.qaoa_steps = steps
        self.beta_temp = tmep
        self.state_prep_angle = np.arctan(np.exp(-1 / self.beta_temp)) * 2.0
        self.param_wb = 0.1 * np.sqrt(6. / self.total_units)
        self.WEIGHTS = np.asarray(np.zeros(shape=[self.visible_units, self.hidden_units]))
        if bias:
            self.BIAS = np.asarray(np.zeros(shape=[self.hidden_units]))
        else:
            self.BIAS = None
        self.reduced = reduced
        self.obs = self.observable()
        self.obs_tilde = self.observable(tilde=True)
        self.data_point = None

observableの作成．tilde=Trueとすることで$$を作成することができます．

    def Zi_Zj(self, q1, q2):
        I_mat = np.array([[1, 0], [0, 1]])
        Z_mat = np.array([[1, 0], [0, -1]])
        if q1 == 0 or q2 == 0:
            tensor = Z_mat
        else:
            tensor = I_mat
        for i in range(1, self.total_units):
            if i == q1 or i == q2:
                tensor = tensorproduct(tensor, Z_mat)
            else:
                tensor = tensorproduct(tensor, I_mat)
        return tensor

    def Zi(self, q):
        I_mat = np.array([[1, 0], [0, 1]])
        Z_mat = np.array([[1, 0], [0, -1]])
        if q == 0:
            tensor = Z_mat
        else:
            tensor = I_mat
        for i in range(1, self.total_units):
            if i == q:
                tensor = tensorproduct(tensor, Z_mat)
            else:
                tensor = tensorproduct(tensor, I_mat)
        return tensor

    def observable(self, tilde=False):
        visible_indices = [i for i in range(self.visible_units)]
        hidden_indices = [i + self.visible_units for i in range(self.hidden_units)]
        total_indices = [i for i in range(self.total_units)]

        obs = np.zeros((2**self.total_units, 2**self.total_units))

        for q1 in visible_indices:
            for q2 in hidden_indices:
                obs += -1.0 * self.Zi_Zj(q1, q2)

        if self.BIAS is not None:
            if tilde:
                for q in hidden_indices:
                    obs += -1.0 * self.Zi(q)
            elif not tilde:
                for q in total_indices:
                    obs += -1.0 * self.Zi(q)
        return obs

パラメーターcircuitを作成します．

    def U_circuit(self, params, qc):
        visible_indices = [i for i in range(self.visible_units)]
        hidden_indices = [i + self.visible_units for i in range(self.hidden_units)]
        total_indices = [i for i in range(self.total_units)]

        p = 2

        alpha = self.state_prep_angle
        for i in total_indices:
            qc.rx(alpha, i)
        for i in visible_indices:
            for j in hidden_indices:
                qc.cx(i, j)

        beta, gamma = params[:p], params[p:]

        def add_U_X(qc, beta):
            for i in total_indices:
                qc.rx(-2**beta, i)
            return qc

        def add_U_C(qc, gamma):
            for q1 in visible_indices:
                for q2 in hidden_indices:
                    qc.cx(q1, q2)
                    qc.rz(-2**gamma, q2)
                    qc.cx(q1, q2)
            return qc

        for i in range(p):
            qc = add_U_C(qc, gamma[i])
            qc = add_U_X(qc, beta[i])

        return qc

step 2を実行します．

    def unclamped_circuit(self, params):
        qr = QuantumRegister(self.total_units)
        cr = ClassicalRegister(self.total_units)
        qc = QuantumCircuit(qr, cr)
        qc = self.U_circuit(params, qc)
        qc.measure(range(self.total_units), range(self.total_units))
        return qc

    def make_unclamped_QAOA(self):
        qaoa = QAOA(qc=self.unclamped_circuit, observable=self.obs, num_shots=10000, p=2)
        counts = qaoa.qaoa_run()
        return counts

ここでQAOAという自作ライブラリーを使用していますが，下記で紹介します．
次にstep 3です．
step 2と異なる箇所はデータのencodeが含まれている所です．

    def clamped_circuit(self, params):
        qr = QuantumRegister(self.total_units)
        cr = ClassicalRegister(self.total_units)
        qc = QuantumCircuit(qr, cr)
        for i in range(len(self.data_point)):
            if self.data_point[i] == 1:
                qc.x(i)
        qc = self.U_circuit(params, qc)
        qc.measure(range(self.total_units), range(self.total_units))
        return qc

    def make_clamped_QAOA(self, data_point):
        self.data_point = data_point
        qaoa = QAOA(qc=self.clamped_circuit, observable=self.obs_tilde, num_shots=10000, p=2)
        counts = qaoa.qaoa_run()
        return counts

最後に学習の実行です．

    def train(self, DATA, learning_rate=1, n_epochs=100, quantum_percentage=1.0, classical_percentage=0.0):

        assert (quantum_percentage + classical_percentage == 1.0)
        DATA = np.asarray(DATA)
        assert (len(DATA[0]) <= self.visible_units)

        for epoch in range(n_epochs):

            print('Epoch: {}'.format(epoch+1))

            visible_indices = [i for i in range(self.visible_units)]
            hidden_indices = [i + self.visible_units for i in range(self.hidden_units)]
            total_indices = [i for i in range(self.total_units)]

            new_weights = deepcopy(self.WEIGHTS)
            if self.BIAS is not None:
                new_bias = deepcopy(self.BIAS)

            counts = self.make_unclamped_QAOA()
            unc_neg_phase_quant = np.zeros_like(self.WEIGHTS)
            for i in range(self.visible_units):
                for j in range(self.hidden_units):
                    model_expectation = average_data(counts, self.Zi_Zj(visible_indices[i], hidden_indices[j]))
                    unc_neg_phase_quant[i][j] = model_expectation

            unc_neg_phase_quant *= (1. / float(len(DATA)))

            if self.BIAS is not None:
                unc_neg_phase_quant_bias = np.zeros_like(self.BIAS)
                for i in range(self.hidden_units):
                    model_expectation = average_data(counts, self.Zi(hidden_indices[i]))
                    unc_neg_phase_quant_bias[i] = model_expectation

                unc_neg_phase_quant_bias *= (1. / float(len(DATA)))

            pos_hidden_probs = sigmoid(np.dot(DATA, self.WEIGHTS))
            pos_hidden_states = pos_hidden_probs > np.random.rand(len(DATA), self.hidden_units)
            pos_phase_classical = np.dot(DATA.T, pos_hidden_probs) * 1. / len(DATA)

            c_pos_phase_quant = np.zeros_like(self.WEIGHTS)
            if self.BIAS is not None:
                c_pos_phase_quant_bias = np.zeros_like(self.BIAS)

            if not self.reduced:

                iter_dat = len(DATA)
                pro_size = len(DATA)
                pro_step = 1

                for data in DATA:
                    counts = self.make_clamped_QAOA(data)
                    ct_pos_phase_quant = np.zeros_like(self.WEIGHTS)

                    for i in range(self.visible_units):
                        for j in range(self.hidden_units):
                            model_expectation = average_data(counts, self.Zi_Zj(visible_indices[i], hidden_indices[j]))
                            ct_pos_phase_quant[i][j] = model_expectation
                    c_pos_phase_quant += ct_pos_phase_quant

                    if self.BIAS is not None:
                        ct_pos_phase_quant_bias = np.zeros_like(self.BIAS)
                        for i in range(self.hidden_units):
                            model_expectation = average_data(counts, self.Zi(hidden_indices[i]))
                            ct_pos_phase_quant_bias[i] = model_expectation
                        c_pos_phase_quant_bias *= ct_pos_phase_quant_bias

                    pro_bar = ('==' * pro_step) + ('--' * (pro_size - pro_step))
                    print('\r[{0}] {1}/{2}'.format(pro_bar, pro_step, pro_size), end='')
                    pro_step += 1

                c_pos_phase_quant *= (1. / float(len(DATA)))
                if self.BIAS is not None:
                    c_pos_phase_quant_bias *= (1. / float(len(DATA)))

            neg_visible_activations = np.dot(pos_hidden_states, self.WEIGHTS.T)
            neg_visible_probs = sigmoid(neg_visible_activations)

            neg_hidden_activations = np.dot(neg_visible_probs, self.WEIGHTS)
            neg_hidden_probs = sigmoid(neg_hidden_activations)

            neg_phase_classical = np.dot(
                neg_visible_probs.T, neg_hidden_probs) * 1. / len(DATA)

            new_weights += learning_rate * \
                           (classical_percentage * (pos_phase_classical - neg_phase_classical) +
                            quantum_percentage * (c_pos_phase_quant - unc_neg_phase_quant))

            if self.BIAS is not None:
                new_bias = new_bias + learning_rate * \
                           (quantum_percentage * (c_pos_phase_quant_bias - unc_neg_phase_quant_bias))

            self.WEIGHTS = deepcopy(new_weights)
            print(self.WEIGHTS)
            if self.BIAS is not None:
                self.BIAS = deepcopy(new_bias)
            with open("RBM_info.txt", "w") as f:
                np.savetxt(f, self.WEIGHTS)
                if self.BIAS is not None:
                    np.savetxt(f, self.BIAS)
            with open("RBM_history.txt", "a") as f:
                np.savetxt(f, self.WEIGHTS)
                if self.BIAS is not None:
                    np.savetxt(f, self.BIAS)
                f.write(str('*' * 72) + '\n')
            print('')

        print("Training Done! ")

    def transform(self, DATA):
        return sigmoid(np.dot(DATA, self.WEIGHTS))


if __name__ == '__main__':

    qbm = QBM(num_visible=6, num_hidden=2,bias=True)

    train_data = [[1, 1, 1, 1, 1, 1],
                  [1, 1, -1, -1, 1, 1], [1, -1, -1, -1, 1, 1], [1, 1, 1, -1, -1, -1]]

    qbm.train(DATA=train_data, n_epochs=100, quantum_percentage=1.0, classical_percentage=0.0)

    print(qbm.transform(train_data))

QAOA

自作ライブラリーQAOAは以前紹介したQiskit Aquaを使わないQAOAの実装で用いたcodeを汎用的に拡張したものです．

QAOA.py

# coding: utf-8

from qiskit import BasicAer, execute
from qiskit.quantum_info.analysis import average_data

from scipy.optimize import minimize
import numpy as np
import random


def classica_minimize(cost_func, initial_params, options, method='powell'):
    result = minimize(cost_func, initial_params, options=options, method=method)
    return result.x


class QAOA:

    def __init__(self, qc, observable, num_shots, p=1, initial_params=None):
        self.QC = qc
        self.obs = observable
        self.SHOTS = num_shots
        self.P = p
        if initial_params is None:
            self.initial_params = [0.1 for _ in range(self.P * 2)]
        else:
            self.initial_params = initial_params

    def QAOA_output_layer(self, params):
        qc = self.QC(params)
        backend = BasicAer.get_backend('qasm_simulator')
        results = execute(qc, backend, shots=self.SHOTS).result()
        counts = results.get_counts(qc)
        expectation = average_data(counts, self.obs)
        return expectation

    def minimize(self):
        initial_params = np.array(self.initial_params)
        opt_params = classica_minimize(self.QAOA_output_layer, initial_params,
                                       options={'maxiter':500}, method='powell')
        return opt_params

    def qaoa_run(self):
        opt_params = self.minimize()
        qc = self.QC(opt_params)
        backend = BasicAer.get_backend('qasm_simulator')
        results = execute(qc, backend, shots=self.SHOTS).result()
        counts = results.get_counts(qc)
        return counts

if __name__ == '__main__':
    pass

計算結果

今回は古典の制限ボルツマンマシンでも同じデータを用いて計算機実験を行い，比較してみました．
古典制限ボルツマンマシンは別の方が実装しているものがあったので参考にさせてもらいました．
pythonで制約ボルツマンマシン実装

実行環境

OS: macOS Catalina ver 10.15.5
CPU: intel Core i7
メモリ: 16 GB

パラメータ

学習率：0.2
epochs: 100

古典ボルツマンマシンの結果

[[7.57147606e-220 4.69897282e-106]
 [1.00548918e-308 1.00000000e+000]
 [1.00000000e+000 3.79341879e-197]
 [1.00000000e+000 7.56791638e-202]
 [1.00000000e+000 2.85625356e-196]
 [1.00000000e+000 2.51860403e-243]
 [0.00000000e+000 1.00000000e+000]
 [9.02745172e-142 1.00000000e+000]]

QABoMの結果

[[0.59991237 0.68602485]
 [0.74497707 0.89553788]
 [0.26436565 0.113528  ]
 [0.2682931  0.1131361 ]
 [0.58273232 0.3268427 ]
 [0.41413436 0.14647751]
 [0.74056361 0.94317095]
 [0.7317069  0.8868639 ]]

ちなみにこれ，計算時間半日近くかかっています．（測定するの忘れた...）
一応古典RBMと同じ結果が得られました．が，古典ほどはっきりとした解ではありませんね．

まとめ

今回は論文に掲載されていたQABoMの実装を紹介しました．
もう少し計算機実験を行って，記事を更新していこうかなと思います．

拙い日本語で申し訳ありませんでした．国語力の改善に努めます．

参考文献一覧

QABoM: A quantum algorithm to train neural networks using low-depth circuits
RBM: pythonで制約ボルツマンマシン実装