はじめに

シリーズ第2回です。
与えられたいくつかの数値データについて、その平均を出力するように、ニューラルネットワーク(NN)に学習させることはできるでしょうか？また、標準偏差はどうでしょうか？やってみましょう。

NNが学習できる問題は、大きく分けて「分類問題」か「回帰問題」であるとされています。今回は「回帰問題」にあたります。

方針

1. ニューラルネットワークに10個(固定)のランダムな数字を与える。
2. 10個の数字の平均と、標準偏差を、計算する。
3. 10個の数字と、これらの平均と標準偏差を、学習データとして、kerasで作成したNNに与える。
4. NNの出口の数は2(「平均」と「標準偏差」の2つ)。
5. NNをトレーニングした後、学習に用いたのではないデータセットを使って学習させたNNの性能評価を行う。

ではやってみましょう。一般的にNNのトレーニングは学習データの準備が大変とされていますが、その点今回は準備が楽です。

学習データの準備

とりあえず、50000個のトレーニング用データセットを準備することにしました。1セットは10個の数値よりなります。10個の数値は、numpyのrandom.normal(a,b,10)を使用して平均a、標準偏差bの分布データに従う10個のランダムな数値としますが、ここで、aとb自体もnumpyのrandom.rand()で発生させています。

「1０個の数値」、および「これらの平均と標準偏差」を計算して、まずはそれぞれリストに格納します。

001.py

import numpy as np
trainDataSize = 50000 #作成するデータセットの数
dataLength = 10 #1セットあたりのデータ数
d = []#空のリスト 10個ずつ数値を入れる。
average_std = []#空のリスト 2つ目。2つずつ数値を入れる。
for num in range(trainDataSize):
    xx = np.random.normal(np.random.rand(),np.random.rand(),dataLength)
    average_std.append(np.mean(xx))
    average_std.append(np.std(xx))
    d.append(xx)

50000セット全部入れたリストができたら、あらためてndarrayに変換します。

002.py

d = np.array(d) # ndarrayにする。
average_std = np.array(average_std)# ndarrayにする。

なぜ最初からndarrayにしないかといえば、遅いからです。

002.py

#良くないコード。遅いから。
d = np.array([])#空のnumpy array
for num in range(trainDataSize):
    xx = np.random.normal(np.random.rand(),np.random.rand(),dataLength)
    d = np.append(d,xx) #この処理が遅い！

作成したndarrayは、順番に数値データを放り込んだものです。ここで行列のshapeを変えます。

003.py

d = d.reshape(50000,10)
average_std = average_std.reshape(50000,2)

50000のデータセットを、トレーニング用の40000セットと評価用の10000セットの2つに分割。今回ハイパーパラメーターの検討はしないので、2分割で良いことにする。

004.py

#前半40000でトレーニング。後半10000で評価。
d_training_x = d[:40000,:]
d_training_y = average_std[:40000,:]
d_test_x = d[40000:,:]
d_test_y = average_std[40000:,:]

NNのデザイン

ポイントは、
1. 入力のshapeを10にする(必須)
2. 最後のレイヤーの出力数を2にする(必須)。
3. 最後の活性化関数をlinearにする。今回のケースではsoftmaxとかsigmoidとかReLuはそぐわない。平均が0を下回るケースがあるため。
4. 損失関数をmean_squared_errorにする。クロスエントロピーはこの場合そぐわない(分類問題ではないから)。
5. その他レイヤーの数、各レイヤーの出力数と活性化関数は、適当に決定した。

005.py

import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam

model = Sequential()
model.add(Dense(100, activation='tanh', input_shape=(10,)))#入力スロットは10個。
model.add(Dense(100, activation='tanh'))
model.add(Dense(40, activation='sigmoid'))
model.add(Dense(20, activation='sigmoid'))
model.add(Dense(2, activation='linear')) #出力スロットは2つ。
# 確率的勾配降下法 Adam
optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999)
# 損失関数　二乗平均誤差
model.compile(loss='mean_squared_error',optimizer=optimizer)
model.summary() #  NNの概要の出力

NNのトレーニング

いよいよ訓練データを放り込みます。

006.py

history = model.fit(d_training_x, d_training_y,
batch_size=256,# 訓練データを、256セットデータ分をまとめて放り込む。
epochs=20,# 訓練データを、何周繰り返すか。
verbose=1,# verboseは冗長、転じて「おしゃべり」の意。1にしておくとトレーニング過程を逐一出力してくれる。
validation_data=(d_test_x, d_test_y))

学習の進み具合の確認

ここではfit()の返り値を、変数historyにしまっています。返り値historyをtype()で調べると、オブジェクトのようです。vars()で調べてみます。

007.py

type(history) # <class 'keras.callbacks.callbacks.History'>
vars(history) 
# 情報がたくさん出力される。
# 出力される情報をかいつまむと、historyオブジェクトが持っているフィールドは、以下の通り。
# validation_data (リスト)、
# model (NNモデルへの参照)、
# params (辞書。keyは'batch_size'、'epochs'、'steps'、'samples'、'verbose'、'do_validation'、'metrics')
# epoch (リスト)、
# history (辞書。keyは'val_loss'、'loss')
#
# historyのkeyは、'val_loss'と'loss'である。
# lossは学習データに対する損失。val_lossは評価用のデータに対する損失。ここでは変数名がhistoryなので、history.history['val_loss']で、学習がどう進んだかの経過データにアクセスできる。

学習が進行する様子をプロットしてみる。

008.py

import matplotlib.pyplot as plt
plt.plot(history.history['val_loss'], label = "val_loss")
plt.plot(history.history['loss'], label = "loss")
plt.legend() # 凡例を表示
plt.title("Can NN learn to calculate average and standard deviation?")
plt.xlabel("epoch")
plt.ylabel(" Loss")
plt.show()

これで書いたグラフ:

NNの評価

学習が進行したことはわかりますが、どれほど精度良く「計算」できるようになったでしょうか？評価用データの先頭200セットをNNに放り込んで、その出力(縦軸)を数学的な計算結果(横軸)に対してプロットしてみる。

009.py

#トレニーングしたNNにデータを与えてみる
inp = d_test_x[:200,:]
out = d_test_y[:200,:]
pred = model.predict(inp, batch_size=1)

#グラフにする: 平均
plt.scatter(out[:,0], pred[:,0])
plt.legend() # 凡例を表示
plt.title("average")
plt.xlabel("mathematical calculation")
plt.ylabel("NN output")
# 線を引く。この線に乗れば、うまく予測できたことになる。
x = np.arange(-0.5, 2, 0.01)
y = x
plt.plot(x, y)
plt.show()

おおよそ精度良く「計算」できていることがわかります。続いて、標準偏差はどうでしょうか？

009.py

#グラフにする: 標準偏差
plt.scatter(out[:,1], pred[:,1])
plt.legend() # 凡例を表示
plt.title("standard deviation")
plt.xlabel("mathematical calculation")
plt.ylabel("NN output")
x = np.arange(0, 1.5, 0.01)
y = x
plt.plot(x, y)
plt.show()

まずまずといったところでしょうか？平均の方は良いとして、標準偏差は今ひとつ物足りません。

ニューラルネットワークで行われる計算は、ざっくりといえば入力値xに対して各ウエイトパラメーターwを掛け合わせた積を得ること、この積の和を活性化関数の入力として出力値を得ること、です。

平均については、入力値それぞれに0.1 (今回の場合入力する数値が10個なので1/10 = 0.1)をかけて足し合わせれば平均になりますので、NNが10個の数値の平均を精度良く計算できるようになることは、容易に想像ができます。

一方で標準偏差はどうでしょうか？平均値を計算し、ついで入力値それぞれに、平均値に-1をかけたものを足して(つまり、平均との差をとって)、これを2乗して足し合わせて、9で割れば、標準偏差になるはずです。このプロセスで、難しそうなのは、2乗するところです。

NNでは内部的に、固定のウエイトパラメータと入力値の掛け算をおこない、これを足し合わせて活性化関数に渡しています。入力値に対して、これを2乗した値をほとんど誤差がないように返すことは果たして可能なのか？ちょっと私にはわかりません。

もしかすると、活性化関数に、入力値を2乗(拡張してn乗)してくれるやつがあったりすれば良いのかもしれませんね。これについてはどこかで考えてみたいと思いますが、とりあえず平均と標準偏差に近い値を出力できるNNができたということで、第2回は終了したいと思います。
シリーズ第3回はこちら

※この記事はUdemyの
「現役シリコンバレーエンジニアが教えるPython3入門+応用+アメリカのシリコンバレー流コードスタイル」
の講座を受講した上での、自分用の授業ノートです。
講師の酒井潤さんから許可をいただいた上で公開しています。

■クロージャー

難しい内容になるので、今の段階では「こんなものがあるんだな」とわかればOK。

closure

def circle_area_func(pi):

    # radiusを渡すと円の面積が返ってくる
    def circle_area(radius):
        return pi * radius * radius

    # circle_areaを返すだけで実行はしない
    return circle_area

# piを3としてcircle_area_funcに渡し、返ってきたcircle_areaをcal1に代入
cal1 = circle_area_func(3)
# piを3.14としてcircle_area_funcに渡し、返ってきたcircle_areaをcal2に代入
cal2 = circle_area_func(3.14)

# radiusを10としてcal1に渡し、結果をprint
print(cal1(10))
# radiusを10としてcal2に渡し、結果をprint
print(cal2(10))

result

300
314.0

クロージャーは、今回のように
初めに設定した引数(pi)を後々用途応じて使い分けたい(3とするのか3.14にするのか)とき
などに有効な手段なので、頭の片隅に置いておこう。

（１）まずはcsvを使って掲示板を作成する

＜ディレクトリ構成＞

test
├app.py
├articles.csv
├Procfile
├requirements.txt
└templates
  ├index.html
  ├layout.html
  └index_result.html

①コンテンツの作成

仮想環境をディレクトリtestの直下に設定、起動。

python3 -m venv .
source bin/activate

必要なフレームワークとwebサーバーをインストール。

pip install flask
pip install gunicorn

articles.csvに、掲示板のデータをはじめに入れておく。

articles.csv

たま,眠いにゃー
しろ,腹減ったにゃー
クロ,なんだか暖かいにゃー
たま,ぽえーぽえーぽえー
ぽんたん,トイレットペーパーがない
なおちん,チーン

app.pyを作成。

app.py

# -*- coding: utf-8 -*-
from flask import Flask,request,render_template
app = Flask(__name__)

@app.route('/')
def bbs():
    lines = []
    #with openしてcsvファイルを読み込む
    with open('articles.csv',encoding='utf-8') as f:
        lines = f.readlines() #readlinesはリスト形式でcsvの内容を返す
    #index.htmlに返す
    return render_template('index.html',lines=lines)

#postメソッドを受け取る
@app.route('/result',methods=['POST'])
def result():
    #requestでarticleとnameの値を取得する
    article = request.form['article']
    name = request.form['name']
    #csvファイルに上書きモードで書き込む
    with open('articles.csv','a',encoding='utf-8') as f:
        f.write(name + ',' + article + '\n')
    #index_result.htmlに返す
    return render_template('index_result.html',article=article,name=name)


if __name__ == '__main__':
    app.run(debug=False)

index.htmlを作成。

index.html

{% extends 'layout.html' %}
{% block content %}
    <h1> にゃん子掲示板</h1>
    <form action='/result' method='post'>
        <label for='name'>にゃん子の名前</label>
        <input type='text' name='name'>
        <p></p>
        <label for='article'>投稿</label>
        <input type='text' name='article'>

        <button type='subimit'>書き込む</button>
    </form>

    <p></p>
    <p></p>

    <table border=1>
        <tr><th>にゃん子の名前</th><th>投稿内容</th></tr>
        {% for line in lines: %}
        <!--columnという変数をセット（変数セットにはsetが必要）  -->
        <!--splitを利用して,で分類する。splitはリストを返す  -->
            {% set column = line.rstrip().split(',') %}
            <tr><td>{{column[0]}}</td><td>{{column[1]}}</td></tr>
        {% endfor %}
    </table>

{% endblock %}

htmlのテンプレートを作成。

layout.html

