音声アプリを作ろうとすると、グラフを動的に書きたくなった。そして、配置も工夫したいということでmatplotlibの使い方の基本を押さえることとした。
qiitaにも参考のような記事があり、ほぼまんまですが、動的というところが少し新しいかもです。

【参考】
①matplotlibでのプロットの基本
②matplotlib基礎 | figureやaxesでのグラフのレイアウト

やったこと

・グラフを書く
・動的グラフを書く

・グラフを書く

import matplotlib.pyplot as plt
import numpy as np

# データ生成
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# プロット領域(Figure, Axes)の初期化
plt.figure(figsize=(12, 8))
fig1=plt.subplot(131) #配置は参考②のとおり
fig2=plt.subplot(132)
fig3=plt.subplot(133)

# 棒グラフの作成
fig1.bar([1,2,3],[3,4,5])
fig1.set_xlabel("x")
fig1.set_ylabel("y")
fig2.barh([0.5,1.5,2.5],[0.5,1,2])
fig2.set_xlabel("xbar")
fig2.set_ylabel("ybar")
fig2.set_xlim(0,3)
fig2.set_ylim(0,3)
fig3.scatter(y1, y2)
plt.xlabel("sin(x)") #pltのときはset_無しでplt.xlabelと記載
plt.ylabel("cos(x)")
plt.xlim(-1.2,1.2)  #pltのときはset無しでplt.xlimと記載
plt.ylim(-1.5,1.5)
#fig3.set_xlabel("sin(x)") #もちろんこっちが正解だけど、上のようにも書ける
#fig3.set_ylabel("cos(x)")
plt.show()

・動的グラフを書く

import matplotlib.pyplot as plt
import numpy as np

# プロット領域(Figure, Axes)の初期化
fig = plt.figure()
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(224)
ax1.axis([-1.2, 1.2, -1.2, 1.2])

# 棒グラフの作成
s = 1
while True:
    # ax1-3を削除する.ただし、ax1を残すと軌跡が見える
    #fig.delaxes(ax1)
    fig.delaxes(ax2)
    fig.delaxes(ax3)
    #plt.pause(0.01) #これ入れるとちかちかする
    #ax1 = fig.add_subplot(221)
    ax2 = fig.add_subplot(222)
    ax3 = fig.add_subplot(224)
    #ax1.axis([-1.2, 1.2, -1.2, 1.2]) 
    ax2.axis([-2.2, 2.2, -2.2, 2.2]) 
    ax3.axis([-1.2, 1.2, -1.2, 1.2]) 
    y1 = np.sin(s/10)*np.exp(-s/1000) #減衰振動にしてみる
    y2 = np.cos(s/10)*np.exp(-s/1000)
    y3 = np.sin(s/10)  #ゆっくりスムーズに動かしたいときは100とかで割る
    y4 = np.cos(s/10)
    ax1.scatter(y1, y2)
    ax2.scatter(y1+y4, y2+y3) #リサじゅーっぽいアプリにした
    ax3.scatter(y4, y3)
    plt.pause(0.001) #表示時間は短くすると動きは速い
    s += 1

上記は動いている途中のシーンを保存しています。

import matplotlib.pyplot as plt
import numpy as np

# プロット領域(Figure, Axes)の初期化
fig = plt.figure()
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(224)
ax4 = fig.add_subplot(223) #追記
ax1.axis([-1.2, 1.2, -1.2, 1.2])

# 棒グラフの作成
s = 1
while True:
    # ax1-3を削除する
    #fig.delaxes(ax1)
    fig.delaxes(ax2)
    fig.delaxes(ax3)
    #plt.pause(0.01) #これ入れるとちかちかする
    #ax1 = fig.add_subplot(221)
    ax2 = fig.add_subplot(222)
    ax3 = fig.add_subplot(224)
    #ax1.axis([-1.2, 1.2, -1.2, 1.2]) 
    ax2.axis([-2.2, 2.2, -2.2, 2.2]) 
    ax3.axis([-1.2, 1.2, -1.2, 1.2]) 
    y1 = np.sin(s/10)*np.exp(-s/1000)
    y2 = np.cos(s/10)*np.exp(-s/1000)
    y3 = np.sin(s/10)
    y4 = np.cos(s/10)
    ax1.scatter(y1, y2)
    ax2.scatter(y1+y4, y2+y3)
    ax3.scatter(y4, y3)
    ax4.scatter(s,y1*y1+y2*y2) #追記
    ax4.set_yscale("log")#y軸のscale追記
    plt.pause(0.001)
    s += 1

x-軸もy-軸も、動的に変化していく。

まとめ

・matplotlibの表記方法がゆらぎがあって迷うので、まとめておいた
・動的なグラフを作成してみた

・ああ、すっきりした

はじめに

python3 標準入力まとめです。
paizaの問題などでよく使いそうなものをまとめています。

1行に要素1個

単語1個

入力

aiueo

main.py

hoge = input()

print(type(hoge))
print(hoge)

出力

<class 'str'>
aiueo

整数1個

入力

100

main.py

hoge = int(input())

print(type(hoge))
print(hoge)

出力

<class 'int'>
100

1行に要素n個

1行に複数要素ある場合。
要素間はスペース区切りを想定しています。

単語n個を配列に格納

入力

foo bar baz

main.py

list = [s for s in input().split()]

print(type(list))
print(list)

出力

<class 'list'>
['foo', 'bar', 'baz']

単語n個を各変数に格納

入力

foo bar baz

main.py

str1, str2, str3 = [s for s in input().split()]

print(type(str1))
print(str1)

print(type(str2))
print(str2)

print(type(str3))
print(str3)

出力

<class 'str'>
foo
<class 'str'>
bar
<class 'str'>
fbaz

整数n個を配列に格納

入力

100 200 300

main.py

list = [int(i) for i in input().split()]

print(type(list))
print(list)

出力

<class 'list'>
['100', '200', '300']

整数n個を各変数に格納

入力

100 200 300

main.py

num1, num2, num3 = [int(i) for i in input().split()]

print(type(num1))
print(num1)

print(type(num2))
print(num2)

print(type(num3))
print(num3)

出力

<class 'int'>
100
<class 'int'>
200
<class 'int'>
300

n行に要素m個

n行に整数m個

要素5つ, 3行の入力を想定しています。

入力

5 3
10 11 12 13 14
20 21 22 23 24
30 31 32 33 34

main.py

n, m = [int(i) for i in input().split()]
table = [[int(i) for i in input().split()] for m in range(m)]

print(type(n))
print(n)
print(type(m))
print(m)

print(type(table))
print(table)

出力

<class 'int'>
5
<class 'int'>
3
<class 'list'>
[[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34]]

おわりに

しっかりしたエラー処理などはしていないため、使用の際は気をつけてください。。。

参考文献

• 新約:標準入力の受け取りその1(Python3対応版)
• Python2で競技プログラミングする時に知っておきたいtips(入出力編)

はじめに

数年前にpythonを触り始めた時のメモをまとめた備忘録です。
※今思うとこの数年でたくさんのことを知ることができて嬉しいです。

順不同に色々

Pythonを簡単に

pythonはインタープリタ言語で、コンパイルやリンクが必要出ないため、短時間でコーディングできる。対話的に(jupyter)利用することもでき、簡単な関数テストもできる。C言語との拡張も可能

引数

スクリプトと引数は、変数sys.argvとして渡される。引数がない時は、sys.argv[0]には起動時スクリプト名が渡される。-cコマンドの形式では、argv[0]は'-c'となり、-mモジュールの時は、argv[0]は、モジュールのファイル名となる。

環境変数設定

pythonを起動する際に、毎度同じコマンドを打つのが面倒なときに環境変数PYTHONSTARTUPに、起動時の実行コマンドを記載したファイルを指定することで、実行が可能。対話型のみで有効なのは注意。

複数の変数へ代入できる

>>> a = b = c = 123
>>> a
123
>>> b
123
>>> c
123
>>> 

複数の型の混合した計算

intはfloatに変換される

>>> 3*2
6
>>> 3*2.0
6.0
>>> 3.0*2.0
6.0
>>> 

複素数

虚数は「j」または「J」で表す
complex(実部,虚部)の関数でも作れる。

>>> 3j*3j
(-9+0j)
>>> 3j*complex(0,3)
(-9+0j)
>>> 3.0j*complex(0,3.0)
(-9+0j)
>>> 

複素数は常に実部、虚部が浮動小数点数で表される。
.realと.imagで取り出すことができる。

>>> a = 2+3J
>>> a.real
2.0
>>> a.imag
3.0
>>> 

複素数は実数に変化する正しい方法が存在しないため、int()やfloat()での変換はできない。
大きさを求める場合には、abs()が利用できる。一応計算式も。

