対象者

機械学習、ディープラーニングを一通り勉強したが、実装するときにどう関連するのかわからない人。
頭の中を整理したい人。
詳しい数学的な説明はしない。数学的な説明はchainerチュートリアルを参照すると良い。

ディープラーニングのモデルになったもの

ディープラーニングは人の神経細胞における情報伝達の仕組みを真似て作られた。これにより、精度が飛躍的に向上した。

ニューラルネットワークの仕組み

ニューロンのモデル化

ニューラルネットワークでは、人間の神経細胞の動きをコンピュータで再現した数式モデルを作る。個々の神経細胞は簡単な演算能力しか持たないが、お互いに繋がり連動することで高度な認識、判断をすることができる。行列や特別な関数の計算をしながら情報伝達の仕組みを数式で再現していく。

ニューロンのモデル

ニューロンには多入力、1出力である。ニューラルネットワークの一つの層は複数のニューロンからなる。
重み:各入力に掛け合わせる係数。シナプスにおける伝達効率に相当し、値が大きいほど多くの情報が伝わる。学習中は自動更新されるので初期値しかいじらない。
バイアス:入力と重みをかけ合わせたものの総和に足す定数。ニューロンの興奮しやすさを調整するためのもの。学習中は自動更新されるので初期値しかいじらない。
活性化関数:ニューロンの興奮状態を表す関数。活性化関数がないとニューロンの演算は単なる積の総和になってしまい、ニューラルネットワークから複雑な表現をする力が失われてしまう。シグモイド関数やLeRUなど様々な関数があり、扱う問題によってある程度最適な関数が決まっている。各層毎に自分で選ぶ必要あり。関数の説明は活性化関数の種類参照。
ちなみに記号としてwは重み、bはバイアスとして表される。

(蛇足) 画像認識ライブラリのyoloは、学習済み(重みやバイアスや層数などが自動調整済み)のwightファイルをインポートすると直ぐに認識ができるようになる。ただし、学習した環境を考慮しないと間違った認識をしたり、追加で学習させても上手く収束しなかったりする。例えばこの記事にあるように、アメリカで学んだ学習モデルだと「寿司」を「hotdog」と認識される。言い換えるなら育った環境(データセット)で性格(計算結果)が変わるとも言える。

ニューロンのネットワーク化(ニューラルネットワーク)

ニューロンを複数接続してネットワーク化することでニューラルネットワークが構築される。(x、ｖ、ｙがニューロン) 図のような層状に並べる。

図 ニューラルネットワークのモデル　　　　　　　　　　　　(pythonで始める機械学習から引用)

ニューラルネットワークにおける層は、入力層、中間層、出力層に分類される。入力層と出力層は1つしか無いが、中間層は増やすことができる。中間層を増やすことによって計算の振る舞いが変わるので調整する必要がある。
通常のニューラルネットワークは、1つのニューロンからの出力が、次の層の全てのニューロンの入力とつながっている。
入力から出力に向けて情報が伝わることを順伝播。
出力から入力に向けて情報が遡っていくことを逆伝播という。逆伝播は出力結果を遡って重みとバイアスを更新するときに行われるもの。通常は自動的に行われるので、調整パラメータと仕組を知っておけば十分使えるレベルになる。
出力された値はデータセットの正解ラベルと比較して誤差が計算され、正解ラベルに近づくように重みとバイアスが自動調整される。

ニューラルネットワークで扱う2つの問題

ニューラルネットワークで扱う問題は、分類問題と回帰問題に分けられる。

ニューラルネットワークの種類

全結合型:「図 ニューラルネットワークのモデル」のように層間の全てのニューロンが接続されているもの。
畳み込み型:画像処理の分野でよく使われる。画像に対して畳み込みを行うことで、画像にある特徴を強めたり弱めたりすることができる。
再帰型:文脈を扱うことができるニューラルネットワークの一種。自然言語処理や系列データによく用いられる。

回帰

回帰問題とは、データの傾向から連続的な数値を予測するもの。基本的な使い方として離散データを集めてそのデータから近似関数を作成させ、未知のデータの予測値を算出するもの。
主な例として
・身長から体重を予測する
・ユーザーの買い物傾向から次に購入するものを予測する
・これまでの株価の傾向から明日の株価を予測する
・物件の情報から家賃を予測する

単回帰

一つの入力から1つの結果を予測するもの。身長から体重など2つの関係性を表す場合に使われる。

重回帰

物件の様々な情報から家賃を予測するなど多入力のものから1つの結果を予測するもの。こちらのほうがよく使われる。

分類

分類問題とは、データを決められた複数の枠に分類する問題のこと。回帰問題と違い出力が複数ある。出力がそのまま分類したものの確率を表している。
主な例として
・葉の画像から植物を分類する
・手書きの文字を分類する
・画像に映る乗り物が何かを判定する

実際に学習させる場合の流れ

1 データセットの準備

データセットとは

学習データxと正解ラベルyが1セットになったデータ群である。データセットは更に訓練データとテストデータに分かれる。訓練データはネットワークの学習に用いるが、テストデータは訓練データから作成したモデルの性能を評価するのに用いる。通常、訓練データはテストデータよりも数を多くする。
学習データにより学習したネットワークがテストデータでも良い結果を出せば、ネットワークが未知のデータにも対応できていることになる。テストデータで良い結果が出なければ、ネットワーク自体や学習方法に何らかの問題があることになる。ネットワークが未知のデータにも対応できる能力を汎化性能と呼ぶ。

データの集め方

学習データは手作業か、スクレイピングで自動で集める。集めるのは自動やることもできるが、ふさわしいデータかどうかは手作業で見極めるので一番大変な作業である。データの集め方はこちらの記事が参考になる。

データセットの作り方

データセットは手作業で作るか、ライブラリを使う。「データセット　作り方」とか検索すれば出てくる。画像の場合はアノテーションツールを使って作成する。ユーザーの多くの時間はこのデータセットの作成に費やされている。
適切な結果を得るためには、画像だったら通常何千枚単位の枚数が必要だが、集めることは困難なので水増しを行うのが普通。

データセットの構造

データセットの学習データと正解ラベルはそれぞれベクトルになっている。
例えば身長の正解ラベルは、以下のような数値が並んだベクトルで表される。
[146.2 170.4 169.3 154.5 179.2]　
この場合は、出力層に5個のニューロンがあり、それぞれの出力値が正解値に近づくようにバイアスと重みの勾配が調整される。
分類問題の場合は、正解ラベルは以下のように、正解が1で正解以外が全て0のベクトルになっている。
[0 0 1 0 0]
このように1が1つで残りが0の数値の並びを、one-hot表現という。

データの整形

学習がしやすい形式に整形する。

2 パラメータの初期値の設定

学習に入る前に重みとバイアスの初期値の設定し、中間層と出力層それぞれの活性化関数を設定する。また、損失関数も設定する。
活性化関数の種類についてはやっぱりよくわからない活性化関数とはが参考になる。

3 ハイパーパラメータの調整

以下の4つの値を設定する。これらはテストデータで評価した出力によってユーザーが何度も調整する。それぞれの説明はこちら
・エポック
・バッチサイズ
・学習係数
・最適化アルゴリズム

4 学習

学習はニューロン同士の結びつきを調整していく過程だ。学習は以下の3つの過程を経る。

4.1 正解との誤差の導出

誤差を導出するために損失関数を用いる。

4.2 勾配の導出

勾配を求めるためには勾配降下法を用いる。出てきた損失関数$L$を$w$で偏微分して勾配$\frac{∂L}{∂w}$が得られる。

(引用:chaierチュートリアル)

4.3 バックプロパゲーション(逆伝播)

順伝播により得られた出力と、予め用意した正解との誤差を1層ずづ逆向きに伝播させる。伝播した誤差をもとに各層で重みとバイアスの更新量を求める。更新後の重みは以下のように求められる。

w←w−η\frac{∂L}{∂w}

ディープラーニングの多層化による問題

局所最適解へのトラップ

勾配を求める際に局所的な最適解に囚われてしまい、全体の最適解にたどり着けなくなる問題。場合によっては勾配が極端に減少してしまい、学習が進まなくなる問題もある。全体で最適な解を見つけるためには一度局所的にベストな状態を離れる必要がある。

(引用:chainerチュートリアル)

過学習

ニューラルネットワークがある特定の範囲のデータのみに最適化されて学習し、未知のデータに対応できなくなってしまうこと。機械学習においては、訓練データに過剰に適合するあまり未知の入力データに対応して推定することができなくなってしまうことでもある。特定のパターンのみ最適化された局所最適解に陥っている状態ともいえる。いろいろなデータに対応できるように、生成されるネットワークは少しいい加減さがあるほうがよい。この過学習を抑制するために後述する様々なパラメータをユーザーが調整していく。
中間層やニューロンの数が多すぎると表現力の過剰により過学習が発生する。また、訓練データのサンプル数不足により発生することもある。

勾配消失

主に活性化関数にシグモイド関数を使うことで起きる問題。シグモイド関数の勾配は最大値が0.25で0から離れるほど0に近づく。逆伝搬する際は、層を遡るごとに活性化関数の微分を各勾配にかけることになる。シグモイド関数の場合、層を遡る毎に各勾配が小さくなっていき勾配消失が発生する。そのため、ディープラーニングでは活性化関数にはReLUを使うことが多い。

学習に時間がかかる

多層のディープラーニングでは、重みとバイアスの数が膨大になる。そのため、学習には数日、数週間かかることもある。この問題に対処するためにはGPUを使う、スペックの高いマシンを使う、必要以上にネットワークを複雑にしないこと、パラメータを調整するなどがある。

ユーザーが調整するパラメータ

多層化に伴う問題は、機械が自動で調整することができないので、ユーザーが結果に合わせて調整する必要がある。そのため、より良い結果を得るために何度も調整と学習を繰り返さなくてはならない。調整する項目としては以下の7つがある。どれをどう調整するかはある程度の経験が必要になってくる。よく調整するのはハイパーパラメータ、データの拡張、データの前処理だ。

1 ハイパーパラメータ

エポック

全ての訓練データを1回学習することを1エポックと数える。

バッチサイズ

データセットをいくつかのサブセットに分けた際のそれぞれに含まれるデータ数のことを言う。学習時間やパフォーマンスに影響するパラメータ。詳しくはこちらの説明が参考になる。

学習係数

勾配降下法の勾配にかける係数。これで勾配の量を調整することができる。学習係数が大きすぎると繰り返しパラメータ更新を行っていく中で損失関数の値が振動したり、発散したりしてしまう。逆に小さすぎると、収束に時間がかかってしまう。この値は最適な値は決まっていないため、経験的に探す必要がある。

最適化アルゴリズム

勾配降下法では、勾配をもとに重みとバイアスを少しずつ調整し、誤差が最小になるようにネットワークを最適化する。この最適化の際に様々なアルゴリズムが存在する。各アルゴリズムの説明はこちら

2 重みとバイアスの初期値

学習の成否に関わる大事なハイパーパラメータ。ある程度小さな値でランダムにばらつきを持たせることが望ましい。

3 早期終了

学習を途中で打ち切る手法。学習を進めるとテストデータの誤差が途中から増加し、過学習になってしまうことがあるので、その前に学習を終了させる。誤差が停滞し学習が進まなくなった場合も、時間短縮のために終了させる。

4 データの拡張

訓練データのサンプル数が少ないと、過学習が起きやすくなる。その場合、サンプルの水増しを行って対処するのが一般的。様々なタイプのサンプルを学習させることでネットワークの汎化性能の向上に役立つ。この記事では実際に画像を学習させた際にサンプル不足で過学習に陥っている様子が書かれてるので参考に。

5 データの前処理

入力データに対して予め処理を施して扱いやすくしておくこと。前処理を行うことでネットワークの性能向上や学習の高速化が望める。機械学習の多くの時間がこれに費やされることになる。
pythonを使っている場合は「pandas」というライブラリを使うと簡単に前処理ができる。
前処理の種類には正規化や標準化など様々ある。やり方はこの記事が参考になる。

