スクレイピングをするときに毎回毎回

test.py

from bs4 import BeautifulSoup

とこのように記述するのが面倒くさいので、とりあえずこれ使っとけば間違いなしのテンプレートを作成します。

test.py

!apt-get update
!apt install chromium-chromedriver
!cp /usr/lib/chromium-browser/chromedriver /usr/bin
!pip install selenium
!pip install requests-html

まずはライブラリ関係。
私は普段clbを使っているので、とりあえずこれ入れとく。

test.py

import pandas as pd
import datetime
from tqdm.notebook import tqdm
import requests
from bs4 import BeautifulSoup
import time
import re
from urllib.request import urlopen
import urllib.request, urllib.error
from requests_html import HTMLSession
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# htmlを取得するところまで
options = webdriver.ChromeOptions()
options.add_argument('--headless')
options.add_argument('--no-sandbox')
options.add_argument('--disable-dev-shm-usage')
driver = webdriver.Chrome('chromedriver',options=options)
driver.implicitly_wait(10)
url="https://www.XXX.com"
driver.get(url)
html = driver.page_source.encode('utf-8')
soup = BeautifulSoup(html, "html.parser")

はい、ここまで脳死でコピペでOKです。
あとは

test.py

soup

これで、とりあえずhtmlを出力するところまではものの数秒で到達できます。

厳密に言えば、tqdmとか使ってないライブラリもあるんですけど、個人的にスクレイピングするときにほぼ毎回セットで使用しているライブラリをインポートするコードも全部詰め込んでます。

私自身、これでコピペして使いまくってます。

サンプルコード class_test.py

class_test.py

class SampleClass:
    num = 0
    def __init__(self, number=1):
        SampleClass.num +=1 # インスタンスが生成される度に、クラス変数numを1インクリメントする
        self.num = number # インスタンス生成時に生成元から受け取った引数numberを、インスタンス変数numに格納する
    def __del__(self):
        SampleClass.num -=1 # インスタンスを削除する度に、クラス変数numを1デクリメントする
        print("このインスタンスを削除しました")

上記のスクリプトファイルを格納したディレクトリと同じ階層で、Python3を起動

Terminal

$ ls
class_test.py
$ cat class_test.py
class SampleClass:
    num = 0
    def __init__(self, number=1):
        SampleClass.num +=1 # インスタンスが生成される度に、クラス変数numを1インクリメントする
        self.num = number # インスタンス生成時に生成元から受け取った引数numberを、インスタンス変数numに格納する
    def __del__(self):
        SampleClass.num -=1 # インスタンスを削除する度に、クラス変数numを1デクリメントする
        print("このインスタンスを削除しました")
$
$ python3
>>>

class_testモジュールをimportして、SampleClassクラスのインスタンスを、生成し、削除してみます。

Terminal

>>> import class_test as ct
>>>
>>> sample_1 = ct.SampleClass()
>>> print(ct.SampleClass.num)
1
>>>
>>> print(sample_1.num)
1
>>>

（ ここでのポイント ）

1. SampleClassクラスのインスタンスを１つ生成しました。
2. インスタンスの個数を管理するクラス変数numの値は、1と表示されました。
3. また、生成させたインスタンスsample_1が持つインスタンス変数numの値は、コンストラクタのデフォルト引数で設定された1に設定されています。

Terminal

>>> sample_2 = ct.SampleClass(number=4)
>>> print(ct.SampleClass.num)
2
>>> print(sample_2.num)
4
>>>

（ ここでのポイント ）

1. SampleClassクラスのインスタンスを、もう１つ生成しました。
2. インスタンスの個数を管理するクラス変数numの値は、2と表示されました。
3. また、生成させたインスタンスsample_2が持つインスタンス変数numの値は、sample_2を生成するときに、コンストラクタに引数として渡した4が、設定されています。

Terminal

>>> sample_3 = ct.SampleClass(number=15)
>>> print(ct.SampleClass.num)
3
>>> print(sample_3.num)
15
>>>

（ ここでのポイント ）

1. SampleClassクラスのインスタンスを、さらにもう１つ、生成しました。これで、合計３個のインスタンスを生成しました。
2. インスタンスの個数を管理するクラス変数numの値は、3と表示されました。
3. また、生成させたインスタンスsample_3が持つインスタンス変数numの値は、sample_3を生成するときに、コンストラクタに引数として渡した15が、設定されています。

ここからが、destructorの挙動の確認になります

Terminal

>>> del sample_2
このインスタンスを削除しました
>>>

（ ここでのポイント ）

1. SampleClassクラスのdestructor内に記述した*print("このインスタンスを削除しました")が実行されました。
2. これで、現在、存在しているインスタンスの数は、2個になりました。

Terminal

>>> print(ct.SampleClass.num)
2
>>> print(sample_1.num)
1
>>> print(sample_3.num)
15
>>> print(sample_2.num)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sample_2' is not defined
>>>

（ ここでのポイント ）

1. インスタンスの個数を管理するクラス変数numの値は、2と表示されました。
2. sample_2という名前を付けたインスタンスを削除した際に、destructorの中に記述した、クラス変数numを1デクリメントする処理が、きちんと実行されたことがわかります。
3. このとき、削除したインスタンスとは別の2つのインスタンス（sample_1およびsample_3）のインスタンス変数は、値が変わることなく、意図せぬ影響を受けていないことも、確認できました。

---

（ 追記 ）

import文は、以下にしたほうが、コードが短くなる。

import文（変更後）

from class_test import SampleClass

Terminal

>>> from class_test import SampleClass
>>>
>>> sample_1 = SampleClass()
>>> print(SampleClass.num)
1
>>> print(sample_1.num)
1
>>>
>>> sample_2 = SampleClass(number=4)
>>> print(SampleClass.num)
2
>>> print(sample_2.num)
4
>>>

---

（ 参考にしたウェブページ ）

1. Pythonのデストラクタの使い方【初心者向け】
2. 【Python】インスタンスの個数を求める
3. Python クラスについて
4. @ysk24okさんのQiita記事「[Python] importの躓きどころ」

Aidemy　2020/11/15

はじめに

　こんにちは、んがょぺです！バリバリの文系ですが、AIの可能性に興味を持ったのがきっかけで、AI特化型スクール「Aidemy」に通い、勉強しています。ここで得られた知識を皆さんと共有したいと思い、Qiitaでまとめています。以前のまとめ記事も多くの方に読んでいただけてとても嬉しいです。ありがとうございます！
　今回は、強化学習の二つ目の投稿になります。どうぞよろしくお願いします。

＊本記事は「Aidemy」での学習内容を「自分の言葉で」まとめたものになります。表現の間違いや勘違いを含む可能性があります。ご了承ください。

今回学ぶこと
・強化学習の構成要素
・マルコフ決定過程について
・価値、収益、状態
・最適な方策について
・ベルマン方程式について

強化学習の構成要素

N腕バンディッド問題と次のステップ

・Chapter1で扱ったN腕バンディッド問題は、「即時報酬である」点と、「エージェントの行動によって状態が変化しない」という点で一般的な問題よりも単純化された問題であった。
・状態とは、環境が今現在どうなっているかを表すものである。ボードゲームを考えるとわかりやすい。エージェントであるプレイヤーが、将棋という環境で、相手にある一手を使われた時、盤面は前の自分の番から変化しているため、次に取るべき行動も変化する。この時「盤面」という状態は変化していると言える。
・また、Chapter1でも軽く触れたが、強化学習では即時報酬ではなく、「ゲームに勝利すること」といった遅延報酬を最大化することが本来の目的である。
・今回は、これらの「状態」「時間」の概念を取り込んだ強化学習を行っていく。

強化学習のモデルについて

・強化学習は、「①エージェントが状態$s_{t}$を受け行動$a_{t}$を起こし環境に作用する」「②それを受け環境は状態$s_{t+1}$に遷移する」「③環境はエージェントに報酬$r_{t+1}$を与える」「④エージェントは②③の結果を受けて次の行動$a_{t+1}$を決定する」という流れで進められていく。
・「t」は何回目の動作かを表す「時間ステップ」である。これが強化学習の時間の基本単位となる。

状態、行動、報酬の数式化

・環境がとりうる状態を集合化したものを数式化すると以下のようになる。
$S$={$s_{0},s_{1},s_{2},...$}
・同様に、エージェントがとりうる行動の集合は以下のように表す。
$A(s)$={$a_{0},a_{1},a_{2},...$}
・時間ステップ「t+1」の時における報酬「$R_{t+1}$」は次のように表す。
$R_{t+1}$=$r(S_{t},A_{t},S_{t+1})$

・上記のような式で報酬を求められる時、$R_{t+1}$を報酬関数と呼ぶ。この報酬関数から分かることでもあるが、未来の状態は現在（t，t＋1）の状態・行動のみによって確率的に決定され、過去の挙動とは一切無関係であるという性質のことを「マルコフ性」と呼ぶ。

マルコフ決定過程

マルコフ決定過程とは