>>> a = 2+3J
>>> a.real
2.0
>>> a.imag
3.0
>>> float(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
>>>
>>> abs(a)
3.605551275463989
>>>
>>> import math
>>> math.sqrt(a.real**2+a.imag**2)
3.605551275463989

アンダースコア

最後に計算された式は、アンダースコアに代入されている。

>>> 3+2
5
>>> 3+_
8

文字列結合

当たり前の結合。注目すべきはシングルクオートであること。

>>> a = "hello"
>>> b = "world"
>>> a+b
'helloworld'

文字列の中に、シングルクオートが含まれていると、最後がダブルクオートになる。

>>> c = "I've said "
>>> c+a+b
"I've said helloworld"

print()を使うとクオートが無くなる。

>>> print(c+a+b)
I've said helloworld

並列で置くだけでも結合される

>>> "hello" "world"
'helloworld'

あくまでリテラル同士であることが大事

>>> "hello".strip() "world"
  File "<stdin>", line 1
    "hello".strip() "world"
                          ^
SyntaxError: invalid syntax

こういう時は演算子使う

>>> "hello".strip()+"world"
'helloworld'

スライスを作る

基本はこれ。

>>> a = "Helloworld"
>>> len(a)
10
>>> a[0]
'H'
>>> a[1]
'e'
>>> a[5]
'w'
>>> a[9]
'd'

負の数だとこう。

>>> a[-1]
'd'
>>> a[-1:]
'd'
>>> a[-5:]
'world'

注意が必要なのは「0」と「−0」。全く同じです。

>>> a[0]
'H'
>>>
>>> a[-0]
'H'

スライスを作るときの考え方も簡単

 +---+---+---+---+---+---+
 | H | e | l | l | o | w |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

スライスは第一のデフォルトが0で、第二が文字列のサイズになっています。
不適切なものが入ると空文字列が返ってきます。

>>> a[0:3]
'Hel'
>>> a[3:]
'loworld'
>>> a[:100]
'Helloworld'
>>> a[5:1]
''
>>> a[-1:-5]
''
>>> a[10:]
''
>>> a[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

C言語とは異なり、文字列は変更不能です。新しい文字列を生成することで同じようにできます。

>>> a[:4]="goodmorning"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>
>>> "goodmorning"+a[5:]
'goodmorningworld'

リストの操作

リストは[,]角括弧のカンマ区切りで、変更が可能です。型は同じでなくても問題ありません。

pop()やremove()やcopy()を使わない操作

>>> a=["hiro","yuki",33,[175,"80kg"]]
>>> a
['hiro', 'yuki', 33, [175, '80kg']]
>>>
>>> a[0:2]
['hiro', 'yuki']
>>> a[0:2] = []
>>> a
[33, [175, '80kg']]
>>> a[0] = "hiro"
>>> a
['hiro', [175, '80kg']]
>>> a[1:1]="yuki"
>>> a
['hiro', 'y', 'u', 'k', 'i', [175, '80kg']]
>>> a[1]="yuki"
>>> a
['hiro', 'yuki', 'u', 'k', 'i', [175, '80kg']]
>>> a[:0]=a
>>> a
['hiro', 'y', 'u', 'k', 'i', 'yuki', 'u', 'k', 'i', [175, '80kg'], 'hiro', 'y', 'u', 'k', 'i', 'yuki', 'u', 'k', 'i', [175, '80kg']]

forやwhileの中でのリスト

反復対象のシーケンスを、ループの中で変更を加えるときには、リストのスライスコピーを作る必要がある。

以下では、無限ループがおきます。

>>> a = ["bbb","ccccc","ddddddd","eeeeeeeee"]
>>> for x in a:
...     if len(x)>6:
...             a.insert(0,x)
>>>

スライスコピーすれば、元のリストは安全です。

>>> a = ["bbb","ccccc","ddddddd","eeeeeeeee"]
>>> for x in a[:]:
...     if len(x)>6:
...             a.insert(0,x)
>>>

range()について

終端値がリストに入らないのは周知ですね。
他の記事も書きましたが、出力の仕方が大事です。

>>> range(10)
range(0, 10)
>>> print(range(10))
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0,10,2))
[0, 2, 4, 6, 8]

関数の実行と参照について

関数が実行されると、関数内のローカルのシンボリックリンクに格納されます。
変数の参照は
・ローカルのシンボリックリンク
・グローバルのシンボリックリック
・ビルトインのシンボリックリンク
を調べるようになっています。

そのため関数内では、グローバル変数は,グローバル文を使わない限りは、参照しかできないようになっています。

また関数のデフォルト値は、関数を定義した時点で定義を行なっているスコープで評価されます。

キーワード引数について

>>> def intro(name,age = 33,weight = 80,height = 175):
...     print("my name is",name)
...     print("my age is",age)
...     print("my weight is",weight)
...     print("my height is",height)
... 
>>> intro("hiro")
my name is hiro
my age is 33
my weight is 80
my height is 175

>>> intro(name = "hiro",age = 35)
my name is hiro
my age is 35
my weight is 80
my height is 175

引数が足りないと以下のようになる

>>> intro()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: intro() missing 1 required positional argument: 'name'

>>> intro(age = 33)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: intro() missing 1 required positional argument: 'name'

引数の重複やキーワード引数の後にキーワードでないものを置いた場合、定義されていないキーワード。
要は
引数のリストでは、位置指定型引数を先に、キーワード引数を後に、コール時には仮引数を使う
必要がある

>>> intro("hiro",name = "yuki")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: intro() got multiple values for argument 'name'

>>> intro(name = "hiro",35)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

>>> intro(name = "hiro","yuki")
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

>>> intro(area = "chiba")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: intro() got an unexpected keyword argument 'area'

ドキュメンテーション文字列(docstirng)

・一行目にオブジェクトの目的を簡潔に書く
・大文字始まりで、ピリオド終わり
・複数行の場合は２行目は空行

リストの操作

list.remove(x):xである最初のアイテムを削除する。該当がなければエラー
list.pop(i):指定された位置のアイテムをリストから削除し。消したアイテムを返す。位置が指定されない時は、最後のアイテムを削除する。
list.sort():インプレース(元のリストのコピーを取らずに)でソートします。reverse()は逆順。
del list[i]:pop()と似ているがスライスを使えるところが便利。値は返さない。

シーケンスのアンパッキング

シーケンスと同等の長さの変数のリストがあればOK

>>> a = ("a","b","c")
>>> a
('a', 'b', 'c')
>>> x,y,z = a
>>> x
'a'

keyvalueペアになっているタプルからなるリストは辞書に簡単に変換できる。

>>> a
[('A', 1), ('B', 2), ('C', 3)]
>>> dict(a)
{'A': 1, 'B': 2, 'C': 3}

zip()を使えば、forループを使うときに、簡単にペアにできる

>>> a = ["a","b","c"]
>>> b = ["x","y","z"]
>>> for i,v in zip(a,b):
...     print(i+"と"+v+"はセット")
... 
aとxはセット
bとyはセット
cとzはセット

reversed（）やsorted()を使うと簡単に順番を変えられる。

>>> for i,v in zip(a,reversed(b)):
...     print(i+"と"+v+"はセット")
... 
aとzはセット
bとyはセット
cとxはセット

条件についてmemo

inとnot inははシーエンスに存在するかどうかのチェック
isとnot isは完全に同一であるかどうか

>>> a = ["a","b","c"]
>>> a
['a', 'b', 'c']
>>> b = a
>>> b
['a', 'b', 'c']
>>> a == b
True
>>> a is b
True
>>> c = a.copy()
>>> c
['a', 'b', 'c']
>>> c == a
True
>>> c == b
True
>>> c is a
False
>>> c is b
False

比較演算子は連結できる

aがbより小さく、かつbがcに等しい

a < b == c

ブール演算子は、比較演算子よりも優先順位は低いことは、とても重要。
ブール演算子の中では、not>and>orの順位になります。

以下では　　　「aでありbではないもの」もしくは「c」であるもの

a and not b or c

オブジェクトの比較

>>> 0 == 0.0
True
>>> 0 is 0.0
False

一旦ここまで

メモはまだ1/5くらい、また更新します。

Djangoでアプリを作ろうとするときに、通ることを避けられない、urls.py。
そして、その中で使うpath関数。

チュートリアルではフンフンと流していましたが、実際のところ、どんなものを入力すれば良いのか、調べてみました。

（例）

myapp.urls.py

urlpatterns = [
    path('admin/', admin.site.urls),
    path("bbs/", include("bbs.urls")),
    path("", RedirectView.as_view(url="/bbs/"))
]

path関数の引数

各pathの第一引数（"admin/"等）に対応するurlへのリクエストが来た場合に、第二引数に対応するviewsやを呼び出します。

pathは、公式ドキュメントによると、以下の引数を取ります。

https://docs.djangoproject.com/ja/2.1/ref/urls/

第一引数は、"admin/"等のroute、
第二引数は、viewを取る、
ということです。

viewを取る、というのは、どういうことかというと、

The view argument is a view function or the result of as_view() for class-based views. It can also be an django.urls.include().

つまり、引数viewは、以下のいずれかを取る、ということのようです。
① view関数
② class-based viewsのas_view()の出力
③ include()関数

上の例でいうと、
include("bbs.urls")は③、
RedirectView.as_view(url="/bbs/")は②、
ということになります。