6 ドロップアウト

過学習抑制テクニック。出力層以外のニューロンを一定の確率でランダムに消去するテクニック。規模の大きなネットワークほど過学習を起こしやすいので、ドロップアウトを用いることでネットワークの規模を下げることができる。

7 正則化

重みに制限を与えること。重みに制限を与えることで重みが極端な値をとり、局所最適解にトラップされることを防ぐ。

活性化関数の種類

LeRU

0以下の入力で出力が0。0より上の入力で入力と同じ出力をする関数。分類問題によく使われる。分類問題では0以下の入力は取りえないため、ノイズ除去のために使われることが多い。プログラムで実装する場合は、if文で0以下を切り捨てる処理をすれば実装できる。

シグモイド関数

入力値が大きくなると一定の値に収束するため、入力が大きなものには使われない。

(wikipedia)

ソフトマックス関数

分類問題を扱うのに適した関数。分類問題の出力層によく用いられる。この関数のK=1からnまでの全ての出力を足し合わせると1になる。そのため、ソフトマックス関数は複数の入力値からなるベクトルXがいかなる値を取ろうとも全出力の合計が1になるように正規化する性質を持つ。そのため、出力層のニューロンの出力値の合計を1として扱う分類問題と相性が良い。

y=\frac{e^{x}}{\sum_{k=1}^{N}e^{x_k}}

恒等関数

入力をそのまま出力として返す関数。回帰問題の出力層の活性化関数としてよく用いられる。

損失関数一覧

平均二乗誤差

回帰問題をときたいときによく用いられる損失関数。

L= \frac{1}{N}\sum_{n=1}^{N}(t_n-y_n)^2

交差エントロピー誤差

分類問題をときたい際によく用いられる損失関数。利点は出力と正解値との隔離が大きいときに学習速度が早い点。

L=\sum_{k=1}^{K}t_k(-\log(y_k))

最適化アルゴリズム一覧

以下では代表的なものをメモしている。他の最適化アルゴリズムについてはこちらを参考に。

SGD(確率的勾配降下法)

更新毎にランダムにサンプルを呼び出すアルゴリズム。局所的最適解に囚われにくいという特徴を持つ。簡単なコードで実装できるが、学習の進行に応じて更新量の調整ができないため、学習に時間がかかることが多い。

AdaGard

更新量が自動的に調整される。学習が進むと次第に学習率が小さくなっていく。設定すべき定数が学習係数しかないため、調整に手間がかからない。

RMSProp

AdaGardの、更新量の低下により学習が停滞する弱点を克服したもの。

Adam

RMSpropを改良したもの。最もよく使われているらしい。

参考

チェイナーチュートリアル
pythonで始める機械学習入門
はじめてのディープラーニング　Pythonで学ぶニューラルネットワークとバックプロパゲーション
キカガク ディープラーニングの基礎
https://www.sbbit.jp/article/cont1/33345
https://qiita.com/nishiy-k/items/1e795f92a99422d4ba7b
https://qiita.com/Lickey/items/b97c3450d7def207bfbf

概要

海外ではエンジニアの面接においてコーディングテストというものが行われるらしく、多くの場合、特定の関数やクラスをお題に沿って実装するという物がメインである。

その対策としてLeetCodeなるサイトで対策を行うようだ。

早い話が本場でも行われているようなコーディングテストに耐えうるようなアルゴリズム力を鍛えるサイト。

せっかくだし人並みのアルゴリズム力くらいは持っておいた方がいいだろうということで不定期に問題を解いてその時に考えたやり方をメモ的に書いていこうかと思います。

Leetcode

ゼロから始めるLeetCode 目次

前回
ゼロから始めるLeetCode Day33「1. Two Sum」

基本的にeasyのacceptanceが高い順から解いていこうかと思います。

Twitterやってます。

問題

118. Pascal's Triangle

偶然YouTubeでこの問題をJavaで解いてるのを見たので私も解いてみようと思いました。

難易度はEasyです！

問題としては、自然数であるnumRowsが与えられるので、例のようなパスカルの三角形を作ってください、という問題です。

Input: 5
Output:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

解説

最初と最後に1を入れることは確定しているので、予め1を挿入した状態を用意してあげて、処理の最後に再び1をappendしてあげれば良さそうです。
問題はどういう風に上位の数字の和を計算し、挿入するかについてですが、forループを二重に回せば二つ分の要素を取得し、足すことが出来そうですね。
なお、今回はnumRowsが0と1の場合は例外として除外するような書き方をしました。
こうすることで、3段目からの処理のみを書けば良いのでより読みやすいと思います。

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        if numRows == 0:
            return []
        elif numRows == 1:
            return [[1]]

        triangle = [[1]]

        for i in range(1,numRows):
            row = [1]

            for j in range(1,i):
                row.append(triangle[i-1][j-1] + triangle[i-1][j])

            row.append(1)
            triangle.append(row)

        return triangle
# Runtime: 28 ms, faster than 73.84% of Python3 online submissions for Pascal's Triangle.
# Memory Usage: 13.8 MB, less than 7.14% of Python3 online submissions for Pascal's Triangle.

はい、こんな感じになりました。

こっちの書き方の方が良いよ！とかこの言語で書いてみたよ！とかがあれば是非コメントしてみてください。

高知に行きたくても行けないので勝手にやりました
https://script.google.com/macros/s/AKfycbzRJCvOuWC5uMFiqhl5soiLHnWbkGE5P-GAkxFmVT08u_3E2hRi/exec

あしたの分も買うちょくきね。～飲食券先買い応援プロジェクト～「参加店舗」
https://www.kochinews.co.jp/norikoeyo/asukau_eatery/
この店舗一覧をgoogle map上のマーカーでわかるようにしました

構成

• フロントはgoogle app script
• フロントからAPI Gateway+LambdaのAPIを呼び店舗情報を取得
• 店舗データはDynamoDBに保存

という完全サーバレスです

まずは店舗一覧のデータ作成

https://www.kochinews.co.jp/norikoeyo/asukau_eatery/
このサイトをスクレイピングするlambdaを書きます（python）
座標取得するため、googleのAPIキーも事前に取得しておきました

import requests
import re
import googlemaps
import time
import boto3

def lambda_handler(event, context):
    dynamo_db = boto3.resource('dynamodb')
    table = dynamo_db.Table('kouchi_shop')

    gmaps = googlemaps.Client(key=API_KEY)

    response = requests.get('https://www.kochinews.co.jp/norikoeyo/asukau_eatery/')
    response.encoding = response.apparent_encoding

    text = response.text.replace('\n', '')
    regex = r'<b>(\d+)(.*?)<\/b>\s*<br>(.*?)<br>'
    result = re.findall(regex, text)

    if result:
        for data in result:
            if not data[0]:
                continue
            number = data[0]
            shop_name = data[1].strip()
            href_result = re.findall(r'<a href=\"(.*?)\"', data[2])
            shop_address = re.sub(r'<a.*<\/a>', '', data[2]).strip()
            url = href_result[0] if href_result else ''
            # 座標取得
            geo_result = gmaps.geocode(shop_address)

            item = {
                'id': int(number),
                'name': shop_name,
                'address': shop_address,
                'url': url,
                'lat': str(geo_result[0]["geometry"]["location"]["lat"]),
                'lng': str(geo_result[0]["geometry"]["location"]["lng"])
            }
            print(item)
            table.put_item(Item=item)
            # 念のため連続でリクエストしないようにsleepを入れておく
            time.sleep(0.5)

    return {
        'statusCode': 200
    }

適当に一回実行してDynamoDBに店舗データを保存させます

beautifulsoupとかは使ってません（DOMの構造上あんまり意味なかったので）
ライブラリのインストールについてはこちらを参考にさせていただきました
https://tech.bita.jp/article/38

店舗一覧を取得するAPIを作る

これもLambdaで書いて、トリガーをAPI Gatewayにします

import json
import boto3
from decimal import Decimal

def lambda_handler(event, context):
    dynamo_db = boto3.resource('dynamodb')
    table = dynamo_db.Table('kouchi_shop')

    return {
        'statusCode': 200,
        'body': json.dumps(table.scan(), default=decimal_default_proc)
    }

def decimal_default_proc(obj):
    if isinstance(obj, Decimal):
        return str(obj)
    raise TypeError

特に絞り込みとかしないのでscan()で全件取得してるだけです
bodyは連想配列のままだとAPIリクエストしたときに{"message":"Internal Server Error"}が出るので必ずjson.dumpsが必要でした（これでちょっと嵌った）

あと、jsonに小数点があるとjsonエンコードでエラーになるのでdecimal_default_procで文字列にキャストしてます（letとlngが小数点）
https://qiita.com/ekzemplaro/items/5fa8900212252ab554a3
こちらを参考にさせていただきました

フロント作成

google app scriptでhtmlを作成し、店舗一覧取得APIからマーカーを設置します

<script>
  var marker = [];
  var info_window = [];

  function init_map () {
    // 初期表示の中心
    var map = new google.maps.Map(document.getElementById('map'), {
      center: {
           lat: 33.561067,
           lng: 133.531465
      },
      zoom: 15
    });

    get_shop(map)
  }

  function marker_event(i) {
    marker[i].addListener('click', function() {
      info_window[i].open(map, marker[i]);
    });
  }

  function set_marker(items, map) {
    for (var i = 0; i < items.length; i++) {        
      // マーカーの設置
      marker[i] = new google.maps.Marker({
        position: {
          lat: parseFloat(items[i]['lat']),
          lng: parseFloat(items[i]['lng'])
        },
        map: map
      });

      // マーカーをクリックした際のポップアップ
      var text = '[' + String(items[i]['id']) + '] ' + items[i]['name'] + '<br>' + items[i]['address'];
      if (items[i]['url']) {
        text += '<br><a href="' + items[i]['url'] + '" target="_blank">' + items[i]['url'] + '</a>';
      }
      info_window[i] = new google.maps.InfoWindow({
        content: text
      });
      marker_event(i);
    }
  }

  function get_shop(map) {
    var req = new XMLHttpRequest();
    req.onreadystatechange = function() {
      if (req.readyState == 4 && req.status === 200) {
        const obj = JSON.parse(req.responseText);
        set_marker(obj['Items'], map)
      }
    }
    req.open('GET', '店舗一覧取得API');
    req.send();
  }
</script>
<script src="https://maps.googleapis.com/maps/api/js?key=API_KEY&callback=init_map"></script>

フロント作成については以下を参考にさせていただきました
https://tonari-it.com/gas-button-event-javascript/
https://www.tam-tam.co.jp/tipsnote/javascript/post7755.html
https://webdesignday.jp/inspiration/technique/css/4213/

最後に

ここ最近毎年高知に行っていて、好きな土地の一つでもあります
早く高知に行けるようになって欲しいです

また、「あしたの分も買うちょくきね。～飲食券先買い応援プロジェクト～「参加店舗」」と私はまったくの無関係です
問題があるようでしたら即刻削除致します

高知に行きたくても行けないので勝手にやりました
https://script.google.com/macros/s/AKfycbzRJCvOuWC5uMFiqhl5soiLHnWbkGE5P-GAkxFmVT08u_3E2hRi/exec

あしたの分も買うちょくきね。～飲食券先買い応援プロジェクト～「参加店舗」
https://www.kochinews.co.jp/norikoeyo/asukau_eatery/
この店舗一覧をgoogle map上のマーカーでわかるようにしました

構成

• フロントはgoogle app script
• フロントからAPI Gateway+LambdaのAPIを呼び店舗情報を取得
• 店舗データはDynamoDBに保存

という完全サーバレスです

まずは店舗一覧のデータ作成

https://www.kochinews.co.jp/norikoeyo/asukau_eatery/
このサイトをスクレイピングするlambdaを書きます（python）
座標取得するため、googleのAPIキーも事前に取得しておきました

import requests
import re
import googlemaps
import time
import boto3