・前項で見た通り、未来の状態は現在の状態や行動によってのみ決定するということを「マルコフ性」と呼ぶ。そして、これを満たす強化学習の過程を「マルコフ決定過程（MDP）」という。
・マルコフ過程は、状態の集合「状態空間$S$」、行動の集合「行動空間$A(s)$」、開始時点の状態を表す確率変数「初期状態分布$P_{0}$」、状態$s$で行動$a$を行った時、状態$s'$になる確率の変遷率を「状態遷移確率$P(s'|s,a)$」、「報酬関数$r(s,a,s')$」の五つの要素を持つ。

・以下の図は、今回使っていく環境「環境1」である。StateAからスタートし、actionXを取る場合「0.7」の確率でStateBに移動し、「0.3」の確率でStateAに戻るということが示されている。最終的に、StateBで、actionXの「0.8」を引ければゴール（End）となる。

・この各場合において、上記5要素を[s,s',a,p(s'|a,s),r(s,a,s')]というように表したものを「状態遷移図」という。(sは今どの状態か、s'は次にどの状態にいくか、aはactionXかYか、p(s'|a,s)は、その確率、r(s,a,s')はその報酬である)

・以下のコードは、この環境1のすべての状態遷移図を配列としてまとめたものである。配列にする際は、StateA＝0、StateB＝1、End＝2のように数値で置き換える。

時間の概念を導入-状態と行動

・マルコフ決定過程の構成要素である前項の五つの変数には、まだ時間の概念が導入されていないので、これらの時間の概念を導入し、数式化を行う。
・状態空間Sについて、時間tの概念を入れた「$S_{t}$」と、行動に時間の概念を導入した「$A_{t}$」を定義する。
・定義において使われるのは、前項の「状態遷移図」の配列である。この配列の0列目は「state」つまり「今（t時点）の状態」であるので、これが「$S_{t}$」となり、2列目は「action」つまり「t時点の行動」であるので、これが「$A_{t}$」となる。
・以下は、$S_{t}$が渡された時、その状態でエージェントがとりうる行動をまとめた$A_{t}$を返す関数である。

・「actions()」関数に渡される「state」が状態「$S_{t}$」であり、Aで参照される「state_transition」が状態遷移図である。この0列目が「$S_{t}$」なので、この部分が渡されたstateと同じ状態のものを参照することを記述し、「A[:,2]」で2列目を参照することでその時にとりうる行動$A_{t}$をリストにして返す。この時、返り値は可能な行動であるので、重複してはいけない、つまり固有の要素でなければならない。これを行うには「np.unique()」を使うと良い。

・実行部分について、今回の状態はStateBにいることを示す「state=[1]」となっている。state_transitionのs部分（現在の状態）、つまり0列目が[1]の行の2列目を見ると、0か1が格納されているので、関数の結果としては、これらが返される。

時間の概念を導入-その他

・ここでは初期状態分布と状態遷移確率、報酬関数を時間の概念を取り入れて再定義する。
・初期状態分布は簡単で、t=0の時の状態$S_{0}$を定義すれば良い。
・状態遷移確率はマルコフ決定過程により、時刻$t+1$における状態$S_{t+1}$は$S_{t}$と$A_{t}$によってのみ決定するものなので、$P(s'|s_{t},a_{t})$というように表せる。
・状態$S_{t+1}$に遷移したときの報酬$R_{t+1}$について、$R_{t+1} = r(s_{t},a_{t},s_{t+1})$で表せる。
この報酬関数について定義したのが、以下のコードである。

・この関数「R」について、引数では先述した$s_{t},a_{t},s_{t+1}$の三つを渡す。前提として、既に終点（terminal）にいる時は報酬が存在しないので、0を返す。
・今回も「state_transition」を参照して報酬を返すのであるが、報酬はこの配列の4列目にあるので、条件にあった状態（行）を抽出して、その4列目を返すようにすれば良い。
・今回の条件とは、引数で渡された「state,after_state,action」について、それぞれが一致するものをstate_transitionの0,1,2列目から探し出せば良い。

・実行部分について、stateが[1]、after_stateが[2]、actionが[0]となっているので、「現在StateBにいて、ActionXを行うことでEndについた」時の状態遷移を参照すれば良い。今回のstate_transitionでいうと、それは4行目の [1, 2, 0, 0.8, 100]であるので、この4列目の報酬が出力されている。

エピソード

・タスク開始から終了までにかかる時間のことを「エピソード」という。「行動→状態変化」というサイクルが何度も続くことによって時間ステップが進んでいき、一つのエピソードが構成されていく。
・強化学習のモデルでは、この一つのエピソードについて「環境を初期化し、エージェントに行動させ、受け取った報酬を元に行動モデルを最適化する」ということを複数回行うことで学習を進めていく。
・ターン性のカードゲームなどが例として非常にわかりやすい。ターンごとにプレイヤーの行動によって盤面は変化していき、「勝敗」という形でタスクが終了する。これを一つのエピソードとして、何度も対戦を行うことで、次第に最適な手を学習していくようになる。

・以下はエピソードを定義した関数「T()」である。この関数は「現在のstateとactionを渡し、state_transitionから対応するものを抽出し、状態遷移確率と遷移後のstateを返す」というものである。

・Tの定義部分について、既に終点（terminals）にいる時は、状態が遷移することはないので [(0, terminals)]と返すようにする。
・Xについては前項と同様に、渡された引数と一致する行を抽出している。この行の「3列目（状態遷移確率）」と「1列目（遷移後のstate）」をAに格納し、とりうる全ての場合について「tuple(A[i,:])」でタプル化して返す。

価値・収益・状態

報酬と収益

・ここまでは強化学習のモデル化、定義を行ってきた。ここからは「何を基準に最適な方策を探っていくか」ということを考える。
・報酬を指標にして考えた場合、これは直前の行動のみによって決まってしまうので、「その時点ではほとんど価値のない行動でも、その後非常に大きな価値を持つ行動」を見落としてしまう。
・これを解決するのが「収益」である。収益はある期間に得られた報酬の合計で算出されるため、その状態より後の報酬も考慮に入れることができる。
・t時点での行動$a_{t}$によって得られる報酬を「$R_{t}$」とすると、ある期間内の報酬の和である収益「$G_{t}$」は次の式で算出できる。
$$
G_{t} =R_{t+1} + \gamma R_{t+2}+ \gamma^2 R_{t+3}+....= \displaystyle\sum_{\tau=0}^{\infty} \gamma^{\tau} R_{t+1+\tau}
$$

・$\gamma$は「割引率」と呼ばれ、（0〜1）の値をとる。これは、「将来もらえる報酬をどれぐらい現在の価値とするか」を表すもので、0に近いほど将来の価値を見出さないようになり、1に近いほど将来の価値に重みをつけるようになる。

・また、報酬の合計の算出にはいくつか手法が存在するが、一般的には「割引報酬和」というものが使われる。これは時刻tからある時刻Tまでの収益の平均を算出し、Tの極限を取ることで算出する、というものである。
・割引報酬和は、以下のように二つの関数で定義することができる。

・「take_single_action()」について、これは「遷移確率に基づいて次の状態を決定する」関数である。コードとしては、まず「random.uniform(0,1)」で0〜1の乱数を生成する。また、累積確率「cumlative_probability」を定義する。
・for文では渡されたstate,actionからエピソード「T」ごとに、考えうる確率「probability」と次の状態である「next_state」を抽出し、累積確率「cumlative_probability」にエピソードごとの「probability」を足し、これが「x」より大きくなったらfor文を終了させ、その時点での「next_state」を返す。

・もう一つの関数「calculate_value()」について、これが「割引報酬和」を計算する関数になる。はじめに「state」「action」と、割引報酬和「sumg」を定義する。
・for文では、エピソードの回数分の繰り返しを行う。今回は2回としている。この中で、次のstateを「take_single_action」で定義し、これと、その時の「state」「action」を使って$R_{t+1}$を計算し、これと$\gamma^i$をかけたものをsumgに累積していく。そして「state」を更新したら次のエピソードにいき、最終的な割引累積和「sumg」を返す。

・実行部分

価値関数・状態価値関数

・前項のやり方のように、報酬を方策の評価基準とするようなやり方では、Rが確率に基づいて決定するため、状態が分岐すればするほど複雑な計算式になってしまうという欠点がある。
・報酬の期待値を取ることで、以上の欠点を解消できる。ある状態をスタートとして、それ以降の行動全てを考慮に入れた報酬の期待値のことを、「価値」または「状態価値」という。方策が良いものであればあるほど状態価値は大きくなる。
・この概念を導入することで、「ある方策において、どの状態が優れているかを比較できる」「ある状態をスタート地点に置いた時の方策ごと良し悪しを比較できる」という二つのことが可能になる。

最適な方策の探索

最適方策

・前項の状態価値関数の導入により、方策ごとの良し悪しを比較できるようになった。
・二つの方策$\pi_{1},\pi_{2}$を比較する時
　・状態空間Sの全ての状態sにおいて、状態価値$V^{\pi_{1}}(s)$が$V^{\pi_{2}}(s)$以上である
　・状態空間Sの少なくとも一つの状態sにおいて、状態価値$V^{\pi_{1}}(s)$が$V^{\pi_{2}}(s)$より大きい

の二つが成り立つ時、「$\pi_{1}は\pi_{2}$よりも良い方策である」ということができる。
・また、この時全ての方策の中には最も良い方策が存在するはずであり、これを最適方策と呼び、$\pi^*$と表す。

行動価値

・状態価値関数は「ある状態をスタートとした時の報酬の期待値」であるが、実際には「ある状態をスタートとし、ある行動を起こした時の報酬の期待値」というように、行動まで考慮に入れた価値を考えた方が良い場合が多い。この時の価値を「行動価値」といい、ある方策下における行動価値を示す関数を「行動価値関数」という。
・行動価値関数は、各「行動」がどれだけ良いかを判断する関数ということができる。
・数式としては、以下の等比級数の公式を使用する。
$$a+ar + ar^2 + \cdots + ar^n = \large\frac{a(1 - r^n)}{1 - r}$$

・この公式の「a」をreward（報酬）、「r」をgammaとして、行動価値関数を計算することができる。これについてのコードが以下のようになる。

最適状態価値関数・最適行動価値関数

・ここまでに見てきた「状態価値関数」と「行動価値関数」のうち、最適な方策に従った場合のそれぞれの関数を「最適状態価値関数」「最適行動価値関数」という。それぞれ、「$V^*(s)$」「$Q^*(s)$」と表す。
・一度最適状態価値関数と最適行動価値関数が求められれば、どの行動が最も収益の大きくなる行動かがわかるということなので、常に最適な行動を選び続ける「greedy手法」を選べば良い。

ベルマン方程式

最適な状態価値

・最適状態価値関数を求めるには、それぞれの状態価値関数を求め、比較すれば良い。行動価値関数についても同様であるので、ここでは状態価値関数を対象に進めていく。
・それぞれの状態価値関数の求めるには、ベルマン方程式を使う。これは「状態sと行動した結果移行する可能性のある状態s'との間に価値関数の関係式を成り立たせる」という発想から成り立つ。
・ベルマン方程式は以下のようにそれぞれの関数を漸化式のようにすることで使用できる。
$V^{\pi}(s) =\displaystyle\sum_{\alpha \in A(s)}^{} \pi(a|s) \displaystyle\sum_{s' \in S}^{} P(s'|s,a)(r(s,a,s') + \gamma V^{\pi}(s'))$

$Q^{\pi}(s,a) =\displaystyle\sum_{s' \in S}^{} (P(s'|s,a)
(r(s,a,s') + \displaystyle\sum_{a' \in A(s')}^{} \gamma \pi(a'|s') Q^{\pi}(s',a')))$

・ここでの$\pi(a|s)$ は、行動の選ばれる確率を表している。

・例えば「環境1」において、「s=StateB」、「$\gamma$=0.8」、「ActionXのみを行う」とするとき、ベルマン方程式で価値関数を算出すると
$V^\pi(B)=0.2(-10+\gamma*V^\pi(B))+0.8(100+\gamma*0)$を$V^\pi(B)$についての方程式として解けば良い。
すなわち、より簡単にいうと、「（そのActionを起こす確率） × （行動によるReward + $\gamma$ × 移動後のState）」を全ての場合について算出し、その和を使って方程式を解けば良い。

・環境1

ベルマン最適方程式

・先述した最適状態関数、最適行動関数についても、当然にベルマン方程式が適用できる。よって、常に最適な方策をとった時のベルマン方程式を「ベルマン最適方程式」という。
・例えば環境1で「常にActionXをとる方策$\pi_{1}$」「常にActionYをとる方策$\pi_{2}$」のどちらがいい方策であるかを比較するとき、収益(割引報酬和)を算出する関数「caluclate_value()」を使って、以下のように表せる。

・Q_optimumはその時の最大の収益を表し、Q_piはその時の方策を表している。Q_piが[0 0]となっていることから、常にActionXを取る方策$\pi_{1}$を取る方が良いことがわかる。

まとめ

・時間ステップ「t+1」の時における報酬「R_{t+1}」は $r(S_{t},A_{t},S_{t+1})$と表される。この時未来の状態（t+1）は現在の状態や行動（t）によってのみ決定されることを「マルコフ性」といい、これを満たす強化学習の過程をマルコフ決定過程という。
・マルコフ決定過程において、構成要素を[s,s',a,p(s'|a,s),r(s,a,s')]というように配列で表したものを「状態遷移図」という。時間の概念を導入した場合は$[S_{t},S_{t+1},A_{t},S_{0},R_{t+1}]$で表される。
・タスク開始から終了までの時間のことを「エピソード」という。強化学習ではこのエピソードについて「環境を初期化し、エージェントの行動による報酬をもとに最適化する」ことを繰り返して学習を行う。
・実際の強化学習では、即時報酬だけでなく、遅延報酬も含めた「収益」を基準に最適な方策を考える。収益は、各時間ステップにおける報酬に「割引率$\gamma$」をかけたものの和である「割引報酬和」で計算する。
・また、最適な方策を探索するにあたっては、収益についてこのまま計算すると計算量が多くなってしまうので、報酬の期待値である「状態価値関数」「行動価値関数」を計算すると良い。これらを求めるときに使われるのが「ベルマン方程式」である。状態価値関数についてベルマン方程式を使うとすると、「Actionを起こす確率」「報酬」「移動後のState」を使って算出される。

今回は以上です。ここまで読んでくださりありがとうございました。

皆様、こんばんは
お久しぶりです。

有難いことに、
アルゴリズムの基礎を勉強させてもらい
色々な問題にチャレンジさせてもらっています。

問題を解くために自分の中のイメージを言語に落とすアプローチは
自由で大空を飛んでいるようです。目的地に最後まで辿り着く難しさが
何とも言えず、楽しいです。

今更ですが、自分はエンジニアではありません。
FAE と言われる、技術営業で、主に半導体(Power IC..DCDC convertor) の
技術サポートと営業活動を生業にしています。

実は過去に 8 年 FPGA の FAE もやってたので
プログラム言語も経験しており、評価ボードで検証することも
たまにやっています。

そんな FAE 歴は、はや 12,3 年。
あらゆる市場トラブルを体験し、日本のモノづくりの現実を見てきました。

そこで痛感した事。
1.何よりも大切なのはコミュニケーション
誰かに奉仕することで給料を貰う以上は、何を満たせば"奉仕"と
認めてもらえるのかはコミュニケーションがないと成り立ちません。

2.逃げずに立ち向かった経験は自分のチカラになる
困難はギフトです。毛根がストレスで 10% 壊死したら喜びましょう。
貴方の実力は格段に上がっている(笑)
誰かを救いたい気持ちを折らずに持ち続けられれば不思議と突破できます。

私は技術力とは何かを後輩に尋ねられたことがあります。
ふと、こんな風に答えました。
"コミュニケーション力と思いやりじゃない？"

すいません、話が逸れてしましました。
今、皆さんは誰のためにプログラムを書いていますか？

私は趣味で書いていますが、
色々なアプローチに出会うことで、
様々な需要に合わせた書き方があるのではないか
考えるようになりました。

かの有名な映画で描かれているように
人の心には光と闇が混在し、表裏一体です。
この取り扱いの難しいと思われがちな人の心ですが、
自分のためではなく、誰かのために神経を集中できると
とてつもない力を発揮するオーパーツでもあります。

私利私欲ではなく、誰かを想いながら書くと
不思議と他のアプローチや考え方が必要じゃないか
考えるようになります。

この積み重ねは大きな力になるのではないでしょうか。

ソフトの設計経験があるわけでは無いので見えてない現実は
多分にあると思いますが、人を想い、コミュニケーションを重んじた
設計者が織りなす技術は美しい結晶となって、いつまでも輝き続けると私は信じます。

私の拙い人生経験が誰かの役に立てば幸いです。
この記事をちょうど読んでいる貴方が内なる何かに苦しんでいるのであれば、
それは恐らく成長のサインかもしれません。

プライドやら欲望やら、全部吐き出して、
何をすべきなのか整理してみましょう。
きっと答えはあると思います。

• 離散型の確率変数は、サイコロの目のように飛び飛びの値をとる変数のことで、例えば｢1｣の次は｢2｣、｢2｣の次は｢3｣というように、その間に 1.1, 1.2, 1.3, ･･･, 1.8, 1.9 などといった連続的な数値は存在しません。
• 主な離散型の確率分布について、scipy.statsのpmf（probability mass function : 確率質量関数)やrvs（random variates : 確率変数）を使ってその特徴を見ていきます。

# 数値計算ライブラリのインポート
import numpy as np
import scipy as sp
import pandas as pd
from pandas import Series, DataFrame
# 可視化ライブラリのインポート
import matplotlib.pyplot as plt
import matplotlib as mpl
import seaborn as sns
%matplotlib inline
# matplotlibの日本語表示モジュール
!pip install japanize-matplotlib
import japanize_matplotlib

⑴ ベルヌーイ分布（Bernoulli distribution）

• 2種類しかない事象のどちらかを発生させることをベルヌーイ試行（Bernoulli trial）といいます。
• ベルヌーイ分布とは1回のベルヌーイ試行において、それぞれの事象が生じる確率分布のことです。
• 例えば、コインを8回投げて表が出たら0、裏が出たら1として結果を次のように仮定します。

x = np.array([0,0,1,1,0,1,0,0])

# 確率分布を計算
p = len(x[x==1]) / len(x)
pmf_bernoulli = sp.stats.bernoulli.pmf(x, p)

# 可視化
plt.vlines(x, 0, pmf_bernoulli, 
           colors='blue', lw=50)
plt.xticks([0,1])
plt.xlim([0 - 0.5, 1 + 0.5])
plt.grid(True)

2種類の事象	確率
0	0.625
1	0.375

⑵ 二項分布（Binomial distribution）

• 互いに独立したベルヌーイ試行をn回くり返したとき、ある事象が何回起こるかという確率分布のことを二項分布といいます。
• 例えば、表が出る確率pが50％のコインを5回投げて、そのうち2回が表になる確率をbinom.pmfを使って求めます。

sp.stats.binom.pmf(n=5, p=0.5, k=2)

• 表が出る確率pが20％のコインを10回投げて表が出た回数を数える、という試行を10000回くり返したと仮定し、binom.rvsを使って二項分布に従う疑似乱数を生成します。
• さらにbinom.pmfを使って、表が出る確率pが20％のコインを10回投げたときに表が出る回数の確率分布を計算し、疑似乱数のヒストグラムと比較してみます。

# 疑似乱数を生成
np.random.seed(1)
rvs_binom = sp.stats.binom.rvs(n=10, p=0.2, size=10000)

# 確率分布を取得
m = np.arange(0, 10+1, 1)
pmf_binom = sp.stats.binom.pmf(n=10, p=0.2, k=m)

# 可視化
sns.distplot(rvs_binom, bins=m, 
             kde=False, norm_hist=True, label='rvs')
plt.plot(m, pmf_binom, label='pmf')
plt.xticks(m)
plt.legend()
plt.grid()

表が出る回数	確率
0	0.107374182
1	0.268435456
2	0.301989888
3	0.201326592
4	0.088080384
5	0.026424115
6	0.005505024
7	0.000786432
8	0.000073728
9	0.000004096
10	0.000000102

⑶ ポアソン分布（Poisson distribution）

• ごく稀に起こる事象の確率で、例えば単位面積当たりの雨粒の数とか、ある交差点で一年間に発生する事故の回数などがポアソン分布に従います。
• つまり、一定の時間や面積に対して一定の割合で発生する確率分布で、サンプル数nが十分に大きく確率pが非常に小さい場合です。
• 例えば、ある期間に平均5回起こる現象が2回だけ起こる確率をpoisson.pmfを使って求めます。

sp.stats.poisson.pmf(k=2, mu=5)

• ポアソン分布のパラメータはある事象の平均発生回数muで、これは強度とかλ（ラムダ）とも呼ばれます。
• ある事象が起こる確率pを20％として、起こった回数を数えるという試行を10000回くり返したと仮定し、poisson.rvsを使ってポアソン分布に従う疑似乱数を生成します。
• さらにpoisson.pmfを使って、発生確率pが20％のときの確率分布を計算し、疑似乱数のヒストグラムと比較してみます。

# 疑似乱数を生成
np.random.seed(1)
rvs_poisson = sp.stats.poisson.rvs(mu=2, size=10000)

# 確率分布を取得
m = np.arange(0, 10+1, 1)
pmf_poisson = sp.stats.poisson.pmf(mu=2, k=m)

# 可視化
sns.distplot(rvs_poisson, bins=m, 
             kde=False, norm_hist=True, label='rvs')
plt.plot(m, pmf_poisson, label='pmf')
plt.xticks(m)
plt.legend()
plt.grid()

発生回数	確率
0	0.135335283
1	0.270670566
2	0.270670566
3	0.180447044
4	0.090223522
5	0.036089409
6	0.012029803
7	0.003437087
8	0.000859272
9	0.000190949
10	0.000038190

• ここで、ポアソン分布と二項分布の関係を考察します。
• 試行回数nが十分に大きく確率pが非常に小さいときの二項分布の確率分布を計算し、先のポアソン分布の例と比較してみます。

# パラメータを指定
n = 100000000
p = 0.00000002

# 二項分布の確率分布を計算
num = np.arange(0, 10+1, 1)
pmf_binom_2 = sp.stats.binom.pmf(n=n, p=p, k=num)

# 可視化
plt.plot(m, pmf_poisson, 
         color='lightgray', lw=10, label='poisson')
plt.plot(m, pmf_binom_2, 
         color='black', linestyle='dotted', label='binomial')
plt.xticks(num)
plt.legend()
plt.grid()

• この場合、ポアソン分布と二項分布はほぼ一致し、両者が近い関係にあることがわかります。
• ポアソン分布は、二項分布の発生確率pが非常に小さく試行回数nが十分に大きいときの状況を近似的に表します。

⑷ 幾何分布（geometric distribution）

• 成功確率がpの独立したベルヌーイ試行をくり返すとき、初めて成功するまでの試行回数kが従う確率分布を幾何分布といいます。
• 例えば、サイコロを１回だけ投げて「1」が出る確率をscipy.statsのgeom.pmfを使って取得します。

%precision 3
sp.stats.geom.pmf(k=1, p=1/6)

• サイコロの目は全部で6つ、すべてが同じ確率とすれば 1/6 で 0.167 になるのは当然ですが、
• 次々と投げて、2回目に初めて｢1｣が出る確率、3回目に初めて｢1｣が出る確率、･･････、10回目に初めて｢1｣が出る確率を求めます。

# 試行回数を指定
num = np.arange(1, 11, 1)

# 確率分布を計算
prob = []
for i in num:
    value = sp.stats.geom.pmf(k=i, p=1/6)
    prob.append(value)

# 可視化
plt.bar(num, prob)
plt.xticks(num)
plt.xlabel('初めて1が出るまでの回数')
plt.ylabel('確率')
plt.show()

• k回投げて、k-1回目までは失敗し、k回目に初めて成功する確率ということで、この場合の確率分布は次の通りです。

試行回数	確率	計算式
1	0.167	⅙
2	0.139	⅚・⅙
3	0.116	⅚・⅚・⅙
4	0.096	⅚・⅚・⅚・⅙
5	0.080	⅚・⅚・⅚・⅚・⅙
6	0.067	⅚・⅚・⅚・⅚・⅚・⅙
7	0.056	⅚・⅚・⅚・⅚・⅚・⅚・⅙
8	0.047	⅚・⅚・⅚・⅚・⅚・⅚・⅚・⅙
9	0.039	⅚・⅚・⅚・⅚・⅚・⅚・⅚・⅚・⅙
10	0.032	⅚・⅚・⅚・⅚・⅚・⅚・⅚・⅚・⅚・⅙

⑸ 離散一様分布（uniform distribution）

• 一様分布には離散型と連続型があり、確率変数が離散型の一様分布を離散一様分布といいます。
• すべての事象の起こる確率が等しい分布で、例えばサイコロは1から6までの目が出る確率がすべて等しいので離散一様分布に従います。

# 全事象を指定
num = np.arange(1, 7, 1)

# 確率分布を計算
prob = []
for i in num:
    value = 1 / len(num)
    prob.append(value)

# 可視化
plt.bar(num, prob)
plt.xticks(num)
plt.xlabel('サイコロの目')
plt.ylabel('確率')
plt.show()

サイコロの目	確率
1	0.167
2	0.167
3	0.167
4	0.167
5	0.167
6	0.167

⑹ 超幾何分布（hypergeometric distribution）

• 例えば、全部で20個のくじがあり、そのうち7個が当たりであるとします。20個からランダムに12個を選んだとき、当たりが何個出るか。
• この「引き当てる個数」を確率変数とする分布を超幾何分布といいます。
• パラメータは3つで、全体の個数M、当たりの個数n、選択する個数Nになります。

# パラメータを指定
M = 20 #全体個数
n = 7  #当たり個数
N = 12 #選択個数

# 確率変数を作成
k = np.arange(0, n+1)

# モデルを作成
hgeom = sp.stats.hypergeom(M, n, N)
# 確率分布を計算
pmf_hgeom = hgeom.pmf(k)

# 可視化
plt.bar(k, pmf_hgeom)
plt.xticks(k)
plt.xlabel('当たりの個数')
plt.ylabel('確率')
plt.show()

当たり個数	確率
0	0.00010
1	0.00433
2	0.04768
3	0.19866
4	0.35759
5	0.28607
6	0.09536
7	0.01022

⑺ 負の二項分布（negative binomial distribution）

• 負の二項分布では、n回の試行でk回成功する確率を求め、最後の試行が成功であることを条件とします。
• 二項分布では成功回数kが確率変数ですが、負の二項分布では成功回数kは固定です。確率変数には、試行回数nを使う代わりに失敗の数n-kを使います。
• 例えば、コイントスをくり返して3回表が出るまでに何回投げる必要があるか。すなわち3回成功するまでに何回失敗する必要があるか、という失敗回数が確率変数になります。

# パラメータを指定
N = 12  #試行回数
p = 0.5 #成功確率
k = 3   #成功回数

# 確率分布を計算
pmf_nbinom = sp.stats.nbinom.pmf(range(N), k, p)

# 可視化
plt.bar(range(N), pmf_nbinom)
plt.xlabel('失敗の回数')
plt.ylabel('確率')
plt.xticks(range(N))
plt.show()

失敗の回数	確率
0	0.125
1	0.188
2	0.188
3	0.156
4	0.117
5	0.082
6	0.055
7	0.035
8	0.022
9	0.013
10	0.008
11	0.005

まとめ

離散型の確率分布を見てきましたが、何が確率変数となるのか、平たく言えばx軸に何を置くかという点を意識して一覧表にまとめます。

	確率分布の種類	確率変数	パラメータ
⑴	ベルヌーイ分布	事象0, 1	発生確率p
⑵	二項分布	試行の回数	発生確率p, 発生回数k, 試行回数n
⑶	ポアソン分布	試行の回数	平均発生回数mu
⑷	幾何分布	試行の回数	成功確率p, 試行回数k
⑸	離散一様分布	事象の種類	※scipy.atatsの一様分布は連続型のみ
⑹	超幾何分布	成功の個数	全体個数M, 全体中の成功個数n, 選択個数N
⑺	負の二項分布	失敗の回数	成功確率p, 成功回数k, 試行回数N

多言語からみるマルチコアの活かし方

はじめに

近年では1つのCPUに複数のコアが搭載されたマルチコアが一般的になっています。
しかし、現状のプログラミング言語ではエンジニアが意識せずにマルチコアをしたプログラムを作ることは難しいです。
そこで、様々な言語から見たマルチコアの活かし方について説明していきます。

プロセスとスレッド

プロセスとは1つ１つのアプリケーションといった実行中のプログラムのことで、スレッドは CPU利用の単位です。プロセスは次のように1つ以上のスレッドを持っており、CPUのコア数分だけスレッドを処理することができます。(また、近年ではSMTという技術によって1つの物理コアで2スレッドといった複数のスレッドを処理することができます。2コア4スレッドみたいなやつです)


マルチコアを有効活用してプログラムを実行するためにはCPUが処理できるコア数に対して適切な数のスレッドをプログラム側で生成する必要があります。コア数以上のスレッドを生成する事も可能ですが、CPUはコア数分のスレッドしか処理を行うことができず、実行するスレッドの切り替えにより処理が遅くなってしまう問題が発生します。

並列と並行

並列(parallel)と並行(concurrent)という似たような言葉が存在しますが、違うものを示します。
並列(parallel)とは複数の処理を同時に行うことで、複数のコアで複数のスレッドを処理するような場合を示します。(シングルコアでは複数処理を同時に実行できないため並列を実現することはできません。)

並行(concurrent)とは複数の処理を切り替えながら同時に実行しているようにすることで、1つのスレッドで複数の処理を切り替えながら実行するような場合を示します。

複数のスレッドで処理を切り替えながら実行することも可能なため、並列かつ並行を実現することも可能です。

C10K問題

WebサーバーのApacheではユーザのリクエスト毎にプロセスを生成する方式を取っており、クライアントが約1万台に達すると、Webサーバーのハードウェア性能に余裕があるにも関わらず、レスポンス性能が大きく下がるというC10K問題というものが存在していました。(C10K問題の具体的な原因はこちらの記事が分かりやすかったです。)
そこで、nginxやNode.jsではシングルスレッドで非同期I/Oに処理をすることにより、並行に処理を行を行うことでC10K問題を解決しようとしました。

Node.js

前述したように、Node.jsはシングルスレッドで動作をし、async/awaitといった非同期処理で並行に処理を行うというアプローチがされています。イメージとしては下図のように、外部APIアクセスをする際に結果が返ってくるまでの時間に他の処理を行い、結果が取得できたらその処理の続きを行うようなイメージです。(詳細はこちらの記事が分かりやすかったです。)

従って標準の非同期処理を行う場合は、マルチコアの性能を引き出すことができません。そこでNode.jsではClusterを用いてプロセスを複数作成するか、worker_threadsを用いてスレッドを複数作成する必要があります。このようにマルチコアコアを活かすためには、プログラム側からプロセスかスレッドを複数作成してあげる必要があり、マルチスレッドでは変数の値の共有を行うことができますが、マルチプロセスではメモリ空間が分離され、変数の値の共有ができないというそれぞれのメリット・デメリットが存在します。

RubyやPythonで起こるGIL

Node.jsでは、プロセスかスレッドを複数作成してあげることでマルチコアを活かすことができました。しかし、RubyやPythonではグローバルインタプリタロック(GIL)というものが存在し、複数のスレッドを作成しても並列に実行することができません。(正確にはC言語で実装されたCPythonとCRubyの場合ですが、ここでは省略します。)
従って、これらの言語でマルチコアを活かそうとした場合、マルチスレッドでは実現できず、プロセスを複数作成してあげる必要があります。

Go言語でのgoroutine

Go言語では、goroutineというものを用いて非同期処理を並列・並行に実現しており、デフォルトでCPUのコア数が設定されたGOMAXPROCSというものが設定されています。この値の数だけスレッドが用意され、そのスレッドの中で軽量スレッドであるgoroutineを実行します。
CPUのコア数が4のGOMAXPROCS=4の場合のイメージとしては下図です。

このようにgoroutineを用いることによりマルチコアを活かして並列・並行にプログラムの実行を行えます。
（goroutineが軽量な理由についてはこちらの記事が分かりやすかったです。)

Rustでのasync/await

Rustでは、async/awaitを用いて非同期処理を行えます。この際、どのランタイムを用いるかによって非同期処理のスレッドの実行割当方法を選択できます。
人気があるランタイムとしては、tokioが挙げられます。tokioではコア数に対してスレッドが生成され、そのスレッドに非同期処理が渡されるというgoroutineと同様のマルチコアの活かし方が実現できます。(他の割当方法や、Rustでの非同期処理についてはこちらの記事が分かりやすかったです。特にここの実行モデルについてが分かりやすいです。)

さいごに

RubyやPythonでは仕組み上マルチスレッドにすることが難しく、Node.jsの非同期処理は、そのままではマルチコアを活かすことができませんでした。
しかし、近年人気のあるGo言語やRustでは非同期処理を呼ぶ事により、エンジニアが意識せずに並列・並行処理を行え、マルチコアを活かすことができます。
マルチコアのCPUが一般的になってきた現代に、Go言語やRustが人気がある事も納得です。

参考

【図解】CPUのコアとスレッドとプロセスの違い,コンテキストスイッチ,マルチスレッディングについて
プロセスとスレッドとタスクの違いを知ってUnity非同期完全理解に近付く
Node.jsの非同期I/Oについて調べてみた
いまさら聞けないNode.js
Pythonで並列処理をするなら知っておくべきGILをできる限り詳しく調べてみた
goroutineはなぜ軽量なのか
Rustの非同期プログラミングをマスターする

背景

農業x深層学習のアプリケーションが作りたい！

という動機のもと、例えば作物の画像を入力してその健康状態を診断するようなアプリが作れるんじゃないかと考えてます。

病気を判定できるすごいモデルのせたアプリを作ったとして、ユーザが対象の作物の画像を正しく入力してくれるかどうかは、そのアプリの信頼性を担保する上で重要な問題になります。

例えば、上記の稲の病気を診断してくれるアプリを作ったとして、ユーザが雑草の画像を入力したとしてもそれっぽい結果を出力してしまえば、そのアプリの診断結果自体が疑わしいものになってしまいます。

この問題に対処するため、メインとなるモデルの前段に入力画像の異常画像検知モデルを置いておけばよいのでは、と考えました。

異常検知モデルにおいて正常と判定された画像のみをメインモデルに渡せば、信頼性の高い結果を出力することができそうです。

できたもの

3年前に購入した iPhoneXにアプリをインストールして、稲と雑草の画像を手元のラップトップに表示し、それを撮影してみました。
右上の円型のゲージに注目していただくと、稲と雑草をなんとなく識別している様子がわかると思います。

以下で、どんなことをやったのかをつらつらと書いていきます。

メトリックラーニング

メトリックラーニングは、ある画像のペアが同一かどうかを判別するモデルを作成するために用いられる手法です。今回の要件にあたっては、入力した画像が学習させた正常画像と同じかどうかを判別するためにこの手法を利用しました。

以下の記事を参考にさせていただきました。
https://qiita.com/shinmura0/items/06d81c72601c7578c6d3

モデル

モデルの作成にはPytorchを使いました。

スマホに載せることを目標としているので、軽量なMobileNetV2を特徴抽出器として利用します。
MobileNetV2はtorchvisionにデフォルトで用意されています。

今回は画像サイズを128x128としました。featuresレイヤーの出力をいい感じに整形して、最終出力を512次元のベクトルにします。

from torchvision.models import MobileNetV2

class MobileNetFeatures(nn.Module):
    def __init__(self):
        super(MobileNetFeatures, self).__init__()
        self.head = MobileNetV2().features
        self.pool = nn.AvgPool2d(4, 4)
        self.flat = nn.Flatten()
        self.fc = nn.Linear(1280, 512)

    def forward(self, x):
        x = self.head(x)
        x = self.pool(x)
        x = self.flat(x)
        x = self.fc(x)
        return x

学習

データセット

学習データとして、正常画像と同時にランダムな異常画像を与える必要があります。
そこで、オープンデータセットであるCOCOデータセットから、正常画像と同じ数だけランダムに抽出し、これを異常画像の集合としました。

Loss関数

割と新しいLoss関数である Arcface を使いました。
Arcfaceの説明としては下記の記事がめちゃくちゃわかりやすかったです。
https://qiita.com/yu4u/items/078054dfb5592cbb80cc

また、以下のレポジトリではこういったメトリックラーニングの最新の論文実装がライブラリとして提供されているため、こちらを利用させていただきました。
https://github.com/KevinMusgrave/pytorch-metric-learning

異常度の測定

学習させたモデルの出力は512次元のベクトル(embedding)です。
入力した画像が異常かどうかを判別するには、正常画像から得られるembeddingとのコサイン類似度をとる必要があります。

そのため、学習フェーズではモデルの保存と同時にバリデーションデータのembeddingの平均ベクトルを保存しておくようにします。

そして推論時にはこれを読み込んで、入力した画像とのコサイン類似度をとることで、異常かどうかの判別を行うことができます。

train.py

    if save_interval > 0 and epoch_id % save_interval == 0:
        model.eval()
　　　　　# 正常画像と異常画像のコサイン類似度をそれぞれ測定する.
        positive_dist = []
        negative_dist = []
        for batch in valid_loader:
            images = batch[0].to(device)
            labels = batch[1].numpy().tolist()
            labels = [bool(i) for i in labels]
            with torch.no_grad():
                embeddings = model(images).cpu().numpy()

            positive_embeddings = embeddings[labels]
            negative_embeddings = embeddings[[not i for i in labels]]

            mean_embedding = np.mean(positive_embeddings, axis=0)
            for pe in positive_embeddings:
                cos_sim = np.dot(mean_embedding, pe) / (np.linalg.norm(mean_embedding, ord=2) * np.linalg.norm(pe, ord=2))
                positive_dist.append(cos_sim)
            for ne in negative_embeddings:
                cos_sim = np.dot(mean_embedding, ne) / (np.linalg.norm(mean_embedding, ord=2) * np.linalg.norm(ne, ord=2))
                negative_dist.append(cos_sim)
        mean_positive_dist = sum(positive_dist) / len(positive_dist)
        mean_negative_dist = sum(negative_dist) / len(negative_dist)

        print(f"epoch{epoch_id}: {mean_positive_dist} {mean_negative_dist}")
        model.train()

        # embeddingを保存する
        features_save_path = f"../saved_features/embedding.txt"
        np.savetxt(features_save_path, mean_embedding, delimiter=",")

スマホモデルへの変換

今回はiOSに載せることを想定し、coreMLを利用しました。

PytorchモデルからcoreMLへの変換のために、一度ONNX形式への変換を経由します。
(coremltoolsの最新版ではONNXを経由せずに変換できるようですが、今回は調査不足のため旧いやり方に従います。)

以下のスクリプトを参照ください。

• Pytorch -> ONNX
  • https://github.com/fltwtn/light_weight_annomaly_detection/blob/main/src/save_onnx.py
• ONNX -> CoreML
  • https://github.com/fltwtn/light_weight_annomaly_detection/blob/main/src/save_coreml.py

注意としては、2020/11/14現在 Python3.8.2の環境ではProtocolBuffer関連のエラーが発生し、ONNX -> CoreML への変換が動作しませんでした。
これは3.7.7を利用することで解決できます。

あとは生成された .mlmodel を Swiftへ組み込めばOKです。

終わりに

プロジェクト全体は以下のリポジトリに置いてあります。
https://github.com/fltwtn/light_weight_annomaly_detection

実際にスマホで動作させてみて、MobileNetV2の速さを改めて実感しました。たぶん30fps以上は出てるんじゃないかな。。。
最近では精度も高く高速なモデルが次々にリリースされているので、今後もいろんなモデルをスマホモデルに変換して試してみようと思います。

この記事では、より多彩な処理を手軽に行うために関数を自分でつくる方法を紹介します。

目次

0.関数とは
1.関数の種類
2.関数をつくるサンプルコード
3.英単語

0.関数とは

関数とは、出力装置のようなものです。
引数の情報を受け取って、処理を実行します。

見た目は、関数名(引数1,引数2,...)のような形をしています。
引数は、パラメーターの役割を果たしています。
つまり、引数をいじると処理の結果が変わってきます。

その点、料理と似てます。
塩の量(パラメーター)をいじると、料理の味(出力)も当然変わってきますよね。

1.関数の種類

関数には2種類あります。

誰かが用意してくれた関数　と　自分でつくる関数　です。

1-0.誰かが用意してくれた関数

今まで頻繁に使ってきた立方体を追加する関数primitive_cube_add()などは誰かが用意してくれた関数です。

primitive_cube_add()とか、長い関数名だなと思った方もいるかもしれませんが、きっとどこかのおじさんたちが頑張って話しあって、こんな長い名前の関数ができたんだと思われます。

1-1.自分でつくる関数

自分でつくる関数は、おじさんたちが用意してくれた関数をありがたく使ってつくります。

①定義
②使用

の順番で進めます。

もう少し具体的にかくと、

def 関数():
    処理

のようにして関数を定義したあと、

関数()

と書くだけです。

次章で具体的に見てみましょう。

1-2.関数をつくってみる

立方体を1つ出現させる関数を自分でつくってみます。

まず、どこかの誰かが用意してくれた立方体を出現させる関数primitive_cube_add( )を見てみましょう。

import bpy

bpy.ops.mesh.primitive_cube_add()

これを利用して自分で関数をつくります。

①定義

以下の例では、cube( )という関数を自分で定義しています。

import bpy

#オリジナル関数の定義
def cube():
    #誰かが用意してくれた関数
    bpy.ops.mesh.primitive_cube_add()

上のコードでは、自分のオリジナルの関数cube()をdefを使って定義しています。構造は以下のような形です。

def 自分で作る関数の名前():
   関数を呼び出した時にさせたい処理

②使用
関数を呼び出してみましょう。

cube()

これだけです。
全体像は以下のようになります。

import bpy

#関数の定義
def cube():
    #関数を呼び出した時にやりたい処理
    bpy.ops.mesh.primitive_cube_add()

#自分で定義した関数cube()を呼び出す
cube()

2.関数をつくるサンプルコード

具体例で見て行った方がわかりやすいと思うので、ここからはサンプルコードと簡単な解説を載せていきます。

オブジェクトをワイヤーフレームにする関数をつくる

import bpy

def cube():
    bpy.ops.mesh.primitive_cube_add()

def wireframe():
    bpy.ops.object.modifier_add(type='WIREFRAME')

cube()
wireframe()

wireframe関数を他の関数の中で使う

import bpy

#オブジェクトをワイヤーフレームにする関数
def wireframe():
    bpy.ops.object.modifier_add(type='WIREFRAME')

#サイズを変えながらワイヤーフレームの立方体を出現させる関数
def wireframe_cube(_size = 2,num = 3):
    for i in range(0,num):
        bpy.ops.mesh.primitive_cube_add(
            size = _size * i
        )
        #出現させたオブジェクトを1つずつワイヤーフレームにしていく
        wireframe()

#最初のサイズは、1でそれを倍にしていく。立方体の数は10個。
wireframe_cube(_size = 1,num = 10)

uv_spehreを出現させる関数をつくる

import bpy

#sphere()という関数を定義する
#滑らかさと出現位置を調整できるようにする
def uv_sphere(_segments = 32,_location = (0,0,0)):
    bpy.ops.mesh.primitive_uv_sphere_add(
    segments=_segments,
    location = _location
    )

#３個出現させる
uv_sphere()
uv_sphere(_segments = 16,_location = (3,0,0))
uv_sphere(_segments = 3,_location = (6,0,0))

---

立方体を1列に並べていく関数をつくる

import bpy

#好きな場所から好きな個数の立方体を1列に出現させる関数の定義
#引数にデフォルトの値を代入する
def cube_line_up(start_position = (0,0,0),num = 2,distance = 2):
    for i in range(0,num * distance + 1,distance):
        bpy.ops.mesh.primitive_cube_add(
        #X軸方向に並べていく
        location=(start_position[0] + i,start_position[1],start_position[2])
        )

#自分で定義した関数cube()を呼び出す
cube_line_up()
cube_line_up(start_position = (0,-4,0),num = 10,distance = 5)
cube_line_up(start_position = (0,-8,0),num = 4,distance = 3)

マテリアル(ガラス)を設定する関数をつくる

import bpy

#立方体を出現させる関数の定義
def cube():
    bpy.ops.mesh.primitive_cube_add()

#マテリアルの設定をする関数の定義
def material(name = 'material',color = (0, 0, 0, 1)):
    material_glass = bpy.data.materials.new(name)
    #ノードを使えるようにする
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/7→roughness(=粗さ)/15→transmission(=伝播)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = color
    p_BSDF.inputs[7].default_value = 0
    p_BSDF.inputs[15].default_value = 1
    #オブジェクトにマテリアルの要素を追加する
    bpy.context.object.data.materials.append(material_glass)

cube()
material(name = 'Red',color = (1, 0, 0, 1))

マテリアル(金属)を設定する関数をつくる

import bpy

#立方体を出現させる関数の定義
def cube():
    bpy.ops.mesh.primitive_cube_add()

#マテリアルの設定をする関数の定義
def material(name = 'material',color = (0, 0, 0, 1)):
    material_glass = bpy.data.materials.new(name)
    #ノードを使えるようにする
    material_glass.use_nodes = True
    p_BSDF = material_glass.node_tree.nodes["Principled BSDF"]
    #0→BaseColor/4→Metallic(=金属)/7→Roughness(=粗さ)
    #default_value = (R, G, B, A)
    p_BSDF.inputs[0].default_value = color
    p_BSDF.inputs[4].default_value = 1
    p_BSDF.inputs[7].default_value = 0
    #オブジェクトにマテリアルの要素を追加する
    bpy.context.object.data.materials.append(material_glass)

cube()
material(name = 'Blue',color = (0, 0, 1, 1))

3.英単語

英単語	訳
function	関数
context	文脈/環境
append	追加する
default	既定の
add	追加する
distance	距離
inputs	取得する
principled	原理、原則の
line up	並べる
segments	部分/区切り

Aidemy　2020/11/15

はじめに

　こんにちは、んがょぺです！バリバリの文系ですが、AIの可能性に興味を持ったのがきっかけで、AI特化型スクール「Aidemy」に通い、勉強しています。ここで得られた知識を皆さんと共有したいと思い、Qiitaでまとめています。以前のまとめ記事も多くの方に読んでいただけてとても嬉しいです。ありがとうございます！
　今回は、強化学習の一つ目の投稿になります。どうぞよろしくお願いします。

＊本記事は「Aidemy」での学習内容を「自分の言葉で」まとめたものになります。表現の間違いや勘違いを含む可能性があります。ご了承ください。

今回学ぶこと
・強化学習とは
・エージェント、環境、報酬
・強化学習の方策

強化学習とは

・機械学習は大別すると「教師あり学習」「教師なし学習」「強化学習」に分けられる。
・そのうち、今回学んでいく強化学習は、「与えられた条件下で最適な行動を発見すること」を目的とした手法である。例えばゲームであれば、強化学習によって勝ち方を発見することができる。

強化学習についての詳細

・強化学習は「エージェント（player）」と「環境（stage）」が相互作用するという前提のもとで進められる。
・あるエージェントが状態sにあるとして、環境に対して行動aを取るとすると、これによって環境はその行動の評価として報酬Rを返し、エージェントは次の状態s'に移行するということを繰り返しながらタスクを進めていく。
・例えばスーパーマリオの例で言えば、エージェントである「マリオ」が、「先に進んでゴールを目指すが、敵に当たると終了」という環境で、「敵を（ジャンプで）避ける」という行動を取ると、環境は「その先に進める権利（そこでゲームが終わらない）」という報酬を返す。これを繰り返して、マリオはゴールというタスクに向かって進んでいく。

・強化学習においては、その場の報酬「即時報酬」を最大化するだけでなく、その後に得られる報酬「遅延報酬」も含めた「収益」を最大化することが必要になる。
・先のマリオの例では、コインを取ることはその場では価値のない行動であるが、100枚集めて「残機を増やす」ことに価値を見出す場合、報酬を最大化するためにはできる限りコインを取るように行動したほうが良いと言える。

N腕バンディット問題

・N腕バンディット問題は強化学習の一例で、「N台のスロットマシーンがあり、あたりなら1外れなら0という報酬が支払われるとする。あたりの確率は台ごとに異なるが、ユーザーからは見えない」とするとき、「ユーザーは1回の試行でどれか一つのスロットを引けるとするとき、試行回数当たりの平均報酬量を最大化するにはどうすれば良いか」を考える問題である。
・考え方としては「最も確率の高い台で引く」ということが理にかなっているが、その台を見つける（推測する）ためにも試行が必要である。というのがこの問題のミソである。
・以降では、この例を使って強化学習について学んでいく。

エージェントの作成

・エージェントとは、より詳しくいうと「環境の中で行動を決定し、環境に対して影響を与えるもの」を指す。
・N腕バンディット問題では、どの台を使うかを判断し、報酬を受け取り、次の判断をするユーザーがエージェントである。
・エージェントが取得した報酬から、どのように次の判断を行うかという指標のことを「方策」という。例えば、この問題において方策が「常に1」というようにきまっているとき、エージェントは常に報酬が1となるような台を狙うことになる。
・このエージェントの最適な方策を決定するのが今回の目的である。

・以下のコードは、今回の手法「どの台を選ぶか」をランダムで決定する関数「randomselect()」である。これによって、どの台を選ぶのかという「slot_num」が返される。

環境の作成

・環境とは、エージェントが行動を起こす対象である。役割としては、行動を受けて状況を観測し、報酬をエージェントに送信し、時間を一つ進めるというものがある。
・今回の問題における環境は「エージェントがある台を引いた時、その台の確率によって当たりかはずれかを出すプロセス」である。

・以下のコードは環境を定義した関数「environment()」である。「coins_p」で各台の当たる確率をNumPy配列で格納し、「results」には「np.random.binomial(n, p)」で試行回数n、確率pの二項分布を求める関数を使用して、スロットを引いた結果を格納する。今回は試行回数1回で確率は「coins_p」であるので、(1, coins_p)と指定すれば良い。environment関数としては、渡された「band_number」の結果を返せば良いので、これを「result」に格納して返す。

報酬の定義

・報酬（reward）とは、エージェントの一連の行動の望ましさを評価する指標のことである。
・今回の問題で言えば、スロットを引いて得られた返り値（0or1）がそのまま報酬である。これは即時報酬に当たる。

・以下のコードは報酬を定義した関数「reward()」である。先ほどのenvironment関数で得た結果を「result」に格納し、引数で渡された配列「record」の現在の試行回数を示す「time」番目にこれを格納する。
・また、[[(台の番号),(選択回数),(報酬合計),(報酬合計÷選択回数)],...]となっているリスト「results」に、それぞれの結果を格納していく。

・さらに、これらの関数を使ったり、自分で値を渡したりして「使う台」「あたりかハズレか」「何回試行するか」などを決め、それぞれの台の試行回数と結果を出力し、平均報酬の遷移を図示したものが以下である。

・結果

・この結果を見ると、「どの台を選ぶか」は完全にランダム（1/5）にしているので、台が選ばれる回数は均等で、当たる確率もおよそ設定した値通りになっている。また、グラフから見てわかるように、平均報酬は0.5付近を維持している。

N腕バンディッド問題の方策

greedy手法

・ここまででエージェントや環境、報酬の型は定義できたので、次は実際に「どうやれば平均報酬を上げられるか」という方策を考えていく。
・基本的な方針としては、最初は情報が全くないので、ランダムに台を選ぶしかない。ある程度試行を重ね、台の当たる確率が推測できるようになったら、最も確率の高い台を探し、その台を選び続ける選択を取ることにする。
・この時の、ある程度試行を重ねて情報を収集することを「探索」といい、最終的に最適な台を選び続けることを「利用」という。

・この方針を最も単純に行う手法が「greedy手法」である。これは、「これまでの結果から最も期待値の大きいものを選択する」という単純明快なものになっている。
・まずは探索を行う。この時、一台につきn回試行するということをあらかじめ決めておき、それをすべての台について行っていく。これが終了したら、その時点での報酬の期待値$u_{i}$を計算し、一番大きいものを選択する。
・期待値$u_{i}$は「(マシンiの報酬の和)÷(マシンiの試行回数)」で求められる。

・以下のコードでは、実際にこの手法を定義して、前項までで作成した環境などを定義した関数も使用して試行した例である。

・greedy手法の定義は、まず「一台の試行回数上限に達するまでslot_numをその台のままにする」というものと、「すべての台が試行回数上限に達したら、slot_numをその時点で最も期待値の高いものにする」というものを定義すれば良い。
・後者について、コードで「np.array()」としているのは、最大値を取得するメソッド「argmax()」を使うためである。

・値を与えてgreedy手法の実践

・結果

・この結果からわかることとして、与えられた探索のための試行回数の上限「n=100」まではすべての台について試行を行なっており、そこからは最も期待値の高い「台4」にすべての試行（残り9500回）を使っている。

ε（イプシロン）-greedy手法

・前項のgreedy手法は、nが小さいほど、つまり探索に使う試行回数が減るほど、間違った台を選ぶ可能性が高くなってしまう。一方、nを大きくすれば最適な台を選ぶ可能性は高くなるが、探索の方に多くの試行回数を使ってしまい、無駄が大きくなってしまう。
・今回の「ε-greedy手法」はこの問題点を解消できる。この手法は探索と利用を織り混ぜることで、探索のコストを減らしつつ間違った台を選び続けるリスクを減らすことができるというものである。
・ε-greedy手法の流れは以下のようになる。
　①まだ選択したことのない台があればそれを選ぶ
　②確率εで全台からランダムで選択する（探索）
　③確率1-εでこれまでの報酬平均（期待値）が最大のマシンを選択する（利用）

・つまり、各試行ごとに、確率εで探索を行い、確率1-εで利用を行うというのがこの手法である。

・ε-greedy手法の定義部分

・実行部分

・結果

楽観的初期値法

・greedy手法では、例えば「0.4と0.6の確率で当たる台A,B」があるとして、「Aの台」の期待値を「0.8」のように多めに予測した場合は、初めはAの台を選び続けるが、試行によって実はAの台は期待値が低そうだ（0.4に収束する）ということを認識し、Bの台に移行していくことができる。
・一方で、「Bの台」の期待値を「0.2」のように少なめに予測してしまうと、「Bの台は試行しない」つまり「Aの台しか選ばない」という状況に陥ってしまい、間違いに気づくことができないという問題点がある。
・このようなリスクを減らす手法として、「不確かな時は期待値を高めに（楽観的に）見積もる」という「楽観的初期値法」が使われる。
・具体的な考え方としては、学習の前に、各台から報酬の最大値をK回得ていることにしてから期待値を計算するということを行う。
・よって、この手法を使う際には「報酬の最大値(rsup)」と「最大値を得たと仮定する回数(K)」を指定する必要がある。
・この二つを使った各台の期待値は$\frac{R(N)+Kr_{sup}}{N + K}$で求められる。R(N)は実際に測定した回数（resultsの3列目に格納）、Nは実際に測定した回数（resultsの2列目に格納）である。よって、コードは以下のようになる。

・実行部分

・結果

soft-max法

・ε-greedy法では、探索の際に、明らかに最悪と考えられる台であっても、決められた回数は必ず試行してしまうことが欠点に挙げられる。例えば当たる確率が20％で、あたりだと「1」ハズレだと「-100」となる台があったとすると、この台を引くことは極めて悪い行動になることが予測されるが、ε-greedy法では、これを避けて探索することはできない。
・これを解消できるのが、「soft-max法」である。これは、「価値の高そうな行動を選ばれやすく、低そうな行動を選ばれにくくする」というものである。つまり、「各行動に重み付け」を行う。
・重みは$\frac{\exp{Q_{i}/ \tau}}{\sum^i \exp{Q_{i}/ \tau}}$という式を使って算出する。 $Q_i$は報酬の期待値、$\tau$(タウ)はパラメータであり、$\tau$が小さいほど上記重み付けの傾向が強くなる。
・soft-max法の流れとしては、データがない場合はすべての報酬を「1」と仮定し、各台の選択確率を上記の式で算出し、これに基づいて選択を行い、報酬を得ることで報酬関数を更新する、というように行われる。具体的なコードは以下の通り。

・上記コードについて、まずは報酬の予測期待値「q」を算出する。これはresultsの4列目を参照すれば良い。次に、データがない場合は報酬期待値「q」はすべて「1」とする、すなわちすべての値が1の配列を「np.ones()」で作成する。
・「q」と渡された「tau」を使った上記の式で選択確率「probability」を算出する。そして、確率がprobabilityで、選択される対象は台の番号であるとして、「np.random.choice(配列,p=確率)」で何が選ばれるかを定義する。

・実行部分

・上記の結果を見てみると、基本的には台の当たる確率通りに選ばれることが多くなっている。ただし、今回の試行では1番の台が全く当たらず、「確率が0の台」とみなされ、それ以降は選ばれていない。

UCB1アルゴリズム

・UCB1アルゴリズムは、楽観的初期値法を改善した手法である。具体的には、「そのマシンがどれだけ当たってきたか（成功率）」と「そのマシンについてどれだけ知っているか(偶然によるデータのばらつきの大きさ)」を合わせて判断することで、あまり探索されていない台は積極的に探索し、データが集まってきたら最も当選確率の高い台を選択するということを同時に行うことができる。
・流れとしては、まず報酬の最大値と最小値の差「R」を算出する。そして、まだ選んだことのない台があればそれを選択し、得られた結果から各台の報酬の期待値（成功率）「$u_{i}$」を計算する。
・また、これらを使った$R\sqrt{\frac{2logT}{N}}$で、各台の偶然によるデータのばらつきの大きさ「$x_{i}$」を計算する。この時の「T」は総プレイ回数、「N」はマシンiのプレイ回数を表す。
・この「$u_{i}$」と「$x_{i}$」の和が最大となる台が最適であると考えて、それを選択する。
・以上をコードで表すと以下のようになる。（N腕バンディッドではR=1である）

・上記コードについて、「まだ選んだことのないマシン」は、resultsの1列目（試行回数）が0であるものと言い換えることができる。また、「これまでの総試行回数（times）」はこの部分をすべて「sum()」で足し合わせれば良い。
・各台の偶然によるデータのばらつきの大きさ「xi」は上記の公式通りに記述すれば良いが「math.sqrt()」でルート、「math.log()」でlogがそれぞれ表現できる。

・実行部分

・この結果について、どの台も最低限の回数は試行されているが、確率の低そうな台はあまり試行されておらず、無駄が少なくなっている。

ここまでの手法について

・ここまでで「greedy手法」「ε-greedy手法」「soft-max手法」「楽観的初期値法」「UCB1アルゴリズム」の五つを見てきたが、明確な優劣はなく、大事なのは問題によって使い分けるということである。
・強化学習の前提として「探索と利用はトレードオフの関係にある」ということが言える。すなわち、探索回数を多くすれば、最適な台以外の試行回数も増えてしまうため無駄が大きくなってしまい、利用回数を多くすれば、最善の台を選ばないリスクが大きくなってしまう。
・例えば全体の試行回数が少ない時は、探索の割合が大きい「ε-greedy法」などは最適な台を見つけやすいため、報酬率が高くなりやすい。一方で、試行回数が多い時は探索の無駄が大きくなってしまうこの手法よりもスマートに探索が行え、利用回数が増える「UCB1アルゴリズム」の方が報酬率が高くなりやすい。
・最初からすべての確率が公表されている時は、エージェントはその中から最適なもののみを試行すれば良い、すなわち探索が必要なくなるが、この時の報酬と、上の五つの手法を使った場合の報酬の差分を「リグレット」と呼ぶ。
・五つの手法の中で、最もリグレットを最小化できるのが「UCB1アルゴリズム」である。

・各手法の結果を表した図（N腕バンディッド問題の場合）

まとめ

・強化学習とは、与えられた条件下で最適な行動を発見することを目的した手法である。
・強化学習では行動者の「エージェント」が存在する。N腕バンディッド問題では「台を選ぶ」という行動をとる。
・また、エージェントが行動を起こす対象である「環境」も存在する。この場合の環境は「台があたりかハズレかを返すプロセス」である。
・「報酬」は、エージェントの行動の望ましさを評価する指標のことである。この報酬の大きさを最大化することが強化学習の目的である。
・この報酬を最大化するための手法として「greedy手法」「ε-greedy手法」「soft-max手法」「楽観的初期値法」「UCB1アルゴリズム」が挙げられる。どの手法も、はじめにそれぞれの台の確率を推定するために「探索」を行い、その結果から最適な台を選ぶ「利用」を行う。

今回は以上です。最後まで読んでいただき、ありがとうございました。

TL;DR

前回、AWSでSSI（include virtual）が記述されたHTMLを、S3の特定バケットに格納しLambdaでインクルード内のソースを結合した上で別のバケットに格納するような仕組みを作りましたが、それのAlibaba Cloud版です。

やりたかったこと

OSS（Object Storage Service）は静的サイトホスティングサービスのため、サーバーサイド側で動的に処理をするということが原則できません。

もちろんその後キャッシュする先であるCDN側（Alibaba Cloud CDN）もできません。

その場合、今であればローカル開発環境を構築しローカル上では別々のファイルにしておき、コンパイルする際に結合する方法がスタンダードだと思いますが、元々SSIが使われていた既存サイトをOSS+CDNへ移管する場合などを含め残念ながらすべての案件でそのフローが導入できるわけでもありません。

なので、元々SSIが使われていた場合、そのまま置換など行わずそのままの形で使用できるようにAlibaba Cloud側で調整を試みました。

やったこと

（前提としてAlibaba Cloud版のIAMであるRAMやKMSの設定が終わった状態です）

基本的に前回の記事を元に、Alibaba Cloud用にカスタマイズしています。
【AWS】S3 / LambdaでSSIっぽいことをやる
Alibaba Cloudの設定についてはSBクラウドさんのこちらの記事が役に立つ思います。
イベント駆動サービス FucntionComputeでオブジェクトストレージを操る

構成

前回と構成は同じです。
なので使用するサービスはOSSとFunction ComputeのみでAlibaba Cloud CDNは必要であれば。

設定方法

OSS

Alibaba Cloud版ではファイルアップするバケットは1つにしています。
その中でtemp用のディレクトリと公開用のディレクトリの2つに分けて処理を行います。

公開/temp用バケット

名前は何でも良いです。
今回は oss-ssi-include としています。

各設定

アクセス許可はそれぞれ適宜設定されているものとします。

公開用ディレクトリとtemp用ディレクトリの作成

公開用ディレクトリ dist とtemp用ディレクトリ src を「ディレクトリの作成」ボタンからそれぞれバケット内に作成してください。

Function Compute

Function ComputeではPUTイベントを検知して、 src/ ディレクトリ内にアップされたHTMLファイル内にSSI（サーバーサイドインクルード）が記述されていれば、Function Computeでインクルード処理を行い、 dist/ ディレクトリに格納するような関数を作成します。

関数コード

import json
import os
import logging
import oss2 
import re
import urllib.parse

logger = logging.getLogger()
logger.setLevel(logging.INFO)

OSS_ENDPOINT        = "oss-ap-northeast-1.aliyuncs.com"
DEST_BUCKET_NAME    = "oss-ssi-include"

def handler(event, context):
    logger.info('## ENVIRONMENT VARIABLES')
    logger.info(os.environ)
    logger.info('## EVENT')
    logger.info(event)

    creds = context.credentials
    auth = oss2.StsAuth(creds.accessKeyId, creds.accessKeySecret, creds.securityToken)
    evt = json.loads(event)

    # 下記書き換える
    input_bucket = oss2.Bucket(auth, OSS_ENDPOINT, DEST_BUCKET_NAME)

    logger.info('## INPUT BUKET')
    logger.info(input_bucket)

    input_key = urllib.parse.unquote_plus(evt['events'][0]['oss']['object']['key'])
    logger.info('## INPUT KEY')
    logger.info(input_key)

    try:
        # 入力ファイルの取得
        response = input_bucket.get_object(input_key)
        logger.info(response)

        # ファイル出力
        output_key    = re.sub('^src/','dist/',input_key)
        logger.info('## OUTPUT KEY')
        logger.info(output_key)

        if not input_key.endswith('.html'):
            logger.info(response)
            input_bucket.put_object(output_key, response)

        else:
            input_html = response.read().decode('utf-8')
            logger.info('## input_html')
            logger.info(input_html)
            output_html = input_html
            # SSI記述を取得
            include_path_base = re.findall(r'<!--#include virtual="/(.*?)" -->.*?\n', input_html, flags=re.DOTALL)
            logger.info('## PATH BASE')
            logger.info(include_path_base)
            if len(include_path_base) > 0:
                for path in include_path_base:
                    include_path = path
                    logger.info('## PATH')
                    logger.info(include_path)

                    # SSIファイルの取得
                    try:
                        include = input_bucket.get_object('src/' + include_path)
                        include_html = include.read().decode('utf-8')
                        # SSIを実行
                        output_html = output_html.replace('<!--#include virtual="/' + include_path + '" -->', include_html)
                    except ClientError:
                        pass


            input_bucket.put_object(output_key, output_html)

    except Exception as e:
        logger.info(e)
        raise e

その他の設定

トリガー設定

トリガータイプ：OSS トリガー
トリガー名：put
イベントソース：
acs:oss:ap-northeast-1:xxxxxxxxxxxxxxxxx:ossname
イベント： oss:ObjectCreated:PutObject , oss:ObjectCreated:PostObject
トリガールール：接頭辞 src/
ロール操作：既存のロールを選択
既存のロール：
ロールはRAMで設定した以下のポリシーでOKです。

{
    "Version": "1",
    "Statement": [
        {
            "Action": [
                "fc:InvokeFunction"
            ],
            "Resource": "*",
            "Effect": "Allow"
        }
    ]
}

おわりに

前回、AWSでSSI（include virtual）が記述されたHTMLを、S3の特定バケットに格納しLambdaでインクルード内のソースを結合した上で別のバケットに格納するような仕組みを作りましたが、諸事情でAlibaba Cloudでも作る必要があったため用意してみました。

AWS版と違ってtemp用ディレクトリにファイルアップ→CloudComputeが処理→公開用ディレクトリにファイルが格納されるため、使い良い形にするのであれば公開用ディレクトリに格納されたファイルはCDNへ配信した方が良いと思います。

あと、日本でAlibaba Cloudの情報を得ようとする時はSBクラウドさんのエンジニアブログがおすすめです。
今回のものも大分参考にさせていただきました。

ただこれって重要あるのかな。。
現場からは以上です。

はじめに

皆様、携帯（スマホ）のカメラで撮影した写真の管理はどうされていますか？
私の場合は、ある程度撮ったらPCにコピーし、スマホからは消す、ということをして、なるべくスマホに大量のデータを残さないようにしています。
しかし、写真をスマホから消してしまうと、ファイル名の連番が戻ってしまい、PCにコピーしようとしたときに同じ名前のファイルができてしまって面倒なことになります。

ということで、ファイル名被りの問題を解決するため、PCにコピーした画像ファイルを撮影日時を使って一括リネームする方法をご紹介します。

検証環境

• Cygwin (Windows 10 20H2 Home)
• Python 3.6.10
  • Pillow 7.2.0

事前準備

$ pip3 install Pillow

コード

rename_images.py

from PIL import Image
from PIL.ExifTags import TAGS
from pathlib import Path
import datetime

# https://www.lifewithpython.com/2014/12/python-extract-exif-data-like-data-from-images.html
def get_exif_of_image(file):
    """Get EXIF of an image if exists.

    指定した画像のEXIFデータを取り出す関数
    @return exif_table Exif データを格納した辞書
    """
    im = Image.open(file)

    # Exif データを取得
    # 存在しなければそのまま終了 空の辞書を返す
    try:
        exif = im._getexif()
    except AttributeError:
        return {}

    # タグIDそのままでは人が読めないのでデコードして
    # テーブルに格納する
    exif_table = {}
    for tag_id, value in exif.items():
        tag = TAGS.get(tag_id, tag_id)
        exif_table[tag] = value

    return exif_table

# 画像が入っているPC側のフォルダのパスを指定
for filename in Path("/path/to/images").glob("DSC_*.JPG"):
    exif = get_exif_of_image(filename)
    if "DateTimeOriginal" in exif:
        # strftime() で新しい名前のフォーマットを指定
        new_name = Path(filename).with_name(datetime.datetime.strptime(exif["DateTimeOriginal"], "%Y:%m:%d %H:%M:%S").strftime("IMG_%Y%m%d_%H%M%S.JPG"))
        print(f"{filename} \n -> {new_name}")
        filename.rename(new_name)
    else:
        print(f"[WARNING] {filename}: no EXIF header")

解説

画像ファイルのEXIFヘッダから撮影日時を取り出し、撮影日時をもとに指定したフォーマットで新しいファイル名を作ってリネームします。

for filename in Path("/path/to/images").glob("DSC_*.JPG"): 部分で、特定のフォルダに含まれている画像ファイルを列挙します。DSC_*.JPG の部分はスマホのカメラアプリが生成するファイルフォーマットに合わせてください。このパターンはXperiaの場合の例です。

get_exif_of_image() で、EXIFヘッダの情報を取得します。この関数は以下のページから引用しました。m(_ _)m
Python Tips：画像の Exif データを取得したい - Life with Python

DateTimeOriginal という名前で撮影日時が記録されていますので、日時の文字列を datetime モジュールで解析します。この記録フォーマットは統一されているはずなので、strptime() の引数をカメラごとにカスタマイズする必要はありません。
この解析結果をもとに新しいファイル名を作成します。お好みで strftime() の引数を変更してください。ただし、DSC_%Y%m%d_%H%M%S.JPG のようなオリジナルと同じフォーマットの名前はやめておいたほうが良いと思います。

strptime() や strftime() のフォーマット文字列の意味についてはこちらをどうぞ。
8.1. datetime --- 基本的な日付型および時間型 — Python 3.6.12 ドキュメント

実行例

以下のようにログが表示されます。ファイルが正しくリネームされているか確認してください。

/path/to/images/DSC_0001.JPG
 -> /path/to/images/IMG_20190928_135805.JPG
/path/to/images/DSC_0004.JPG
 -> /path/to/images/IMG_20191104_172704.JPG
/path/to/images/DSC_0005.JPG
 -> /path/to/images/IMG_20191106_174423.JPG
/path/to/images/DSC_0006.JPG
 -> /path/to/images/IMG_20191106_174752.JPG
/path/to/images/DSC_0007.JPG
 -> /path/to/images/IMG_20191106_174808.JPG
/path/to/images/DSC_0009.JPG
 -> /path/to/images/IMG_20191213_180056.JPG
/path/to/images/DSC_0010.JPG
 -> /path/to/images/IMG_20191213_180103.JPG
/path/to/images/DSC_0011.JPG
 -> /path/to/images/IMG_20191213_180112.JPG

補足

もし可能なら、撮影時点でスマホ側でリネームしておくほうが面倒がなくてよいと思います。
Androidならこういうアプリが使えます。私もこれからはアプリを使っていきます。
「DSC Auto Rename」を使って写真撮影時にファイル名を自動的にリネームする | 忘れ荘

概要

2020年11月に受験したPython3エンジニア認定データ分析試験で、勉強方法の1つとして作っていた自作問題集です。これから受験される方の一助になれば嬉しいです。

体験記はこちらの記事でまとめています↓
https://qiita.com/pon_maeda/items/a6c008fb3d993278fccb

注意点

• この問題集は、隙間時間で手軽に解けるよう、一問一答や穴埋めといった出題形式で作っています。
• 実際の試験は四者択一形式のため(2020/11/15時点)、ご注意下さい。
  • 実際の試験よりやや難易度が高くなっています。
• 個人用としてざっくりと作成したものなので、問題文として至らないところもあるかもしれません。ご容赦下さい。

問題集

1. データ分析エンジニアの役割

機械学習は大きく分けて3つ。( ) 学習と、( ) 学習、 ( ) 学習の3である。

答え

- 教師あり学習
- 教師なし学習
- 強化学習

正解ラベルとも呼ばれる、 ( ) 変数は、 ( ) 学習にのみ使用される。

答え

- 目的変数
- 教師あり学習

この正解ラベルが連続値である場合に使われる手法は ( )、その他の値である場合に使われる手法は ( )。

答え

連続値 : 回帰
その他の値 : 分類

教師なし学習の手法で、主な2つは何か。

答え

- クラスタリング
- 次元削減

2. Pythonと環境

venvは、Pythonのバージョンを使い分けることができるツールである。 (Yes / No)

答え

No
venvはPythonの下に組み込むので、Python自体のバージョン管理はできない。

Pythonでファイル名をワイルドカードで指定することができる関数。

答え

glob関数

3. 数学の基礎

sinとcos、tanの日本語読み。

答え

sin : 正弦
con : 余弦
tan : 正接

ネイピア数はいくつか。

答え

2.7182…

1の対数は。

答え

0

1の階乗は。

答え

1

6面体のサイコロを1回振った場合、その出目の数自体は不明なものの、奇数が出ていることを教えられたとする。この場合の確率を ( ) 確率と呼び、これは ( ) の定理の基本となっている。

答え

- 条件付き確率
- ベイズの定理

4. ライブラリによる分析の実践

4.1. NumPy

4.1.1. NumPyの概要

NumPyには配列用の型である ( ) と、行列用の型である ( ) がある。

答え

配列用 : ndarray
行列用 : matrix
※ データ分析試験では、ndarrayが主役

↑の特徴として、型を ( 複数使える or 一種類にしなければならない ) ことが挙げられる。

答え

一種類にしなければならない。
ここが、DataFrameと違うところ。

4.1.2. NumPyでデータを扱う

配列でサイズを確認する関数

答え

shape関数

ravel関数は ( ) を返すのに対して、flatten関数は ( ) を返す。

答え

ravel関数 : 参照 (または浅いコピー) を返す
flatten関数 : (深い) コピーを返す

配列の型を確認する関数

答え

dtype関数

配列の型を変換する関数

答え

astype関数

整数の一様乱数を生成する関数

答え

np.random.randint関数
※ {{第1引数}}以上、{{第2引数}}未満の範囲で生成
※ 第3引数にタプルを渡すと、その行列サイズで生成してくれる

小数の一様乱数を生成する関数

答え

np.random.uniform関数
※ 引数はnp.random.randint関数と同じ

整数の標準正規分布からの乱数を作成する関数

答え

np.random.randn関数

標準正規分布とは、平均 ( ) 、分散 ( )の分布か。

答え

平均0、分散1の分布

正規分布乱数の生成で、平均や標準偏差を指定して生成する関数は何か。

答え

np.random.normal関数

指定した対角要素を持つ単位行列を作る関数

答え

np.eye関数
np.eye(3)とすると、↓こんなのができる
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

要素全てが指定の値の配列を作る関数

答え

np.full関数
例 : np.full((2, 4), np.pi)

指定範囲で均等割りの配列をつくる関数

答え

np.linespace関数
例 : np.linespace(0, 1, 5) // → array([0., 0.25, 0.5, 0.75, 1.0])

配列の要素間の差分を見れる関数

答え

np.diff関数

a = [1, 2, 3]
b = [4, 5, 6]
np.concatnate([a, b])

とすると、以下のどれになるか。

1. [1, 2, 3, 4, 5, 6]
2. [[1, 2, 3],[4, 5, 6]]
3. [1, 2, 3, [4, 5, 6]]

答え

1. [1, 2, 3, 4, 5, 6]

np.concatnate関数は、一次元配列同士の連結の場合は、( 行 or 列 )方向連結となる。

答え

列方向に連結される。 (hstack関数と同じ挙動)

np.concatnate関数は、二次元配列同士の連結の場合は、デフォルトで ( 行 or 列 ) 方向に連結される。

答え

行方向に連結される。 (vstack関数と同じ挙動)

この関数に引数axis=1を指定すると ()方向連結となる。

答え

列方向に連結される。 (hstack関数と同じ挙動)

二次元配列を列方向に分割する関数。

答え

np.hsplit関数
例) first, second = np.hsplit(hoge_array, [2]) # → 3列目で分割

二次元配列を行方向に分裂する関数

答え

np.vsplit関数
例) first, second = np.vsplit(hoge_array, [2]) # → 3行目で分割

二次元配列の転置とはどういう意味か。

答え

行と列を入れ替えること

aという二次元配列があった場合に、転置するにはどうするか。

答え

a.T

要素数を指定せずに、一次元配列の次元を増やす関数は何か。

答え

np.newaxis関数
※ 要素数を指定して良ければ、reshape関数を使う方法もある。

a = np.array([1, 5, 4])
# array([[1, 5, 4]])

先の関数を使って、上記のように次元を増やすにはどうすればよいか。

答え

a[np.newaxis, :]

a = np.array([1, 5, 4])
# array([[1],
         [5],
         [4]])