admin.site.urlsは、一見、どこにも当てはまりません・・・。
以下のように、URLPattern型のオブジェクトのリストが帰ります。
まあ、最初から入っている特別なオブジェクト、ということで良いのかな・・。

>>python manage.py shell

>>> admin.site.urls
([<URLPattern '' [name='index']>, <URLPattern 'login/' [name='login']>, <URLPattern 'logout/' [name='logout']>, <URLPattern 'password_change/' [name='password_change']>, <URLPattern 'password_change/done/' [name='password_change_done']>, <URLPattern 'jsi18n/' [name='jsi18n']>, <URLPattern 'r/<int:content_type_id>/<path:object_id>/' [name='view_on_site']>, <URLResolver <URLPattern list> (None:None) 'auth/group/'>, <URLResolver <URLPattern list> (None:None) 'auth/user/'>, <URLResolver <URLPattern list> (None:None) 'bbs/article/'>, <URLPattern '^(?P<app_label>auth|bbs)/$' [name='app_list']>], 'admin', 'admin')

前回:
次回:
目次:https://qiita.com/New_enpitsu_15/private/479c69897780cabd01f4

Hello world

プログラミングを始める第一歩。
まずは、適当なファイル名.pyというファイルを作って
適当なテキストエディタで開いてみましょう。

そしたら、

file.py

print("Hello world")
input()

と書いて、保存。実行してみてください。(ファイルをダブルクリックすれば実行されます。)

Hello worldと黒い画面に表示されましたか？

表示されたら、あなたはもうパイソニアです。
これから解説サイトを片手にプログラムを楽しんでいきましょう。

ナポリタンが食べたい

ひとまず、先ほどのファイルを表示してください。

file.py

print("ナポリタンが食べたい")
input()

と書き換えて実行してみましょう。
ナポリタンが食べたいと画面に表示されたはずです。

では、最後にあなたの好きな食べ物の名前を表示してみましょう。
できましたか？わからなかったらコメントで聞いてくださいね。

解説

print()

printという関数は、()内の文字を表示します。
例えばprint("ナポリタン")だったら、"ナポリタン"と表示されるはず…
いいえ、ナポリタンと表示されます。なぜでしょう？

それは、ダブルクオーテーション"とシングルクオーテーション'は文字列を表す文字だからです。

詳しくは次回説明するので、今は""か''で囲わなければならないのだと思っておいてください。

input()

input()という関数は私たち(ユーザー)からの入力を待つ関数です。
試しに、

print(input("入力:"))
input()

というファイルを作り、実行してみてください。
黒い画面に入力した文字が、もう一度表示されましたね。

私たち(ユーザー)からの入力がprintに文字列として渡されました。

ですが、最後の行のinput()は何でしょう？
これは、画面をとどめておくために書いているものです。では試しに

print("Hello world")

だけで実行してみましょう。どうですか？
「実行できない」、「黒い画面が出てすぐ消えてしまう」という感想を持ったでしょう。
これは、print("Hello world")を実行したらすぐにプログラムが終了して画面が閉じてしまうからです。

そのため、input()でユーザーからの入力を待つことにより一旦処理を停止して、画面が閉じないようにしているのです。

次回は…

文字列と数字について説明します。

はじめに

AmazonComprehend(AWSの自然言語処理サービス)のAPIを、Python3から実行してみました。幾つかの記事を参考にさせて頂きましたが、一つにまとまっているものはなかったので、それらをまとめてみました。

環境

MacOS Sierra 10.12.6
python 3.7.0

インストール

$ sudo pip install awscli

次に、AWSアクセスキーを取得する。
参考サイト：

• インストール https://qiita.com/reflet/items/e4225435fe692663b705
• AWSアクセスキー https://aws.amazon.com/jp/developers/access-keys/

AWSアクセスキーは、リクエストを正常に AWS API に送信するために必要、とのことです。

AWSアクセスキーの取得

以下の記事を参照してください。
https://qiita.com/miwato/items/291c7a8c557908de5833

プログラムの実行

以下の記事にサンプルコードや結果がまとめられています。
https://dev.classmethod.jp/cloud/comprehend-operations-using-python-boto3-ja/

感想

Qiita初投稿、ということもあり、至らぬ点やアドバイスいただけると幸いです。
また参考にさせて頂いた記事の著者の皆様、ありがとうございました。

本記事でやること

• 前回の記事で行なったトレーニングジョブ結果から生成されたモデルのデプロイを行う。
• S3に置いてあるデータをまとめて推論するバッチ変換ジョブを実行する。

本記事でやらないことは以下の通りなので、他の記事を参照してください。

• 前回の記事で行なった独自アルゴリズムを使ったトレーニングジョブの実行方法
• SageMakerやS3などにアクセスするためのIAMロールの作成

対象読者

• とりあえずAWS SageMakerを動かしてみたい人
• Dockerに関して一通りの基礎知識がある人

使用言語

• Python 3.6.3

トレーニングジョブ結果から生成されたモデルのデプロイを行う

公式ドキュメントに記載がある通り、推論を行う際にアプリケーションがリクエストを送るエンドポイントは、モデルをデプロイした際に取得されます。なので、トレーニングジョブが完了された後にモデルのデプロイを必ず行う必要があります。

以下、コードからモデルのデプロイを行います。

class SagemakerClient:

    def __init__(self):
        self.client = Session(profile_name="hoge").client("sagemaker", region_name="ap-northeast-1")

    def create_model(self, model_data_url):

        model_params = {
            "ExecutionRoleArn": "arn:aws:iam::123:role/dev-sagemaker", 
            "ModelName": "sample-model", # モデル名
            "PrimaryContainer": {
                "Image": "123.dkr.ecr.ap-northeast-1.amazonaws.com/sagemaker-repo:latest", # ECRにプッシュしたイメージURL
                "ModelDataUrl": model_data_url # モデルデータが格納されているS3のパス
            }
        }

        self.client.create_model(**model_params)


if __name__ == '__main__':
    model_data_url = ...
    SagemakerClient().create_model(model_data_url)

上記コードでのcreate_modelメソッドの引数（model_data_url）は、boto3のdescribe_training_jobから得られるのでこちらの公式ドキュメントをご参照ください。

参考程度にmodel_data_urlを取得するコードを以下に記載いたします。また、describe_training_jobの引数TrainingJobNameはトレーニングジョブを送信する際に返ってくるTransformJobArnから取得をしています。

client = Session(profile_name="hoge").client("sagemaker", region_name="ap-northeast-1")

model_data_url = client.describe_training_job(TrainingJobName=training_job_name)['ModelArtifacts']['S3ModelArtifacts']

以下のようにAmazon SageMaker > モデルにモデルが現れていれば無事完了です。

S3に置いてあるデータをまとめて推論するバッチ変換ジョブを実行

今回、推論時に使用したデータや推論結果の出力先などは以下のようなフォルダ構成でS3に置きました。

bucket
├── input-data-prediction
│     └── YYYY-MM-DD
│          └── multiclass
│               └── iris.csv
├── output-data-prediction
│     └── YYYY-MM-DD
│          └── multiclass
│               
├── input-data-training
│     └── YYYY-MM-DD
│          └── multiclass
│               └── iris.csv
└── output-model
     　└── YYYY-MM-DD
          　└── multiclass
               　└── model名（←ここからはSageMakerが出力する）

以下のコードからバッチ変換ジョブを送信します。
ジョブを送信する際の引数であるModelNameは、デプロイしたモデル名を使用します。
デプロイしたモデル名は、boto3のlist_modelsメソッドで得られるのでこちらの公式ドキュメントをご参照ください。（モデル名に含まれている文字列とデプロイした時間からしか検索ができないみたいです）

class SagemakerClient:

    def __init__(self):
        self.client = Session(profile_name="hoge").client("sagemaker", region_name="ap-northeast-1")

    def submit_transform_job(self):

        model_name = self.client.list_models(
            NameContains="base_model_name", # 各自デプロイしたモデル名に含まれている文字列
            SortOrder='Descending',
            SortBy='CreationTime')["Models"][0]["ModelName"]

        transform_params = {
            "TransformJobName": "sample-transform_job_name", #　バッチ変換ジョブ名
            "ModelName": model_name, # デプロイしたモデル名
            "MaxConcurrentTransforms": 2,
            "MaxPayloadInMB": 50,
            "BatchStrategy": "MultiRecord",
            "TransformOutput": {
                "S3OutputPath": "s3://bucket/output-data-prediction/YYYY-MM-DD/multiclass/" # 推論結果を格納するS3パス
            },
            "TransformInput": {
                "DataSource": {
                    "S3DataSource": {
                        "S3DataType": "S3Prefix",
                        "S3Uri": "s3://bucket/input-data-prediction/YYYY-MM-DD/multiclass/" # 推論を行うインプットデータが格納されているS3パス
                    }
                },
                "ContentType": "text/csv",
                "SplitType": "Line"
            },
            "TransformResources": {
                "InstanceType": "ml.c4.xlarge",
                "InstanceCount": 1
            }
        }

        self.client.create_transform_job(**transform_params)

if __name__ == '__main__':
    SagemakerClient().submit_transform_job()