def lambda_handler(event, context):
    dynamo_db = boto3.resource('dynamodb')
    table = dynamo_db.Table('kouchi_shop')

    gmaps = googlemaps.Client(key=API_KEY)

    response = requests.get('https://www.kochinews.co.jp/norikoeyo/asukau_eatery/')
    response.encoding = response.apparent_encoding

    text = response.text.replace('\n', '')
    regex = r'<b>(\d+)(.*?)<\/b>\s*<br>(.*?)<br>'
    result = re.findall(regex, text)

    if result:
        for data in result:
            if not data[0]:
                continue
            number = data[0]
            shop_name = data[1].strip()
            href_result = re.findall(r'<a href=\"(.*?)\"', data[2])
            shop_address = re.sub(r'<a.*<\/a>', '', data[2]).strip()
            url = href_result[0] if href_result else ''
            # 座標取得
            geo_result = gmaps.geocode(shop_address)

            item = {
                'id': int(number),
                'name': shop_name,
                'address': shop_address,
                'url': url,
                'lat': str(geo_result[0]["geometry"]["location"]["lat"]),
                'lng': str(geo_result[0]["geometry"]["location"]["lng"])
            }
            print(item)
            table.put_item(Item=item)
            # 念のため連続でリクエストしないようにsleepを入れておく
            time.sleep(0.5)

    return {
        'statusCode': 200
    }

適当に一回実行してDynamoDBに店舗データを保存させます

beautifulsoupとかは使ってません（DOMの構造上あんまり意味なかったので）
ライブラリのインストールについてはこちらを参考にさせていただきました
https://tech.bita.jp/article/38

店舗一覧を取得するAPIを作る

これもLambdaで書いて、トリガーをAPI Gatewayにします

import json
import boto3
from decimal import Decimal

def lambda_handler(event, context):
    dynamo_db = boto3.resource('dynamodb')
    table = dynamo_db.Table('kouchi_shop')

    return {
        'statusCode': 200,
        'body': json.dumps(table.scan(), default=decimal_default_proc)
    }

def decimal_default_proc(obj):
    if isinstance(obj, Decimal):
        return str(obj)
    raise TypeError

特に絞り込みとかしないのでscan()で全件取得してるだけです
bodyは連想配列のままだとAPIリクエストしたときに{"message":"Internal Server Error"}が出るので必ずjson.dumpsが必要でした（これでちょっと嵌った）

あと、jsonに小数点があるとjsonエンコードでエラーになるのでdecimal_default_procで文字列にキャストしてます（letとlngが小数点）
https://qiita.com/ekzemplaro/items/5fa8900212252ab554a3
こちらを参考にさせていただきました

フロント作成

google app scriptでhtmlを作成し、店舗一覧取得APIからマーカーを設置します

<script>
  var marker = [];
  var info_window = [];

  function init_map () {
    // 初期表示の中心
    var map = new google.maps.Map(document.getElementById('map'), {
      center: {
           lat: 33.561067,
           lng: 133.531465
      },
      zoom: 15
    });

    get_shop(map)
  }

  function marker_event(i) {
    marker[i].addListener('click', function() {
      info_window[i].open(map, marker[i]);
    });
  }

  function set_marker(items, map) {
    for (var i = 0; i < items.length; i++) {        
      // マーカーの設置
      marker[i] = new google.maps.Marker({
        position: {
          lat: parseFloat(items[i]['lat']),
          lng: parseFloat(items[i]['lng'])
        },
        map: map
      });

      // マーカーをクリックした際のポップアップ
      var text = '[' + String(items[i]['id']) + '] ' + items[i]['name'] + '<br>' + items[i]['address'];
      if (items[i]['url']) {
        text += '<br><a href="' + items[i]['url'] + '" target="_blank">' + items[i]['url'] + '</a>';
      }
      info_window[i] = new google.maps.InfoWindow({
        content: text
      });
      marker_event(i);
    }
  }

  function get_shop(map) {
    var req = new XMLHttpRequest();
    req.onreadystatechange = function() {
      if (req.readyState == 4 && req.status === 200) {
        const obj = JSON.parse(req.responseText);
        set_marker(obj['Items'], map)
      }
    }
    req.open('GET', '店舗一覧取得API');
    req.send();
  }
</script>
<script src="https://maps.googleapis.com/maps/api/js?key=API_KEY&callback=init_map"></script>

フロント作成については以下を参考にさせていただきました
https://tonari-it.com/gas-button-event-javascript/
https://www.tam-tam.co.jp/tipsnote/javascript/post7755.html
https://webdesignday.jp/inspiration/technique/css/4213/

最後に

ここ最近毎年高知に行っていて、好きな土地の一つでもあります
早く高知に行けるようになって欲しいです

また、「あしたの分も買うちょくきね。～飲食券先買い応援プロジェクト～「参加店舗」」と私はまったくの無関係です
問題があるようでしたら即刻削除致します

概要

皆様，いかがお過ごしでしょうか．
コロナウイルス感染症の拡大に伴い，自宅でお仕事や研究をされている方も多いのではないでしょうか．
かくいう私も，ここ数か月はずっと自宅でPCとにらめっこの毎日です．さすがに疲れましたね笑

さて，今回は，生成モデルを活用した再構成タスクに着目してみたいと思います．
特に，「動画」の再構成にトライします．
（当記事でご理解いただけるのは，動画の異常検知に拡張可能な，encoder-decoderベースの時系列モデルをかませた再構成手法の実験結果と考察であり，数式などの理論的背景までは追いません．）

巷でよく，「異常検知」分野などに応用されているのは，「画像」の再構成ですね．
画像をencoder-decoderモデルに入力して再構成し，入出力間の差分をとることで異常度を計算する手法です．
画像の再構成に活用できる生成モデルとして，VAEは特に有名ですし，最近ではGANを活用した異常検知手法(AnoGAN，EfficientGANなど)なんかも登場しています．以下はAnoGANの例です．

上記画像はこちらから引用

しかしなぜか，「動画」の再構成となると，全然研究の事例が見つからないのです．
（動画「生成」の事例は，GANを活用した手法が散見されますが．）

画像の異常検知技術は，産業応用などですさまじく世の中で普及しているかと思います．動画像もそれなりに需要があると思うのですが，あまり発展していないのですかね．

もちろん動画の異常検知，「再構成」にこだわらなければ昔からいろいろとありますね．
（昔ながらの，ST-Patch特徴量などからSVMを用いてクラス分類するなど）

しかし，これだけDeepLearningが普及した世の中です．動画の再構成もできるでしょう！
今回は，時系列モデルであるGRUと，encoder-decoderモデルを組み合わせて，動画再構成モデルを実装します．なお，コードはすべてこちらで公開しております．

動画再構成モデル

今回実装するモデルを以下に示します．

$\boldsymbol{x_1,x_2,...,x_T}$は，Tの長さを持つ動画を意味し，$\boldsymbol{x_t}$は各frameです．
encoderは各frameの画像を受け取り，$\boldsymbol{z}$へと写像します．これをT回繰り返すことで，入力の動画に対応する系列長の潜在変数，$\boldsymbol{Z_1,Z_2,...,Z_T}$を得ます．
この潜在変数を，GRUを用いてモデル化します．各tにおける出力が，$\boldsymbol{\hat{z_t}}$に対応します．あとはこれを用いて，decoderにより観測空間へ写像するという手順になります．

動画像再構成タスクの鉄板がよくわからないので，上記のようなモデルが厳密な数学的正しさを保証できているかというと全く自信はありませんが，とりわけ優秀かどうかは置いといて，一応動画の再構成は可能です．

ここで一点補足ですが，なぜ動画像を潜在空間上の一点に符号化しないかという点についてです．
通常のencoder-decoderモデルでは，入力画像を潜在変数をただ一点に符号化しています．動画像に拡張する場合もこれに倣おうかと考えたのですが，ちょうど研究でGAN系の論文のサーベイを実施する中で，動画像を潜在空間上の一点に対応するのはやりすぎという議論があったのを発見しました．

これには私も同意で，というのも過去の経験則的に言えます．以前，Kerasを用いて動画像の再構成にトライしたのですが，上記のやり方では思うような成果が挙げられませんでした．

そこで今回は，その反省を生かして，系列の潜在変数を扱うことを考え，上記のようなモデルを定義するに至りました．

モデルの学習・検証

再構成の流れとしては、以下の通りです。

1. human action datasetを用意する
2. GRU-AEで学習を行う
3. 学習済みモデルを使って、動画の再構成を行う

1.human action dataset

こちらのデータは，MocoGANと呼ばれる動画の生成モデルで検証に用いられていたもので，（初出は知りませんが）その名の通り，人が歩いたり手を振ったりしている様子を収めたものとなっています．

こちらからダウンロードできます．（上記画像も，こちらのリンクにあるデータからの引用です．）

2. GRU-AEによる学習

続いて，上記のデータを用いてモデルを学習します．
損失関数はMSEで，当然ですが入出力間の誤差を最小化します．
モデルの詳細に関しては，こちらの実装コード(PyTorchで実装)をご覧ください．

学習は10,000itr回し，lossは以下のように推移しました．後半ほぼ0となってしまい，あまり変化がわかりませんが，無事収束している印象です．

3.モデルによる動画の再構成

モデルを用いて推論を行います．上記の実装では，引数で指定したcheck point毎に再構成結果をlogsフォルダの中のgenerated_videosに保存していきます．
学習に連れて，以下のような挙動を示しました．各itr上段が入力，下段が出力です．

• 0 itr目　
  当然ながら全く再構成できません．
  
  

• 1,000 itr目
  ぼやけてはいますが，人の形ができています．
  
  

• 5,000 itr目
  5,000回ともなると，動きもよく再現されております．
  
  

• 9,000 itr目
  サンプルが微妙ですが，ほぼ完全に近い形での再構成が可能となった印象です．
  
  

まとめ

今回は，GRU-AEを用いて動画像の再構成に挑戦しました．
シンプルなモデルですが，ポイントは潜在変数を時系列で扱っている点です．
本手法を用いて，異常検知などへの拡張も期待できそうですね．
しかし，正直なところ，最近はやっているのはGANと比較すると，新規性としてどうなの？というところです．
さらに，GANから再構成される画像なんかと比較すると，正直見劣りする（ぼやけているところがある）のは否めません．
（以前私の記事でも，VAEGANを紹介しました）
しかしシンプルな手法で手軽ではあるので，是非とも使用してみていただければ幸いです．

ツイートの取得

概要

株式投資において投資判断としてテクニカル分析とファンダメンタルズ分析の二つの方法があります。
今回扱うのはテクニカル分析の方です。

Twitterを用いた日経平均株価の予測を行います。まず、大まかな流れを説明します。

1,TwitterAPIを用いてTwitterからあるアカウントの過去のツイートを取得します。
2,極性辞書を用いて日毎のツイートの感情分析をします。
3,日経平均株価の時系列データを取得します。
4,日毎のsentimentから次の日の株価の上下の予測を機械学習を用いて行います。

アクセストークン

Twitteからツイートを取得する際にアクセストークンというものが必要となります。
これは、ユーザーアカウントにおけるIDとPASSのように

「Access Token Key」「Access Token Secret」という2種類の文字列を指します。
ここではある単語を含むツイートを取得します。

import time
from requests_oauthlib import OAuth1Session
import json
import datetime, time, sys

CK = 'AxH3XJGIeqsz8IcnROFYhMIxq'                             # Consumer Key
CS = 'RdJRXRvVTncJ9K0I0aEUZr34NLi9E2lT3p3tHqQOqMUSLu8wwg'         # Consumer Secret
AT = '728488434826772481-158c2BioeYhEDOQoIuiYzq1xxgv2VtV' # Access Token
AS = 'H5TrpQnd86JXCq9gPxnxk2CsTZYLYhzhEo4dtD3hajqh5'         # Accesss Token Secert

session = OAuth1Session(CK, CS, AT, AS)

url = 'https://api.twitter.com/1.1/search/tweets.json'
res = session.get(url, params = {'q':u'python', 'count':100})
res_text = json.loads(res.text)
for tweet in res_text['statuses']:
    print ('-----')
    print (tweet['created_at'])
    print (tweet['text'])