先の関数を使って、上記のように次元を増やすにはどうすればよいか。

答え

a[:, np.newaxis]

グリッドデータを生成する関数は何か。

答え

np.meshgrid関数

np.arange(1, 10, 3)

この結果はどうなるか。

答え

array([1, 4, 7])
1以上、10未満(つまり9まで)で、3等分される。

4.1.3. NumPyの各機能
sin()やlog()など、配列要素を一括で変換してくれる、NumPyの便利関数群のことを何というか。

答え

ユニバーサルファンクション

配列要素の絶対値を返す関数

答え

np.abs関数

a = np.array([0, 1, 2])
b = np.array([[-3, -2, -1],
              [0, 1, 2]])
a + b

上記の通り、二次元配列と一次元配列の和はどうなるか。

答え

array([[-3, -1, 1],
[0, 2, 4]])
aが2行になったような形で、bに加算される。

配列にスカラーを演算できることを何というか。

答え

ブロードキャスト

@演算子は何を意味するか。

答え

行列の乗算のための中置演算子

A_matrix @ B_matrix

を別の書き方に。

答え

np.dot(A_matrix, B_matrix)
または、A_matrix.dot(B_matrix)

真偽の配列で、Trueの数を求められる関数。

答え

np.count_nonzero関数
または、np.sum関数