<!DOCTYPE html>
<html lang='ja'>
  <head>
      <meta charset='utf-8'>
      <title>Nyanko BBS</title>
      <style>body{padding:10px;}</style>
  </head>
  <body>
    {% block content %}
    {% endblock %}
  </body>
</html>

index.htmlで入力したフォームの内容をindex_result.htmlであらわす。

layout.html

{% extends 'layout.html' %}
{% block content %}
    <h1>　にゃ-んと掲示板に書き込みました</h1>
    <p>{{name}}{{article}}</p>

    <!--formで/に戻る -->
    <form action='/' method='get'>
      <button type='submit'>戻る</button>
    </form>

{% endblock %}

②Herokuへデプロイ

Herokuへのデプロイ詳細は以下の記事に書いた通りなので、詳細説明を省く。
Heroku、Flask、Python、Gitでアップロードする方法（その②）
Procfile、requirements.txtを作成、gitで操作して無事にデプロイできた。

”いわし”、”魚が大好き”と投稿すると、

書き込み成功！
戻ると、

ちゃんと掲示板に書き込みされてます。

次回はデータベースを組み込む

csvの書き込みはしばらくすると（３０分）データが消えてしまうので、データベースを使ってみたい。

機械学習で「Input contains NaN, infinity or a value too large for dtype('float64').」というエラーが出たときの対処法

エラーの原因

上のエラーに書いてある通りデータにNaNかinfかfloat64でないタイプのものが混じっている。文字列を含む列をpandasで以下のように書き、Naも埋めたのにエラーが出た。

df=df.drop(columns=df.select_dtypes(include='object').columns)

これでは列の中に一部含まれるfloat以外の値を変換することができないみたいだ。
そこでnumpyで使えるようにndarrayに変換した後、float以外の値になるやつをfloat型に変換させ、float型に変更不可能なものをNaとし、その後欠損値を変換した。

X = df.iloc[:, 1:].values
y = df.iloc[:, 0].values
for i in range(X.shape[1]):
    X[:,i]= pd.to_numeric(X[:,i], errors='coerce')
X1=np.nan_to_num(X)

これが正しい処理なのかはよくわからないが、とりあえずモデルを学習させるときのエラーはなくなった。
なにかいいやり方があったらコメントお願いします。

※この記事はUdemyの
「現役シリコンバレーエンジニアが教えるPython3入門+応用+アメリカのシリコンバレー流コードスタイル」
の講座を受講した上での、自分用の授業ノートです。
講師の酒井潤さんから許可をいただいた上で公開しています。

■関数内関数

◆使い方

inner_function

def outer(a, b):

    def plus(c, d):
        return c + d

    r = plus(a, b)
    print(r)

outer(1, 2)

result

3

関数の中で、さらに新しい関数を定義することも可能である。
内側の関数(plus)を、外側の関数(outer)以外の場所で使わない場合、
関数内関数として記述してやるとよい。

※この記事はUdemyの
「現役シリコンバレーエンジニアが教えるPython3入門+応用+アメリカのシリコンバレー流コードスタイル」
の講座を受講した上での、自分用の授業ノートです。
講師の酒井潤さんから許可をいただいた上で公開しています。

■関数の説明の記述

◆関数内に記述する

docstrings

def example_func(param1, param2):
    """Example function with types documented in the docstring.

    Args:
        param1 (int): The first parameter. 
        param2 (str): The second parameter.

    Returns:
        bool: The return value. True for success, False otherwise.
    """
    print(param1)
    print(param2)
    return True

一旦サンプルの関数を用意した。
このサンプルの説明書きとして、通常であれば説明する行の上にコメントアウトするが、
関数の場合は内側の先頭に書くのがお約束。

◆docstringsを呼び出す

docstrings

def example_func(param1, param2):
    """Example function with types documented in the docstring.

    Args:
        param1 (int): The first parameter.
        param2 (str): The second parameter.

    Returns:
        bool: The return value. True for success, False otherwise.
    """
    print(param1)
    print(param2)
    return True

print(example_func.__doc__)

result

Example function with types documented in the docstring.

    Args:
        param1 (int): The first parameter.
        param2 (str): The second parameter.

    Returns:
        bool: The return value. True for success, False otherwise.

.__doc__のメソッドで、その関数のdocstrinsを呼び出せる。

◆docstringsを呼び出す2

docstrings

def example_func(param1, param2):
    """Example function with types documented in the docstring.

    Args:
        param1 (int): The first parameter.
        param2 (str): The second parameter.

    Returns:
        bool: The return value. True for success, False otherwise.
    """
    print(param1)
    print(param2)
    return True

help(example_func)

result

Help on function example_func in module __main__:

example_func(param1, param2)
    Example function with types documented in the docstring.

    Args:
        param1 (int): The first parameter.
        param2 (str): The second parameter.

    Returns:
        bool: The return value. True for success, False otherwise.

helpを使うことでも、docstringsを呼び出すことができる。

はじめに

今回から、python3で競プロの問題(AtCoder)を解く毎日という企画をしようと思います。問題の選択は、AtCoder ProblemsのRecommendationsからです。

目的

• レートを上げる。
• 初見問題への対応力をつける

#1

問題

考えたこと
2WAしました。場合分けを考える問題が苦手なことが分かりました。
この問題は、n mod(10)の大きさで場合分けしました。問題を読むと、N個以上買うのにいくらかかるかを答えるので、Nを越えた数を買ってもよいことが分かります。個別に買った方が安いのか、まとめて買った方が安いのかをn mod(10)で比較すると次のようになります。

n mod(10), 個別, 個別とまとめて買ったときの差
1 , 15 , 85
2 , 30 , 70
3 , 45 , 55
4 , 60 , 40
5 , 75 , 25
6 , 90 , 10
7 , 105 , -5
8 , 120 , -20
9 , 135 , -35
10 , 150 , -50

となります。
このことからn mod(10)>6のときにまとめて買った方が安いことが分かります。
よって、