人工知能を含むツイートの取得がこちら

import time
from requests_oauthlib import OAuth1Session
import json
import datetime, time, sys

CK = 'AxH3XJGIeqsz8IcnROFYhMIxq'                             # Consumer Key
CS = 'RdJRXRvVTncJ9K0I0aEUZr34NLi9E2lT3p3tHqQOqMUSLu8wwg'         # Consumer Secret
AT = '728488434826772481-158c2BioeYhEDOQoIuiYzq1xxgv2VtV' # Access Token
AS = 'H5TrpQnd86JXCq9gPxnxk2CsTZYLYhzhEo4dtD3hajqh5'         # Accesss Token Secert

session = OAuth1Session(CK, CS, AT, AS)

url = 'https://api.twitter.com/1.1/search/tweets.json'
res = session.get(url, params = {'q':u'人工知能', 'count':100})
res_text = json.loads(res.text)
for tweet in res_text['statuses']:
    print ('-----')
    print (tweet['created_at'])
    print (tweet['text'])

アカウントのツイートを取得

日経産業新聞のツイートを取得してみます。

import tweepy
import csv

consumer_key = "AxH3XJGIeqsz8IcnROFYhMIxq"
consumer_secret = "RdJRXRvVTncJ9K0I0aEUZr34NLi9E2lT3p3tHqQOqMUSLu8wwg"
access_key = "728488434826772481-158c2BioeYhEDOQoIuiYzq1xxgv2VtV"
access_secret = "H5TrpQnd86JXCq9gPxnxk2CsTZYLYhzhEo4dtD3hajqh5"

auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
api = tweepy.API(auth)

#ツイート取得
tweet_data = []

tweets = tweepy.Cursor(api.user_timeline,screen_name = "@nikkei_bizdaily",exclude_replies = True)
for tweet in tweets.items():
    tweet_data.append([tweet.id,tweet.created_at,tweet.text.replace('\n',''),tweet.favorite_count,tweet.retweet_count])
tweet_data

csvデータとして保存

#  tweets.csvという名前でdataフォルダ内に保存
with open('./6050_stock_price_prediction_data/tweets.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f, lineterminator='\n')
    writer.writerow(["id", "text", "created_at", "fav", "RT"])
    writer.writerows(tweet_data)

感情分析

感情分析その1

感情分析とは自然言語処理を用いて、テキストがポジティブな意味合い
またはネガティブな意味合いを持つかを判断する技術のことです。

商品のレビューを感情分析することで
マーケティングやカスタマーサポートなど幅広く利用されています。

感情分析の主な仕組みは文中に出現する単語が
ポジティブ・ネガティブ・ニュートラルな意味合いを持つかどうかで判断します。

判断の基準となるものに極性辞書があり
あらかじめ形態素にポジティブかネガティブが定義された辞書中に定義されています。

文書中の各単語を極性辞書を参照することで、感情分析を行います。
それではまずMeCabを用いて形態素解析をします。

import MeCab
import re
# MeCabインスタンスの作成．引数を無指定にするとIPA辞書になります．
m = MeCab.Tagger('')

# テキストを形態素解析し辞書のリストを返す関数
def get_diclist(text):
    parsed = m.parse(text)      # 形態素解析結果（改行を含む文字列として得られる）
    lines = parsed.split('\n')  # 解析結果を1行（1語）ごとに分けてリストにする
    lines = lines[0:-2]         # 後ろ2行は不要なので削除
    diclist = []
    for word in lines:
        l = re.split('\t|,',word)  # 各行はタブとカンマで区切られてるので
        d = {'Surface':l[0], 'POS1':l[1], 'POS2':l[2], 'BaseForm':l[7]}
        diclist.append(d)
    return(diclist)

明日は晴れるでしょう。と引数に設定した場合がこちら

import MeCab
import re
# MeCabインスタンスの作成．引数を無指定にするとIPA辞書になります．
m = MeCab.Tagger('')

# テキストを形態素解析し辞書のリストを返す関数
def get_diclist(text):
    parsed = m.parse(text)      # 形態素解析結果（改行を含む文字列として得られる）
    lines = parsed.split('\n')  # 解析結果を1行（1語）ごとに分けてリストにする
    lines = lines[0:-2]         # 後ろ2行は不要なので削除
    diclist = []
    for word in lines:
        l = re.split('\t|,',word)  # 各行はタブとカンマで区切られてるので
        d = {'Surface':l[0], 'POS1':l[1], 'POS2':l[2], 'BaseForm':l[7]}
        diclist.append(d)
    return(diclist)

get_diclist("明日は晴れるでしょう。")

感情分析その2

今回は極性辞書として単語感情極性対応表を用います。

これは「岩波国語辞書（岩波書店）」を参考に、-1から+1の実数値を割り当ています。

-1に近いほどnegative
+1に近いほどpositiveとなっています。

それでは極性辞書を読み込み
リストと辞書を作成します。

#word_list, pn_listにそれぞれリスト型でWordとPNを格納してください。
import pandas as pd
pn_df = pd.read_csv('./6050_stock_price_prediction_data/pn_ja.csv', encoding='utf-8', names=('Word','Reading','POS', 'PN'))
word_list=list(pn_df['Word'])
pn_list=list(pn_df['PN'])

#pn_dictとしてword_list, pn_listを格納した辞書を作成してください。
pn_dict = dict(zip(word_list,pn_list))

感情分析その3

極性辞書を参照してPNの値を返すところの実装を行います。

また
get_diclist("明日は晴れるでしょう。")を関数add_pnvalueに渡して働きを調べて
またそれを関数get_meanに渡してPN値の平均を調べます。

import numpy as np


def add_pnvalue(diclist_old, pn_dict):
    diclist_new = []
    for word in diclist_old:
        base = word['BaseForm']        # 個々の辞書から基本形を取得
        if base in pn_dict:
            pn = float(pn_dict[base]) 
        else:
            pn = 'notfound'            # その語がPN Tableになかった場合
        word['PN'] = pn
        diclist_new.append(word)
    return(diclist_new)

# 各ツイートのPN平均値を求める
def get_mean(dictlist):
    pn_list = []
    for word in dictlist:
        pn = word['PN']
        if pn!='notfound':
            pn_list.append(pn)
    if len(pn_list)>0:
        pnmean = np.mean(pn_list)
    else:
        pnmean=0
    return pnmean


dl_old = get_diclist("明日は晴れるでしょう。")
# get_diclist("明日は晴れるでしょう。")を関数add_pnvalueに渡して働きを調べてください。
dl_new = add_pnvalue(dl_old, pn_dict)
print(dl_new)

# またそれを関数get_meanに渡してPN値の平均を調べてください。
pnmean = get_mean(dl_new)
print(pnmean)

感情分析その4

PN値の変化をグラフで表示します。

import matplotlib.pyplot as plt
%matplotlib inline
df_tweets = pd.read_csv('./6050_stock_price_prediction_data/tweets.csv', names=['id', 'date', 'text', 'fav', 'RT'], index_col='date')
df_tweets = df_tweets.drop('text', axis=0)
df_tweets.index = pd.to_datetime(df_tweets.index)
df_tweets = df_tweets[['text']].sort_index(ascending=True)

# means_listという空のリストを作りそこにツイートごとの平均値を求めてください。
means_list = []
for tweet in df_tweets['text']:
    dl_old = get_diclist(tweet)
    dl_new = add_pnvalue(dl_old, pn_dict)
    pnmean = get_mean(dl_new)
    means_list.append(pnmean)
df_tweets['pn'] = means_list
df_tweets =  df_tweets.resample('D', how='mean')

# 日付をx軸PN値をy軸にしてプロットしてください。
x = df_tweets.index
y = df_tweets.pn
plt.plot(x,y)
plt.grid(True)

# df_tweets.csvという名前でdf_tweetsを再び出力してください。
df_tweets.to_csv('./6050_stock_price_prediction_data/df_tweets.csv')

感情分析その5

グラフの結果を見ると全体的に負の値が多いように感じられます。

これは極性辞書にネガティブな意味合いの語彙が多く含まれているためです。
この結果を調整するために標準化を行います。

PN値を標準化して
またPNを日付ごとの平均に変え、プロットします。

# means_listに標準化を施し、x_stdとして出力
df_tweets['pn'] = (df_tweets['pn'] - df_tweets['pn'].mean()) / df_tweets['pn'].std()

# またPNを日付ごとの平均に変え、プロットします。
df_tweets =  df_tweets.resample('D', how='mean')
x = df_tweets.index
y = df_tweets.pn
plt.plot(x,y)
plt.grid(True)

実行環境

実行環境1

machine	MacBook Air(Retina, 13-inch,2019)
OS	MacOS Catalina version 10.15.4
メモリ	8 GB 2133 MHz LPDDR3
グラフィック	Intel UHD Graphics 617 1536 MB

module	version
Keras	2.2.4
plaidml	0.7.0
plaidml-keras	0.7.0
plaidbench	0.7.0

実行環境2

machine	MacBook (Retina, 12-inch, 2017)
OS	MacOS Catalina version 10.15.4
メモリ	8 GB 1867 MHz LPDDR3
グラフィック	Intel HD Graphics 615 1536 MB

module	version
Keras	2.2.4
plaidml	0.7.0
plaidml-keras	0.7.0
plaidbench	0.7.0

PlaidML実装の動機

GWに無料で機械学習を勉強することができるコンテンツが増えたことや元々やりたいと考えていた画像処理系の機械学習に手を出してみようと思ったため。
誇るほど高いスペックのマシーンを持っているわけでもなく、実行環境にも書いた通り、実行環境がMacBookということもあり、NVIDIA製のGPUを使うことができない環境は、PCにかける負担もですが、時間がとてもかかる。CPUだけでは学習に限界を感じたため、MacBookでもGPUを使って学習をすることができると噂のPlaidMLの実装をしてみました。

参考文献

Plaid MLのGitHubをメインに参考にしました。

PlaidMLの実装について

何をするモジュールなのか

PlaidMLは、intelなどが開発している科学数理計算ライブラリのフレームワークです。
標準でKerasがサポートしてる科学数理計算ライブラリのフレームワークは、tensorflowやTheanoなどがあります。
これらのライブラリで、PCのGPU（グラフィック）を使おうとした時NVIDIA製のGPUでしかサポートされておりませんでした。
AMD製のGPUを搭載しているMacではGPUを使って計算することができませんでした。

しかし、このPlaidMLはNVIDIA製という縛りがなく、GPUを使えるようにするためのモジュールとなっており、Kerasのバックエンドのフレームワークとして採用されているモジュールとなっています。
今回の実装では、このKerasのバックエンドにPlaidMLを設定するまでを行います。

詰まるところ

Macで、GPUを使って、機械学習ができる
ということです。

実装

PlaidML Github QuickStart Link
QuickStarでは、virtualenvを使った仮想環境を構築していますが、僕はしませんでした。
特に理由はないです。

必要なモジュールのインストール

module_install

pip3 install plaidml-keras plaidbench
pip3 install keras

PlaidMLセットアップ

PlaidMLのセットアップを行います。
PlaidMLでCPUを使って計算をするのか、GPUを使って計算をするのかなどのセットアップを行います。

plaidml-setup

plaidml-setup

Quick Start通りに進めましたが、ここでエラーが出ました。
エラー文は下記の通りとなっています。

error

Traceback (most recent call last):
  File "/usr/local/bin/plaidml-setup", line 5, in <module>
    from plaidml.plaidml_setup import main
  File "/usr/local/lib/python3.7/site-packages/plaidml/__init__.py", line 50, in <module>
    import plaidml.settings
  File "/usr/local/lib/python3.7/site-packages/plaidml/settings.py", line 33, in <module>
    _setup_config('PLAIDML_EXPERIMENTAL_CONFIG', 'experimental.json')
  File "/usr/local/lib/python3.7/site-packages/plaidml/settings.py", line 30, in _setup_config
    'Could not find PlaidML configuration file: "{}".'.format(filename))