---

• np.count_nonzeroメソット
  • 0でない要素数を出力する関数。
  • PythonではFalseを0として扱うので、Trueの数を数えてくれる。
• np.sum関数
  • 要素内を足し算する関数
  • PythonではTrueを1として扱うので、結果的にTrueの数が求められる。

真偽の配列で、Trueが含まれているか求める関数。

答え

np.any関数

真偽の配列で、全ての要素がTrueであるか求める関数。

答え

np.all関数

4.2. pandas

4.2.1. pandasの概要

df.head()とdf.tail()で、でDataFrameの先頭および末尾を、それぞれ ( ) 行のみ出力する。

答え

5行

dfのサイズを知る関数

答え

df.shape

dfから、AカラムとBカラムの2つの情報を取得する方法

答え

df[“A“, “B“]
または、
df.loc[:, [“A“, “B“]]など

4.2.2. データの読み込み・書き込み

4.2.3. データの整形

歩数と摂取カロリーのDataFrameであるdfがあったとして、歩数が10000歩以上のレコードだけを抽出する方法

答え

df[df[“歩数“] >= 10000]

または
df[df.loc[:, “歩数“] >= 10000]や
df.query('歩数 >= 10000')など

歩数と摂取カロリーのDataFrameであるdfがあったとして、歩数の降順にソートする方法