if n % 10 > 6:
    b = 100 * (n // 10 + 1)
else:
    p = n % 10
    b = 100 * (n // 10) + p * 15

にすれば、うまく条件を満すことができます。
あとは上のコードに標準入力と出力をつけるだけです。出力には、min()を使います。

n = int(input())
a = 15 * n
if n % 10 > 6:
    b = 100 * (n // 10 + 1)
else:
    p = n % 10
    b = 100 * (n // 10) + p * 15
print(min(a,b))

まとめ

A問題なのに2WAも出してしまったのが悔しい。タグに不穏なワードが入っていますが、そうならないようにがんばります。

※この記事はUdemyの
「現役シリコンバレーエンジニアが教えるPython3入門+応用+アメリカのシリコンバレー流コードスタイル」
の講座を受講した上での、自分用の授業ノートです。
講師の酒井潤さんから許可をいただいた上で公開しています。

■キーワード引数の辞書化

◆例

keyword_augment_dict

def menu(food='beef', drink='wine'):
    print(food, drink)

menu(food='beef', drink='coffee')

result

beef coffee

まずこういったサンプルを用意する。
ここに、食べ物や飲み物だけでなく、他にも付け足したいときを考える。

◆キーワード引数を辞書化する

keyword_augment_dict

def menu(**kwargs):
    print(kwargs)

menu(food='beef', drink='coffee')

result

{'food': 'beef', 'drink': 'coffee'}

menuにわたす引数の頭に**をつけることで、
わたした引数が辞書化される。

keyword_augment_dict

def menu(**kwargs):
    for k , v in kwargs.items():
        print(k, v)

menu(food='beef', drink='coffee')

result

food beef
drink coffee

作成された辞書のkeyとvalueを引っ張ってきてprintするように組んだ。

keyword_augment_dict

def menu(**kwargs):
    for k , v in kwargs.items():
        print(k, v)

d = {
    'food': 'beef',
    'drink': 'ice coffee',
    'dessert': 'ice cream'
}
menu(**d)

result

food beef
drink ice coffee
dessert ice cream

dで作った辞書は、menu(**d)により、それぞれのkeyとvalueのセットに展開されて渡される。

■普通の引数、位置引数のタプル化、キーワード引数の辞書化の同時使用

◆同時使用も可能

args

def menu(fruit, *args, **kwargs):
    print(fruit)
    print(args)
    print(kwargs)

menu('banana', 'apple', 'orange', food='beef', drink='wine')

result

banana
('apple', 'orange')
{'food': 'beef', 'drink': 'wine'}

最初のbananaは普通の引数としてfruitに渡され、
appleとorangeは*argsに渡されることでタプル化され、
beefとwineは**kwargsにより辞書化された。

◆注意点

args

def menu(fruit, **kwargs, *args):
    print(fruit)
    print(kwargs)
    print(args)

menu('banana', food='beef', drink='wine', 'apple', 'orange')

result

    def menu(fruit, **kwargs, *args):
                              ^
SyntaxError: invalid syntax

**kwargsを先に、*argsを後にするとエラーとなる。
これらを同時に使う場合は、* → **の順で使うようにしよう。

※この記事はUdemyの
「現役シリコンバレーエンジニアが教えるPython3入門+応用+アメリカのシリコンバレー流コードスタイル」
の講座を受講した上での、自分用の授業ノートです。
講師の酒井潤さんから許可をいただいた上で公開しています。

■位置引数のタプル化

◆例

positional_augment_tuple

def say_something(word1, word2, word3):
    print(word1)
    print(word2)
    print(word3)

say_something('Hi!', 'Mike', 'Nancy')

result

Hi!
Mike
Nancy

もちろんこのように、いちいちword1,word2,word3のように設定してもよいが、
位置引数をタプル化することでうまくやる方法がある。

◆位置引数をタプル化する

positional_augment_tuple

def say_something(*args):
    print(args)

say_something('Hi!', 'Mike', 'Nancy')

result

('Hi!', 'Mike', 'Nancy')

say_something()の()の中に入れる引数の頭に*をつけることで、
そこに入ってくる引数をタプル化することができる。

これで生成したタプルをさらにforループを回してprintすることで、先程のものを再現できる。

positional_augment_tuple

def say_something(*args):
    for arg in args:
        print(arg)

say_something('Hi!', 'Mike', 'Nancy')

result

Hi!
Mike
Nancy

◆普通の引数と組み合わせる

positional_augment_tuple

def say_something(word, *args):
    print('word =', word)
    for arg in args:
        print('arg =', arg)

say_something('Hi!', 'Mike', 'Nancy')

result

word = Hi!
arg = Mike
arg = Nancy

say_something'に渡す引数として、wordを追加してみた。
すると、最初の引数であるHi!のみがまずwordに入り、
それ以降の引数であるMikeとNancyは*argsに入ることがわかる。

◆注意点

positional_augment_tuple

def say_something(*args, word):
    print('word =', word)
    for arg in args:
        print('arg =', arg)

say_something('Hi!', 'Mike', 'Nancy')

result

    say_something('Hi!', 'Mike', 'Nancy')
TypeError: say_something() missing 1 required keyword-only argument: 'word'

*argsを先に、wordを後にすると、エラーとなってしまう。
必ず、普通の引数 → *の順で使うようにしよう。

今回はABC43のC,D問題を解いてみた。

まずC問題から。

abc43_c.py

n = int(input())
a = list(map(int,input().split()))
avg = 0
for i in a:
    avg = avg + i

avg1 = avg//n
avg2 = avg//n + 1
ans1 = 0
ans2 = 0

for i in a:
    ans1 = ans1 + pow((i-avg1),2)
    ans2 = ans2 + pow((i-avg2),2)

print(min(ans1,ans2))     

続いてD問題。

abc43_d.py

 s = input()
# print(s)
flag=0
for i in range(len(s)-1):
    if s[i]==s[i+1]:
        print(i+1,i+2)
        flag = 1
        break
    if i<len(s)-2:
        if s[i]==s[i+2]:
            print(i+1,i+3)
            flag = 1
            break
if flag ==0:
    print(-1,-1)

最初に

https://twitter.com/shikumie に @付きでメンションするとオススメボカロ曲を教えてくれます。
こちらを試してからの方が下記記事は理解しやすいかもしれません。

こんな感じになる筈です

なお、 返信までに最大5分程度かかります。
気長にお待ちください。

5分待っても返信が来なかったらとりこぼしていたり、なんらかの理由で落ちている可能性があります。
次の日などに試していただけるともしかしたらうまくいくかもしれません

やったこと（ざっくり）

下記を5分に1回実行するlambdaを作成した
1. メンションがきているかを確認し、リプライ先となるstatus_idを取得
2. 1.で得られた返信先ユーザの直近のツイート(最大5つ)を取得
3. ツイートに含まれる特徴量を抽出し、事前に作っておいた楽曲の特徴量と比較、最も近い物を選択
4. 3で得た楽曲情報を1.で得たstatus_idにリプライ

やったこと(詳細)

0. 事前準備

0.1 Twitter APIの準備

botにツイートしてもらったり、オススメを聞いてきた人のツイートを取得したりするのにAPIを利用します。

自分が開発を行った際は、下記記事を読んで、とりあえずツイートできるところまで進めました。
https://qiita.com/channel-techtok/items/dc5028f667a9dde17092

0.2 lambdaの準備

5分に1回、lambdaが起動するように準備しておきます。
今回はsam-cliを使用しました。

この辺りの準備に関しては、以前記事を書いているので参考にしていただければと思います。
https://qiita.com/miyatsuki/items/c221b48830db2b0a9eba#2-1%E3%81%A7%E4%BD%9C%E3%81%A3%E3%81%9F%E3%82%B9%E3%82%AF%E3%83%AA%E3%83%97%E3%83%88%E3%82%92lambda%E7%B5%8C%E7%94%B1%E3%81%A7%E5%AE%9A%E6%9C%9F%E5%AE%9F%E8%A1%8C%E3%81%95%E3%81%9B%E3%82%8B

1. メンションがきているかを確認し、リプライ先となるstatus_idを取得

メンションは下記のAPIで取得できます。
https://developer.twitter.com/en/docs/tweets/timelines/api-reference/get-statuses-mentions_timeline

メンションの投稿時刻, screen_name, ツイート文, メンションのstatus_id(リプライ先) を取得します。

get_mentions.py

def get_mentions(twitter):
    # ツイート処理
    res = twitter.get("https://api.twitter.com/1.1/statuses/mentions_timeline.json", params={"count": 200})

    # エラー処理
    if res.status_code != HTTPStatus.OK:
        print(f"Failed: {res.status_code}")
        return []

    mentions = []
    for mention in res.json():

        # 会話中の@mentionは無視する
        if mention["in_reply_to_status_id_str"]:
            continue

        unixtime = int(datetime.strptime(mention["created_at"], '%a %b %d %H:%M:%S %z %Y').timestamp())
        mentions.append((unixtime, mention["user"]["screen_name"], mention["text"], mention["id"]))

    return mentions

CONSUMER_KEY        = 'XXX'
CONSUMER_SECRET     = 'XXX'
ACCESS_TOKEN_KEY    = 'XXX'
ACCESS_TOKEN_SECRET = 'XXX'

# twitter操作用クラス
twitter = OAuth1Session(
    CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET
)

#[[unixtime, screen_name, tweet, status_id], ...]
mentions = get_mentions(twitter)

2. 1.で得られた返信先ユーザの直近のツイート(最大5つ)を取得

各ユーザのツイートは下記APIで取得できます。
https://developer.twitter.com/en/docs/tweets/timelines/api-reference/get-statuses-user_timeline

get_new_tweets.py

def get_new_tweets(twitter, screen_name):

    # RTなども取得件数に含まれてしまうので、countは多めに取っておく
    res = twitter.get("https://api.twitter.com/1.1/statuses/user_timeline.json", params={"screen_name": screen_name, "count": 20})

    # エラー処理
    tweets = []
    if not res.status_code == HTTPStatus.OK:
        print(f"Failed: {res.status_code}")
        return []

    for res_i in res.json():
        print(res_i["text"])
        tweet = res_i["text"]

        # メンションは無視する (botへの呼びかけも含んでしまうので)
        if "@" in tweet:
            continue

        tweets.append(tweet)

        # いったん5ツイート集まったら終わりにする
        if len(tweets) >= 5:
            break

    return tweets

CONSUMER_KEY        = 'XXX'
CONSUMER_SECRET     = 'XXX'
ACCESS_TOKEN_KEY    = 'XXX'
ACCESS_TOKEN_SECRET = 'XXX'

# twitter操作用クラス
twitter = OAuth1Session(
    CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET
)

user_tweets_map = {}

# screen_namesはツイートを取得したいscreen_nameを格納したiteratable
for screen_name in screen_names:
    tweets =  get_new_tweets(twitter, screen_name)
    if tweets:
        user_tweets_map[screen_name] = tweets

3. ツイートに含まれる特徴量を抽出し、事前に作っておいた楽曲の特徴量と比較、最も近い物を選択

3.1. 楽曲から特徴量を取得

3.1.0 歌詞データの収集

今回は推薦対象の楽曲の歌詞データから特徴量を取得します。
その前提として、推薦する楽曲の歌詞データを事前に取得しておく必要がありますが、ここはすでにあるものとして話を進めます。
実際にはスクレイピングしてデータを集めていますが、その部分の詳細についてはここでは触れません。

3.1.1 特徴量の計算(学習)

今回は「ドキュメント内の文字を漢字のみに絞った」上で各漢字をwordとみなしてword2vecを計算することで漢字ごとにベクトルを算出、ドキュメント内に含まれる漢字ベクトルの平均値をドキュメントの特徴量としました。

普通に考えると「既存のword2vec」のモデルを流用した方が良さそうな気もするのですが、それができない、異なるレイヤーの問題が存在します

• 歌詞という文脈における単語の使われ方と既存のニュース記事やwikipediaにおける単語の使われ方が一致していないような気がする
  • 例えば「太陽」という単語はニュース記事では天文分野の他の単語（惑星）などが近い気がするが、歌詞の文脈だと比喩表現としてもっと近い単語があるように思える（情熱とか）
• そもそも推論フェーズで形態素解析が動かない可能性があるので、形態素ベースの既存モデルが使えない
  • lambdaの場合、使用できるライブラリの上限が250MBという制約がある
    • 厳密にはlambdaにアップロードできるファイルサイズの上限
  • 例えばpure pythonの形態素解析ライブラリであるjanomeはこれだけで100MB程度を占有する
    • janome: https://mocobeta.github.io/janome/
  • さらに、実行時もメモリ量ごとに従量課金額が変動するので可能な限り使用するライブラリを節約しメモリ量を削減したい

ということで、推論時の負荷を可能な限り下げ、かつ、歌詞の文脈における情報も可能な限り持たせる方法ということで漢字のみのword2vecを使用することにしました。

学習時のコードは下記の通りです。
この部分のコードは事前に計算しておく前提なので、numpyやgensimを使っています。

なお、漢字だけを抜き出す部分については下記を参考にしました
https://qiita.com/mocha_xx/items/00c5a968f7069d8e092c

train.py

### 歌詞から漢字の部分だけを抜き出して、学習用データ作成
import re

re_kanji = re.compile(r'^[\u4E00-\u9FD0]$')

corpus = []
title_list = []

### lyrics_mapは lyrics_map["title"] = "lyrics" であるdict
for title, lyric in lyrics_map.items():
    token_list = []

    for line in lyric.split("\n"):
        for token in line:
            if re_kanji.fullmatch(token):
                token_list.append(token)

    if len(token_list) > 20:    
        title_list.append(title)
        corpus.append(token_list)

### gensimのword2vecで漢字ごとのベクトルを計算
from gensim.models import word2vec
model = word2vec.Word2Vec(corpus, size=200, min_count=20, window=10)

### 推論時はgensimのモデルを使えないので、普通のdictにしておく
word_wv_map = {}
print(len(model.wv.index2word))
for word in model.wv.index2word:
    wv = [0.0] * len(model.wv[word])

    for i, val in enumerate(model.wv[word]):
        wv[i] = float(val)

    word_wv_map[word] = wv

### 歌詞全体のベクトルは、歌詞に含まれる漢字ベクトルの平均とする
import numpy as np
import json
import math

title_wv_map = {}

for title in title_list:
    token_count = 0
    wv = np.array([0.0] * len(model.wv[word]))
    wv_list = [0] * len(wv)

    lyric = lyrics_map[title]

    for line in lyric.split("\n"):
        for token in line:
            if token in model.wv:
                wv += model.wv[token]
                token_count += 1

    # 平均した後L2正規化する
    if token_count > 20:
        wv /= token_count
        wv /= math.sqrt(sum(wv*wv))

        for i, val in enumerate(wv):
            wv_list[i] = float(val)

        title_wv_map[title] = wv_list

### 推論用に保存
with open("features_wv.json", "w") as f:
    json.dump(word_wv_map, f)

with open("title_wv.json", "w") as f:
    json.dump(title_wv_map, f)

3.1.2 特徴量の計算(推論)

3.1.1で作ったモデルを使って推論＝最もその人のツイートに近い楽曲の推薦を行います。
この部分はlambda上で動かすので、numpyやgensimは使わずにpure pythonで書いています。

predict.py

def get_wv_from_tweets(feature_wv_map, tweets):
    wv_length = 200
    wv = [0.0] * wv_length

    token_count = 0
    for tweet in tweets:
        for token in tweet:
            if token in feature_wv_map:
                for i, val in enumerate(feature_wv_map[token]):
                    wv[i] += val
                    token_count += 1

    if token_count == 0:
        return

    # 平均を計算する
    for i in range(len(wv)):
        wv[i] /= token_count

    # L2正規化
    l2_acc = 0
    for val in wv:
        l2_acc += val * val

    for i in range(len(wv)):
        wv[i] /= math.sqrt(l2_acc)

    return wv


def get_nearest_title(title_vector_map, wv):
    max_sim = 0
    max_title = None

    for title, vec in title_vector_map.items():
        sim = 0
        for val_wv, val_test in zip(vec, wv):
            sim += val_wv * val_test

        if sim > max_sim:
            print(title, sim)
            max_sim = sim
            max_title = title

    if sim == 0:
        return
    else:
        return max_title

with open("features_wv.json") as f:
    feature_wv_map = json.load(f)

with open("title_wv.json") as f:
    title_wv_map = json.load(f)

### tweets = ["tweet1", "tweet2", ... ] というiteratable
wv = get_wv_from_tweets(feature_wv_map, tweets)
nearest_title = get_nearest_title(title_wv_map, wv)

4. 3で得た楽曲情報を1.で得たstatus_idにリプライ

tweet.py

def post_tweet(twitter, body, reply_id):
    res = twitter.post(
        "https://api.twitter.com/1.1/statuses/update.json",
        params={"status": body, "in_reply_to_status_id": reply_id},
    )
    print(res)

    # エラー処理
    if res.status_code == HTTPStatus.OK:
        print("Successfuly posted: ", body)
    else:
        print(f"Failed: {res.status_code}")
        print(body)

CONSUMER_KEY        = 'XXX'
CONSUMER_SECRET     = 'XXX'
ACCESS_TOKEN_KEY    = 'XXX'
ACCESS_TOKEN_SECRET = 'XXX'

# twitter操作用クラス
twitter = OAuth1Session(
    CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN_KEY, ACCESS_TOKEN_SECRET
)

### 「本文」には3.で求めた楽曲のタイトルとかをよしなに入れてください
### reply_idは1.で求めてたstatus_idです
post_tweet(twitter, "本文", reply_id)

所感

• lambdaで機械学習系のプロダクトを作るのはかなり厳しいなあと思いました
  • 実行時のメモリはお金を積めば無理やり解決できるが、アップロード制限を回避する方法がないため
• 今回はいったん形にすることを最優先にして「漢字だけのword2vec」という謎のアプローチを採用しましたが、ちゃんとEC2立てて普通にword2vec使った方がいいんだろうなあという気がしています
• ただ、（自分がTwitterでそこまで感情を吐く方ではないので、）楽曲の推薦結果が妥当かどうかの判断が主観的にすら難しいなあと思いました
  • ので、誰かが使ってくれるとうれしいです。

再掲

https://twitter.com/shikumie に @付きでメンションするとオススメボカロ曲を教えてくれます。
ここまで書いた仕組みで動いていますので、興味がある方はお試しください。

※この記事はUdemyの
「現役シリコンバレーエンジニアが教えるPython3入門+応用+アメリカのシリコンバレー流コードスタイル」
の講座を受講した上での、自分用の授業ノートです。
講師の酒井潤さんから許可をいただいた上で公開しています。

■デフォルト引数で気をつけること

◆空のリストや辞書はデフォルト引数に使わない

list_augment

def test_func(x, l = []):
    l.append(x)
    return l

r = test_func(100)
print(r)

r = test_func(100)
print(r)

result

[100]
[100, 100]

毎回新しいリストを使う場面が多いが、
そんなときにデフォルト引数に空のリストを設定してしまうと、
1つのリストをずっと使い続けることになる。

◆毎回初期化するように組み込む

list_augment

def test_func(x, l = None):
    # lを空のリストに初期化する
    if l is None:
        l = []
    l.append(x)
    return l

r = test_func(100)
print(r)

r = test_func(100)
print(r)

result

[100]
[100]

def内で、最初にlを初期化するように記述してやる。
そうすると、test_funcを呼び出すごとに毎回lの初期化が行われるため、
毎回空のリストを使えるようになる。

はじめに

自然言語処理の様々なタスクでSOTAを更新したBERTですが、2019年12月に日本語のpretrainedモデルがpytorch版BERTに追加されました。これにより日本語のBERTが以前より簡単に試せるようになりました。しかし、依然としてBERTの日本語QAモデルに関する記事が存在しなかったため、この記事では日本語pretrainedモデルをfinetuningすることで日本語QAモデルを作成する方法について説明します。モデル作成の大まかな流れは以下のようになっているので、この流れを頭に入れて記事を読むと理解しやすいと思います。

モデル作成の流れ

1.モデルの学習データを用意する（これができれば、ほぼ完了です）
2.すでに用意された、run_squad.pyと言うスクリプトを実行する
3.モデル完成

この記事で扱う内容

1. 事前知識
   　・BERTとは
   　・squadの形式
2. 学習データの用意
   　・学習データの構造の説明
   　・squadを25025問翻訳する
   　・Squad2形式に変更
   　・オリジナルデータを使う場合
   
3. finetuningの仕方
   　・使用する事前学習モデルの選択
   　・変更する必要のあるスクリプトについて
   　・finetuningに必要なデータ量の目安、学習時間
   
4. モデルの使用方法
   
5. 結果
   　・モデルの精度
   　・モデルの出力

事前知識

この記事で紹介する方法でfinetuningをする場合、BERTへの理解よりもSQuADの形式の理解の方が大切になってくるため、SQuADの説明を重点的にします。

BERTとは

BERTに関する説明はすでに多くの方が説明しているのでここでは詳細は省きますが、BERTは2018年にgoogleが発表した自然言語処理モデルで現在googleの検索エンジンなどに使われています。BERTの大きな特徴はfinetuningすることでQA、感情分析など様々なタスクに適用することができることです。

詳しいことが気になる方は下記のリンクをご覧ください。
https://qiita.com/Kosuke-Szk/items/4b74b5cce84f423b7125

squadの形式

Stanford Question Answering Dataset（SQuAD）は質疑応答に関するタスクで、問題文とそれに関する質問・回答で構成されるデータセットです。すべての質問に対する回答は、対応する問題文の一部になっています（国語の抜き出し問題に似ています）。SQuADにはバージョンが二つあり(v1.1、v2.0)、v1.１は全ての質問が回答可能でv2.0では答えられない質問が含まれています。今回は答えられない質問などにも対応したいため、SQuAD 2.0形式のデータを使ってBERTをfinetuningします。

SQuAD 1.1

• train-v1.1.json
• dev-v1.1.json

SQuAD 2.0

• train-v2.0.json
• dev-v2.0.json

実際のSQuAD 2.0のデータ形式は以下のようになります。

{
    "version": "v2.0",
    "data": [
        {
            "title": "りんご",
            "paragraphs": [
                {
                    "qas": [
                        {
                            "question": "りんごは何色?",
                            "id": "56be85543aeaaa14008c9063",
                            "answers": [
                                {
                                    "text": "赤",
                                    "answer_start": 4
                                }
                            ],
                            "is_impossible": false
                        },
                        {
                            "plausible_answers": [
                                {
                                    "text": "美味しい",
                                    "answer_start": 7
                                }
                            ],
                            "question": "バナナは美味しい？",
                            "id": "5a8d7bf7df8bba001a0f9ab1",
                            "answers": [],
                            "is_impossible": true
                        }
                    ],
                    "context": "りんごは赤くて美味しい。"
                }
            ]
        }
    ]
}

それぞれの項目の説明

キー	値
version	バージョンを示している（今回は SQuAD 2.0を使うため v2.0）
data	問題文ごとにデータをリスト形式で保持
title	問題文のタイトル
paragraphs	問題文の段落一つとそれに関連する複数の質問、回答を保持
qas	質問と回答をリスト形式で保持
question	質問
answers	問題文から抜き出した答えとその位置のデータをリスト形式で保持。 train-v2.0では答えは0個または1個、dev-v2.0では答えは4つ存在する。
text	問題文から抜き出した答えのテキスト
answer_start	問題文中の答えの位置情報、pythonの 問題文.find(答え) の値と一致する。（問題文内に答えが一回しか登場しない場合）
id	質問固有のid
is_impossible	答えられない質問の時にtrue、それ以外の時はfalse
plausible_answers	質問が答えられないの時のみ存在する項目、問題文から答えになりうる部分を抜き出している
context	答えが存在すると考えられる文章（問題文に当たる）

学習データの用意

すでにQAのデータを持っている場合、データをSQuAD2.0の形式に成形するだけで学習データができるのですが、おそらく多くの方はこれらのデータを用意できないと思うので、今回はデータがない状態からSQuAD 2.0形式のデータを2万問分用意した方法も説明します。

データ作成

SQuAD 2.0形式のデータを作成するためには以下の情報が必要です。

1.context(問題文)
2.question(質問)
3.answer(回答)

日本語のQAデータにはNIILC Question Answering Dataset、NTCIR-6 QAC4、Yahoo! 知恵袋データ（第3版）などがありますが、上記の情報が含まれデータ数が多いデータセットが存在しません。（もし知っていれば教えてください）
そのため今回はSQuAD 2.0自体ををgoogle翻訳で翻訳してデータを作成します。

finetuningの仕方

はじめにでも言ったようにfinetuningはrun_squad.pyを少し変更して実行するだけでできます。

事前学習モデルの選択

この記事で使用しているTransformersのバージョン(2.8.0)では4つのモデルが使用できます。

• bert-base-japanese
  
• bert-base-japanese-whole-word-masking
  
• bert-base-japanese-char
  
• bert-base-japanese-char-whole-word-masking

詳細はcl-tohoku repositoryを見てください。
今回試したところbert-base-japanese-whole-word-maskingが一番性能がよかったのでこれを使用しますが、もし他のモデルも試してみたい場合はこのノートブックで簡単に試せるので試してみてください。

run_squad.pyの変更点

run_squad.pyの変更点は以下の3つだけです。すでに必要なところを変更したスクリプトをgithubに公開しているのでこちらを見るとわかりやすいと思います。
https://github.com/kuma807/bert_qa/blob/master/run_squad.py

1.mecabをimportする

import MeCab

mecabは形態素解析器で、BERTに与える日本語を分割するために使用します。

2.transformersレポジトリから新たに

• BertForQuestionAnswering
• AutoTokenizer
• AutoConfig

をimportする。これらは事前学習モデル、tokenizer、設定になっています。

from transformers import (
    WEIGHTS_NAME,
    AdamW,
    AlbertConfig,
    AlbertForQuestionAnswering,
    AlbertTokenizer,
    ...省略...
    XLNetTokenizer,
    get_linear_schedule_with_warmup,
    squad_convert_examples_to_features,
    BertForQuestionAnswering,
    AutoTokenizer,
    AutoConfig,
)

3.MODEL_CLASSESに

• bert-base-japanese-whole-word-masking

を追加する。このクラス名はのちにfinetuningするときに使います。

MODEL_CLASSES = {
    "bert": (BertConfig, BertForQuestionAnswering, BertTokenizer),
    "camembert": (CamembertConfig, CamembertForQuestionAnswering, CamembertTokenizer),
    "roberta": (RobertaConfig, RobertaForQuestionAnswering, RobertaTokenizer),
    "xlnet": (XLNetConfig, XLNetForQuestionAnswering, XLNetTokenizer),
    "xlm": (XLMConfig, XLMForQuestionAnswering, XLMTokenizer),
    "distilbert": (DistilBertConfig, DistilBertForQuestionAnswering, DistilBertTokenizer),
    "albert": (AlbertConfig, AlbertForQuestionAnswering, AlbertTokenizer),
    "bert-base-japanese-whole-word-masking": (AutoConfig.from_pretrained("cl-tohoku/bert-base-japanese-whole-word-masking"), BertForQuestionAnswering.from_pretrained("cl-tohoku/bert-base-japanese-whole-word-masking"), AutoTokenizer.from_pretrained("cl-tohoku/bert-base-japanese-whole-word-masking")),
}

MODEL_CLASSESに追加する形式は
"モデルのクラス名": モデルの設定, 事前学習モデル, tokinizerの設定
となっています。

run_squad.pyの実行

run_squad.pyの実行は以下のコマンドでできます。以下のコマンドはノートブック形式で実行されることを想定しているため、ターミナルから実行する場合は一番最初の!を取り除いてください。

!python bert_qa/run_squad.py\
  --model_type  モデルのクラス名 \
  --model_name_or_path モデルの名前 \
  --predict_file テストデータへのパス \
  --train_file 学習データへのパス \
  --do_train \
  --per_gpu_train_batch_size 12 \
  --learning_rate 3e-5 \
  --num_train_epochs 2.0 \
  --max_seq_length 384 \
  --doc_stride 128 \
  --fp16 \
  --do_eval \
  --save_steps 3000 \
  --version_2_with_negative \
  --output_dir 学習したモデルの保存場所/

今回の例でいくとモデルのクラス名がbert-base-japanese-whole-word-masking、モデルの名前がcl-tohoku/bert-base-japanese-whole-word-maskingになっています。

オプション	意味
fp16	浮動小数点の精度を落とすことで学習を高速化する、これがないとcolaboratoryで実行できない
version_2_with_negative	squad 2.0で学習する場合必要

モデルの使用方法

こちらもノートブックの　”モデルの使用方法”　にモデルを使用するためのスクリプトが乗っているので確認してください。qiitaではモデルを使用するためのスクリプトについて説明します。さらに詳しいことがきになる方はこちらへ。

モデルの読み込み

1.設定をmodel_directoryから読み込む

config = AutoConfig.from_pretrained(model_directory + "/config.json")
tokenizer_config = AutoConfig.from_pretrained(model_directory + "/tokenizer_config.json")

名前から分かるようにconfigはモデルの設定、tokenizer_configはtokenizerの設定になっています。

2.　1.の設定でモデル読み込む

model = BertForQuestionAnswering.from_pretrained(pretrained_model, config=config)
model.load_state_dict(torch.load(model_directory + "/pytorch_model.bin", map_location=torch.device('cpu')))
tokenizer = AutoTokenizer.from_pretrained(pretrained_model, config=tokenizer_config)

2行目のmap_location=torch.device('cpu')となっているところをmap_location=torch.device('cuda')と変更することでgpuでの実行ができるようになります。

モデルへの入力

モデルへの入力は

• input_ids
• token_type_ids
  の二つになります。

question = "りんごは何色?"
context = "りんごは赤くて美味しい。"
input_ids = tokenizer.encode(question, context)
token_type_ids = [0 if i <= input_ids.index(3) else 1 for i in range(len(input_ids))]

input_ids

tokenizer.encode(question, context)で行われてる処理を説明します。
まずquestionとcontextをmecabで分割します。この時一つの単語が分割された場合、 ##を前につけることでもとは一つの単語であったことを表しています。分割したものを特別なトークン(CLSとSEP)を使って、[CLS] + question + [SEP] + context + [SEP]　のように連結します。この特別なトークンについてはそのようなものがある程度の認識でいいと思います。

実際の値
['[CLS]', 'りん', '##ご', 'は', '何', '色', '?', '[SEP]', 'りん', '##ご', 'は', '赤く', 'て', '美味', '##しい', '。', '[SEP]']

[CLS]は文章の始まり、[SEP]は文章の終わりに追加される特別なトークンです。
これを単語ごとにidに変換したものがinput_idsになります。

実際の値
[2, 9768, 29066, 9, 1037, 1232, 2935, 3, 9768, 29066, 9, 22628, 16, 18178, 485, 8, 3]
対応関係
{'[CLS]': 2, 'りん':9768, '##ご':29066, 'は':9, '何':1037, '色':1232, '?':2935, '[SEP]':3, '赤く':22628, 'て':16, '美味':18178, '##しい':485, '。':8, '[SEP]'}

ここで注意する点としては日本語のBERTでは[CLS]が2、[SEP]が3に対応していることです。（英語版では[CLS]:101, [SEP]:102に対応しています）

token_type_ids

token_type_idsは一つ目の文章には0, 二つ目の文章には1を割り当てたリストです。

実際の値
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]

また一つ目の[SEP]は一つ目の文章として扱われます。

モデルの出力

モデルの出力のされ方は、「start_scores」「end_scores」のスコアで表現され、それぞれ「答えが始まる位置のスコア」「答えが終わる位置のスコア」にあたります。

start_scores, end_scores = model(torch.tensor([input_ids]), token_type_ids=torch.tensor([token_type_ids]))

start_scores,end_scores共にtensorflowのtensor型（softmax前）です。

実際の値
start_scores
tensor([[-5.4366, -3.2602, -8.1666, -8.0910, -3.1464, -5.3078, -6.6031, -5.4042,
-1.6283, -6.9755, -7.4763, 2.0868, -6.4028, -3.1525, -6.1728, -6.0557,
-5.2687]], grad_fn=)
end_scores
tensor([[-4.9398, -9.0989, -7.0649, -8.9144, -3.7368, -2.6993, -4.5407, -0.1127,
-7.2395, -5.5424, -7.2156, 1.9255, -1.7737, -4.3648, -0.3700, -1.0993,
0.0879]], grad_fn=)

この時のstart_scoresの最大値のindexから、end_scoresの最大値のindexまでがモデルの予想する答えになります。（例は "モデルの出力を日本語に変換"　に記載）

モデルの出力を日本語に変換

input_idsは全て日本語に対応する数値だ表されているため、これを日本語に直しall_tokensと言う変数に格納します。

all_tokens = tokenizer.convert_ids_to_tokens(input_ids)

実際の値
all_tokens
['[CLS]', 'りん', '##ご', 'は', '何', '色', '?', '[SEP]', 'りん', '##ご', 'は', '赤く', 'て', '美味', '##しい', '。', '[SEP]']

このall_tokoensとstart_scores、end_scoresを使うことでモデルの出力を見ることができます。

prediction = ''.join(all_tokens[torch.argmax(start_scores) : torch.argmax(end_scores)+1])
prediction = prediction.replace("#", "")
prediction = prediction.replace(" ","")

上のstart_scoresとend_scoresの例で言うとstart_scoresの最大値のindexが11、end_scoresの最大値のindexが11となっているため、モデルの予想はall_tokens[11:11 + 1]の"赤く"になります。またpredictionには無駄なスペースや"#"が含まれるためこれを取り除きます。

結果

作成したモデルの精度

20,216問学習させたところ答えが存在しない問題に対して精度は約97.09%の確率で答えがないと、答えが存在する問題に対して完全一致する答えを約57.46%の確率で文章中から抜き取ることができました。

テストデータの詳細
答えがある問題	2329問
答えがない問題	2295問
全体	4624問

モデルの予想精度	答えと出力が完全一致したパーセント
答えがある問題	57.46%
答えがない問題	97.09%
全体	77.11%

また学習に使った質問数とモデルの精度の関係は以下のグラフのようになりました。このグラフから分かるようにモデルの性能が14,000問を超えたあたりから全体の精度・答えのある問題の精度が共に収束してきているので、おそらく14,000問ほどデータを用意できれば十分だと思います。答えのない問題だけに関しては学習に使った問題数が2,000問の時点で97%を超える精度で予想できてるので、人間の作成したデータのみでの学習も比較的容易だと思います。

モデルの出力

実際にモデルを動かせるノートブックを作成したのでよかったら動かしてみてください。ノートブックを使うには学習済みモデルを事前にダウンロードしておいてください。
テストデータの一部に対するモデルの予想は以下のようになっており、答えられない問題のanswerは[CLS]となっています。
モデルの精度評価に利用した4624問に対する全ての予想をみたい方はこちらを。questionが質問、answerは正しい答え、predictionはモデルの予想結果になっています。

問題文
他のほとんどの大学と同様、ノートルダムの学生は多くのニュースメディアを運営しています。学生が運営する9か所のアウトレットには、3つの新聞、ラジオ局とテレビ局、いくつかの雑誌と雑誌があります。 1876年9月に1ページの雑誌として始まり、Scholastic誌は月に2回発行され、米国で最も古い継続的な大学出版物であると主張しています。もう1つの雑誌The Jugglerは年に2回発行され、学生の文学とアートワークに焦点を当てています。ドーム年鑑は毎年発行されます。新聞にはさまざまな出版物の関心があり、オブザーバーは毎日発行され、主に大学やその他のニュースを報告し、ノートルダムとセントメアリー大学の両方の学生がスタッフを務めています。 ScholasticやThe Domeとは異なり、The Observerは独立した出版物であり、教授陣や大学からの編集上の監督はありません。 1987年、一部の学生がThe Observerが保守的な偏見を示し始めたと信じたとき、リベラルな新聞、Common Senseが出版されました。同様に、2003年に、他の学生がこの論文がリベラルな偏見を示していると信じたとき、保守的な論文Irish Roverが生産に移行しました。どちらの論文もThe Observerほど頻繁には出版されていません。ただし、3つはすべての生徒に配布されます。最後に、2008年春、政治学研究のための学部ジャーナルBeyond Politicsがデビューしました。

question	answer	prediction
学生論文Common Senseがノートルダムで出版を開始したのは何年ですか？	1987	1876
聖十字会の本部はどこですか？	ローマ	ローマ
ポーランド文学におけるショパンの最も早い目撃は何ですか？	[CLS]	[CLS]
ノートルダム寺院で最も古い建物は何ですか？	オールドカレッジ	オールドカレッジ
建設技術者は誰として知られていましたか？	[CLS]	[CLS]
世界の文化の中心地と呼ばれているのはどの都市ですか？	[CLS]	[CLS]
ビヨンセは誰と結婚していますか？	[CLS]	[CLS]
ノートルダム大学工学部は何年に設立されましたか？	1920	1920

はじめに

最近データサイエンティストやデジタル人材の役割・スキルの記事が多いので、小売業に必要となるデータサイエンティストの役割について考察していきたいと考えています。

• 小売業に必要なデータサイエンティストの役割について考える①

データサイエンティストを内部に置くべきか

私の立場から言うのはおかしいかもしれませんが、本当に社内にデータサイエンティストが必要でしょうか。
小売の本質はものを仕入れて（バイヤー）・ものを売る（店舗）こと。それを補助する業務は、適切に外部に依頼してしまうのも手だと思います。

ただ、一方で「データを扱う」という理由だけで、IT部門がデータサイエンスの業務を兼任するというパターンがあります。（というか、他社に聞く限り、それが多い）
しかし、IT部門（またはCIO）は、システムのプロフェッショナルであって、データのプロフェッショナルではありません。ですので、それだけは絶対に避けなければいけません。

そうではなく、顧客接点やビジネスを”仕切っている”部署がリードすべき事項です。その部署が中心になって、データサイエンティストを外部に依頼するのか、内部に創り出すのかを検討していくべきでしょう。

どのような役割が必要か

外部・内部のどちらにせよ、小売業のデータサイエンティストにはどの様な役割が必要でしょうか。

ビジネスオーナー（経営層）

自社でも、他社の例を聞いていても思いますが、やはり経営層のコミットメントは必須です。
他の業界では、現場のリーダーから小さく育ててということもあるようですが、こと小売業については、それは難しいですね。

店舗の意見が強い企業・商品部門の意見が強い企業、それぞれあると思いますが、どちらも大体データを使って何かと言っても、聞いてくれないので、経営層から推進してもらうことが重要です。

データが分かるビジネスリーダー（内部）

「データサイエンスや機械学習が分かるリーダー」となると、あまりにも探すのが難しいので、「データが分かるリーダー」としました。（もちろん、データサイエンスや機械学習が分かれば、それに越したことはないです）

やはり、小売業は現場叩き上げのリーダーが多い（様に思う）ので、KKD（経験・勘・度胸）でなんとかしようとしてしまいがち＆部下にもそれを求めがちです。
もちろん、それも良いんだけど、「ちょっと待って、１度データがどうなっているか見てみよう」と言える人が必ずいるはず。

そんな人が、ビジネスオーナーとセットで動いていくと、データサイエンスの声が全体に広まっていきやすいと思います。

データアナリスト（内部 + 外部）

チームのメインとなるプレイヤーですが、いわゆる、データサイエンティストほどのスキルは必要ないかなと。
※必要なスキルセットも今後整理したいですが

よくあるのが、データ出すのは外部のベンダーとかに集計してもらって、その結果を読んでますという役割の人。
最初はそれでいいと思いますが、結局外部のベンダー頼みになると、自分が指示しているはずが、上手くコントロールされてしまっていることにもなりかねない。本当は自分が操作（SQLでもBIシステムでも）して数字を出している。その上で、外部に指示を出すというのが望ましいですね。

データエンジニア（内部 or 外部）

ここはIT部門の役割だと思います。
ただ、IT部門に依存しすぎてしまうと、「必要なデータを出すこと」という最も基本となる仕事が、分析部署のコントロール外になりがちなので、そのパイプが重要ですね。

企業によっては、ITのほぼ全てを外部に任せてしまっている企業もあるので、それは仕方がないですね。
でも、データ活用を進めるのであれば、多少なりともITの機能を内部に戻す or 自分の手足のように使える外部を持たせる

データストーリーテラー（内部）

これが良いワードか分かりませんが、「すべてのデータサイエンスチームが雇うべき3つの見落とされがちな役割」で、おお！となったのがこの役割。

結果、このアウトプットに基づくと、こうすべきなんだよを言える人です。
なぜ、我々はデータを分析するのか？
複雑なプログラムが欲しいからでも、綺麗な数表が欲しいからでもありませんよね。
それの基づいて行動し、結果を生み出すためです。

ただ、行動するまで全てを１人ではできないため、ストーリーテラー的な役割で店舗や、商品部に広めていき、行動を生み出していく。
その役割をこれまでは、ビジネスリーダーが兼務していました（まあ、兼務できる力量があれば問題ないかもいしれません）が、これをメインでやる役割の人が、小売にも今後は必要になってくるように思います。

おわりに

今回は、小売業のデータサイエンス組織において、必要と思われる役割を整理してみました。
もちろん、企業の規模によって、もっと様々に役割を分担したり、兼務したりというのはあると思います。

ただ、今の世の中の様に、派手に宣伝をすれば売れる・いい商品を出せば売れるといった単純にはいかない状況になっている中で、「データ」という武器をつかいこなしていくためには、それを自社の中でどの様な位置づけとするのか考えることが重要です。
そんな役割は、内部で持たせていくべきだと思います。

概要

Webやスプレッドシートなどのテーブルをクリップボードにコピーして、それを何かしらのマークダウンに記録したい時、地味に面倒だったのでコマンドを作った話です。

PyPIにも上げています。

下記のようなものです。

インストール方法

pip install clipable

ツールの概要

こちら何も難しいことはしておらず、下記の2つのライブラリがあれば誰でも瞬殺で作れるやつです。

• pandas（クリップボードからテーブルを作成し、マークダウン出力するため）
• pyperclip（クリップボードにコピーするため）

poetryが凄かった

今回依存関係の管理にpoetryを使いました。

poetry new パッケージ名

で新しいプロジェクトを作成し

poetry add パッケージ名

で依存するパッケージを追加します。

新規作成したパッケージ名と同名のフォルダの下にcli.pyというファイルを作ります。
そこにmain関数を作成します。そしてその後にtomlでコマンドを実行できるようにscriptの設定を追加します。

pyproject.toml

[tool.poetry.scripts]
clipable = "clipable.cli:main"

基本的に重要なのはこれぐらいでした。

あとは

poetry build

でビルドして

poetry publish

とするとPyPIに登録できます。

感想

Poetryで公開までがあまりの簡単さに感動した。

参考

• Poetryを使ったPythonパッケージ開発からPyPI公開まで

Twitterデータのpythonでの収集方法と、時系列のテキストデータに対するバースト検出方法の説明です。

技術的には、以下の過去記事と同様です。

過去記事：
「クッパ姫」に関するツイートをpythonで収集して、バースト検出してみた
https://qiita.com/pocket_kyoto/items/de4b512b8212e53bbba3

この時に採用した方法の汎用性を確認するために、2020年3月10日時点で話題の「コロナ」をキーワードとして、Twitterデータの収集と、「コロナ」と共起する語のバースト検出を実践してみました。

「コロナ」に関するツイートを収集する

収集方法は、基本的に過去記事とほぼ同じです。

まずは、ライブラリの読み込みなど、ツイート収集の準備を行います。

# Twitterデータ収集用のログインキーの情報
KEYS = { # 自分のアカウントで入手したキーを記載
        'consumer_key':'*********************',
        'consumer_secret':'*********************',
        'access_token':'*********************',
        'access_secret':'*********************',
       }

# Twitterデータの収集（収集準備）
import json
from requests_oauthlib import OAuth1Session
twitter = OAuth1Session(KEYS['consumer_key'],KEYS['consumer_secret'],KEYS['access_token'],KEYS['access_secret'])

Twitterデータ収集用のログインキーの取得方法に関する情報は、参考[1]のサイトが分かりやすいです。

ツイート収集用の関数は、以下のように定義しています。
ツイート場所は今回使わないため、デフォルトの引数（None）を設定できるようにしました。
また、1回あたり最大100ツイートしか検索できないので、for文で繰り返しリクエストする必要があるのですが、Twitterデータ取得関数の外で管理した方がスマートだったので、そのように実装しています。
このあたりは、参考[2]の書き方を踏襲しました。

# Twitterデータ取得関数
def getTwitterData(key_word, latitude=None, longitude=None, radius=None, mid=-1):

    url = "https://api.twitter.com/1.1/search/tweets.json"
    params ={'q': key_word, 'count':'100', 'result_type':'recent'} #取得パラメータ
    if latitude is not None: # latitudeのみで判定
        params = {'geocode':'%s,%s,%skm' % (latitude, longitude, radius)}

    params['max_id'] = mid # midよりも古いIDのツイートのみを取得する
    req = twitter.get(url, params = params)

    if req.status_code == 200: #正常通信出来た場合

        tweets = json.loads(req.text)['statuses'] #レスポンスからツイート情報を取得

        # 最も古いツイートを取るための工夫（※もっと良い書き方ありそう）
        user_ids = []
        for tweet in tweets:
            user_ids.append(int(tweet['id']))
        if len(user_ids) > 0:
            min_user_id = min(user_ids)
        else:
            min_user_id = -1

        # メタ情報
        limit = req.headers['x-rate-limit-remaining'] if 'x-rate-limit-remaining' in req.headers else 0
        reset = req.headers['x-rate-limit-reset'] if 'x-rate-limit-reset' in req.headers else 0  

        return {'tweets':tweets, 'min_user_id':min_user_id, 'limit':limit, 'reset':reset}

    else: #正常通信出来なかった場合
        print("Failed: %d" % req.status_code)
        return {}

上記の関数を連続で実行するための制御関数（getTwitterDataRepeat）を作成しました。
リクエスト制限に引っかからないように、制限に引っかかりそうになったら自動で待機します。

# Twitterデータ連続取得
import datetime, time
def getTwitterDataRepeat(key_word, latitude=None, longitude=None, radius=None, mid=-1, repeat=10):

    tweets = []

    for i in range(repeat):

        res = getTwitterData(key_word, latitude, longitude, radius, mid)

        if 'tweets' not in res: #エラーとなった場合は離脱
            break
        else:
            sub_tweets = res['tweets']
            for tweet in sub_tweets:
                tweets.append(tweet)

        if int(res['limit']) == 0:    # 回数制限に達した場合は休憩

            # 待ち時間の計算. リミット＋５秒後に再開する
            now_unix_time = time.mktime(datetime.datetime.now().timetuple())  #現在時刻の取得
            diff_sec = int(res['reset']) - now_unix_time
            print ("sleep %d sec." % (diff_sec+5))
            if diff_sec > 0:
                time.sleep(diff_sec + 5)

        mid = res['min_user_id'] - 1

    print("ツイート取得数：%s" % len(tweets))
    return tweets

このように実装することで、リクエストの上限を気にせず、ツイートの収集が自動で可能となります。
あとは、時間帯別でツイートを分けて収集したかったので、以下のようなスクリプトを回しました。

# 参考[3]で作成されていた関数を拝借しました
import time, calendar
def YmdHMS(created_at):
    time_utc = time.strptime(created_at, '%a %b %d %H:%M:%S +0000 %Y')
    unix_time = calendar.timegm(time_utc)
    time_local = time.localtime(unix_time)  # 2018/9/24に修正しました
    return time.strftime("%Y/%m/%d %H:%M:%S", time_local)

# コロナに関するツイートを6時間おきに1週間分取得する
tweet_corona = {}
mid = -1

for t in range(4*7):
    tweets = getTwitterDataRepeat("コロナ", mid=mid, repeat=10)    
    old_tweet = tweets[-1]  # 収集した中で最も古いツイート

    key = YmdHMS(old_tweet["created_at"])  # YmdHMS関数
    tweet_corona[key] = tweets  # 最も古いツイートの時刻をキーとして保存する

    mid = old_tweet["id"] - 15099494400000*6 # 約6時間遡って収集する

ツイートを6時間ずつ遡りながら収集したかったので、最も古いツイートのmidから15,099,494,400,000 * 6を引いています。
この15,099,494,400,000という値は、Tweeterのtweet IDの仕様より決めています。
Twitter の tweet ID はミリ秒タイムスタンプ＋ ID を発行するマシンの番号＋シーケンス番号を 64 bit に押し込めた構造になっています。（参考[4]）

「コロナ」に関するツイートを時系列で比較してみる

ここまでで、「コロナ」を含むツイートを時系列で収集することができました。
まずはデータを理解するために、単語の出現頻度を時系列で可視化したいと思います。

以下のような関数を定義して、janomeで形態素解析して、単語の出現頻度をカウントしました。

# 文章を形態素解析して、Bag of Wordsに変換する
from janome.tokenizer import Tokenizer
import collections
import re

def CountWord(tweets):
    tweet_list = [tweet["text"] for tweet in tweets]
    all_tweet = "\n".join(tweet_list)

    t = Tokenizer()

    # 原形に変形、名詞のみ、1文字を除去、漢字・平仮名・カタカナの連続飲みに限定
    c = collections.Counter(token.base_form for token in t.tokenize(all_tweet) 
                            if token.part_of_speech.startswith('名詞') and len(token.base_form) > 1 
                            and token.base_form.isalpha() and not re.match('^[a-zA-Z]+$', token.base_form)) 

    freq_dict = {}
    mc = c.most_common()
    for elem in mc:
        freq_dict[elem[0]] = elem[1]

    return freq_dict

可視化方法はWordCloudを用いました。以下のように実装しました。

# Word Cloudで可視化、WordCloud可視化関数
def color_func(word, font_size, position, orientation, random_state, font_path):
    return 'white'

from wordcloud import WordCloud
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
from matplotlib.font_manager import FontProperties
fp = FontProperties(fname=r'C:\WINDOWS\Fonts\meiryo.ttc', size=50) #日本語対応

def DrawWordCloud(word_freq_dict, fig_title):

    # デフォルト設定を変更して、colormapを"rainbow"に変更
    wordcloud = WordCloud(background_color='white', min_font_size=15, font_path='C:\WINDOWS\Fonts\meiryo.ttc',
                          max_font_size=200, width=1000, height=500, prefer_horizontal=1.0, relative_scaling=0.0, colormap="rainbow")    
    wordcloud.generate_from_frequencies(word_freq_dict)
    plt.figure(figsize=[20,20])
    plt.title(fig_title, fontproperties=fp)
    plt.imshow(wordcloud,interpolation='bilinear')
    plt.axis("off")

これらを用いて、
単語の出現頻度を時系列で可視化します。

出力：
(中略)
:

:
(中略)
:

:
(中略)
:

:
(中略)
:

:
(中略)
:

---

「新型」「ウイルス」「感染」など、「コロナ」という単語と共起しやすい語群の影響が強く出ました。
この可視化結果からは、「コロナ」の影響で話題になった単語が分かりにくいため、自動検出してみることにします。

コロナの影響で、話題になった単語を自動検出してみる

今回収集したデータセットと、バースト検出と呼ばれる手法を用いて、「コロナ」の影響で、話題になった単語を自動検出してみたいと思います。
バースト検出という手法に関しては、書籍では、「ウェブデータの機械学習 (機械学習プロフェッショナルシリーズ)」に詳しくまとめられているようですが、ネットには解説記事が少ないです。
今回は、自然言語処理に関する研究室として著名な、東北大学　乾・鈴木研究室の解説記事を参考として、バースト検出手法の実装・適用に挑戦してみたいと思います。

今回は、Moving Average Convergence Divergence (MACD) という指標を用いて、バースト検出に取り組んでみました。
バースト検出手法としては、Kleinbergが2002年に発表した手法がベースラインとして、よく用いられるようですが、He and Parker が2010年に発表したMACDのほうがシンプル、かつ計算量が少ないようです。

↓MACDの解説については、乾・鈴木研究室のものが分かりやすいので、そのまま引用したいと思います。

---

【MACDの解説】

ある時刻におけるMACDは，

MACD = (時系列値の過去f期間の移動指数平均) - (時系列値の過去s期間の移動指数平均)
Signal = (MACD値の過去t期間の移動指数平均)
Histgram = MACD - Signal

ここで，f, s, tはパラメータ（f < s）で，これらをまとめてMACD(f, s, t)と書きます． 今回の実験では，He and Parker (2010) の実験でも用いられていた MACD(4, 8, 5) を採用しました． MACDをテクニカル指標として用いる時は，「Signal < MACD」の状態を上げトレンド，「MACD < Signal」の状態を下げトレンドとし，Histgramがトレンドの強さを表すと言われています． 今回は，15分間の期間をひとまとまりとして（15分足），その期間内にツイッター上に出現した単語の出現頻度を15で割った値，つまり出現速度[回/分]を観測値として，MACDによるトレンド分析を行いました． MACDの計算に必要な移動指数平均の値は逐次計算が可能で，今回のトレンド分析はストリーミング・アルゴリズムとして実装できるため，ビッグデータからのトレンド分析に適していると考えています．

---

上記の解説内容から、MACDを以下のように実装しました。

# Moving Average Convergence Divergence (MACD) の計算
class MACDData():
    def __init__(self,f,s,t):
        self.f = f
        self.s = s
        self.t = t

    def calc_macd(self, freq_list):
        n = len(freq_list)
        self.macd_list = []
        self.signal_list = []
        self.histgram_list = []

        for i in range(n):

            if i < self.f:
                self.macd_list.append(0)
                self.signal_list.append(0)
                self.histgram_list.append(0)
            else :
                macd = sum(freq_list[i-self.f+1:i+1])/len(freq_list[i-self.f+1:i+1]) - sum(freq_list[max(0,i-self.s):i+1])/len(freq_list[max(0,i-self.s):i+1])
                self.macd_list.append(macd)
                signal = sum(self.macd_list[max(0,i-self.t+1):i+1])/len(self.macd_list[max(0,i-self.t+1):i+1])
                self.signal_list.append(signal)
                histgram = macd - signal
                self.histgram_list.append(histgram)   

このプログラムを用いて、2020年3月4日（水）～2020年3月10日（火）にかけて、
コロナの影響で、話題になった単語を自動検出してみたいと思います。

上記の関数へデータを代入するプログラム（折り込み）

# 各時間帯のツイートで、上位100語にランクインする用語をバースト検出する

top_100_words = []

i = 0

for freq_dict in datetime_freq_dicts:

    for k,v in freq_dict.items():
        top_100_words.append(k)
        i += 1

        if i >= 100:
            i = 0
            break

top_100_words = list(set(top_100_words))  # ユニークな単語に限定
print(len(top_100_words))

# MACD計算結果の取得
word_list_dict = {}

for freq_dict in datetime_freq_dicts:

    for word in top_100_words:
        if word not in word_list_dict:
            word_list_dict[word] = []

        if word in freq_dict:
            word_list_dict[word].append(freq_dict[word])
        else:
            word_list_dict[word].append(0)

# 正規化
word_av_list_dict = {}

for k, v in word_list_dict.items():
    word_av_list = [elem/sum(v) for elem in v]
    word_av_list_dict[k] = word_av_list

# 計算(He and Parker(2010)と同じパラメータ)
f = 4
s = 8
t = 5

word_macd_dict = {}

for k, v in word_av_list_dict.items():
    word_macd_data = MACDData(f,s,t)
    word_macd_data.calc_macd(v)
    word_macd_dict[k] = word_macd_data

# バースト検出
word_burst_dict = {}

for k,v in word_macd_dict.items():
    burst = max(v.histgram_list)  # Histgramがトレンドの強さを表すことから、期間内での最大値を取る
    word_burst_dict[k] = burst

データを投入した結果は以下の通りです。

i = 1
for k, v in sorted(word_burst_dict.items(), key=lambda x: -x[1]):
    print(str(i) + "位：" + str(k))
    i += 1

出力：
1位：九郎
2位：ロッテマリーンズ
3位：グラウンド
4位：区役所
5位：尊厳
6位：つば
7位：自習
8位：配達員
9位：メタノール
10位：港北
11位：血清
12位：イープラス
13位：ハラスメント
14位：装置
15位：スナック
16位：佐川急便
17位：リベロ
18位：みゆき
19位：美神
20位：サイケ
21位：ライヴ
22位：横浜市立大学
23位：恐慌
24位：全巻
25位：コロハラ
26位：獣疫
27位：払戻し
28位：登場
29位：義務
30位：表示
:
(中略)
:

---

「つば」「九郎」「ロッテマリーンズ」などが、「コロナ」の影響で話題になった単語として検出されました。
他の単語についても、概ね納得感のある結果でした。

次いで、話題になった時期の推定も行ってみました。

可視化プログラム（折り込み）

# 結果の可視化
import numpy as np
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
from matplotlib.font_manager import FontProperties
fp = FontProperties(fname=r'C:\WINDOWS\Fonts\meiryo.ttc', size=10) #日本語対応

x = np.array(sorted(tweet_corona.keys()))
y1 = np.array(word_macd_dict["ロッテマリーンズ"].histgram_list)
y2 = np.array(word_macd_dict["自習"].histgram_list)
y3 = np.array(word_macd_dict["配達員"].histgram_list)
y4 = np.array(word_macd_dict["メタノール"].histgram_list)
y5 = np.array(word_macd_dict["スナック"].histgram_list)
y6 = np.array(word_macd_dict["ハラスメント"].histgram_list)


plt.plot(x, y1, marker="o")
plt.plot(x, y2, marker="+", markersize=10, markeredgewidth=2)
plt.plot(x, y3, marker="s", linewidth=1)
plt.plot(x, y4, marker="o")
plt.plot(x, y5, marker="+", markersize=10, markeredgewidth=2)
plt.plot(x, y6, marker="s", linewidth=1)

plt.xticks(rotation=90)

plt.title("バースト検出結果", fontproperties=fp)
plt.xlabel("日時", fontproperties=fp)
plt.ylabel("バースト検出結果", fontproperties=fp)
plt.ylim([0,0.2])
plt.legend(["「ロッテマリーンズ」","「自習」", "「配達員」","「メタノール」", "「スナック」","「ハラスメント」"], loc="best", prop=fp)

可視化結果は、以下の通りです。

ヤクルトスワローズ　対　ロッテマリーンズの無観客試合が行われたのが、
3月7日（土）なので、正しく推定できていそうです。
3月10日（火）現在では、「メタノール」が話題の単語の一つとなっているようです。

まとめと今後

今回は、「コロナ」をテーマにバースト検出に取り組んでみました。
技術的には、過去記事の内容の焼き直しですが、妥当な分析結果が得られたのではないかと考えています。
過去記事では、「クッパ姫」をテーマとしていましたが、手法自体は汎用性が高いことを確認できました。

引き続き、Twitterデータ分析にチャレンジしていきたいと思います。

参考

[1]
【2019年】TwitterのAPIに登録し、アクセスキー・トークンを取得する具体的な方法
https://miyastyle.net/twitter-api
[2]
スタバのTwitterデータをpythonで大量に取得し、データ分析を試みる その１
https://qiita.com/kenmatsu4/items/23768cbe32fe381d54a2
[3]
Streaming APIで取得したつぶやきの処理方法
http://blog.unfindable.net/archives/4302
[4]
スケーラブルな採番とsnowflake
https://kyrt.in/2014/06/08/snowflake_c.html
[5]
東北大学　乾・鈴木研究室　Project 311 / Trend Analysis
http://www.cl.ecei.tohoku.ac.jp/index.php?Project%20311%2FTrend%20Analysis
[6]
Dan He and D. Stott Parker(2010)
「Topic Dynamics: An Alternative Model of 'Bursts' in Streams of Topics」
https://dollar.biz.uiowa.edu/~street/HeParker10.pdf

ご挨拶

初めまして。あめみんと申します。discord.py始めたばかりですが、
これから自分が教わったこと・共有できることどんどん共有するので、
上級者の皆様温かい目で見守ってください...
一緒に頑張りましょう！

～動作環境～

python V3.8.1
pip V19.3.1
discord.py V1.2.5
Windows10

discordのbotを作るうえで必要なもの...

①discordbot用のアカウント

discord developer portalで以下の画像を参照に初期設定を行います！

1.portalのapplicationから、"New Application"を選択する

2.botの名前を決める。※名前はあとから変更できます。

3."Create"をクリックしsettingsのBotカテゴリをクリックする。

4.画面の右のほうにある"Add bot"をクリックして、確認画面が出てくるのでyesを選択する

5.botカテゴリの下の方に移動し、botの権限を設定する。

6(サーバーに招待するとき).OAuth2カテゴリへ移動し、botを選択する

7.下の方に移動し、そのサーバーにbotが入る際に必要とする権限を設定する。

※botカテゴリのTOKENは他人に絶対教えないこと！botのプログラムにアクセスするのに必要なキーだと思ってください。

botアカウントの作成については以上です。

②discord.pyのインストール

以下をターミナルで実行する。

discord.py インストール

$ python3 -m pip install -U discord.py[voice]

今回はここまでとしとく。。。
明日何書こう...

はじめに

　トレーニー（筋トレを愛している人）の多くが習慣化している「自撮り（肉体）」。トレーニング後にパンプした肉体を撮りためて、後で見返すのが至福のときですよね。さらに、撮りためた画像をタイムラプスのようにアニメーションで表示させたら、より筋肉の成長が手に取るようにわかりますよね！
　この記事はディープラーニングを使って、肉体のタイムラプスを劇的に見やすくした話を書いています。

まずは結果から

2017/12～2020/3の体の変化

※データサイズの都合上、画像をクロップ&圧縮しています。

概要

　撮りためた画像からタイムラプスの作成を行いました。しかし、画像間のズレが気になるため、手作業で補正を行い、なめらかなタイムラプスを作成しました。さらに、手作業の手間を省くために、ディープラーニングを用いて自動で補正を行いました。

1.手作業での補正

1-1. そのまま表示

　とりあえず、そのままの画像を連続で切り替えるだけのタイムラプスを作ってみます。

タイムラプス作成コード（一部）

# opencvでもで動画は作れますが、
# google colabの環境で、discord上で再生できるmp4ファイルを作るためには、
# skvideoを使うやり方が楽ちんでした。
import skvideo.io

def create_video(imgs, out_video_path, size_wh):
  video = []
  vid_out = skvideo.io.FFmpegWriter(out_video_path,
      inputdict={
          '-r': '10'
      },
      outputdict={
          '-r': '10'
      })

  for img in imgs:
    img = cv2.resize(img, size_wh)
    vid_out.writeFrame(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))

  vid_out.close()

imgs = load_images("images_dir")
create_video(imgs,  "video.mp4", (w,h))

　結果は、下記の通りです。

　ズレが気になって我が子（肉体）に集中できません。

1-2. 位置の固定

　なんとかして楽にこのズレを解消したい。身体のどこかに基準点を設けてそれを固定すれば、、、と考えて0.1秒くらいで「乳首」と「おへそ」という解にたどり着きました。
乳首とおへそをどのように固定するかを以下に説明します。

1-2-1. 乳首おへそ座標付与ツール

　まず、乳首とへそのUV座標を付与するツールを作ります。cvatなどを使っても実現できるかもしれませんが、使いこなすまでの時間とツールを自作する時間を見積もると、今回は自作した方が早いという結論になったので作りました。

　ツールの仕様は、フォルダを指定すると、画像が連続して表示されるので各画像に対して、乳首とおへその３点をクリックしていき、クリックした座標をcsvファイルに出力する、というものになります。GUIはtkinterを利用しました。

※後述で利用するディープラーニング用のアノテーションデータの場合は、画像とアノテーションデータが1:1になったほうが取り回しが良いと思います。が今回はさくっと済ませるために作り込みませんでした。

1-2-2.動画作成

　乳首とおへその場所は、1枚目の画像に合わせてアフィン変換することにより固定します。

補正版タイムラプス作成コード（一部）

def p3affine_img(img, src_p, dst_p):
    h, w, ch = img.shape
    pts1 = np.float32([src_p[0],src_p[1],src_p[2]])
    pts2 = np.float32([dst_p[0],dst_p[1],dst_p[2]])
    M = cv2.getAffineTransform(pts1,pts2)
    dst = cv2.warpAffine(img,M,(h, w))
    return dst


df = read_annotationd() # 省略

imgs = []
src_p = None
for index, row in df.iterrows():
    img = cv2.imread(row.file)
    dst_p = [ [row.p1x, row.p1y], # 左乳首
              [row.p2x, row.p2y], # 右乳首
              [row.p3x, row.p3y]] # おへそ
    if src_p is None:
      src_p = dst_p
    else:
      img = p3affine_img(img, dst_p, src_p)

    imgs.append(img)

write_video(imgs) # 省略

結果は以下の通りです。

　期待通りのタイムラプスを作ることができました、めでたしめでたし。ではありません！

　今回座標を付与した枚数は、120日分（期間は2019/9〜2020/3）。しかし手元には2017/12から撮りためた、座標付与していない画像がまだ281枚もあるのです。更に今後数十年に渡って筋トレを行う、つまり数十年に渡って座標を付与し続ければいけないのです。想像しただけでもコルチゾールが分泌されカタボリックに陥ってしまいます。これを解決するために糖質補給して考えました。

　そうだ、ジム行こうディープラーニングだ。

2.ディープラーニングを用いた自動補正

　「乳首」と「おへそ」の位置推定をするモデルを作ります。これが実現すればあとは先ほどの通りアフィン変換をかけるだけです。乳首とおへその検出には、セグメンテーションタスクとしてアプローチします。姿勢推定のようなキーポイント検出のほうが筋が良さそうですが、個人的にセグメンテーションタスクの経験の方が多いのでそちらをチョイスしました。

2-1.アノテーションデータ作成

　「右乳首」「左乳首」「おへそ」「背景」の４クラス分類で解くことも考えられますが、今回は「右乳首・左乳首・おへそ」「背景」の２クラス分類にしました。３点の検出さえできればルールベースでそれらをクラス分類することは簡単だと考えたからです。
　では、早速マスク画像を作ります。先ほど作成した座標データを元に、座標点を少し大きくして1で埋めます。それ以外は背景なので0とします。

for index, row in df.iterrows():
  file = row.file
  mask = np.zeros((img_h, img_w), dtype=np.uint8)
  mask = cv2.circle(mask,(row.p1x, row.p1y,), 15, (1), -1)
  mask = cv2.circle(mask,(row.p2x, row.p2y,), 15, (1), -1)
  mask = cv2.circle(mask,(row.p3x, row.p3y,), 15, (1), -1)
  save_img(mask, row.file) # 省略

　視覚的にする（1を白、0を黒にする）と下記のようなデータになります。

　これらを肉体画像とペアになるように作ります。

2-2.学習

　学習は、DeepLab v3(torchvision)を使いました。120枚の画像を訓練と検証のために8:2になるように分けました。だいぶ枚数は少ないですが、下記の理由より、データ拡張はしませんでした。

• 肉体画像は同じカメラで撮影している
• カメラ姿勢や照明環境が画像間である程度揃っている

　ただし、本来はデータ拡張はした方が良いと思います（めんどくさくてしてないだけです）。

データセットクラス・学習関連関数

class MaskDataset(Dataset):
  def __init__(self, imgs_dir, masks_dir, scale=1, transforms=None):
    self.imgs_dir = imgs_dir
    self.masks_dir = masks_dir

    self.imgs = list(sorted(glob.glob(os.path.join(imgs_dir, "*.jpg"))))
    self.msks = list(sorted(glob.glob(os.path.join(masks_dir, "*.png"))))
    self.transforms = transforms
    self.scale = scale

  def __len__(self):
      return len(self.imgs_dir)

  @classmethod
  def preprocess(cls, pil_img, scale):

    # グレースケールにしても良さそうだけど、めんどうだからしない
    # pil_img = pil_img.convert("L") 

    w, h = pil_img.size
    newW, newH = int(scale * w), int(scale * h)
    pil_img = pil_img.resize((newW, newH))

    img_nd = np.array(pil_img)

    if len(img_nd.shape) == 2:
      img_nd = np.expand_dims(img_nd, axis=2)

    # HWC to CHW
    img_trans = img_nd.transpose((2, 0, 1))
    if img_trans.max() > 1:
        img_trans = img_trans / 255

    return img_trans

  def __getitem__(self, i):

    mask_file = self.msks[i]
    img_file = self.imgs[i]

    mask = Image.open(mask_file)
    img = Image.open(img_file)

    img = self.preprocess(img, self.scale)
    mask = self.preprocess(mask, self.scale)

    item = {'image': torch.from_numpy(img), 'mask': torch.from_numpy(mask)}
    if self.transforms:
      item = self.transforms(item)
    return item

from torchvision.models.segmentation.deeplabv3 import DeepLabHead

def create_deeplabv3(num_classes):
  model = models.segmentation.deeplabv3_resnet101(pretrained=True, progress=True)
  model.classifier = DeepLabHead(2048, num_classes)

  # グレースケールにしても良さそうだけど、めんどうだからしない
  #model.backbone.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)

  return model

def train_model(model, criterion, optimizer, dataloaders, device, num_epochs=25, print_freq=1):
  since = time.time()

  best_model_wts = copy.deepcopy(model.state_dict())
  best_loss = 1e15

  for epoch in range(num_epochs):
    print('Epoch {}/{}'.format(epoch+1, num_epochs))
    print('-' * 10)

    loss_history = {'train': [], 'val': []}

    for phase in ['train', 'val']:

      if phase == 'train':
        model.train()
      else:
        model.eval()

      for sample in tqdm(iter(dataloaders[phase])):
        imgs = sample['image'].to(device, dtype=torch.float)
        msks = sample['mask'].to(device, dtype=torch.float)

        optimizer.zero_grad()

        with torch.set_grad_enabled(phase == 'train'):
          outputs = model(imgs)
          loss = criterion(outputs['out'], msks)

          if phase == 'train':
            loss.backward()
            optimizer.step()

      epoch_loss = np.float(loss.data)
      if (epoch + 1) % print_freq == 0:
        print('Epoch: [%d/%d], Loss: %.4f' %(epoch+1, num_epochs, epoch_loss))
        loss_history[phase].append(epoch_loss)

      # deep copy the model
      if phase == 'val' and epoch_loss < best_loss:
        best_loss = epoch_loss
        best_model_wts = copy.deepcopy(model.state_dict())

  time_elapsed = time.time() - since
  print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
  print('Best val Acc: {:4f}'.format(best_loss))

  model.load_state_dict(best_model_wts)

  return model, loss_history

学習実行

dataset = MaskDataset("images_dir", "masks_dir", 0.5, transforms=None)

# 訓練用と検証用に分ける
val_percent= 0.2
batch_size=4
n_val = int(len(dataset) * val_percent)
n_train = len(dataset) - n_val
train, val = random_split(dataset, [n_train, n_val])
train_loader = DataLoader(train, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=True, drop_last=True )
val_loader = DataLoader(val, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True, drop_last=True )

dataloaders = {'train': train_loader, 'val': val_loader}

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

num_classes = 1 # BCEWithLogitsLossを使う際に２値分類だと1と指定

model = create_deeplabv3(num_classes)

# pre trained用
#model.load_state_dict(torch.load("model.pth"))

model.to(device)

# 背景が圧倒的に多いのでpos_weightで調整する
criterion = nn.BCEWithLogitsLoss(pos_weight=torch.tensor(10000.0).to(device))

params = [p for p in model.parameters() if p.requires_grad]

#optimizer = torch.optim.SGD(params, lr=0.005,momentum=0.9, weight_decay=0.0005)
optimizer = optim.Adam(params)

total_epoch = 50

model, loss_dict = train_model(model, criterion, optimizer, dataloaders, device, total_epoch)

　今回は50エポックほど回すとある程度学習が収束しました。

2-3.未知画像への適用

　2017/12～2019/8の、未知の（アノテーションしていない）画像に適用します。

　結果としては、概ね良好で、３点がちゃんと反応していましたが、たまに下記のような結果もありました（ヒートマップ表現）。

　当然、左乳首が２つあることはないので、一番右上の小さな点がFalse Positiveです。
ちなみに、False Negativeはありませんでした。

2-4.後処理

　先ほどの推論結果から、後処理では以下を行います。

1. 各ピクセルの出力値が閾値以下のものは切り捨てる
2. オブジェクト分割する
3. クラスタが4つ以上の場合は、面積の大きい順に3つ選択し、残りを破棄する
4. 各クラスタの重心を求める
5. 各クラスタの重心のx座標が小さい順に並べ替える（右乳首→おへそ→左乳首）

2-4-1.各ピクセルの出力値が閾値以下のものは切り捨てる

　次の処理のために、明確な確度をもったピクセル以外は切り捨てます。今回の閾値は経験的に、0.995にします。

2-4-2.オブジェクト分割する

　オブジェクト分割には、cv2.connectedComponentsを使います。詳細は、OpenCV - connectedComponents で連結成分のラベリングを行う方法 - pynoteをご参考ください。

2-4-3.クラスタが4つ以上の場合は、面積の大きい順に3つ選択し、残りを破棄する

　事例から、乳首とおへそ以外にでたFalse Positiveは面積が小さいことがわかりました。よって、面積の大きい３つを選択することにします。本当はこのような対処はあまり頑健性がない気がしますが、今回はうまくいったので採用します。

2-4-4.各クラスタの重心を求める

　各クラスタの重心を求めるのは、cv2.momentsを使います。詳細は、Python+OpenCVで重心を求める - CV画像解析入門をご参考ください。

2-4-5.各クラスタの重心のx座標が小さい順に並べ替える（右乳首→おへそ→左乳首）

　アフィン変換する際に点が対応する必要があるため、画像間で乳首とおへその座標順を統一する必要があります。今回の画像は、全て直立して撮ったものであり、横軸方向で乳首→おへそ→乳首が出現することは間違いないため、単純にx座標で並び替えます。

推論時

#マスクから３点検出
def triangle_pt(heatmask, thresh=0.995):
  mask = heatmask.copy()

  # 2-4-1.各ピクセルの出力値が閾値以下のものは切り捨てる
  mask[mask>thresh] = 255
  mask[mask<=thresh] = 0
  mask = mask.astype(np.uint8)
  # 2-4-2.オブジェクト分割する
  nlabels, labels = cv2.connectedComponents(mask)

  pt = []
  if nlabels != 4:

    # 少ない場合は、何もしない
    # 本当は閾値さげてやりたいけど、めんどいので
    if nlabels < 4:
      return None

    # 2-4-3.クラスタが4つ以上の場合は、面積の大きい順に3つ選択し、残りを破棄する
    elif nlabels > 4:
      sum_px = []
      for i in range(1, nlabels):
        sum_px.append((labels==i).sum())
      # 背景分+1する
      indices = [ x+1 for x in np.argsort(-np.array(sum_px))[:3]]

  else:
    indices = [x for x in range(1, nlabels)]

  # 2-4-4.各クラスタの重心を求める
  for i in indices:
    base = np.zeros_like(mask, dtype=np.uint8)
    base[labels==i] = 255
    mu = cv2.moments(base, False)
    x,y= int(mu["m10"]/mu["m00"]) , int(mu["m01"]/mu["m00"])
    pt.append([x,y])

  # 2-4-5.各クラスタの重心のx座標が小さい順に並べ替える（右乳首→おへそ→左乳首）
  sort_key = lambda v: v[0]
  pt.sort(key=sort_key)
  return np.array(pt)


def correct_img(model, device, in_dir, out_dir, 
                draw_heatmap=True, draw_triangle=True, correct=True):

  imgs = []

  base_3p = None
  model.eval()
  with torch.no_grad():
    imglist = sorted(glob.glob(os.path.join(in_dir, "*.jpg")))

    for idx, img_path in enumerate(imglist):

      # めんどいのでバッチサイズ1
      full_img = Image.open(img_path)
      img = torch.from_numpy(BasicDataset.preprocess(full_img, 0.5))
      img = img.unsqueeze(0)
      img = img.to(device=device, dtype=torch.float32)

      output = model(img)["out"]
      probs = torch.sigmoid(output)
      probs = probs.squeeze(0)

      tf = transforms.Compose(
                [
                    transforms.ToPILImage(),
                    transforms.Resize(full_img.size[0]),
                    transforms.ToTensor()
                ]
            )

      probs = tf(probs.cpu())
      full_mask = probs.squeeze().cpu().numpy()

      full_img = np.asarray(full_img).astype(np.uint8)
      full_img = cv2.cvtColor(full_img, cv2.COLOR_RGB2BGR)

      # 三角形
      triangle = triangle_pt(full_mask)
      if draw_triangle and triangle is not None:
        cv2.drawContours(full_img, [triangle], 0, (0, 0, 255), 5)

      # ヒートマップ
      if draw_heatmap:
        full_mask = (full_mask*255).astype(np.uint8)
        jet = cv2.applyColorMap(full_mask, cv2.COLORMAP_JET)

        alpha = 0.7
        full_img = cv2.addWeighted(full_img, alpha, jet, 1 - alpha, 0)

      # アフィン変換
      if correct:
        if base_3p is None and triangle is not None:
          base_3p = triangle
        elif triangle is not None:
          full_img = p3affine_img(full_img, triangle, base_3p)

      if out_dir is not None:
        cv2.imwrite(os.path.join(out_dir, os.path.basename(img_path)), full_img)

      imgs.append(full_img)

  return imgs

imgs = correct_img(model, device,
                   "images_dir", None,
                    draw_heatmap=False, draw_triangle=False, correct=True)

2-5.結果

　補正直前のタイムラプスは下記の通りです。

補正後のタイムラプスは下記の通りです。

まとめ

　ディープラーニングを用いて乳首とおへその検出を行い、自動で画像補正することによって、タイムラプスを劇的に見やすくしました。これでさらにトレーニングに対するモチベーションが上がりました。開発は、座標付与ツールを除いて全部google colabで行いました、3150ぅう！
　課題としては、他の人の肉体でうまくいくのかは不明（まあ学習させればいいのですが）。全体的に大きくなった場合は非対応（乳首・おへそ以外の基準点が必要）。などがありますが、コルチゾールが分泌されるのであまり硬いことは気にしないようにします！

　それでは、楽しい筋トレライフを！