plaidml.exceptions.PlaidMLError: Could not find PlaidML configuration file: "experimental.json".

こちらのエラーに関して、GitHubの方で、すでに議論がありました。
興味がある方は覗いてみてください。
plaidml.exceptions.PlaidMLError: Could not find PlaidML configuration file: "experimental.json". #370

結論として、
PATHが通っていないため、エラーが出ているという結論があったため、記載されていたPATHを設定します。
再度exportを実行し、設定したPATHが通っていることを確認したら...

PATH

export PLAIDML_NATIVE_PATH=/usr/local/lib/libplaidml.dylib
export RUNFILES_DIR=/usr/local/share/plaidml

export

再度セットアップを実行

plaidml-setup

plaidml-setup

~~
Enable experimental device support? (y,n)[n]:y #y を選択

Multiple devices detected (You can override by setting PLAIDML_DEVICE_IDS).
Please choose a default device:

   1 : llvm_cpu.0
   2 : opencl_intel_uhd_graphics_617.0
   3 : metal_intel(r)_uhd_graphics_617.0

Default device? (1,2,3)[1]:3 # 下二つが、GPU今回は、グラフィックの3を選択
~~
# 今回の選択結果を保存するかどうか
Save settings to /Users/linda/.plaidml? (y,n)[y]:y #yを選択

実行結果(全体)

PlaidML Setup (0.7.0)

Thanks for using PlaidML!

The feedback we have received from our users indicates an ever-increasing need
for performance, programmability, and portability. During the past few months,
we have been restructuring PlaidML to address those needs.  To make all the
changes we need to make while supporting our current user base, all development
of PlaidML has moved to a branch — plaidml-v1. We will continue to maintain and
support the master branch of PlaidML and the stable 0.7.0 release.

Read more here: https://github.com/plaidml/plaidml 

Some Notes:
  * Bugs and other issues: https://github.com/plaidml/plaidml/issues
  * Questions: https://stackoverflow.com/questions/tagged/plaidml
  * Say hello: https://groups.google.com/forum/#!forum/plaidml-dev
  * PlaidML is licensed under the Apache License 2.0


Default Config Devices:
   llvm_cpu.0 : CPU (via LLVM)
   metal_intel(r)_uhd_graphics_617.0 : Intel(R) UHD Graphics 617 (Metal)

Experimental Config Devices:
   llvm_cpu.0 : CPU (via LLVM)
   opencl_intel_uhd_graphics_617.0 : Intel Inc. Intel(R) UHD Graphics 617 (OpenCL)
   metal_intel(r)_uhd_graphics_617.0 : Intel(R) UHD Graphics 617 (Metal)

Using experimental devices can cause poor performance, crashes, and other nastiness.

Enable experimental device support? (y,n)[n]:y
Multiple devices detected (You can override by setting PLAIDML_DEVICE_IDS).
Please choose a default device:

   1 : llvm_cpu.0
   2 : opencl_intel_uhd_graphics_617.0
   3 : metal_intel(r)_uhd_graphics_617.0

Default device? (1,2,3)[1]:3

Selected device:
    metal_intel(r)_uhd_graphics_617.0

Almost done. Multiplying some matrices...
Tile code:
  function (B[X,Z], C[Z,Y]) -> (A) { A[x,y : X,Y] = +(B[x,z] * C[z,y]); }
Whew. That worked.

Save settings to /Users/linda/.plaidml? (y,n)[y]:y
Success!

推論性能のベンチマーク

次に、MobileNetの推論性能をベンチマークしてみます。

plaidbench keras mobilenet

Running 1024 examples with mobilenet, batch size 1, on backend plaid
INFO:plaidml:Opening device "metal_intel(r)_uhd_graphics_617.0"
Compiling network...INFO:plaidml:Analyzing Ops: 266 of 413 operations complete
 Warming up... Running...
Example finished, elapsed: 2.280s (compile), 32.101s (execution)

-----------------------------------------------------------------------------------------
Network Name         Inference Latency         Time / FPS          
-----------------------------------------------------------------------------------------
mobilenet            31.35 ms                  0.00 ms / 1000000000.00 fps
Correctness: PASS, max_error: 6.440454399125883e-06, max_abs_error: 5.811452865600586e-07, fail_ratio: 0.0

上から２行目INFO:plaidml:Opening device "metal_intel(r)_uhd_graphics_617.0"
で、自分がセットアップしたアクセラレーターのベンチマークを取られていることが確認できます。

実際にここまでで、設定自体は終わっていますが、本当にKerasのバックエンドが、PlaidMLに変わっているかを確認します。

このPATHなどを通してあるターミナル上で、jupyterを起動させる。

要注意

ここで別のターミナルの窓でJupyterを起動させたり、今まで設定していたターミナルの窓を消すと設定がし直しになる。

PlaidMLの確認

jupyter上で

import plaidml.keras
plaidml.keras.install_backend() #バックエンドに設定
import keras
print(keras.backend.backend()) #Kerasのバックエンドの確認

>>> tensorflow

kerasのバックエンドが、tensorflowのままです。

実際にはPlaidmlをkerasのバックエンドに設定するためには、

plaidml.keras.install_backend() #バックエンドに設定

ではなく、バックエンドに設定するPATHを設定してあげる必要がある。

export KERAS_BACKEND=plaidml.keras.backend