答え

df.sort_values(by=”歩数”, ascending=False)

High, Mid, Lowの3つの値が入った運動指数カラムを、接頭語に「運動」と加えてつつ、One-hotエンコーディングする。

答え

df.get_dummies(df.loc[:, “運動指数“], prefix=”運動”)

4.2.4. 時系列データ

2020-01-01〜2020-10-01の日付の配列を作成する方法。

答え

pd.date_range(start=”2020-01-01”, end=”2020-10-01”)

2020-01-01から100日間の日付の配列を作成する。

答え

pd.date_range(start=”2020-01-01”, period=100)

2020-01-01〜2020-10-01の日付のうち、土曜日だけの配列を作成する。

答え

pd.date_range(start=”2020-01-01”, end=”2020-10-01”, freq=”W-SAT”)

時系列データdfに対して、月ごとのデータにグルーピングして、値を平均値にする。

答え

df.groupby(pd.Grouper(freq='M')).mean()

または、
df.resample('M'),mean()など

4.2.5. 欠損値処理

fillna関数でNanを前の値で埋めたいときに使う引数。

答え

df.fillna(method='ffill')

DataFrameだと、一行上の値で埋める。
bfillだと、逆に一行下の値で埋める。

fillna関数の引数に中央値を与えたい場合どうするか。