以下のようにAmazon SageMaker > バッチ変換ジョブでステータスがCompletedになれば無事完了です。上記で指定したS3のパスに推論結果が格納されているはずです。

終わりに

今回は、モデルをデプロイ~バッチ変換ジョブを送信するコードのみを記載しましたが、SageMakerのDockerコンテナ内にあるpredictor.pyやserveは公式のgithubにあるサンプルをそのまま使用しています。

・はじめに

Kerasを使ったディープラーニングを使いこなすにあたって必須知識のメモです。

・次元（ベクトルとテンソル）

・ベクトルデータ

1. 2次元テンソル

(samples, features)

例：生命表データセット
- ・データ数：10万件
- ・生命表（年齢、国、収入）
- ・テンソル：(100000, 3)

samples	age	country	annual income
1	25	jp	680
2	34	usa	1200
3	53	china	7000
...	42	usa	1500
100000	43	korea	650

2.　3次元テンソル

(samples, timesteps, features)
例：株価のデータセット（1分毎の最高値と最安値を360日分用意）
- ・データ数：360件(360日分）
- ・取引時間：390分
- ・データ（1分毎, 最高値、最安値）
- ・テンソル：(360, 3, 390)

timesteps: 390
※取引時間/1分毎

samples	max	min
1	20000	19900
2	20250	19950
3	20170	19800
...	21330	21100
360	23500	23300

3. 4次元テンソル

（samples, height, width, channels) または（samples, channels, height, width)
※TensorFlowは前者（チャネルラスト）を採用、Theanoは後者（チャネルファースト）を採用。

例：画像のデータセット
- ・データ数：10000件
- ・データサイズ：{"height" : "300px", "width" : "250px"}
- ・チェンネル数：3 ※RGB
- ・テンソル：(10000, 300, 250, 3)

3. 5次元テンソル

（samples, frames, height, width, channels) または（samples, frames, channels, height, width)

例：Youtubeの1分間動画（4FPS、144×256）のビデオクリップのサンプリング
- ・データ数：動画10本
- ・フレーム数：240※60 × 4
- ・チャンネル数：3
- - ・テンソル：(10, 240, 144, 256, 3)

4. MNISTの概要

1. (train_images, train_labels), (test_images, test_labels) = mnist.load_data()

・訓練データと訓練用ラベル、テストデータをテスト用ラベルを取得
- 訓練データの中身はこんな感じ※サイズ28×28の画像データが60000件

(60000, 28, 28)

- 訓練用ラベルの中身

(2, 1, 3, 9, 7...)

データとラベルは対になっている。

samples	labels
1	2
2	1
3	3
...	8
60000	0

2. train_images = train_images.reshape(60000, 28 * 28))

・データを2次元テンソル形式に変換

3. train_images = train_images.astype('float32') / 255

・データを8ビット整数値から32ビットfloat型へ変換

4. network = models.Sequential()

ニューラルネットワークモデルを初期化

5. network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))

密結合ネットワークを実装
layers.Dense(出力数, 演算タイプ, 入力数) : 2次元テンソルで活用される密結合モデル
演算タイプ ：入力テンソルから出力テンソルへ変換する際の演算タイプを指定
入力数 : テンソル数を指定

6. network.add(layers.Dense(10, activation='softmax'))

密結合ネットワークを実装
※入力数は省略可

7. network.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])

• optimizer : 最適化関数
  入力パラメータ（重み）の値を最適化していく
  ニューラルネットワークモデルそのものが最適化されていく

• loss : 損失関数
  目的値と予想値から損失率を割り出すための導関数
  損失率=0に近づく値を探していく

• metrics : 訓練とテストを監視するための指標
  評価基準の定義

8. network.fit(train_images, train_labels, epochs=5, batch_size=128)