このPATHを設定した後に確認すると...
```

import keras
print(keras.backend.backend())

>>>plaidml.keras.backend

変更されていることが確認できる。

最後に

今後画像解析系の学習をさせていきたいと思います。　

関連文献

脱NVIDIAを夢見て ~ PlaidML ~

はじめに

自然言語処理の問題集として有名な自然言語処理100本ノックの2020年版が4/6に公開されました。
この記事では、以下の第1章から第10章のうち、第1章: 準備運動を解いてみた結果をまとめています。

• 第1章: 準備運動
• 第2章: UNIXコマンド
• 第3章: 正規表現
• 第4章: 形態素解析
• 第5章: 係り受け解析
• 第6章: 機械学習
• 第7章: 単語ベクトル
• 第8章: ニューラルネット
• 第9章: RNN, CNN
• 第10章: 機械翻訳

事前準備

回答にはGoogle Colaboratoryを利用しています。
Google Colaboratoryのセットアップ方法や基本的な使い方は、こちらの記事が詳しいです。
なお、以降の回答の実行結果を含むノートブックはgithubにて公開しています。

第1章: 準備運動

00. 文字列の逆順

文字列”stressed”の文字を逆に（末尾から先頭に向かって）並べた文字列を得よ．

str = 'stressed'
ans = str[::-1]

print(ans)

Pythonで文字列を抽出

01. 「パタトクカシーー」

「パタトクカシーー」という文字列の1,3,5,7文字目を取り出して連結した文字列を得よ．

str = 'パタトクカシーー'
ans = str[::2]

print(ans)

02. 「パトカー」＋「タクシー」＝「パタトクカシーー」

「パトカー」＋「タクシー」の文字を先頭から交互に連結して文字列「パタトクカシーー」を得よ．

str1 = 'パトカー'
str2 = 'タクシー'
ans = ''.join([i + j for i, j in zip(str1, str2)])

print(ans)

Python, zip関数の使い方: 複数のリストの要素をまとめて取得
Pythonリスト内包表記の使い方
Pythonで文字列を連結・結合

03. 円周率

“Now I need a drink, alcoholic of course, after the heavy lectures involving quantum mechanics.”という文を単語に分解し，各単語の（アルファベットの）文字数を先頭から出現順に並べたリストを作成せよ．

import re

str = 'Now I need a drink, alcoholic of course, after the heavy lectures involving quantum mechanics.'
str = re.sub("[,\.]", "", str) # ,と.を除去
splits = str.split() # スペースで区切って単語ごとのリストを作成
ans = [len(i) for i in splits]

print(ans)

Pythonで文字列を置換
Pythonで文字列を分割

04. 元素記号

“Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.”という文を単語に分解し，1, 5, 6, 7, 8, 9, 15, 16, 19番目の単語は先頭の1文字，それ以外の単語は先頭に2文字を取り出し，取り出した文字列から単語の位置（先頭から何番目の単語か）への連想配列（辞書型もしくはマップ型）を作成せよ．

str = 'Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.'
splits = str.split()
one_ch = [1, 5, 6, 7, 8, 9, 15, 16, 19] # 1文字を取り出す単語の番号リスト
ans = {}
for i in range(len(splits)):
  if i + 1 in one_ch:
    ans[splits[i][:1]] = i + 1 # リストにあれば1文字を取得
  else:
    ans[splits[i][:2]] = i + 1 # なければ2文字を取得

print(ans)

Pythonのfor文によるループ処理
Pythonで辞書を作成するdict()と波括弧、辞書内包表記

05. n-gram

与えられたシーケンス（文字列やリストなど）からn-gramを作る関数を作成せよ．この関数を用い，”I am an NLPer”という文から単語bi-gram，文字bi-gramを得よ．

def ngram(n, lst):
    return set(zip(*[lst[i:] for i in range(n)]))

str = 'I am an NLPer'
words_bi_gram = ngram(2, str.split())
chars_bi_gram = ngram(2, str)

print('単語bi-gram:', words_bi_gram)
print('文字bi-gram:', chars_bi_gram)

Pythonで関数を定義・呼び出し
Python, set型で集合演算

06. 集合

“paraparaparadise”と”paragraph”に含まれる文字bi-gramの集合を，それぞれ, XとYとして求め，XとYの和集合，積集合，差集合を求めよ．さらに，’se’というbi-gramがXおよびYに含まれるかどうかを調べよ．

str1 = 'paraparaparadise'
str2 = 'paragraph'
X = ngram(2, str1)
Y = ngram(2, str2)
union = X | Y
intersection = X & Y
difference = X - Y

print('X:', X)
print('Y:', Y)
print('和集合:', union)
print('積集合:', intersection)
print('差集合:', difference)
print('Xにseが含まれるか:', {('s', 'e')} <= X)
print('Yにseが含まれるか:', {('s', 'e')} <= Y)

07. テンプレートによる文生成

引数x, y, zを受け取り「x時のyはz」という文字列を返す関数を実装せよ．さらに，x=12, y=”気温”, z=22.4として，実行結果を確認せよ．

def generate_sentence(x, y, z):
  print('{}時のとき{}は{}'.format(x, y, z))

generate_sentence(12, '気温', 22.4)

Python, formatで書式変換

08. 暗号文

与えられた文字列の各文字を，以下の仕様で変換する関数cipherを実装せよ．
英小文字ならば(219 - 文字コード)の文字に置換
その他の文字はそのまま出力
この関数を用い，英語のメッセージを暗号化・復号化せよ．

def cipher(str):
  rep = [chr(219 - ord(x)) if x.islower() else x for x in str]

  return ''.join(rep)

message = 'the quick brown fox jumps over the lazy dog'
message = cipher(message)
print('暗号化:', message)
message = cipher(message)
print('復号化:', message)

PythonでUnicodeコードポイントと文字を相互変換
Pythonで大文字・小文字を操作する文字列メソッド一覧

09. Typoglycemia

スペースで区切られた単語列に対して，各単語の先頭と末尾の文字は残し，それ以外の文字の順序をランダムに並び替えるプログラムを作成せよ．ただし，長さが４以下の単語は並び替えないこととする．適当な英語の文（例えば”I couldn’t believe that I could actually understand what I was reading : the phenomenal power of the human mind .”）を与え，その実行結果を確認せよ．

import random

def shuffle(words):
  splits = words.split()
  if len(splits) > 4:
    splits = splits[:1] + random.sample(splits[1:-1], len(splits) - 2) + splits[-1:]

  return ' '.join(splits)

words = "I couldn't believe that I could actually understand what I was reading : the phenomenal power of the human mind."
ans = shuffle(words)

print(ans)

Pythonでリストの要素をシャッフル

おわりに

自然言語処理100本ノックは自然言語処理そのものだけでなく、基本的なデータ処理や汎用的な機械学習についてもしっかり学ぶことができるように作られています。
オンラインコースなどで機械学習を勉強中の方も、とても良いアウトプットの練習になると思いますので、ぜひ挑戦してみてください。

GitLab CIを使ってPythonコードの静的解析を行ったのでメモです。微妙に簡単な導入記事が見つからなかったので誰かのお役に立てれば。

目的

• GitLabはSaaS版、つまりWebブラウザ版をつかう
• しかも無課金
• Python
• とりあえずコードの静的解析さえできればいい
• 無料ではグループあたり2000分/月なのでマージリクエスト発行時だけをトリガーにする

ymlファイル作成

ルートディレクトリに .gitlab-ci.yml を作成します。

.gitlab-ci.yml

# Docker Imageを指定
image: python:latest

# キャッシュの保存先
variables:
  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"

# pip installしたものをキャッシュするためにvirtualenvを導入
cache:
  paths:
    - .cache/pip
    - venv/

# 実行前スクリプト
before_script:
  - python -V
  - pip install virtualenv
  - virtualenv venv
  - source venv/bin/activate

# testというstageを使う
# 長さが79文字以下はちょっといやだったので無視
test:
  script:
    # - python setup.py test
    - pip install flake8
    - flake8 *.py --exclude venv/,.cache --ignore E501
  only:
    refs:
      - merge_requests

実行

このファイルが含まれたマージリクエストを作成してください。くるくるテストが回り始めます。テストに通るとマージできるようになります。

GitLab CIを使ってPythonコードの静的解析を行ったのでメモです。微妙に簡単な導入記事が見つからなかったので誰かのお役に立てれば。

目的

• GitLabはSaaS版、つまりWebブラウザ版をつかう
• しかも無課金
• Python
• とりあえずコードの静的解析さえできればいい
• 無料ではグループあたり2000分/月なのでマージリクエスト発行時だけをトリガーにする

ymlファイル作成

ルートディレクトリに .gitlab-ci.yml を作成します。

.gitlab-ci.yml

# Docker Imageを指定
image: python:latest

# キャッシュの保存先
variables:
  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"

# pip installしたものをキャッシュするためにvirtualenvを導入
cache:
  paths:
    - .cache/pip
    - venv/

# 実行前スクリプト
before_script:
  - python -V
  - pip install virtualenv
  - virtualenv venv
  - source venv/bin/activate

# testというstageを使う
# 長さが79文字以下はちょっといやだったので無視
test:
  script:
    # - python setup.py test
    - pip install flake8
    - flake8 *.py --exclude venv/,.cache --ignore E501
  only:
    refs:
      - merge_requests

実行

このファイルが含まれたマージリクエストを作成してください。くるくるテストが回り始めます。テストに通るとマージできるようになります。

はじめに

scikit-learnはPythonの便利な機械学習ライブラリで、Numpy・Scipy・Matplotlibと一緒に気軽に使うことができます。
scikit-learnは、APIのデザインパターンを知ると飛躍的に使いやすくなります。

今回はscikit-learnの著者による論文をもとに、scikit-learnの魅力を解説します。

基本デザイン

scikit-learnのオブジェクトはAPIの一貫性を保つため、いくつかのパターンに従って設計されています。
このパターンを理解することでどのオブジェクトでも不自由なく使うことが出来ます。

Estimator

scikit-learnではEstimatorというインターフェースが基本となっています。
Estimatorは、データに基づき何らかのモデル（のパラメータ）を学習させます。
必ずfitというメソッドを持っていて、fitの引数にデータを流すことで学習を行います。
また、学習に必要なハイパーパラメータを（コンストラクタまたはset_paramsメソッドで）設定することができます。

ロジスティック回帰を行うLogisticRegressionというクラスもEstimatorの一つです。

from sklearn.linear_model import LogisticRegession
clf = LogisticRegression(penalty="l1") # ハイパーパラメータの設定
clf.fit(X_train, y_train) # 訓練データに基づきモデルを学習

Predictor

Estimatorの多くは同時にPredictorのインターフェスを導入しています。
Predictorはfitで学習したモデルをもとに予想（出力）を行います。
predictのメソッドにデータを引数として渡すと、予想が返されます。
また、scoreというメソッドを持っており、データセットとラベルを渡すことでモデルを評価できます。

例えば、LogisticRegressionはPredictorなので、predict、scoreのメソッドを問題なく使えます。

clf.predict(X_test) # テストデータについて予測

clf.score(X_test, y_test) # テストデータについての予想と実際の答えを比較

Transformer

Predictorの他に、Transformerというインターフェスを導入するクラスもあります。
名前にある通り、Transformerはデータを変形することができます。
機械学習モデルよりはデータ処理のAPIにおいて多用されます。
transformというメソッドを使って変形されたデータを返します。
また、fit_transformというメソッドを使うと、学習と変形を同時に行うことが出来るような設計です。

下の例では、データセットの標準化を行うStandardScalerによる変形を実装します。
StandardScalerの場合、複雑なモデルではなく各特微量の平均と分散を学習します。

from sklearn.preprocessing import StandardScaler 
scaler = StandScaler()
X_train = scaler.fit_transform(X_train) # 訓練データを学習・変形
X_test = scaler.transform(X_test) # テストデータは学習せず変形（訓練データの平均・分散を用いる）

また、PredictorとTransformerのインターフェスは同時に導入することができます。

パラメータ・ハイパーパラメータの取得

自分が設定したハイパーパラメータ、学習されたパラメータはオブジェクトの中に保存されています。（学習されたパラメータの名前はアンダーバーで終わります）
パラメータ・ハイパーパラメータのアクセス方法については、各オブジェクトのドキュメントで「Attributes」を参照してください。

例：StandardScalerが学習した平均、分散を取得する

# 前から続く
mean = scaler.mean_
variance = scaler.var_

よって、どのEstimatorでも
1. インスタンスを作りハイパーパラメータを設定する
2. fitで学習する
3. predict、score、transformなどで目的を達成する、学習されたパラメータを確認する
という手順に従うことで、簡単にワークフローを構築することができます。
データ全処理からモデル学習・評価までの実装が全てEstimatorを使って行えます。

応用デザイン

Estimatorの合成

全てのEstimatorが同じメソッドを持っているため、複数のEstimatorを簡単に合成することができます。
並列処理の場合Pipeline、並行処理の場合FeatureUnionを使って合成します。

例えば、データを標準化しロジスティック回帰を行いたい場合、パイプラインを使うことできれいに処理を実装できます。

from sklearn.pipeline import Pipeline
pipe = Pipeline([
    {'std_scaler', StandardScaler()},
    {'log_reg', LogisticRegression()} # transformerの変形したデータを受け取る
])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)

Cross ValidationもEstimator

scikit-learnではGridSearchCVやRandomSearchCVなどといったクラスを使ってハイパーパラメータの検証を行うことができます。
これらも、Estimatorのインターフェスを導入しており、fitを使って学習を行います。

例：ロジスティック回帰に最適なハイパーパラメータをGrid Searchを使って求める

from sklearn.model_selection import GridSearchCV
clf = GridSearchCV(
    estimator=LogisticRegression(),
    param_grid={
        'C' = [1, 3, 10, 30, 100]
    }
)
clf.fit(X_train, y_train) # param_gridにあるハイパーパラメータを一つずつ適用して複数のモデルを学習させる
best_clf = clf.best_estimator_ # 最適なEstimatorをゲット！

自前のEstimatorを作る

fitなど、インターフェースに定義されたメソッドを持つクラスを作ることで、簡単にパイプラインや検証に使うことができます。
Estimatorを作る場合、BaseEstimatorを継承し、さらにTransformerなどを作る場合は同時に適当なMixinを継承します。

Transformerの例：

from sklearn.base import BaseEstimator, TransformerMixin

class MyTransformer(BaseEstimator, TransformerMixin):
  def __init__(self, param_1, param_2):
    # ハイパーパラメータの処理
    self.param_1 = param_1
    # ...

  def fit(self, X, y=None):
    # 処理
    return self 

  def transform(self, X, y=None):
     # Numpy行列の処理
     # X = ...
    return X 

  # fit_transformは自動的にTransformerMixinが実装

transformer = MyTransformer()
X_transformed = transformer.fit_transform(X_train)

結論

scikit-learnには色々な機械学習手法を実装したオブジェクトが用意されていますが、内容が分からなくてもEstimator、Predictor、Transformerのデザインパターンを理解していれば一通り使えてしまいます。
scikit-learnのAPIは一貫性が高いところが魅力的で、簡単に機械学習を進めることができます。

背景

faker-python の fake.address() を使って住所生成したら，

兵庫県中野区松石4丁目14番7号 クレスト千塚106

こんな感じでフェイク住所が出て来ますが，実際マップを使用したアプリケーションでテストをする際など，これらの情報を検索にかけても実行結果が出ません．

なので

1.　フェイクデータではなく実際の住所データを生成する．
2.　またダミーデータとして一度の実行にの多くの住所を取得する．

今回はこの２点を抑えてデータを生成したいと思います．

どうやって作るか

すぐに思いついたのが，住所情報を提供するAPI経由で，情報を整形して生成する方法．
とりあえずやってみます．

HeartRails Geo API

今回お世話になるAPIは，HeartRails Geo API さんです．
ここの緯度経度による住所検索 APIを使ってダミー住所を生成していきます．

住所生成プログラム

import requests
import random
import json

#xml_url = 'httpi://geoapi.heartrails.com/api/xml?method=searchByGeoLocation'
json_url = 'http://geoapi.heartrails.com/api/json?method=searchByGeoLocation'

# APIリクエスト関数
def get_data(lug,lat):
    payload = {'method': 'searchByGeoLocation', 'x': lug, 'y': lat}
    try:
        ret = requests.get(json_url, params=payload)
        json_ret = ret.json()
    except requests.exceptions.RequestException as e:
        print("ErrorContent: ",e)
    return json_ret

# 住所データの整形関数
def data_serealize(data):
    try:
        enc = json.dumps(data, indent=2, ensure_ascii=False)
        dic = data['response']['location'][9]
        det = dic['prefecture'] + dic['city'] + dic['town']
        return det
    except KeyError as e:
        print(e)

# 軽度・緯度に使う乱数の生成
def gene_number(lug_fnum, lug_lnum, lat_fnum, lat_lnum):
    lug = round(random.uniform(lug_fnum,lug_lnum),6)
    lat = round(random.uniform(lat_fnum,lat_lnum),6)
    return lug,lat

def main():
    for i in range(10):
        lug,lat = gene_number(122,153,19,45)
        print("経度： " + str(lug) + "," + "緯度： " + str(lat) + "\n")
        ret = get_data(lug,lat)
        print(data_serealize(ret))

if __name__ == '__main__':
    main()                                                                                                                                                                                                                                                                              

データフォーマットは今回json形式を選びました．理由は特にありません．

・　get_data関数は，データを取ってくる関数．
・　data_number関数は，取ってきたデータを整形します．
・　gene_number関数は，日本国内の経度緯度を自動生成して，それをget_data関数に渡します．

検証

経度： 149.691295,緯度： 20.525873

'location'
None
経度： 146.369748,緯度： 23.905043

'location'
None
経度： 128.552226,緯度： 28.268003

'location'
None
経度： 138.839354,緯度： 36.14651

群馬県甘楽郡甘楽町秋畑
経度： 128.442362,緯度： 24.173392

'location'
None
経度： 149.328955,緯度： 35.501685

'location'
None
経度： 143.701187,緯度： 31.806533

'location'
None
経度： 152.518577,緯度： 38.932277

'location'
None
経度： 131.0144,緯度： 38.670175

'location'
None
経度： 149.70269,緯度： 36.445081

'location'
None

一度のプログラムの実行に10個のデータを生成するように指定しましたが，ほとんどのデータがNoneの表示されています．生成できたのは4番目の群馬県甘楽郡甘楽町秋畑のデータのみです．

どういうわけか．．．

あ．．

試しに２番目の座標データを調べてみました．

海ですね．

経緯度の設定値を変える

経度： 139.286021,緯度： 34.639237

東京都大島町野増下平
経度： 138.097037,緯度： 34.790162

静岡県菊川市富田
経度： 138.110693,緯度： 34.654774

静岡県御前崎市門屋
経度： 138.752411,緯度： 34.708536

静岡県賀茂郡松崎町雲見
経度： 138.616241,緯度： 34.723031

'location'
None
経度： 138.418079,緯度： 34.81724

静岡県焼津市田尻北
経度： 138.33815,緯度： 34.515467

'location'
None
経度： 138.290422,緯度： 34.019396

'location'
None
経度： 139.842906,緯度： 34.022007

'location'
None
経度： 139.00311,緯度： 34.997854

静岡県伊豆市大野

ちょっと増えた．

結論

どうやら，日本国土の経緯度レンジは大体(経度123-154),(緯度20-46)の範囲あるということで設定してみたら，海が含まれていることを忘れていた．

なので，設定する経緯度は，国土内の経度に的を絞ったほうが良さそうです．
後は，自作の関数や微調整なりでなんとかなりそう．

背景

faker-python の fake.address() を使って住所生成したら，

兵庫県中野区松石4丁目14番7号 クレスト千塚106

こんな感じで兵庫県の中に中野区がある、凄まじいフェイク住所が出て来てますが，実際マップを使用したアプリケーションでテストをする際など，これらの情報を検索にかけても実行結果が出ません．

なので

1.　フェイクデータではなく実際の住所データを生成する．
2.　またダミーデータとして一度の実行にの多くの住所を取得する．

今回はこの２点を抑えてデータを生成したいと思います．

どうやって作るか

すぐに思いついたのが，住所情報を提供するAPI経由で，情報を整形して生成する方法．
とりあえずやってみます．

HeartRails Geo API

今回お世話になるAPIは，HeartRails Geo API さんです．
ここの緯度経度による住所検索 APIを使ってダミー住所を生成していきます．

住所生成プログラム

import requests
import random
import json

#xml_url = 'httpi://geoapi.heartrails.com/api/xml?method=searchByGeoLocation'
json_url = 'http://geoapi.heartrails.com/api/json?method=searchByGeoLocation'

# APIリクエスト関数
def get_data(lug,lat):
    payload = {'method': 'searchByGeoLocation', 'x': lug, 'y': lat}
    try:
        ret = requests.get(json_url, params=payload)
        json_ret = ret.json()
    except requests.exceptions.RequestException as e:
        print("ErrorContent: ",e)
    return json_ret

# 住所データの整形関数
def data_serealize(data):
    try:
        dic = data['response']['location'][9]
        det = dic['prefecture'] + dic['city'] + dic['town']
        return det
    except KeyError as e:
        print(e)

# 軽度・緯度に使う乱数の生成
def gene_number(lug_fnum, lug_lnum, lat_fnum, lat_lnum):
    lug = round(random.uniform(lug_fnum,lug_lnum),6)
    lat = round(random.uniform(lat_fnum,lat_lnum),6)
    return lug,lat

def main():
    for i in range(10):
        lug,lat = gene_number(122,153,19,45)
        print("経度： " + str(lug) + "," + "緯度： " + str(lat) + "\n")
        ret = get_data(lug,lat)
        print(data_serealize(ret))

if __name__ == '__main__':
    main()                                                                                                                                                                                                                                                                              

データフォーマットは今回json形式を選びました．理由は特にありません．

・　get_data関数は，データを取ってくる関数．
・　data_number関数は，取ってきたデータを整形します．
・　gene_number関数は，日本国内の経度緯度を自動生成して，それをget_data関数に渡します．

検証

経度： 149.691295,緯度： 20.525873

'location'
None
経度： 146.369748,緯度： 23.905043

'location'
None
経度： 128.552226,緯度： 28.268003

'location'
None
経度： 138.839354,緯度： 36.14651

群馬県甘楽郡甘楽町秋畑
経度： 128.442362,緯度： 24.173392

'location'
None
経度： 149.328955,緯度： 35.501685

'location'
None
経度： 143.701187,緯度： 31.806533

'location'
None
経度： 152.518577,緯度： 38.932277

'location'
None
経度： 131.0144,緯度： 38.670175

'location'
None
経度： 149.70269,緯度： 36.445081

'location'
None

一度のプログラムの実行に10個のデータを生成するように指定しましたが，ほとんどのデータがNoneの表示されています．生成できたのは4番目の群馬県甘楽郡甘楽町秋畑のデータのみです．

どういうわけか．．．

あ．．

試しに２番目の座標データを調べてみました．

海ですね．

経緯度の設定値を変える

経度： 139.286021,緯度： 34.639237

東京都大島町野増下平
経度： 138.097037,緯度： 34.790162

静岡県菊川市富田
経度： 138.110693,緯度： 34.654774

静岡県御前崎市門屋
経度： 138.752411,緯度： 34.708536

静岡県賀茂郡松崎町雲見
経度： 138.616241,緯度： 34.723031

'location'
None
経度： 138.418079,緯度： 34.81724

静岡県焼津市田尻北
経度： 138.33815,緯度： 34.515467

'location'
None
経度： 138.290422,緯度： 34.019396

'location'
None
経度： 139.842906,緯度： 34.022007

'location'
None
経度： 139.00311,緯度： 34.997854

静岡県伊豆市大野

ちょっと増えた．

結論

どうやら，日本国土の経緯度レンジは大体(経度123-154),(緯度20-46)の範囲あるということで設定してみたら，海が含まれていることを忘れていた．

なので，設定する経緯度は，国土内の経度に的を絞ったほうが良さそうです．
後は，自作の関数や微調整なりでなんとかなりそう．

便利な反面、登録が面倒極まりない Microsoft Word のスタイルを python で一括登録します。

実行イメージ

• 文字単位のスタイルは背景色＋下線の種類で区別
• 段落単位のスタイルは背景色＋囲み線の色で区別

• 表は外周の罫線の色で区別

コード

別の記事 で書いたように、pywin32 を使って現在開いている文書を見ながら処理します（Word VBA の定数は こちらの記事 など参照）。

デフォルトだと「実行時点でカーソルがある段落の書式設定」を基準に新規スタイルが作成されます。冒頭にタイトルとして大きなフォントが指定されているような場合に困るので、「標準」スタイルの書式を基準にしました。

activeword_set-style.py

import win32com.client

class vb:
    wdLineStyleSingle          = 1
    wdLineWidth050pt           = 4
    wdLineWidth025pt           = 2
    wdLineWidth150pt           = 12
    wdStyleNormal              = -1
    wdStyleTypeCharacter       = 2
    wdStyleTypeParagraphOnly   = 5
    wdStyleTypeTable           = 3
    wdUnderlineThick           = 6
    wdUnderlineDouble          = 3
    wdUnderlineWavyHeavy       = 27
    wdUnderlineDotDotDashHeavy = 26
    wdUnderlineDottedHeavy     = 20
    wdUnderlineDotDashHeavy    = 25
    wdUnderlineDashHeavy       = 23

def colorhex_to_int(colorcode):
    hex = colorcode[1:7]
    r = int(hex[0:2], 16)
    g = int(hex[2:4], 16)
    b = int(hex[4:6], 16)
    return r + g*256 + b*256*256

def add_marker_style(doc, base_style):
    print('creating new marker style...')
    marker_color_table = (
        [1, {"fill":"#f5ff3d", "border":"#1700c2"}],
        [2, {"fill":"#97ff57", "border":"#ff007b"}],
        [3, {"fill":"#5efffc", "border":"#ffaa00"}],
        [4, {"fill":"#ff91fa", "border":"#167335"}],
        [5, {"fill":"#ffca59", "border":"#2f5773"}],
        [6, {"fill":"#d6d6d6", "border":"#0f1c24"}],
    )
    for mkr in marker_color_table:
        marker_style_name = f"myMaker{mkr[0]}"
        try:
            marker_style = doc.Styles.Add(marker_style_name, vb.wdStyleTypeParagraphOnly)
            marker_style.ParagraphFormat = base_style.ParagraphFormat
            for i in (-4,-3,-2,-1):
                marker_style.ParagraphFormat.Borders(i).LineStyle = vb.wdLineStyleSingle
                marker_style.ParagraphFormat.Borders(i).LineWidth = vb.wdLineWidth050pt
                marker_style.ParagraphFormat.Borders(i).Color = colorhex_to_int(mkr[1]["border"])
            marker_style.Font = base_style.Font
            marker_style.NextParagraphStyle = base_style
            marker_style.ParagraphFormat.Shading.BackgroundPatternColor = colorhex_to_int(mkr[1]["fill"])
            marker_style.ParagraphFormat.OutlineLevel = mkr[0]
            marker_style.QuickStyle = True
            print(f' + "{marker_style_name}"')
        except:
            print(f'failed to create style "{marker_style_name}" ...')

def add_character_style(doc, base_style):
    print('creating new character style...')
    char_color_table = (
        [1, "#ffda0a",vb.wdUnderlineThick],
        [2, "#66bdcc",vb.wdUnderlineDotDashHeavy],
        [3, "#a3ff52",vb.wdUnderlineDottedHeavy],
        [4, "#ff7d95",vb.wdUnderlineDouble],
        [5, "#bf3de3",vb.wdUnderlineDashHeavy],
        [6, "#ff9500",vb.wdUnderlineWavyHeavy],
    )
    for char in char_color_table:
        char_style_name = f"myChar{char[0]}"
        try:
            char_style = doc.Styles.Add(char_style_name, vb.wdStyleTypeCharacter)
            char_style.Font = base_style.Font
            char_style.Font.Shading.BackgroundPatternColor = colorhex_to_int(char[1])
            char_style.Font.Color = colorhex_to_int("#111111")
            char_style.Font.Underline = char[2]
            char_style.QuickStyle = True
            print(f' + "{char_style_name}"')
        except:
            print(f'failed to create style "{char_style_name}" ...')

def add_table_style(doc, base_style):
    print(f'creating new table style...')
    border_color_table = (
        [1,"#2b70ba"],
        [2,"#fc035a"],
        [3,"#0d942a"],
        [4,"#ff4f14"],
        [5,"#fffb00"],
    )
    for tbl in border_color_table:
        table_style_name = f"myTable{tbl[0]}"
        try:
            table_style = doc.Styles.Add(table_style_name, vb.wdStyleTypeTable)
            table_style.Font = base_style.Font
            for i in (-4,-3,-2,-1):
                table_style.Table.Borders(i).LineStyle = vb.wdLineStyleSingle
                table_style.Table.Borders(i).LineWidth = vb.wdLineWidth150pt
                table_style.Table.Borders(i).Color = colorhex_to_int(tbl[1])
                table_style.Table.Shading.BackgroundPatternColor = colorhex_to_int("#eeeeee")
            print(f' + "{table_style_name}"')
        except:
            print(f'failed to create style "{table_style_name}" ...')

def main():
    wdApp = win32com.client.Dispatch("Word.Application")
    if wdApp.Documents.Count < 1:
        if not wdApp.Visible:
            wdApp.Quit()
        return 0

    doc = wdApp.ActiveDocument
    normalStyle = doc.Styles(vb.wdStyleNormal)

    add_marker_style(doc, normalStyle)
    add_character_style(doc, normalStyle)
    add_table_style(doc, normalStyle)

if __name__ == '__main__':
    main()

powershell から呼び出す

メイン使用の powershell から下記のコマンドレットを作って呼び出しています。もちろん python activeword_set-style.py で直接呼び出しても構いません。

function Set-MyStyleToActiveWordDocumentWithPython {
    if ((Get-Process | Where-Object ProcessName -EQ "winword").Count -lt 1) {
        return
    }
    $pyCodePath = "{0}\python_code\activeword_set-style.py" -f $PSScriptRoot
    'python -B "{0}"' -f $pyCodePath | Invoke-Expression
}

はじめに

ここでは、Pythonを用いたファイル走査の方法として、osモジュールとpathlibモジュールの利用方法を紹介します。

osモジュール

osモジュールは、ファイルやディレクトリを扱う上でベーシックなモジュールです。
よく使うメソッドなどは以下になります。

import os


directory = 'ディレクトリー名'
file = 'ファイル名'

file_path = os.path.join(directory, file)
print(file_path) # ディレクトリ名/ファイル名
print(os.path.isfile(file_path)) # True
print(os.path.isdir(file_path)) # False
print(os.path.isdir(directory)) # True
print(os.path.exists(file_path)) # True

entry_list = []
for entry in os.listdir(directory):
    entry_list.append(entry)
print(directory_list)

directory_list = []
file_list = []
path_list = []
for root, dirs, files in os.walk(directory):
    for drc in dirs:
        directory_list.append(drc)
    for file in files:
        file_list.append(file)
        file_path.append(os.path.join(root, file))
print(directory_list)
print(file_list)
print(path_list)

pathlibモジュール

Python3.4以降はpathlibモジュールを利用することができます。

from pathlib import Path


p_dir = Path('ディレクトリ名')
p_file = Path('ファイル名')

p_path = p_dir / p_file
p_path.mkdir(parents=True, exist_ok=True)
print(p_path)

print(p_path.parts)
print(p_path.parent)
print(p_path.name)
print(p_path.stem)
print(p_path.suffix)

print(p_path.is_file()) # True
print(p_path.is_dir()) # False
print(p_dir.is_dir()) # True
print(p_path.exists()) # True

p_path.rmdir()
print(p_path.exists()) # False

まとめ

ここでは、osモジュールとpathlibモジュールについて解説しました。
まだ説明不足なところもあるので、後日追記予定です。

参考資料・リンク

プログラミング言語Pythonとは？AIや機械学習に使える？

はじめに

普段Flaskをよく使いますが、「FastAPIはいいぞ！」と知人に進められたので簡単な画像認識APIを作って見ようと思いました。
しかし、あまりFastAPIとMLの日本語記事を見かけなかったので、メモ代わりに本記事を作成することにしました！

本記事では、開発環境を整えた後、APIサーバとフロントエンドの簡単な説明を記載しております。

今回使用したコードはすべてGithubに公開しています。
（以下実装のフォルダ構成などはGithubを前提に記載しています。サンプルモデルのダウンロードについてもREADME.mdに記載しています。）

FastAPIとは？

FlaskのようなPythonのフレームワークの１つです。

かんたんな概要と使い方のまとめは、以下の記事を参照していただけると良いと思います。（本記事でも大変お世話になりました、ありがとうございます！！）

https://qiita.com/bee2/items/75d9c0d7ba20e7a4a0e9

もっと詳しく知りたい方は、FastAPIの公式チュートリアルが充実しておりオススメです！

https://fastapi.tiangolo.com/tutorial/

画像認識について

今回は時間がなかったため、tensorflow.kerasのモデルを使って構築します！

具体的には、imagenetで学習されたResNet50をそのまま利用し、入力画像を1000クラスのどれに属するかを推論することとします。

（本当に使いたかったモデルは、只今絶賛学習中で間に合わなかった...）

https://www.tensorflow.org/versions/r1.15/api_docs/python/tf/keras?hl=ja

開発環境

Mac OS X Mojave
Python3.7.1（Anaconda）

環境構築

必要なPythonライブラリをインストールします。

$pip install tensorflow==1.15
$pip install fastapi
$pip install uvicorn

以下のような条件があることから、それに必要なライブラリもインストールします。
- index.htmlをRenderする
- 画像ファイルをアップロードする
- 画像を読み込み、リサイズする

$pip install Jinja
$pip install aiofiles
$pip install python-multipart
$pip install opencv-python

APIサーバ

APIサーバの実装は以下のようになりました。

# -*- coding: utf-8 -*-
import io
from typing import List

import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.applications.resnet50 import decode_predictions
from fastapi import FastAPI, Request, File, UploadFile
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

# 画像認識モデルの用意
global model, graph
graph = tf.get_default_graph()
model = tf.keras.models.load_model("./static/model/resnet_imagenet.h5")

# FastAPIの用意
app = FastAPI()

# static/js/post.jsをindex.htmlから呼び出すために必要
app.mount("/static", StaticFiles(directory="static"), name="static")

# templates配下に格納したindex.htmlをrenderするために必要
templates = Jinja2Templates(directory="templates")


def read_image(bin_data, size=(224, 224)):
    """画像を読み込む

    Arguments:
        bin_data {bytes} -- 画像のバイナリデータ

    Keyword Arguments:
        size {tuple} -- リサイズしたい画像サイズ (default: {(224, 224)})

    Returns:
        numpy.array -- 画像
    """
    file_bytes = np.asarray(bytearray(bin_data.read()), dtype=np.uint8)
    img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img = cv2.resize(img, size)
    return img


@app.post("/api/image_recognition")
async def image_recognition(files: List[UploadFile] = File(...)):
    """画像認識API

    Keyword Arguments:
        files {List[UploadFile]} -- アップロードされたファイル情報 (default: {File(...)})

    Returns:
        dict -- 推論結果
    """
    bin_data = io.BytesIO(files[0].file.read())
    img = read_image(bin_data)
    with graph.as_default():
        pred = model.predict(np.expand_dims(img, axis=0))
        result_label = decode_predictions(pred, top=1)[0][0][1]
        return {"response": result_label}


@app.get("/")
async def index(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

フロントからデータを受け取る

@app.post("/api/image_recognition")
async def image_recognition(files: List[UploadFile] = File(...)):
    """画像認識API

    Keyword Arguments:
        files {List[UploadFile]} -- アップロードされたファイル情報 (default: {File(...)})

    Returns:
        dict -- 推論結果
    """
    bin_data = io.BytesIO(files[0].file.read())
    img = read_image(bin_data)
    with graph.as_default():
        pred = model.predict(np.expand_dims(img, axis=0))
        result_label = decode_predictions(pred, top=1)[0][0][1]
        return {"response": result_label}

今回は、FastAPIのUploadFileを使用してPOSTされる画像を取得しております。

bin_data = io.BytesIO(files[0].file.read())

ファイルは一つしかPOSTされないのでfiles[0]としており、フロント側からBASE64形式で渡されるのでAPI側でBytes配列に変換しました。

データを画像に変換する

def read_image(bin_data, size=(224, 224)):
    """画像を読み込む

    Arguments:
        bin_data {bytes} -- 画像のバイナリデータ

    Keyword Arguments:
        size {tuple} -- リサイズしたい画像サイズ (default: {(224, 224)})

    Returns:
        numpy.array -- 画像
    """
    file_bytes = np.asarray(bytearray(bin_data.read()), dtype=np.uint8)
    img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img = cv2.resize(img, size)
    return img

opencvの力を借りて、Byte配列からuint8の画像に変換します。
このとき、opencvのデフォルトフォーマットがBGRなため、RGBに変換してリサイズしました。

推論する

global model, graph
graph = tf.get_default_graph()
model = tf.keras.models.load_model("./static/model/resnet_imagenet.h5")

...

with graph.as_default():
        pred = model.predict(np.expand_dims(img, axis=0))
        result_label = decode_predictions(pred, top=1)[0][0][1]

事前にresnet_imagenet.h5を作成しておき、それをファイル上部で読み込んでいます。
推論処理自体は、with graph.as_default() でグローバルで設定したTensorFlowのグラフにこのスレッドでのコンテキストを固定して、predict関数で推論しています。

今回はtf.kerasのResNet50を使っていることから、predictの結果をラベルに変換するdecode_predictionsを使って推論結果を取得しています。

他のモデルや自作モデルも、プロジェクトディレクトリのどこかに.h5ファイルを保存しておき、それをload_modelすることで、この実装のように使うことができるかと思います。

フロント実装

こちらを参考にさせていただきました。（ありがとうございます！）

https://qiita.com/katsunory/items/9bf9ee49ee5c08bf2b3d

<html>
<head>
    <meta http-qeuiv="Content-Type" content="text/html; charset=utf-8">
    <title>Fastapi　画像認識テスト</title>
    <script src="//code.jquery.com/jquery-2.2.3.min.js"></script>
    <script src="/static/js/post.js"></script>
</head>

<body>

<!-- ファイル選択ボタン -->
<div style="width: 500px">
  <form enctype="multipart/form-data" method="post">
    <input type="file" name="userfile" accept="image/*">
  </form>
</div>

<!-- 画像表示領域 -->
<canvas id="canvas" width="0" height="0"></canvas>

<!-- アップロード開始ボタン -->
<button class="btn btn-primary" id="post">投稿</button>
<br>
<h2 id="result"></h2>
</body>
</html>

// 画像をリサイズして、HTMLで表示する
$(function () {
  var file = null;
  var blob = null;
  const RESIZED_WIDTH = 300;
  const RESIZED_HEIGHT = 300;

  $("input[type=file]").change(function () {
    file = $(this).prop("files")[0];

    // ファイルチェック
    if (file.type != "image/jpeg" && file.type != "image/png") {
      file = null;
      blob = null;
      return;
    }

    var result = document.getElementById("result");
    result.innerHTML = "";

    // 画像をリサイズする
    var image = new Image();
    var reader = new FileReader();
    reader.onload = function (e) {
      image.onload = function () {
        var width, height;

        // 縦or横の長い方に合わせてリサイズする
        if (image.width > image.height) {
          var ratio = image.height / image.width;
          width = RESIZED_WIDTH;
          height = RESIZED_WIDTH * ratio;
        } else {
          var ratio = image.width / image.height;
          width = RESIZED_HEIGHT * ratio;
          height = RESIZED_HEIGHT;
        }

        var canvas = $("#canvas").attr("width", width).attr("height", height);
        var ctx = canvas[0].getContext("2d");
        ctx.clearRect(0, 0, width, height);
        ctx.drawImage(
          image,
          0,
          0,
          image.width,
          image.height,
          0,
          0,
          width,
          height
        );

        // canvasからbase64画像データを取得し、POST用のBlobを作成する
        var base64 = canvas.get(0).toDataURL("image/jpeg");
        var barr, bin, i, len;
        bin = atob(base64.split("base64,")[1]);
        len = bin.length;
        barr = new Uint8Array(len);
        i = 0;
        while (i < len) {
          barr[i] = bin.charCodeAt(i);
          i++;
        }
        blob = new Blob([barr], { type: "image/jpeg" });
        console.log(blob);
      };
      image.src = e.target.result;
    };
    reader.readAsDataURL(file);
  });

  // アップロード開始ボタンがクリックされたら
  $("#post").click(function () {
    if (!file || !blob) {
      return;
    }

    var name,
      fd = new FormData();
    fd.append("files", blob);

    // API宛にPOSTする
    $.ajax({
      url: "/api/image_recognition",
      type: "POST",
      dataType: "json",
      data: fd,
      processData: false,
      contentType: false,
    })
      .done(function (data, textStatus, jqXHR) {
          // 通信が成功した場合、結果を出力する
        var response = JSON.stringify(data);
        var response = JSON.parse(response);
        console.log(response);
        var result = document.getElementById("result");
        result.innerHTML = "この画像...「" + response["response"] + "」やんけ";
      })
      .fail(function (jqXHR, textStatus, errorThrown) {
          // 通信が失敗した場合、エラーメッセージを出力する
        var result = document.getElementById("result");
        result.innerHTML = "サーバーとの通信が失敗した...";
      });
  });
});

ajaxを使って画像認識APIへPOSTを行い、結果を表示しています。

動作確認

結果こんな感じに動くようになりました！

（フロントをもうちょっとオサレにしたかったのですが...）

おわりに

FastAPIのお勉強に画像認識APIを作ってみました。
今回作った実装がベストプラクティスではないと思いますが、動くものをつくることができてよかったかと思います。

今後どのフレームワークを使って仕事をするかわかりませんが、FastAPIは割と使いやすくてFlaskから乗り換えようかなぁと思いました。

最後となりますが、参考にさせていただいた皆様に感謝いたします！