答え

df.fillna(df.median())
※ method='median'ではないので注意

4.2.6. データ連結

df_1とdf_2を列方向にデータ連結して、df_mergeを作成する。

答え

df_merge = pd.concat([df_1, df_2], axis=1)

4.2.7. 統計データの扱い

最頻値を確認する関数

答え

mode関数

中央値を出す関数

答え

median関数

標準偏差 (標本標準偏差) を出す関数

答え

std関数

標準偏差 (母集団) を出す関数と引数

答え

std関数に、ddof=0引数を渡す

4.3. Matplotlib

円グラフはどこから配置されるか。

答え

上から配置される

円グラフは ( 時計 or 反時計 ) 周りに配置される。

答え

時計回り

円グラフで、時計回りに実装するには ( ) メソッドに ( ) 引数を渡す。

答え

pieメソッドで、counterclock=Falseを渡す。
なんか、世のWebサイトには逆に書いてる。なんで。笑
デフォルトはcounterclock=True

円グラフで、グラフの描画を始める場所を指定するには、 ( ) メソッドに ( ) 引数を渡す。

答え

startangle={{出力を開始したい角度}}
デフォルト値はNoneで、3時の位置から描画される。
90度指定で12時からになる。

4.4. scikit-learn

4.4.1. 前処理