128サンプルの小分けされたバッチを用いて訓練データの学習(イテレーション）を5回繰り返す。
※訓練データ全体に渡るイテレーションはエポックと呼ばれる。
イテレーションごとにネットワークはバッチごとの損失値から重みの勾配を計算し、重みを更新していく。
これを5エポック繰り返す。（※各エポックで469回、重みを更新、全体では2345回の値を更新）
[もう少し解説]
1. 60000件のデータを128件ごとに損失率をだし、最適化を行う
2. 上記1を5回繰り返す

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

ボゾンサンプリングとは

例によって、主に公式文献のp.18に従って学んでいきます。
もう少し詳細な文献だとこれとか良さそうです。

ボゾンサンプリングはパッシブな線形光学素子だけで構成可能な、比較的シンプルな量子計算機です。
ただしそれゆえにユニバーサルな量子計算機にはなり得ないです。
では何が嬉しいかと言うと、ボゾンサンプリングはPermanent関数の結果を吐き出します。
ただし現実的に有用かというと実はそうでもないようです。

そこで今回は、このような流れで書いていこうと思います。
- Permanent関数とは
- ボゾンサンプリングの実装
- ボゾンサンプリングの解析的計算
- 実際のところ役に立つの？

Permanent関数とは

Permanent関数は次のような数式で書けます。

$$
\mathrm{Perm(A)}= \sum_{\sigma \in S_n} \prod_{i=1}^{n} a_{i,\sigma (i)}
$$

$A$は$a_{i,j}$を要素にもつ$n \times n$行列で、$S_n$はn個の数字で可能な順列の集合です。
例えば、
$S_3 = $ { $(1,2,3),(1,3,2),(2,1,3),(2,3,1),(3,1,2),(3,2,1)$ }
です。

簡単に$A=2\times 2$行列の場合を考えると、
$\mathrm{Perm(A)}=a_{11} a_{22} + a_{12} a_{21}$
です。
$n=3$以降も計算するとわかるのですが、行列式と非常に似ています。
ただし行列式は各項の符号が偶置換or奇置換で変わりますが、Permanentは符号が変わりません。

応用例として、n人でランダムにプレゼント交換する場合に、誰も自分が持ってきたプレゼントを引き当てないような組み合わせの数を求めることができるようです。(リンク先の"derangement problem")

Permanent関数は古典計算だと最も効率的なアルゴリズムでも $O(2^{n-1} n^2)$ の計算量が必要だそうで、nについて指数関数的な計算リソースが必要です。よってもしこれを量子計算で効率的に求められれば量子計算の優位性を示すことができます。

ボゾンサンプリングの実装

ここはほとんど公式文献のまま、Jupiter notebook 実装ですが、入力光子数状態をランダム生成できるようにコードを追加しています(コメントアウトしてますが)。

import numpy as np
import strawberryfields as sf
import random as rd
from strawberryfields.ops import *
from numpy.linalg import multi_dot
from scipy.linalg import block_diag
import math

NodeNum = 4
SumOfPhoton = 3

# 入力光子数状態(FockList_ini)をランダムに生成
'''
FockList_ini = np.zeros(4, dtype=int)
for i in range(SumOfPhoton):
    tmp = rd.randint(0, NodeNum-1)
    FockList_ini[tmp] += int(1)
'''

# 1つのポートに2光子以上存在しない場合
'''
arr = np.arange(NodeNum)
np.random.shuffle(arr)
for i in range(SumOfPhoton):
    FockList_ini[arr[i]] += int(1)
'''

FockList_ini = [1,1,0,1]

eng, q = sf.Engine(4)

with eng:
    # prepare the input fock states
    Fock(FockList_ini[0]) | q[0]
    Fock(FockList_ini[1]) | q[1]
    Fock(FockList_ini[2]) | q[2] # vacuum state (optional)
    Fock(FockList_ini[3]) | q[3]

    # rotation gates
    Rgate(0.5719)
    Rgate(-1.9782)
    Rgate(2.0603)
    Rgate(0.0644)

    # beamsplitter array
    BSgate(0.7804, 0.8578)  | (q[0], q[1])
    BSgate(0.06406, 0.5165) | (q[2], q[3])
    BSgate(0.473, 0.1176)   | (q[1], q[2])
    BSgate(0.563, 0.1517)   | (q[0], q[1])
    BSgate(0.1323, 0.9946)  | (q[2], q[3])
    BSgate(0.311, 0.3231)   | (q[1], q[2])
    BSgate(0.4348, 0.0798)  | (q[0], q[1])
    BSgate(0.4368, 0.6157)  | (q[2], q[3])
    # end circuit
    # not performing measurement

# run the engine
state = eng.run('fock', cutoff_dim=8)

# extract the joint Fock probabilities
probs = state.all_fock_probs()

# print the joint Fock state probabilities
print(probs[1,1,0,1])

出力結果は、出力側光子検出器で検出されたフォトン数が{1,1,0,1}となる確率を示しています。
当然、光子数は入出力間で保存します。

0.17468916048563937

RゲートとBSゲートの結合は1つの$4 \times 4$ユニタリゲート$U$と等価で、入力ポート$i$のフォトンが出力ポート$j$から出てくる確率は$U_{ij}$で表せます。
この結果がPermanent関数と結びつく直感的な説明はこれのp.5がわかりやすいです。

例えば、入力ポート1,2に1つずつ存在したフォトンが、出力ポート3,4から1つずつ検出される確率は以下のように書けますね。
$$
U_{13} U_{24} + U_{14} U_{23}
$$
上の$2\times 2$行列のPermanent関数と見比べると、これは$4 \times 4$ユニタリゲート$U$を上手く整形してPermanent関数に渡してやれば出てきそうな気がしませんか？

ボゾンサンプリングの解析的計算

出力光子数状態${n_{1},n_{2},…,n_{N}}$が測定される確率は以下の通りです。
$$
\braket{ n_{1},n_{2},…,n_{N}}{ \psi^{'}} ^{2} =
\frac{|\mathrm{Perm}(U_{st})|^{2}}{m_{1}!m_{2}!,…,m_{N}!n_{1}!n_{2}!,…,n_{N}!}
$$

これを計算する実装例は以下の通りです。
元ネタとより詳細な説明はこちらになります。

def transform(photonNumList):
    resList = []
    for i in range(len(photonNumList)):
        for j in range(photonNumList[i]):
            resList.append(int(i))
    return resList

# Permanent関数を求める古典アルゴリズム
def perm(M):
     n = M.shape[0]
     d = np.ones(n)
     j =  0
     s = 1
     f = np.arange(n)
     v = M.sum(axis=0)
     p = np.prod(v)
     while (j < n-1):
         v -= 2*d[j]*M[j]
         d[j] = -d[j]
         s = -s
         prod = np.prod(v)
         p += s*prod
         f[0] = 0
         f[j] = f[j+1]
         f[j+1] = j+1
         j = f[0]
     return p/2**(n-1)

def Fact_Fock(FockList_ini, FockList_after):
    FockList_ini_Fact = [np.math.factorial(i) for i in FockList_ini]
    FockList_after_Fact = [np.math.factorial(i) for i in FockList_after]

    res = 1
    for i in range(len(FockList_ini)):
        res *= FockList_ini_Fact[i]

    for i in range(len(FockList_after)):
        res *= FockList_after_Fact[i]
    return res


# RゲートとBSゲートを結合し、1つのユニタリゲートで記述する
###################
Uphase = np.diag([np.exp(0.5719*1j),np.exp(-1.9782*1j),np.exp(2.0603*1j),np.exp(0.0644*1j)])

BSargs = [
(0.7804, 0.8578),
(0.06406, 0.5165),
(0.473, 0.1176),
(0.563, 0.1517),
(0.1323, 0.9946),
(0.311, 0.3231),
(0.4348, 0.0798),
(0.4368, 0.6157)
]

t_r_amplitudes = [(np.cos(q), np.exp(p*1j)*np.sin(q)) for q,p in BSargs]
BSunitaries = [np.array([[t, -np.conj(r)], [r, t]]) for t,r in t_r_amplitudes]
# list of 2x2 numpy array

UBS1 = block_diag(*BSunitaries[0:2])
UBS2 = block_diag([[1]], BSunitaries[2], [[1]])
UBS3 = block_diag(*BSunitaries[3:5])
UBS4 = block_diag([[1]], BSunitaries[5], [[1]])
UBS5 = block_diag(*BSunitaries[6:8])
U = multi_dot([UBS5, UBS4, UBS3, UBS2, UBS1, Uphase])
###################

# 出力側光子検出器の検出結果(FockList_after)をランダムに生成
###########
FockList_after = np.zeros(4, dtype=int)

for i in range(SumOfPhoton):
    tmp = rd.randint(0, NodeNum-1)
    FockList_after[tmp] += int(1)
###########

# 任意の値を使用する場合
FockList_after = [1,0,1,1]

print("Input photon number states")
print(list(FockList_ini))
print("Measured photon number states")
print(list(FockList_after), '\n')

# ボゾンサンプリングの出力を解析的に計算
div = Fact_Fock(FockList_ini, FockList_after)

ini_vec = transform(FockList_ini)
after_vec = transform(FockList_after)
clasic_calc = np.abs(perm(U[:,ini_vec][after_vec]))**2 / div
Boson_calc = probs[FockList_after[0],
                   FockList_after[1],
                   FockList_after[2],
                   FockList_after[3]]
print('Probability calculated with:')
print('Classical algorithm',clasic_calc)
print('Boson sampling',Boson_calc)

大まかな流れとして、
- RゲートとBSゲートを結合し、1つのユニタリゲート$U$で記述する
- 光子が存在する入出力ポートに合わせて$U$を上式中$U_{st}$に整形し、Permanent関数を計算する。
- 解析的に得られた出力確率と、先ほど実装したボゾンサンプリング回路で得られた出力確率を比較する。
といったことを行っています。

出力結果はこのようになります。
比較の結果で言うと、非常によく一致します。
Strawberry Fieldsが非常によくできていることのデモンストレーションですね。

Input photon number states
[1, 1, 0, 1]
Measured photon number states
[1, 0, 1, 1] 

Probability calculated with:
Classical algorithm 0.046297023812036465
Boson sampling 0.046297023812036486

このように特定の入出力状態とそれが得られる確率がわかれば、$\mathrm{Perm}(U_{st})$を計算できます。

実際のところ役に立つの？

ここまで上手くいっていますが、ボゾンサンプリングには実用上の問題点があるようです。
まず、現実にボゾンサンプリングを実行しても上記コードのように直接出力確率が得られることはなく、あくまで1つの出力結果が得られるだけです。
よって、ある入出力状態について確率を知るには十分な回数のサンプリングを繰り返す必要があります。

ところが得られる出力光子数状態の組み合わせは光子数$n$に対してsuper exponentialです。
よって、サンプリングによって一定の精度を担保しようとすると結局指数関数的にリソースが増えかねないです。
また、そもそもどれだけサンプリングすればどれだけの精度を担保できるか自体が非常に難しい問題です。

入力光子数状態の生成にも課題があります。
各ポートには光子がほぼ同時に入力される必要がありますが、光子生成源があるtime bin $\delta t$ の間に光子を吐く確率が$p$であるような性質を持っている場合、$\delta t$の間にn個の光子が生成される確率は $p^n$ となってしまいます。
よって試行回数は光子数$n$の指数関数でスケールされてしまいます。

確率的でなく決定論的に単一光子を生成するのは技術的ハードルが高いようです。
あまり詳しくないですが。
ただし、入力光子数状態の問題は後に Gaussian Boson Sampling という手法が提案され回避可能になります。

過去の研究者の苦難の跡が見えますね。色々と勉強になります。
次は流れ的には Gaussian Boson Sampling ですが、似ているので飛ばすかもしれません。
読んでいただきありがとうございました！

参考にした文献

・公式ドキュメント
・https://en.wikipedia.org/wiki/Permanent_(mathematics)
・https://arxiv.org/abs/1406.6767

tl;dr

下記のコマンドでインストールされるopenCVのバージョンが'4.0.0'となりました。
私の既存の環境では、3.x.xで開発していたため、新しい環境でopenCVを入れ直すと、エラーが出るようになりました。
暫定措置でopenCVをダウングレードすることにしました。その手順を記載します。

pip install opencv-python

コマンド

uninstallしてバージョン指定して再インストールします。この例では、3.4.5を入れています。

pip3 uninstall opencv-python
pip3 install opencv-python==3.4.5.20

ZetCodeのPyQt5チュートリアルにあるテトリスのソースコードを拝見したのですが、モデルが分離されておらず、気になってしまったので MVC(Model-View-Controller) 化に挑戦しました。

• Model(データ) は表示に左右されない部分、PyQt5(GUI)は登場しない
• Modelは大きく Tetrimino と Field の2つで構成、FacadeパターンでModelに統合
• View(表示) と Controller(操作) で PyQt5を使用
• チュートリアルではwidgetを継承して使用しているが、名前衝突を嫌って継承しないように変更

改善点などありましたらコメントお願いします。
何か参考になることがあれば幸いです。

tetrimino.py

class Tetrimino:
    """
    # python -m doctest -v tetrimino.py
    >>> len(tetriminos)
    7
    >>> print(tetrimino_names['Z'].rotate_left())
    ## 
     ##
    >>> print(tetrimino_names['S'].rotate_right())
     ##
    ## 
    >>> print(tetrimino_names['I'].rotate_left())
    ####
    >>> print(tetrimino_names['T'])
    ###
     # 
    >>> print(tetrimino_names['O'])
    ##
    ##
    >>> tetrimino_names['O'] is tetrimino_names['O'].rotate_right()
    True
    >>> print(tetrimino_names['L'].rotate_right().rotate_right())
    # 
    # 
    ##
    >>> print(tetrimino_names['J'].rotate_left().rotate_left())
     #
     #
    ##
    """

    def __init__(self, name, *offsets, rotate=True):
        self.name = name
        self.offsets = offsets
        self.can_rotate = rotate

    def __iter__(self):
        return iter(self.offsets)

    def __str__(self):
        xs = range(self.min_x(), self.max_x() + 1)
        ys = range(self.min_y(), self.max_y() + 1)
        return '\n'.join(''.join(' #'[(x, y) in self.offsets] for x in xs)
                         for y in ys)

    def min_x(self):
        return min(x for x, y in self)

    def max_x(self):
        return max(x for x, y in self)

    def min_y(self):
        return min(y for x, y in self)

    def max_y(self):
        return max(y for x, y in self)

    def move(x, y):
        return Tetrimino(self.name, *self.offsets, rotate=self.can_rotate)

    def rotate_unclockwise(self):
        if not self.can_rotate:
            return self
        return Tetrimino(self.name, *((y, -x) for x, y in self.offsets))

    def rotate_clockwise(self):
        if not self.can_rotate:
            return self
        return Tetrimino(self.name, *((-y, x) for x, y in self.offsets))


tetriminos = (  # (+0, +0) is rotation center
    Tetrimino('Z', (+0, -1), (+0, +0), (-1, +0), (-1, +1)),
    Tetrimino('S', (+0, -1), (+0, +0), (+1, +0), (+1, +1)),
    Tetrimino('I', (+0, -1), (+0, +0), (+0, +1), (+0, +2)),
    Tetrimino('T', (-1, +0), (+0, +0), (+1, +0), (+0, +1)),
    Tetrimino('O', (+0, +0), (+1, +0), (+0, +1), (+1, +1), rotate=False),
    Tetrimino('L', (-1, -1), (+0, -1), (+0, +0), (+0, +1)),
    Tetrimino('J', (+1, -1), (+0, -1), (+0, +0), (+0, +1)),
)

tetrimino_names = {tetrimino.name: tetrimino for tetrimino in tetriminos}

field.py

class TetrisField:
    """
    # python -m doctest -v field.py
    >>> field = TetrisField(6, 4)
    >>> print(field)
    |      |
    |      |
    |      |
    |      |
    >>> field.put(((-1, -1), (0, -1), (-1, 0), (0, 0)), 1, 3)
    >>> print(field)
    |      |
    |      |
    |##    |
    |##    |
    >>> field.clear_complete_lines()
    0
    >>> field.can_put(((0, 0), (1, 0), (2, 0), (3, 0)), 2, 3)
    True
    >>> field.put(((0, 0), (1, 0), (2, 0), (3, 0)), 2, 3)
    >>> print(field)
    |      |
    |      |
    |##    |
    |######|
    >>> field.clear_complete_lines()
    1
    >>> print(field)
    |      |
    |      |
    |      |
    |##    |
    """

    WALL = (-1, 0)

    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.tiles = [[None] * width for y in range(height)]

    def __str__(self):
        return '\n'.join('|' + ''.join('# '[tile is None] for tile in row) + '|'
                         for row in self.tiles)

    def __iter__(self):
        return iter(self.tiles)

    def __setitem__(self, coodinates, tile):
        x, y = coodinates
        if 0 <= x < self.width and 0 <= y < self.height:
            self.tiles[y][x] = tile

    def __getitem__(self, y_or_xy):
        if isinstance(y_or_xy, int):
            y = y_or_xy
            return self.tiles[y] if 0 <= y < self.height else ()
        x, y = y_or_xy
        if y < 0:
            return None
        elif 0 <= x < self.width and y < self.height:
            return self.tiles[y][x]
        else:
            return self.WALL

    def copy(self):
        field = TetrisField(self.width, self.height)
        for y, tiles in enumerate(self):
            for x, tile in enumerate(tiles):
                field[x, y] = tile
        return field

    def can_put(self, tetrimino, x, y):
        tetrimino = tetrimino or self.WALL
        return all(self[x + dx, y + dy] is None for dx, dy in tetrimino)

    def put(self, tetrimino, x, y):
        for dx, dy in tetrimino:
            self[x + dx, y + dy] = tetrimino

    def clear_complete_lines(self):
        for y, tiles in enumerate(self.tiles[:]):
            if all(tile is not None for tile in tiles):
                del self.tiles[y]
        clear_lines = self.height - len(self.tiles)
        if clear_lines > 0:
            self.tiles[:0] = [[None] * self.width for y in range(clear_lines)]
        return clear_lines

model.py

import random
from tetrimino import tetriminos, tetrimino_names
from field import TetrisField


class TetrisModel:
    """
    # python -m doctest -v model.py
    >>> model = TetrisModel(4, 6)
    >>> model.put(tetrimino_names['T'], 2, 0)
    True
    >>> model.drop_down()
    >>> print(model)
    |    |
    |    |
    |    |
    |    |
    | ###|
    |  # |
    >>> model.put(tetrimino_names['I'], 0, 0)
    True
    >>> model.drop_down()
    >>> print(model)
    |    |
    |    |
    |    |
    |#   |
    |#   |
    |# # |
    >>> model.score
    1
    """

    SCORE = (0, 1, 2, 4, 8)  # by clear lines

    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.field = TetrisField(width, height)
        self.tetrimino = None
        self.x = 0
        self.y = 0
        self.score = 0
        self.alive = True

    def __iter__(self):
        field = self.field.copy()
        self.tetrimino and field.put(self.tetrimino, self.x, self.y)
        return iter(field)

    def __str__(self):
        field = self.field.copy()
        self.tetrimino and field.put(self.tetrimino, self.x, self.y)
        return str(field)

    def is_alive(self):
        return self.alive

    def dead(self):
        self.alive = False

    def put_new_tetrimino(self):
        tetrimino = random.choice(tetriminos)
        x = self.field.width // 2
        for y in range(tetrimino.min_y(), tetrimino.max_y() + 1):
            if self.field.can_put(tetrimino, x, -y):
                self.put(tetrimino, x, -y)
                return
        self.dead()

    def put(self, tetrimino, x, y):
        if self.field.can_put(tetrimino, x, y):
            self.tetrimino = tetrimino
            self.x = x
            self.y = y
            return True
        return False

    def replace(self, tetrimino):
        return self.put(tetrimino, self.x, self.y)

    def move(self, x, y):
        return self.tetrimino and self.put(self.tetrimino, x, y)

    def move_left(self):
        self.move(self.x - 1, self.y)

    def move_right(self):
        self.move(self.x + 1, self.y)

    def rotate_clockwise(self):
        self.tetrimino and self.replace(self.tetrimino.rotate_clockwise())

    def rotate_unclockwise(self):
        self.tetrimino and self.replace(self.tetrimino.rotate_unclockwise())

    def move_down(self):
        if self.tetrimino is None:
            return False
        if self.move(self.x, self.y + 1):
            return True
        self.fixed()
        return False

    def drop_down(self):
        while self.move_down(): pass

    def fixed(self):
        if self.tetrimino is None:
            return True
        self.field.put(self.tetrimino, self.x, self.y)
        self.tetrimino = None
        clear_lines = self.field.clear_complete_lines()
        self.score += self.SCORE[clear_lines]
        return False

    def step(self):
        if not self.is_alive():
            return
        if self.tetrimino:
            self.move_down()
        else:
            self.put_new_tetrimino()

qt5view.py

from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QMainWindow, QFrame, QDesktopWidget
from PyQt5.QtGui import QPainter, QColor

TILE_COLORS = {
    'Z': QColor(0xCC6666),
    'S': QColor(0x66CC66),
    'I': QColor(0x6666CC),
    'T': QColor(0xCCCC66),
    'O': QColor(0xCC66CC),
    'L': QColor(0x66CCCC),
    'J': QColor(0xDAAA00),
}


class ModelView:

    def __init__(self, parent, model):
        self.model = model
        self.widget = QFrame(parent)
        self.widget.setFocusPolicy(Qt.StrongFocus)
        self.widget.paintEvent = self.draw

    def draw(self, event):
        width  = self.widget.contentsRect().width()  // self.model.width
        height = self.widget.contentsRect().height() // self.model.height
        tiles = ((x, y, tile)
                 for y, tiles in enumerate(self.model)
                 for x, tile in enumerate(tiles)
                 if tile is not None)
        for x, y, tile in tiles:
            color = TILE_COLORS[tile.name]
            self.drawTile(x * width, y * width, width, height, color)

    def drawTile(self, x, y, width, height, color):
        x2, y2 = x + width, y + height

        painter = QPainter(self.widget)
        painter.fillRect(x, y, width, height, color)

        painter.setPen(color.lighter())
        painter.drawLine(x, y, x2, y)
        painter.drawLine(x, y, x, y2)

        painter.setPen(color.darker())
        painter.drawLine(x + 1, y2 - 1, x2 - 1, y2 - 1)
        painter.drawLine(x2 - 1, y + 1, x2 - 1, y2 - 1)


class TetrisView:

    def __init__(self, model, width, height):
        self.widget = QMainWindow()
        self.model_view = ModelView(self.widget, model)
        self.status = self.widget.statusBar()
        self.widget.setWindowTitle('Tetris')
        self.widget.setCentralWidget(self.model_view.widget)
        self.widget.resize(width, height)
        self.centering()

    def centering(self):
        screen = QDesktopWidget().screenGeometry()
        size = self.widget.geometry()
        self.widget.move((screen.width() - size.width()) // 2,
                         (screen.height() - size.height()) // 2)

    def show(self):
        self.widget.show()

    def showStatus(self, message):
        self.status.showMessage(message)

    def update(self):
        self.model_view.widget.update()
        self.widget.update()

    def on_keyin(self, handler):
        # call handler(key) when key is pressed
        def hook(event):
            handler(event.key())
        self.widget.keyPressEvent = hook

    def on_close(self, handler):
        def closeEvent(event):
            handler()
        self.widget.closeEvent = closeEvent

qt5tetris.py

import sys
from PyQt5.QtCore import Qt, QObject, pyqtSignal, QBasicTimer
from PyQt5.QtWidgets import QApplication
from model import TetrisModel
from qt5view import TetrisView


class Status(QObject):
    signal = pyqtSignal(str)

    def on(self, handler):
        self.signal[str].connect(handler)

    def set(self, message):
        # It will call handler(message) that set self.on(handler)
        self.signal.emit(message)


class Timer(QObject):

    def __init__(self, handler):
        super().__init__()
        self.handler = handler
        self.timer = QBasicTimer()

    def start(self, interval):
        # It will call self.timerEvent(event) after each interval
        self.timer.start(interval, self)

    def stop(self):
        self.timer.stop()

    def timerEvent(self, event):
        if event.timerId() == self.timer.timerId():
            self.handler()


class Tetris:
    SPEED = 300

    def __init__(self, app):
        self.app = app
        self.model = TetrisModel(width=10, height=20)
        self.view = TetrisView(self.model, width=180, height=380)
        self.status = Status()
        self.status.on(self.view.showStatus)
        self.key_map = self.make_key_map()
        self.view.on_keyin(self.keyin)
        self.view.on_close(self.quit)
        self.timer = Timer(self.step)
        self.is_started = False

    def make_key_map(self):
        return {
            Qt.Key_Q:     self.quit,
            Qt.Key_P:     self.pause,
            Qt.Key_Left:  self.model.move_left,
            Qt.Key_Right: self.model.move_right,
            Qt.Key_Up:    self.model.rotate_clockwise,
            Qt.Key_Down:  self.model.rotate_unclockwise,
            Qt.Key_Space: self.model.drop_down,
            Qt.Key_D:     self.model.move_down,
        }

    def keyin(self, key):
        if key not in self.key_map:
            return False
        self.key_map[key]()
        return True

    def start(self):
        if not self.is_started:
            self.is_started = True
            self.view.show()
            self.timer.start(self.SPEED)

    def step(self):
        self.model.step()
        if self.model.is_alive():
            self.status.set(f"Score: {self.model.score}")
        else:
            self.status.set(f"Game Over (Score: {self.model.score})")
        self.view.update()

    def pause(self):
        if self.is_started:
            return
        self.is_paused = not self.is_paused
        if self.is_paused:
            self.timer.stop()
            self.status.set("Paused")
        else:
            self.timer.start(self.SPEED)
            self.status.set(f"Score: {self.model.score}")

    def quit(self):
        self.app.quit()


def main():
    app = QApplication(sys.argv)
    tetris = Tetris(app).start()
    sys.exit(app.exec_())

if __name__ == '__main__':
    main()

iPhoneで見ていたページを共有する方法は幾つかあるが、その場で共有するならともかく、一旦、どこかで保持してから共有するのは、どうも使いにくい。下の３枚の画像は①SafariからiOS標準のメモ帳で記録し、②メモ腸からTwitterで共有する、という流れだが③でURLの情報が失われている。

といって、URLだけ保存していると、QiitaのURLのように、あとでURLを見て何のページかわからない。そこでPythonista3でURLにタイトルを付与するというスクリプトを書いてみた。利用イメージとしては、下の３枚の画像のように①事前にPythonistaを有効にしておき、②Safariの共有で「Run Pythonista Script」を起動して、③URLを送るスクリプトを送るという流れである。

URLはappex.get_url()もしくはクリップボードから取得し、タイトルの取得にはBeautifulSoupを使っている。

import sys
import appex
import urllib.request
import clipboard
from bs4 import BeautifulSoup

def main():
    if appex.is_running_extension():
        url = appex.get_url()
    else:
        url = clipboard.get()

    try:
        html = urllib.request.urlopen(url=url)
        soup = BeautifulSoup(html, 'html.parser')
        title = soup.title.string
        print(title+'\r\n'+url)
        clipboard.set(title)
    except:
        print(url)
        print(sys.exc_info()[0])
        pass

if __name__ == '__main__':
    main()

後半にprint(title+'\r\n'+url)で書いているようにタイトル、URLの順で画面表示され、クリップボードにタイトルが格納される。

単にタイトルを取得するだけでなく、あんなことやこんなことにも応用できそうだ。

はじめに

pandasデータフレームをRのdplyr同様に操作可能にするdfplyライブラリについてまとめるシリーズです。
dfplyについてはこちらをご参照ください。
dplyr使いのためのpandas dfplyすごい編

Window関数？

SQLではおなじみですが、主に集計や分析に使われる関数ですね。
実行結果がgroup_byしたときのように集約されるわけではなく、入力データに対しての実行結果が戻されます。そのためmutateと一緒に使うことが多いと思います。
dplyrでのwindow関数は、matsuou1氏がまとめているこちらも参考にして頂けるとわかりやすいです。

事前準備、例データ

今回も、みんな大好きtitanicを使用します。

Python：事前準備、例データ

import pandas as pd
import numpy as np
from dfply import * #dfply読み込み

import seaborn as sns
titanic = sns.load_dataset('titanic') #titanic読み込み

ランキング

選択列の値に対して順位番号をつけていく関数です。
dfplyでは、以下の関数が実装されているようです。

関数	説明
row_number	選択列の値に対して順番付け（デフォルトは昇順）
min_rank	選択列の値に対して順番付け（同値は同番号、その場合次番号は飛ぶ）
dense_rank	選択列の値に対して順番つけ（同値は同番号、その場合次番号は飛ばない）
percent_rank	min_rankのスケールを０～１に変換したもの

Python：ランキング

titanic >> arrange(X.age) >> select(X.age) >> mutate(
    row_number=row_number(X.age, ascending=True),
    min_rank=min_rank(X.age, ascending=True),
    dense_rank=dense_rank(X.age, ascending=True),
    percent_rank=percent_rank(X.age, ascending=True)) >> head(6)

- 各順位番号はnull（None, NaN）を対象には含みません。
- ascending = Trueは省略可

オフセット

選択列の前後のレコードの値を取得できます。

関数	説明
lead	選択列の値に対して前レコードの値をとる
lag	選択列の値に対して後レコードの値をとる

Python：オフセット

# lag lead
titanic >> group_by(X.sex) >> mutate(
    lead1=lead(X.age, i=1),
    lead2=lead(X.age, i=2),
    lag1=lag(X.age, i=1),
    lag2=lag(X.age, i=2)) >> \
    head(3) >> select(X.sex, X.age, X.lead1, X.lead2, X.lag1, X.lag2)

- group_byを使うとそのグループ内でのオフセットも可能です（dplyrと一緒です）
- i = は何レコード分ずらすかの指定です（省略可）
- dplyrではnull値を埋める数値も指定できましたが、dfplyではできないようです

累積

選択した列に対して1レコードずつ累積で関数を処理していきます。例で見た方が理解が早いですね。

累積1：cumsum, cummin, cummax, cummean, cumprod

関数	説明
cumsum	対象レコードまでの累積和（足し算）
cummin	対象レコードまでの最小値
cummax	対象レコードまでの最大値
cummean	対象レコードまでの平均値
cumprod	対象レコードまでの積

Python：累積1

titanic >> select(X.age) >> mutate(
    cumsum=cumsum(X.age),
    cummin=cummin(X.age),
    cummax=cummax(X.age),
    cummean=cummean(X.age),
    cumprod=cumprod(X.age)) >> head(7)

- 例えばcummaxはageの６レコード目に54がでてきて累積値で一番高い数値になったため、54が返されています

累積2：cumany, cumall

cumany,cumallは少々ややこしいです（使用機会も少ないと思いますが）。
選択列がTrue or Falseのbool型のときに判定を行う関数です。これも例を見た方が理解が早いですね。

Python：累積2

#bool型のデータを作成
test = pd.DataFrame({'bools':[True,False,False,True,False]})
#cumany, cumall
test >> mutate(cumany=cumany(X.bools), cumall=cumall(X.bools))

• cumanyは選択列にTrueが表れた時点で以降すべてTrueと判定します
• cumallは選択列にFalseが表れた時点で以降すべてをFalseと判定します

その他

between

選択した列の値が、指定した値の範囲内にあるかないかを判定しbool型を返します。

Python：between

#ageが25~30の範囲内にあるかどうか判定
titanic >> mutate(age_btwn=between(X.age, 25, 30, inclusive=True)) >> \
    select(X.age, X.age_btwn) >> head(6)

まとめ

window関数もdplyr同様しっかり再現されてますね。
dfplyやっぱりすごいです。

この記事、何?

pythonを使って、Windowsでhttpsからファイルを取得するという話。

ちょっと前の記事でWindowsでwget代わりにPowerShellでInvoke-WebRequestしてた。
ただ、https相手だとうまくいかなかった。
それをトラブルシュートするよりpythonしたほうが楽っぽかったので頼ってみた、という話。

どういう人向け?

まあ・・・自分あて。
クローニングとかもいろいろ潤沢な時代に「httpsあてでもファイル取れるわ～」って言われても、ね?
でもQiitaの記事を取れるバッチファイルも付けたのでよければどうぞ。

参考にした記事

結局は他力本願なんですけどね。
Alice1017さん、ありがとうございます。

■Pythonでバイナリファイルを保存する
https://qiita.com/Alice1017/items/34befe8168cd771f535f

やったこと

Pythonスクリプト1つ、呼出用のバッチが一つ。

#17-01.py
#Qiitaの投稿ID(?)をもらって、Markdownをファイル化
import sys
import shutil
import requests
args = sys.argv
id = args[1]
URL = 'https://qiita.com/siinai/items/' + id + '.md'
print(URL)
filepath = id + '.md'
print(filepath)
res = requests.get(URL, stream = True)
with open(filepath, 'wb') as fp:
    shutil.copyfileobj(res.raw, fp)

rem 呼び出し用のバッチファイル
rem python 17-01.py [qiita-id]
python 17-01.py 4deb8529a2224a238b91
python 17-01.py 7b4196f4271448093a1f
python 17-01.py 457977b61b6c4cb15ac4
...

感想

まあ・・・普通。
Pythonってこんなに簡単なのね・・・
いいわぁ♪

概要

グラフにエラーバーをつけたいことは多々ありますよね。
今回はグラフにエラーバーをつけて、検量線を描くことを目標とします。

データの用意

from matplotlib import pyplot as plt
import random
import numpy as np
from sklearn.metrics import r2_score

## テストデータの作成
x = [i+random.uniform(-0.2, 0.2) for i in range(5)] # 変数を初期化
y = [i+random.uniform(-0.5, 0.5) for i in range(5)]
x_err = [random.uniform(-0.5, 0.5) for i in range(5)] # 誤差範囲を乱数で生成
y_err = [random.uniform(-0.5, 0.5) for i in range(5)] 

y軸方向にerror barを設定

もっとも多く使うのはy軸方向にerror barを設定するケースだと思います。
put.errorbarのyerrに誤差の入った配列を設定します。以下によく使う引数をまとめました。

引数	意味
x	x軸の値(配列)
y	y軸の値(配列)
xerr	x軸の誤差の値(配列)
yerr	y軸の誤差の値(配列)
fmt	マーカーの表示, 'o', 'v'など　詳しくはこちら
markersize	マーカーの大きさ
color	マーカーの色
markeredgecolor	マーカーの縁の色
ecolor	エラーバーの色
capsize	エラーバーの横線の長さ

(matplotlib.pyplot.errorbarにはもっと詳しくあります。)

また、検量線はnp.polyfitで一次近似して、scikit_learnのr2_scoreで決定係数を出します。

# y軸方向にのみerrorbarを表示
plt.figure(figsize=(10,7))
plt.errorbar(x, y, yerr = y_err, capsize=5, fmt='o', markersize=10, ecolor='black', markeredgecolor = "black", color='w')
coef=np.polyfit(x, y, 1)
appr = np.poly1d(coef)(x)
plt.plot(x, appr,  color = 'black', linestyle=':')
y_pred = [coef[0]*i+coef[1] for i in x]
r2 = r2_score(y, y_pred)
plt.text(max(x)/3.7, max(y)*6/8, 'y={:.2f}x + {:.2f}, \n$R^2$={:.2f}'.format(coef[0], coef[1], r2), fontsize=15)
plt.xlabel('x', fontsize=20)
plt.ylabel('y', fontsize=20)
# plt.savefig('y_error_bar.png')

x, y軸両方にerror barを設定

x軸方向にもerror barをつけたいこともあるでしょう。
その場合は、xerr引数に誤差配列を渡せばできます。

# x軸方向にもerrorbarを表示
plt.figure(figsize=(10,7))
plt.errorbar(x, y, yerr = y_err, xerr = x_err, capsize=5, fmt='o', markersize=10, ecolor='black', markeredgecolor = "black", color='w')
coef=np.polyfit(x, y, 1)
appr = np.poly1d(coef)(x)
plt.plot(x, appr,  color = 'black', linestyle=':')
y_pred = [coef[0]*i+coef[1] for i in x]
r2 = r2_score(y, y_pred)
plt.text(max(x)/3.7, max(y)*6/8, 'y={:.2f}x + {:.2f}, \n$R^2$={:.2f}'.format(coef[0], coef[1], r2), fontsize=15)
plt.xlabel('x', fontsize=20)
plt.ylabel('y', fontsize=20)
# plt.savefig('xy_error_bar.png')

リソース

以下のrepositoryに実行コードがあります。
https://github.com/YutoOhno/ErrorBar

・膨大な素晴らしきプログラムの集積地であるQiitaの中から、無作為に試してみて、惜しげもなく我が物顔を炸裂する記事第一弾。
・興味のあるものは何の躊躇も恥もなく無心で模倣してきた「自己解決反対運動」の信者のため、思う存分発揮していこう。
・初回として、顔認識処理が簡単に扱える記事を発見したので、これを試してみよう。

概要

• Google Colaboratoryという、Jupyter Notebook環境を構築不要ですぐに試せるサービスを使って、指定画像を顔認識処理にかけて、返してくれる。
  ※Jupyter Notebookとは、実行記録型のデータ分析ツールである。主にPython実行環境として使用されていたが、現在は様々な言語に対応している。

結果

＜指定画像、処理前＞

＜指定画像、処理後＞

使用環境・技術

• 1. Google Colaboratory
• 2. Python
• 3. OpenCV（解析ライブラリ）

手順

使用画像の用意

• 今回顔認識処理に用いる好きな画像を用意する。（※公開等なければ、著作権はあまり気にしない。）
• 画像決定すれば、名前をつけて保存。その際の保存名はメモしておく。
  ※今回の保存名は「test.jpg」で、使用画像は下記。

解析ライブラリの設定

• 画像の顔認識処理のために、解析ライブラリであるOpenCVの公式GitHubから下記のファイルを自分のパソコンにダウンロードする。
  「ファイル名」・・・haarcascade_frontalface_default.xml
  「取得リンク」・・・ここ

Google Colaboratoryの設定

• GoogleドライブからColaboratoryプロジェクト作成。
  ※Googleアカウントを持っていない人は、作成する。
  • Googleドライブを起動
  • 「新規」→　「その他」→「アプリを追加」の順にクリック。
    
  • アプリ検索欄に「colab」と入力して検索。
    
  • 検索結果に「Colaboratory」が表示されるので、そこの「接続」ボタンをクリック
  • 改めて「新規」→ 「その他」の順にクリックしていくと、「Colaboratory」が表示されているので、クリック。

• 起動したプロジェクトに名前をつける
  ※プロジェクト名が反映されるわけではないが、自分がわかる名前をつける。
  
• GPU割り当てのため、プロジェクト上部メニューの「ランタイム」から「ランタイムのタイプを変更」をクリック。
  

• ノートブックの設定を下記のように設定。
  
  

• ノートブック設定後、プロジェクトに下記のコードを入力後、左の三角ボタンで実行する。

from google.colab import files
f = files.upload()

• ファイル選択ボタンが表示されるので、先程保存した下記の2つのファイルをアップロードする。
  
  ※アップロードは1つずつ行う。
  
  ①使用画像ファイル・・・今回は「test.jpg」
  
  ②解析ライブラリファイル・・・「haarcascade_frontalface_default.xml 」

• アップロード後、下記のコードを入力して、実行する。

import cv2
from matplotlib import pyplot as plt
# 画像読み込み
img=cv2.imread("./test.jpg")
# 画像のRGB形式への変換
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# 解析ライブラリの使用
cascade = cv2.CascadeClassifier('./haarcascade_frontalface_default.xml')
# 検出処理
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
face = cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=3, minSize=(30, 30))
# 検出領域のデザイン処理
for (x, y, w, h) in face:
  cv2.rectangle(img, (x, y), (x + w, y + h), (200,0,0), 3)
# 標準軸の非表示処理
plt.grid(False)
plt.tick_params(labelbottom=False, labelleft=False, labelright=False, labeltop=False)
plt.imshow(img)

※好きな画像を使用している場合は、「test.jpg」の部分を自分用に変える。

• 実行後、下記のようになれば完了。
  

まとめ

• 初回は顔認識処理ということで、「賢人の方々の知の結晶のおかげで、こんなにも恩恵を受けているのだな」と、水分の跡も見られないまぶたをぬぐいながら、記事を書く。
• とはいえこの模倣学習は、GoogleやQiitaや作成者等の多くの方々の偉大な功績によるものなので、毎回の礼拝作業は欠かさない。
• 「今後も、自己満足促進のための素晴らしきプログラム探しに精進しよう」と、堂々他人依存決断。

参考

• https://qiita.com/FrozenVoice/items/d1dc5f3d780f5097bfab
  →こちらの記事を参考にしました。大変お世話になりました。