欠損値

欠損値があった場合、データを補完する場合に使うクラスは何か。

答え

Imputerクラス

上記のクラスでstrategy引数に渡す値について。

mean = ①、median = ②、most_frequent = ③

答え

1. 平均
2. 中央値
3. 最頻値

カテゴリ変数のエンコーディング

カテゴリ変数のエンコーディングを行うクラスは何か。

答え

LabelEncoderクラス

エンコーディング後、元の値を確認する属性は何か。

答え

.classes_属性

カテゴリ変数のエンコーディングとともに、メジャーな処理方法と言えば何エンコーディングか。

答え

One-hotエンコーディング
血液型4種類だったら、4カラム追加してフラグにする感じのやつ。

このエンコーディングの別の呼び方は。

答え

ダミー変数化

行列のうち、多くの成分が0である行列と、多くの成分が0でない行列をそれぞれ何というか。

答え

疎行列と密行列

特徴量の正規化

分散正規化とは、特徴量の平均が ( ) 、標準偏差が ( ) になるように、特徴量を変換する処理。

答え

特徴量の平均が0、標準偏差が1

分散正規化を行うクラスは何か。

答え

StanderdScalerクラス

最小最大正規化とは、特徴量の最小値が ( ) 、最大値が ( ) になるように、特徴量を変換する処理。

答え

特徴量の最小値が0、最大値が1

最小最大正規化を行うクラスは何か。

答え

MinMaxScalerクラス

4.4.2. 分類

分類は教師 ( ) 学習の典型的なタスク。

答え

教師あり学習
分類は、既知のデータを教師として利用し、各データをクラスに振り分けるモデルを学習する。

上記は、正解となるラベルを用いるが、そのラベルを ( ) 変数という。

答え

目的変数

分類の代表的なアルゴリズム3つ

答え

- サポートベクタマシン
- 決定木 (けっていぎ)
- ランダムフォレスト

分類モデル構築の流れ

分類モデルの構築には、手元のデータを ( ) する。

答え

学習データセットとテストデータセットに分割する。

分類のおける「学習」とは、( ) データセットを用いて分類モデルを構築することを指す。

答え

学習データセット

構築したモデルのテストデータセットに対する予測から算出した、未知のデータに対する対応能力を何と言うか。

答え

汎化能力

各データセットを分ける関数はなにか。

答え

model_selection.train_test_split関数

scikit-learnでは、学習を ( ) 関数、予測を ( ) 関数を使用する。

答え

学習 : fit関数
予測 : predict関数

サポートベクタマシン

サポートベクタマシンは、分類や回帰だけでなく、( )にも使えるアルゴリズム。

答え

外れ値検出

2つのクラスに属する2次元データを考えたとき、各クラスのデータのうち境界に最も近いデータを何というか。

答え

サポートベクタ

2つのクラスに属する2次元データを考えたとき、サポートベクタ間の距離が最も ( ) くなるように ( ) の直線を引く。

答え

- 大きく (遠く)
- 決定境界

この直線と、サポートベクタの距離を ( ) と呼ぶ。

答え

マージン

ランダムフォレスト

ランダムフォレストで使う、ランダムに選択されたサンプルと特徴量 (説明変数) のデータを何というか。

答え

ブートストラップデータ

ランダムフォレストは決定木の集合であり、このように複数の学習機を用いた学習を何というか。

答え

アンサンブル学習

4.4.3. 回帰

回帰とは、 ( ) 変数を、特徴量で代表される ( ) 変数で説明するタスク。

答え

- 目的変数
- 説明変数

線形回帰は、説明変数が1変数のときを ( ) 、2変数以上のときを ( ) と呼ぶ。

答え

- 単回帰
- 重回帰

4.4.4. 次元削減

データが持っている情報をなるべく損ねずに、データを ( ) するタスク。

答え

圧縮

主成分分析

scikit-learnでは、主成分分析はどのモジュールのどのクラスを使うか。

答え

decompositon.PCSクラス

4.4.5. モデルの評価

カテゴリの分類精度

データのカテゴリをどの程度当てられたかを定量化する指標4つ。

( ) 率、 ( ) 率、 ( ) 率、 ( ) 値

答え

- 適合率
- 再現率
- F値
- 正解率

また、これらの指標は ( ) 行列から計算する。

答え

混同行列

( ) 率と ( ) 率は、トレードオフ関係にある。

答え

- 適合率
- 再現率

予測確率の正確さ

データに対する予測確率の正確さを定量化する指標として、 ( ) 曲線とそこから算出する ( )が用いられる。

答え

- ROC曲線
- AUC

4.4.6. ハイパーパラメータの最適化

ハイパーパラメータは、学習のときに値が ( 決定される or 決定されない )。

答え

決定されない。
学習とは別に、ユーザが値を指定する必要がある。

ハイパーパラメータを最適化する代表的な方法2つ。

答え

- グリッドサーチ
- ランダムサーチ

さいごに

拙い問題ですが、誰かの役に立てば嬉しいです。
誤り等があらば、是非コメントでツッコミ頂けると嬉しいです。
最後までありがとうございました。

はじめに

複数の端末に対してRDP接続する必要がある場合に、わざわざExcelのリストを見て手入力で接続するのは面倒、と思い、RDPファイルをまとめてPythonで作れるようにしてみました...!!

準備

入力情報、Pythonファイルを以下に示します。

入力情報

以下の2ファイルを作成します。
1. RDP接続先リスト(接続先リスト_sample.xlsx)
2. RDPテンプレート(template.rdp)

1. RDP接続先リスト(接続先リスト_sample.xlsx)

2. RDPテンプレート(template.rdp)

以下のように「コンピュータ名」を「ComputerAddress」に、「ユーザー名」を「UserName_for_RDP」として、「名前を付けて保存」を使って、template.rdpとして作業用ディレクトリに保存しておきます。

なお、RDP接続ファイル（template.rdp）はテキストエディタで開くと以下のようになっています。パスワードはRDPファイル自体には保存されないことが読み取れます。

template.rdp

screen mode id:i:2
use multimon:i:1
desktopwidth:i:1920
desktopheight:i:1080
session bpp:i:32
winposstr:s:0,1,759,0,980,270
compression:i:1
keyboardhook:i:2
audiocapturemode:i:0
videoplaybackmode:i:1
connection type:i:7
networkautodetect:i:1
bandwidthautodetect:i:1
displayconnectionbar:i:1
enableworkspacereconnect:i:0
disable wallpaper:i:0
allow font smoothing:i:0
allow desktop composition:i:0
disable full window drag:i:1
disable menu anims:i:1
disable themes:i:0
disable cursor setting:i:0
bitmapcachepersistenable:i:1
full address:s:ComputerAddress
audiomode:i:0
redirectprinters:i:1
redirectcomports:i:0
redirectsmartcards:i:1
redirectclipboard:i:1
redirectposdevices:i:0
autoreconnection enabled:i:1
authentication level:i:2
prompt for credentials:i:0
negotiate security layer:i:1
remoteapplicationmode:i:0
alternate shell:s:
shell working directory:s:
gatewayhostname:s:
gatewayusagemethod:i:4
gatewaycredentialssource:i:4
gatewayprofileusagemethod:i:0
promptcredentialonce:i:0
gatewaybrokeringtype:i:0
use redirection server name:i:0
rdgiskdcproxy:i:0
kdcproxyname:s:
drivestoredirect:s:
camerastoredirect:s:*
devicestoredirect:s:*
username:s:UserName_for_RDP

Pythonのファイル

RDP_File_Generator.py

# -*- coding: utf-8 -*-
"""
 RDPファイル作成PGM
"""

import tkinter, tkinter.filedialog, sys, os
import pandas as pd

dir1 = r"C:\Users\XXXXX\Desktop\xxxxxx"
# ↑「RDP接続先リスト」や「RDPテンプレート」を格納しているファイルパスを指定

## tkinterのお決まり。
root = tkinter.Tk()
root.withdraw()

msg1 = '接続先リストを選択してください'
typ1 = [('エクセルファイル','*.xlsx')] 
inFile1 = tkinter.filedialog.askopenfilename(title=msg1, filetypes = typ1, initialdir = dir1) 
if (not inFile1): #[キャンセル]クリック時の処理
  print('ファイルを選んでください。')
  sys.exit

input_book1 = pd.ExcelFile(inFile1)
input_sheet_name1 = input_book1.sheet_names
input_sheet_df1 = input_book1.parse(input_sheet_name1[0],header=3)
df_s = input_sheet_df1.iloc[:,2:]

msg2 = 'RDPファイルを選択してください'
typ2 = [('RDPファイル','*.rdp')] 
inFile2 = tkinter.filedialog.askopenfilename(title=msg2, filetypes = typ2, initialdir = dir1) 
if (not inFile1): #[キャンセル]クリック時の処理
  print('ファイルを選んでください。')
  sys.exit


path_name = os.path.dirname(inFile2)
output_folder_path = os.path.join(path_name,"output")
## RDPファイル出力先フォルダ作成（exist_ok:既存の場合はスキップ）
os.makedirs(output_folder_path,exist_ok = True)

## RDPテンプレートファイルをテキストファイルとして開く
with open(inFile2,encoding='utf_16') as f:
  s = f.read()

## 接続先リストにある接続先の数だけ、RDPファイルを生成する
for i in range(len(df_s)):
  temp = s
  temp = temp.replace("UserName_for_RDP", df_s["ユーザID"].iat[i])
  temp = temp.replace("ComputerAddress", df_s["IPアドレス"].iat[i])
  path_w = os.path.join(output_folder_path,df_s["ユーザID"].iat[i]+".rdp")
  with open(path_w,mode="w") as f:
    f.write(temp)

実行してみる

以下、実行イメージです。

まず、「RDP_File_Generator.py」を実行すると、tkinterによるダイアログが表示されるので、接続先リストを選択します。

次に、RDPファイルのテンプレートを選択します。

outputフォルダができ、その中にRDPファイルが一括で出力されています！成功です！！

おわりに

パスワードはRDPファイル内に埋め込まれたりすることはないので、初回接続時にパスワード入力して資格情報を接続元PCで保存する、という手間は残りますが、便利だと思うので、良かったら参考にしていただけると嬉しいです！

はじめに

LINEでシステムから情報を一斉配信したので、その時の手順を残しておきます。

LINEはLINE@とLINE公式アカウントが別々で別れてましたが統合されたようです。
アカウントは無料で作成することができ、登録にはメールアドレスのみで登録できます。
LINEにはAPIがいくつかありますが、一斉配信にはMessaging APIを使用します。
一つのチャンネルで1000通までは無料で配信できるので、十分にテストできると思います。

チャネル作成

まずはこちらのURLからビジネスアカウント作成をクリックして、メールアドレスで作成をクリックします。
https://account.line.biz/login

次に、作成したビジネスアカウントでログインをしてプロバイダとチャネルを作成してください。
https://developers.line.biz/ja/docs/messaging-api/getting-started/#using-oa-manager

チャネルアクセストークン発行

チャネルの個別設定画面の上のタブの「Messaging API設定」を選択します。

その画面の一番下の「チャネルアクセストークン(長期)の発行ボタンをクリックしてトークンを発行してください。

プログラム実行

下のプログラムを実行すると配信できます。
先ほど発行したアクセストークンを変数にセットしてご使用ください。

test_delivery.py

# -*- coding:utf-8 -*-
import requests
import urllib.request, urllib.error
import json

url = 'https://api.line.me/v2/bot/message/broadcast'
channel_access_token = '作成したchannel_access_token'
# 送信用のデータ
# messageの中にtype,textの配列を追加すれば一度に複数のメッセージを送信できます。(最大件数5)
data = {
    'messages' : [{
        'type':'text',
        'text':'配信したいテキスト'
    }]
}
jsonstr = json.dumps(data).encode('ascii')
request = urllib.request.Request(url, data=jsonstr)
request.add_header('Content-Type', 'application/json')
request.add_header('Authorization', 'Bearer ' + channel_access_token)
request.get_method = lambda: 'POST'
# 送信実行(レスポンスが200なら送信成功)
response = urllib.request.urlopen(request)

詳細な使用方法は公式がわかりやすいです。
https://developers.line.biz/ja/reference/messaging-api/#send-broadcast-message

最後に

初めてLINE MessagingAPIを使用しましたが、わかりやすくて非常に使用しやすいものでした。
webhookやOAuthなんかもあるので、そちらも時間ができたら試します。
なにかこちらの記事で間違い等あればご指摘ください。

この記事について

AnacondaをWindows10に導入し仮想環境を作成するまでの手順を記載します。
仮想環境はプロジェクトごとの固有な設定やライブラリをインストールする際に他のプロジェクトに影響を与えないように開発するための便利な方法です。

筆者の環境
OS：Windows10
CPU：AMD Ryzen 5 PRO 350Uw / Radeon Vega Mobile Gfx 2.10Ghz
メモリ：8.00GB

インストール

ダウンロード

以下のサイトよりダウンロードし、インストーラーに従ってインストールします。（すべて推奨設定）
https://www.anaconda.com/products/individual

仮想環境の作成

プロンプトの起動

インストールするとスタートメニューに作成Anaconda3の起動メニューが作成される。
Anaconda Promptを起動する

仮想環境の作成

#仮想環境の確認
conda info -e

#仮想環境の作成
#conda create -n [任意の環境名]
conda create -n hogehoge

#仮想環境の確認
conda info -e

#仮想環境の起動
#activate [作成した環境名]
activate hogehoge

これで仮想環境の作成は完了です。

はじめに

前回の記事で、KaggleのHouse Sales in King County, USAのデータセットを使って、XGboost機械学習で学習モデルを生成して、その学習モデルをFlaskでAPIサーバーにするというのをやりました。今回は、そのAPIサーバー使って、HTMLからJSONでAjax通信するまでの手順を説明しています。機械学習で学習したモデルをAPIサーバーにするまでの手順は以下の記事を参考にしてみてください。

KaggleのHouse Sales in King County, USAのデータセットを使って、機械学習を行い、APIサーバーにするまでの手順

Ajax通信

ここでは、HTMLからjavascriptのAjaxで通信できるようにするために、Flaskで書いた、APIサーバーの起動ファイルを以下のように追記する必要があります。追記するのは、flask_corsというライブラリとそれに関連するコードです。flask_corsは事前にインストールしてある必要があります。

housesails_app.py

import json

from flask import Flask
from flask import request
from flask import abort
from flask_httpauth import HTTPBasicAuth
from flask_cors import CORS #追加する

import pandas as pd
from sklearn.externals import joblib
import xgboost as xgb

model = joblib.load("house_sales_model.pkl")

app = Flask(__name__)

# 追加
@app.after_request
def after_request(response):
  response.headers.add('Access-Control-Allow-Origin', '*')
  response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization')
  response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
  return response
# ↑ここまでを追加

# BasicAuth
auth = HTTPBasicAuth()

users = {
    "username1": "password1",
    "username2": "password2"
}

@auth.get_password
def get_pw(username):
    if username in users:
        return users.get(username)
    return None

# Get headers for payload
headers = ['sqft_living','sqft_above','sqft_basement','lat','long','sqft_living15','grade_3','grade_4','grade_5','grade_6','grade_7','grade_8','grade_9','grade_10','grade_11','grade_12']

@app.route('/house_sails', methods=['POST'])

# BasicAuth
@auth.login_required

def housesails():
    if not request.json:
        abort(400)
    payload = request.json['data']
    values = [float(i) for i in payload.split(',')]
    data1 = pd.DataFrame([values], columns=headers, dtype=float)
    predict = model.predict(xgb.DMatrix(data1))
    return json.dumps(str(predict[0]))


if __name__ == "__main__":
    app.run(debug=True, port=5000)

HTMLからPOSTをしてJSONデータをAPIサーバーに送信する

HTMLファイルは、インターフェイスの部分はタグ内のinputタグなどで、データの入力フォームを作ります。その入力データをjavascriptで受け取って、整形し、JSON形式に変換して、Ajax通信でPOSTしています。通信が成功したら、APIサーバーからの予測値を受け取り、それをtextareaタグのエリア内に表示するという処理をしています。

index.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>HTMLファイルからPOSTでJSONデータを送信する</title>
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.0/jquery.min.js"></script>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.5.3/dist/css/bootstrap.min.css" integrity="sha384-TX8t27EcRE3e/ihU7zmQxVncDAy5uIKz4rEkgIXeMed4M0jlfIDPvg6uqKI2xXr2" crossorigin="anonymous">
</head>
<body>
    <div class="container">
    <h1>HTMLファイルからPOSTでJSONデータを送信する</h1>
    <div class="alert alert-primary" role="alert">
    <p>URL: <input type="text" id="url_post" name="url" class="form-control" size="100" value="http://localhost:5000/house_sails"></p>
    </div>
    <div class="d-flex bd-highlight">
    <div class="flex-fill bd-highlight alert alert-primary mr-3" role="alert">
    <p>sqft_living: <input type="number" id="value1" class="form-control" size="30" value=-1.026685></p>
    </div>

    <div class="flex-fill bd-highlight alert alert-primary mr-3" role="alert">
    <p>sqft_above: <input type="number" id="value2" class="form-control" size="30" value=-0.725963></p>
    </div>

    <div class="flex-fill bd-highlight alert alert-primary" role="alert">
    <p>sqft_basement: <input type="number" id="value3" class="form-control" size="30" value=-0.652987></p>
    </div>
    </div>

    <div class="d-flex bd-highlight">
    <div class="flex-fill bd-highlight alert alert-primary mr-3" role="alert">
    <p>lat: <input type="number" id="value4" class="form-control" size="30" value=-0.323607></p>
    </div>

    <div class="flex-fill bd-highlight alert alert-primary mr-3" role="alert">
    <p>long: <input type="number" id="value5" class="form-control" size="30" value=-0.307144></p>
    </div>

    <div class="flex-fill bd-highlight alert alert-primary" role="alert">
    <p>sqft_living15: <input type="number" id="value6" class="form-control" size="30" value=-0.946801></p>
    </div>
    </div>

    <div class="alert alert-primary" role="alert">
    <p>gradeを選択:
    <select name="grade" id="grade" class="form-control form-control-lg">
        <option value="grade1">grade1</option>
        <option value="grade2">grade2</option>
        <option value="grade3">grade3</option>
        <option value="grade4">grade4</option>
        <option value="grade5">grade5</option>
        <option value="grade6">grade6</option>
        <option value="grade7">grade7</option>
        <option value="grade8">grade8</option>
        <option value="grade9">grade9</option>
        <option value="grade10">grade10</option>
        <option value="grade11">grade11</option>
        <option value="grade12">grade12</option>
      </select>
    </p>
    </div>

    <p>usename: <input type="text" name="username" id="username" class="form-control" value="bitstudio"/></p>
    <p>password: <input type="password" name="password" id="password" class="form-control" value="hirayama"/></p>
    <p><button id="button" type="button" class="btn btn-primary">submit</button></p>
    <textarea id="response" class="form-control" cols=120 rows=4 disabled></textarea>
    <p><p>
</div>

</body>

<script type="text/javascript">

$(function(){

    $("#response").html("Response Values");

    $("#button").click( function(){
        let value07 = 0;
        let value08 = 0;
        let value09 = 0;
        let value10 = 0;
        let value11 = 0;
        let value12 = 0;
        let value13 = 0;
        let value14 = 0;
        let value15 = 0;
        let value16 = 0;
        let element = document.getElementById("grade");
        let grade01 = element.value;
        if (grade01 == "grade1") {
        value07 = 0;
        }else if (grade01 == "grade2") {
            value07 = 0;
        }else if (grade01 == "grade3") {
            value07 = 1;
        }else if (grade01 == "grade4") {
            value08 = 1;
        }else if (grade01 == "grade5") {
            value09 = 1;
        }else if (grade01 == "grade6") {
            value10 = 1;
        }else if (grade01 == "grade7") {
            value11 = 1;
        }else if (grade01 == "grade8") {
            value12 = 1;
        }else if (grade01 == "grade9") {
            value13 = 1;
        }else if (grade01 == "grade10") {
            value14 = 1;
        }else if (grade01 == "grade11") {
            value15 = 1;
        }else{
            value16 = 1;
        }
        var url = $("#url_post").val();
        var feature1 =
            $("#value1").val() + "," +
            $("#value2").val() + "," +
            $("#value3").val() + "," +
            $("#value4").val() + "," +
            $("#value5").val() + "," +
            $("#value6").val() + "," +
            value07 + "," +
            value08 + "," +
            value09 + "," +
            value10 + "," +
            value11 + "," +
            value12 + "," +
            value13 + "," +
            value14 + "," +
            value15 + "," +
            value16;

        var JSONdata = {
                data: feature1
            };

        alert(JSON.stringify(JSONdata));

        var username = $("input#username").val();
        var password = $("input#password").val();

        $.ajax({
            type: 'POST',
            url: url,
            //basic認証送信
            beforeSend: function(xhr){
            xhr.setRequestHeader('Authorization', 'Basic ' + btoa(username+':'+password));},
            data: JSON.stringify(JSONdata),
            contentType: 'application/JSON',
            dataType: 'JSON',
            scriptCharset: 'utf-8',
            success : function(data) {

                // Success
                alert("success");
                alert(JSON.stringify(JSONdata));
                $("#response").html(JSON.stringify(data));
            },
            error : function(data) {

                // Error
                alert("error");
                alert(JSON.stringify(JSONdata));
                $("#response").html(JSON.stringify(data));
            }
        });
    })
})
</script>

</html>