はじめに

雑誌の掲載順をグラフ化するときに、matplotlibで特定の項目にだけマーカー（グラフに打つ点）をつけたくなった（センターカラーのときにだけわかりやすいように目印をつけたかった）が、探しても全く出てこなかったのでメモ。

↑こんな感じで強調するために特定の値の時だけマーカーを適用したかった。

環境

$ uname -a                                                                                                                              
Linux kali 4.18.0-kali2-amd64 #1 SMP Debian 4.18.10-2kali1 (2018-10-09) x86_64 GNU/Linux

$ python3 --version                                                                                                                             
Python 3.7.6

$ pip3 show matplotlib                                                                                                                         
Name: matplotlib
Version: 3.1.2

問題

例えば、以下のようなデータがあったとする。

month	1月	2月	3月	4月	5月	6月	7月	8月	9月	10月	11月	12月
data	13	15	21	5	10	18	21	17	15	16	21	13

これらをグラフにするとこうなる。

このグラフの1,4,7,10月のデータにだけダイヤモンドでマーカーを付けたい（その他には付けたくない）ときどうすればいいだろうか。

解決法

マーカーを付けたい部分だけを配列にしてプロットするときにmarkevery=で渡す。
X番目にマーカーを付けたければX-1番目の数を配列に追加する。

こんな感じ。

#!/usr/bin/env python 
import matplotlib.pyplot as plt

X_data=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Y_data=[13,15,21,5,10,18,21,17,15,16,21,13]
month_name=['Jan.','Feb.','Mar.','Apr.','May','Jun.','Jul.','Aug.','Sep.','Oct.','Nov.','Dec.']
mark_point=[0,3,6,9]

plt.xlabel('month')
plt.ylabel('data')

plt.grid(color='gray')
plt.xticks(X_data,month_name)
plt.yticks(range(1,max(Y_data)+1))
plt.plot(X_data,Y_data, '.', linestyle='solid', marker="D", markevery=mark_point)
plt.show()

結果

y軸のデータを基準にしたければ、先にデータを比較して配列に格納すれば良い。
例）データが奇数のときだけマーカーを適応する

#!/usr/bin/env python 
import matplotlib.pyplot as plt

X_data=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Y_data=[13,15,21,5,10,18,21,17,15,16,21,13]
month_name=['Jan.','Feb.','Mar.','Apr.','May','Jun.','Jul.','Aug.','Sep.','Oct.','Nov.','Dec.']
mark_point=[]

for i,data in enumerate(Y_data):
    if data%2:
        mark_point.append(i)

plt.xlabel('month')
plt.ylabel('data')

plt.grid(color='gray')
plt.xticks(X_data,month_name)
plt.yticks(range(1,max(Y_data)+1))
plt.plot(X_data,Y_data, '.', linestyle='solid', marker="D", markevery=mark_point)
plt.show()

結果

一件落着。

参考文献

Markevery Demo — Matplotlib 3.1.2 documentation

はじめに

今回、掲示板の作成について、以下の通り６つに分類にして記述した。
（１）環境構築
（２）csvで掲示板
（３）SQLとSQLAlchemyで掲示板
（４）PostgreSQLとSQLAlchemyで掲示板
（５）SQLAlchemyを使ってデータ操作
（６）Postgresqlを使ってデータ操作

（１）環境構築

デスクトップにディレクトリtestを作成。
test内に仮想環境を構築して起動。

python3 -m venv .
source bin/activate

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

pip install flask
pip install gunicorn

（２）csvで掲示板

まず、ローカル環境でcsvを使って掲示板を作る。

①ディレクトリ構成

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

②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

{% 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という変数をセット（jinja2の変数セットにはsetが必要）  -->
        <!--splitを利用して,で分類する。splitはリストを返す  -->
            {% set column = line.rstrip().split(',') %}
            <tr><td>{{column[0]}}</td><td>{{column[1]}}</td></tr>
        {% endfor %}
    </table>

{% endblock %}

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_result.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へのデプロイ詳細は以下の記事に書いた通りなので、エッセンスのみとし、詳細説明を省く。
Heroku、Flask、Python、Gitでアップロードする方法（その②）
Heroku、Flask、Python、Gitでアップロードする方法（その③）
Herokuにログインし、Heroku上にアプリを作成

heroku login

アプリ名はcat-bbsとした。

Heroku create cat-bbs

ディレクトリappを初期化して、

git init

Herokuとローカル環境を紐つけて、

heroku git:remote -a cat-bbs

ディレクトリappにrequirements.txtを作成して、

pip freeze > requirements.txt

ディレクトリapp内にProckfileを作成し、以下を入力。
この時、gの前はブランク一つ必要、また、:appの前のappは、app.pyのappという意味なので注意が必要（form.pyなら、form:app）

web: gunicorn app:app --log-file -

全てをaddして、

git add .

今回は、the-firstという名前でcommitして、

git commit -m'the-first'

Herokuにpushする。

git push heroku master

最後に、

heroku open

heroku openのコマンドを入力すると、ブラウザが立ち上がり以下が表示された。

にゃん子の名前を”いわし”とし、投稿内容を”魚が大好き”と投稿すると、

ちゃんと掲示板に書き込みされた。
herokuでは書き込みされたcsvは一定時間（３０分）経過すると消えてしまうので、データベースの組み込みに取り掛かる。

（３）SQLとSQLAlchemyで掲示板

①ディレクトリ構成等

test
├app.py
├articles.csv
├Procfile
├requirements.txt
├assets
│ ├init.py   
│ ├database.py
│ └models.py
│
└templates
  ├index.html
  ├layout.html
  └index_result.html

SQLAlchemyとは、Pythonの中では最もよく利用されているORMの一つ。
最初にsqlite3のバージョン確認（Mac）と、sqlalchemyをインストールする。

sqlite3 --version
pip install sqlalchemy

また、app.pyから、database.pyやmodels.pyをモジュールとして読み込むために必要なファイルとして、 init.pyをassetsフォルダ内に作成する（アンダーバーがつくので注意）

touch __init__.py

②SQLAlchemyの初期設定

以下の２つのファイルをassetsフォルダ内に作成する。

database.py・・・sqliteやmysqlなど、どのデータベースを使うのかを定義するファイル
models.py・・・そのデータベースにどのような情報を入れるかを定義するファイル
まず、database.pyは以下の通り。

database.py

#coding: utf-8

#database.py/sqliteなど、どのデータベースを使うのか初期設定を扱うファイル
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session,sessionmaker
from sqlalchemy.ext.declarative import declarative_base

import datetime
import os

#data_dbという名前で、database.pyのある場所に（os.path.dirname(__file__)）、絶対パスで（os.path.abspath）、data_dbを保存する
database_file = os.path.join(os.path.abspath(os.path.dirname(__file__)),'data.db')

#データベースsqliteを使って（engin)、database_fileに保存されているdata_dbを使う、またechoで実行の際にsqliteを出す（echo=True)
engine = create_engine('sqlite:///' + database_file,convert_unicode=True,echo=True)
db_session = scoped_session(
                sessionmaker(
                    autocommit = False,
                    autoflush = False,
                    bind = engine
                )
            )

#declarative_baseのインスタンス生成する
Base = declarative_base()
Base.query = db_session.query_property()


#データベースの初期化をする関数
def init_db():
    #assetsフォルダのmodelsをインポート
    import assets.models
    Base.metadata.create_all(bind=engine)

次に、models.pyは以下の通り。
ここで、投稿日時も掲示板に反映させるようした。

models.py

#coding: utf-8


from sqlalchemy import Column,Integer,String,Boolean,DateTime,Date,Text
from assets.database import Base
from datetime import datetime as dt

#データベースのテーブル情報
class Data(Base):
    #テーブルnameの設定,dataというnameに設定
    __tablename__ = "data"
    #Column情報を設定、uniqueはFalseとする（同じ値でも認めるという意味）
    #主キーは行を検索する時に必要、通常は設定しておく
    id = Column(Integer,primary_key=True)
    #nameは投稿者
    name = Column(Text,unique=False)
　　 #articleは投稿内容
    article = Column(Text,unique=False)
    #timestampは投稿日時
　　 timestamp = Column(DateTime,unique=False)

    #初期化する
    def __init__(self,name=None,article=None,timestamp=None):
        self.name = name
        self.article = article
        self.timestamp = timestamp

③app.pyを修正する

データベースの作成や削除等には以下２つが必要なためインポートする。
assetsフォルダのdatabaseモジュールから変数de_sessionのインポートと、assetsフォルダのmodelsモジュールから、Dataクラスをインポート。

from assets.database import db_session
from assets.models import Data

③−１データベースへの書き込み

index.htmlからarticle、nameの値を取得する処理が必要。また、それぞれの値をで取得時の（書き込み時の）日時をtoday()で取得し、today変数に代入する処理が必要。具体的には以下の通り。

article = request.form['article']
name = request.form['name']
today = datetime.datetime.today()

上記の内容をrowに格納し、db_sessionとde_commitでデータベースに書き込む処理が必要。具体的には以下の通り。

row = Data(name=name,article=article,timestamp=today)
db_session.add(row)
db_session.commit()

③−２データベースからの読み込み

データベースからデータを読み込むには、db_session.query(Data).all()で取得できる。
例えば、データベースの中の値を取り出すために以下のように記述すると、

db_session.query(Data.name,Data.article,Data.timestamp).all()

以下のようにリスト形式で出力される（分かりやすさの観点から、掲示板で何件か投稿し、データベースに保存された場合を想定）

('ミケ', '本日は晴れ', datetime.datetime(2020, 3, 13, 0, 7, 4, 828409)),
 ('しろ', '明日は雨だにゃー', datetime.datetime(2020, 3, 13, 0, 7, 4, 828409)),
 ('クロ', 'ぽかぽか', datetime.datetime(2020, 3, 13, 0, 7, 4, 828409)),
 ('ぽんたん', 'にゃーにゃーカラスは紙飛行機', datetime.datetime(2020, 3, 13, 0, 7, 4, 828409)),
 ('しろ', '腰が痛いにゃー', datetime.datetime(2020, 3, 13, 0, 7, 46, 513144)),
 ('ミケ', 'もんだろにゃ？', datetime.datetime(2020, 3, 13, 0, 8, 57, 193710)),
 ('クロ', 'ぽかぽか', datetime.datetime(2020, 3, 13, 0, 9, 42, 45228)),
 ('ミケ', '本日は曇り', datetime.datetime(2020, 3, 13, 0, 17, 13, 709028)),
 ('ブー太郎', '今日は一日雨かにゃー', datetime.datetime(2020, 3, 14, 13, 26, 29, 438012)),

index.htmlに読み込んだデータベースの内容を返す処理が必要。具体的には以下の通り。

data = db_session.query(Data.name,Data.article,Data.timestamp).all()
return render_template('index.html',data=data)

これまでの修正についてまとめると、app.py全体としては以下の通り。

app.py

#coding: utf-8
from flask import Flask,request,render_template
import datetime

#データベースを使うにあたり追加
from assets.database import db_session
from assets.models import Data

app = Flask(__name__)


@app.route('/')
def bbs():

    #データベースから読み込む
    data = db_session.query(Data.name,Data.article,Data.timestamp).all()

    #index.htmlに返す
    return render_template('index.html',data=data)


#postメソッドを受け取る
@app.route('/result',methods=['POST'])
def result():
    #requestでarticleとnameの値を取得する
    article = request.form['article']
    name = request.form['name']
    #today関数でpostメソッドを受け取った日時を変数に代入
    today = datetime.datetime.today()

    #index_resultからの情報をデータベースに書き込む
    row = Data(name=name,article=article,timestamp=today)
    db_session.add(row)
    db_session.commit()

    #index_result.htmlに返す
    return render_template('index_result.html',article=article,name=name)


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

③−４（参考）データベースからの削除

参考として、読み込んだデータベースからの削除は以下の通り。
db_session.query(Data).allから削除したい項目を指定して（以下のケースは１番目の項目）、de_session.deleteを使う

#coding: utf-8

from assets.database import db_session
from assets.models import Data

def csv_sakujo():
    data = db_session.query(Data).all()
    datum = data[0]
    db_session.delete(datum)
    db_session.commit()

csv_sakujo()

③−５（参考）読み込んだデータベースをcsvに書き出し

参考として、読み込んだデータベースをcsvに書き出すファイルは以下の通り。

to_csv.py

#coding: utf-8

from assets.database import db_session
from assets.models import Data

#データを読み込む
def csv_kakikomi():
    data = db_session.query(Data.name,Data.article,Data.timestamp).all()
    print(data)
    #csvファイルに書き込みモードで書き込む#
    with open('articles2.csv','w',encoding='utf-8') as f:
        for i in data:
            f.write(str(i[0])+',')
            f.write(str(i[1])+',')
            f.write(str(i[2])+',' + '\n')

csv_kakikomi()

④index_html.pyを修正する

app.pyから送られてきたdataの値を表示する。
dataの値のうち、data[2]は現在日時であるが、投稿前はNoneの値があるため、if文でエラーにならないように設定。投稿後はdatatime型をstr型にstrftimeを用いて変換した上で表示。

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>
          <th>投稿日時</th>
        </tr>
        {% for datum in data %}
             <tr>
              <td>{{datum[0]}}</td>
              <td>{{datum[1]}}</td>
              {% if datum[2] == None %}
                  <td>{{datum[2]}}</td>
              {% else %}
                  <td>{{datum[2].strftime('%Y年%m月%d日/%H時%M分%S秒')}}</td>
              {% endif %}
            </tr>
        {% endfor %}
    </table>

{% endblock %}

ここまでを、一度ローカル環境で正常に動くかどうかを試す。

問題なく稼働するのを確認したら、次にHeokuへのデプロイと、HerokuのPostgreSQLを使う。

（４）PostgreSQLとSQLAlchemyで掲示板

Herokuへデプロイし、PostgreSQLを使う。

①環境準備

postgresqlをbrewを使ってインストールする。

brew install postgresql

次に postgresqlを使うためのpython用のドライバーとして、 psycopg2-binaryをインストールする。psycopg2をそのままインストールすると、なぜかエラーが出るため、psycopg2-binaryをインストール（原因不明）。

pip install  psycopg2-binary

次にdatabase.pyを修正するが、environというHeroku上の環境変数を見に行ってDATABASE_URLというデータベースを取得する処理を記述する。environには接続先のURLがセットされる。また、orをつけることで、ローカル環境上はsqliteをデータベースとして参照することとした。herokuに接続されている場合はpostgresqlのurlを参照して、接続されていない場合はsqlを参照に行くという格好。具体的には以下の通り。

engine = create_engine(os.environ.get('DATABASE_URL') or 'sqlite:///' + database_file,convert_unicode=True,echo=True)

修正後のapp.py全体は以下となる

database.py

#coding: utf-8

#database.py/sqliteなど、どのデータベースを使うのか初期設定を扱うファイル
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session,sessionmaker
from sqlalchemy.ext.declarative import declarative_base

import datetime
import os

database_file = os.path.join(os.path.abspath(os.path.dirname(__file__)),'data.db')

engine = create_engine(os.environ.get('DATABASE_URL') or 'sqlite:///' + database_file,convert_unicode=True,echo=True)
db_session = scoped_session(
                sessionmaker(
                    autocommit = False,
                    autoflush = False,
                    bind = engine
                )
            )

#declarative_baseのインスタンス生成する
Base = declarative_base()
Base.query = db_session.query_property()


#データベースの初期化をする
def init_db():
    #assetsフォルダのmodelsをインポート
    import assets.models
    Base.metadata.create_all(bind=engine)

②Herokuへデプロイする

Herokuへデプロイする。

heroku login

Herokuとローカル環境を紐つけて、

heroku git:remote -a cat-bbs

あらためて、ディレクトリappにrequirements.txtを作成する。
（psycopg2-binaryをインストールしたため、再度の作成が必要。）

pip freeze > requirements.txt

Prockfileは作成済みのため今回は触らず。

全てをaddして、

git add .

今回は、the-secondという名前でcommitして、

git commit -m'the-second'

Herokuにpushする。

git push heroku master

最後にheroku openする

herokuにデプロイする前に、データベースの初期化を行う。
heroku上でpythonを起動する（pythonモード）。

heroku run python

データベースを初期化する。
pythonモードで以下を記述。

from assets.database import init_db
init_db()

pythonモードを終了し、herokuをrestartして、openする。

heroku restart
heroku open

ブラウザで以下を確認して成功。

（５）SQLAlchemyを使ってデータ操作

例として、データベースの１番上の項目を削除してみる（”クロ”）。
Heokuのpythonモード起動。

heroku run python

pythonモードで以下を記述

from assets.database import db_session
from assets.models import Data
data = db_session.query(Data).all()
datum = data[0]
db_session.delete(datum)
db_session.commit()

として、heroku openしてブラウザで確認すると、

一番上の”クロ”が削除された。
（pythonモードは忘れずに終了させること）

（６）Postgresqlを使ってデータ操作

PostgreSQL をインストールすると、heroku pg コマンドで Heroku Postgres を操作できるようになる。
例えば以下を入力すると、インストールした Heroku Postgresの状況は以下のように確認できる。

heroku pg:info

=== DATABASE_URL
Plan:                  Hobby-dev
Status:                Available
Connections:           2/20
PG Version:            12.2
Created:               2020-03-14 04:53 UTC
Data Size:             8.2 MB
Tables:                1
Rows:                  3/10000 (In compliance)
Fork/Follow:           Unsupported
Rollback:              Unsupported
Continuous Protection: Off

hobby-dev プラン (無料枠) で、Status は Available (有効) 。

以下を入力すると、Heroku Postgresに接続できる。

heroku pg:psql

接続後はPostgreSQLのコマンドを使用
例えば、１番上の項目を削除してみる（”テスト”、”うんち”）。

テーブル一覧の表示のコマンド
\dt;

テーブル内のデータを一覧するコマンド
select * from data（テーブル名）;

以下が出力される。

cat-bbs::DATABASE=> select * from data;
 id |    name    |      article       |         timestamp          
----+------------+--------------------+----------------------------
  3 | テスト     | うんち             | 2020-03-14 05:59:38.062361
  4 | プーさん   | なし               | 2020-03-14 15:14:12.453124
  5 | まちゃあき | それがどうした     | 2020-03-14 15:14:12.453124
  6 | どぶろっく | だから             | 2020-03-14 15:14:12.635542
  7 | 変だ       | なし               | 2020-03-14 15:14:12.635542
  8 | おう       | そだね             | 2020-03-14 15:14:12.453124
  9 | ニューあ   | ムーン             | 2020-03-14 15:32:49.082485
 10 | 女子       | 高め               | 2020-03-14 15:59:30.175208
 11 | ほんま     | 相談               | 2020-03-14 15:59:47.029891
 12 | え？       | フォンド           | 2020-03-14 16:15:58.35794
 13 | なおき     | テスト             | 2020-03-14 16:24:47.435301
 14 | ぽち       | ぽちでも猫だにゃん | 2020-03-14 22:52:41.633207
(12 rows)

次に、deleteで１番上の項目を削除する（”テスト”、”うんち”）。

delete from data（テーブル名） where id=3;

とすると、

cat-bbs::DATABASE=> select * From data;
 id |    name    |      article       |         timestamp          
----+------------+--------------------+----------------------------
  4 | プーさん   | なし               | 2020-03-14 15:14:12.453124
  5 | まちゃあき | それがどうした     | 2020-03-14 15:14:12.453124
  6 | どぶろっく | だから             | 2020-03-14 15:14:12.635542
  7 | 変だ       | なし               | 2020-03-14 15:14:12.635542
  8 | おう       | そだね             | 2020-03-14 15:14:12.453124
  9 | ニューあ   | ムーン             | 2020-03-14 15:32:49.082485
 10 | 女子       | 高め               | 2020-03-14 15:59:30.175208
 11 | ほんま     | 相談               | 2020-03-14 15:59:47.029891
 12 | え？       | フォンド           | 2020-03-14 16:15:58.35794
 13 | なおき     | テスト             | 2020-03-14 16:24:47.435301
 14 | ぽち       | ぽちでも猫だにゃん | 2020-03-14 22:52:41.633207
(11 rows)

削除した。
ブラウザで確認してもちゃんと削除されている。

目的関数の書き方

dfが

• PassengerID (乗客のID)
• Survived (trainデータだけ)
• Pclass (部屋のクラス)
• Name
• Sex
• Age
• SibSp
• Parch
• Ticket
• Fare
• Cabin (客室を持っていたか)
• Embarked　(どこの港で乗ったか)

このような項目を持っていた時に

説明変数は

x=df[["項目名1","項目名2","項目名3","項目名4"]]

というように、自分選びたい項目を[["項目"]]のように追加します。

目的関数

目的関数は一つしか項目がないので、

t=df["目的関数の項目"]

終わり

こんなかんじで、このあとモデルに学習させたりします。

__signature__ という属性がどこからやってきたのを理解するために PEP 362 -- Function Signature Object を読むことになったので、自分の理解をメモに残しておく。

概要

• これまで関数シグネチャの表現は複雑な形式で表現されていた
• PEP 362 では、関数シグネチャを表現する Signature というクラスを使って、関数シグネチャをシンプルに表現できるようにする
• また、 inspect.signature() という関数を使って、かんたんに関数オブジェクトから関数シグネチャを取り出せるようにする

感想

あとは細かい使い方なので説明は省きます。PEP 362 を読んでもいいし、Python のドキュメントの inspect のページ を読んでもよいです。
かつて inspect.getargspec() やオブジェクトの属性を駆使して関数シグネチャを読み取っていた過去がありましたが、いまや inspect.signature() ひとつで大抵のことが事足りるようになりました。ビバ、Signature。

さて、最初の疑問であった __signature__ についてもこの PEP で言及されていました。Signature オブジェクトを func.__signature__ に保存しておくと inspect.signature() はその値を返してくれる、とのことです。つまりキャッシュみたいなものですね。

なお、PEP 362 では C拡張については対象外とされていましたが、Argument Clinic How-To を流し読みした限りでは、C ファイルのプリプロセッサである Argument Clinic を使って(従って)C拡張を作ると Signature に対応したモジュールが作れるようです。便利ですね。

なかなか関数シグネチャを必要とする場面は少ないのですが、引数や関数の型について調べたいに活躍するので試してみてはどうでしょうか。

AtCoder パナソニックプログラミングコンテスト2020 参戦記

panasonic2020A - Kth Term

2分半で突破. まあ、書くだけ.

K = int(input())

t = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(t[K - 1])

panasonic2020 B - Bishop

6分くらい?で突破. 1WA. H と W が1の場合をすっかり忘れてました.

H, W = map(int, input().split())

if H == 1 or W == 1:
    print(1)
elif W % 2 == 0:
    print(H * W // 2)
else:
    if H % 2 == 0:
        print(H * W // 2)
    else:
        print((W + 1) // 2 + (H - 1) * W // 2)

panasonic2020C - Sqrt Inequality

敗退. 整数で計算しないと駄目なんだろうとは分かっていても、整数の式に落とせなかった. 二回二乗すればいいじゃんと言われればあああーってすぐ分かるやつ. 何故かコンテスト中は分からない orz. 数学問題嫌いだー.

panasonic2020D - String Equivalence

32分半で突破. 1WA. 何回読んでも、何回読んでも定義が頭に入ってこなくて困った. で、完全に定義を誤解して出して WA を食らい、その後に N = 4 くらいまで手で全部書いてようやく分かって AC. 要するに N - 1 までの文字列に、aからそれまでに出ている文字の一番辞書順で大きいやつの次のやつまでを追加したのが答え.

N = int(input())

q = ['a']
for i in range(N - 1):
    nq = []
    for s in q:
        stop = ord(max(s)) + 2
        for i in range(ord('a'), stop):
            nq.append(s + chr(i))
    q = nq
for s in q:
    print(s)

はじめに

今回はA,Bしか解けませんでした。ABC相当のコンテストでAとBしか解けないのは良くない。

A問題

問題

考えたこと
問題に書いてある数列をコピーして、kでindexを指定してprintしました。

k = int(input())
l = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(l[k-1])

B問題

問題
1WA
考えたこと
問題文の図を見ると、i行目とi+1行目を足すとWになると思ったのでhの偶奇で判別して計算しようとしたら1WAしました。WAの理由は、W,Hが1のときを考慮していなかったためです。ですので、どちらかが1のときを場合分けして書きました。

import math
h, w = map(int,input().split())
if w == 1 or h == 1:
    print(1)
    quit()
if h % 2 != 0:
    ans = w * (h-1) / 2 + math.ceil(w / 2)
    print(int(ans))
else:
    ans = w * h / 2
    print(int(ans))

C問題

問題
12WA NoAC

考えたこと
やったー、数学の問題じゃんと思っていたら地獄を見ました。まずは、安直に全部sqrtにつっこんで計算して1WA付きたので、計算をうまく減らしてあげないといけないと思いました。ですので、紙とペンを用意して必死にゼロに近い数学力で計算していました。

\sqrt(a) + \sqrt(b) < \sqrt(c)は両辺は0以上なので、両辺を二乗して \\
= a + b < c 
= a + b - c + 2\sqrt(ab)< 0 が成り立てば\sqrt(a) + \sqrt(b) < \sqrt(c)を満たす \\

a + b - cは整数だから計算的にあふれないと思ったので、\\
2\sqrt(ab)をどうやって処理するかを考えました。\\
相加相乗平均の関係より、 \\
a + b >= 2 \sqrt(ab) \\
が成り立つ。等号成立条件はa = bなので、そのときはifで分ければいいと考えてました。 \\ 
問題は、a != bのときで、自分の力ではどうしても根号を消すことができませんでした。 \\

それで、うまく工夫したつもりでしたがWAは消えず...結局ACできませんでした。
コンテスト終了した後に他のACした人のコードを見るとDecimalとかいうモジュールを使って小数をうまく計算していました。こんなに楽に計算できたら、楽勝問題だったのに...

<追記>

from decimal import *

a, b, c = map(int, input().split())
if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():
    print("Yes")
else:
    print("No")

でACでました。

まとめ

言語に対しての知識不足を再認識するコンテストでした。色々と悔しいし、悲しい。毎日AtCoderチャレンジをしているので、次回のコンテストこそは結果を残したいです。
では、おやすみなさい。

前書き

　春休みの間を利用して安全工学に関する強化学習による研究を進めていたが、どうにも具体的な形にまで昇華できなさそうであるので、今回できた分までを背景と並べてここに示す。

強化学習と研究背景

迷路問題

　強化学習において、迷路問題は良く取り扱われる問題の1例である。
　実装の例としてはこちらを参考にした。

説明：

　図で示したような迷路で、S(start)からG(Goal)までの道筋を学習することが目的となる。今回はQ学習でε‐greedy法を用いて学習を行っていく。

　Q学習ではそれぞれのマス目に対して取れる移動の選択肢(方策)が定められていて、その方策ごとに行動価値が決まっている。あるマス目である方策をとった場合、その移動先の行動価値の最大値との差をある割合で増加させて、そのマス目におけるその方策の行動価値を更新する。
　もう一つ、Goalにおいてはある一定の行動価値が定められていて、Goalに到着する方策はその報酬により行動価値を更新して迷路を解く1セットを終了する。

　行動価値Qの更新式の基本形は以下のようになる。
$$Q(s,a)\leftarrow Q(s,a) + \alpha[r+\gamma*max_{a'}Q(s',a')-Q(s,a)]$$

$Q$：行動価値
$s$：状態(エージェントの位置、マス目)
$a$：行動
$\alpha$：学習率
$\gamma$：時間割引率
$r$：報酬
としてあたえられる。$s', a'$は1つ先の状態(すなわち、決定された行動先の行動価値)であることを表している。

　上の式を見ればわかる通り、Q学習における更新は1つ先のマス目の行動価値Qとの差を更新の駆動力としているので、もし最初に与えられる各マス目のQの値が一律0であるならば、エージェントはstartから各マスをランダムに動き回り、偶然Goalにたどり着く方策を取得した場合のみそのマスの行動価値が更新される。
　これは実際その通りであって、最初にうちはランダムな探索を行い報酬を得て、だんだんとGoalやその近辺のマスからStartへ向かって行動価値が伝播していく。

　一方で、上式では一旦行動価値がStartからGoalまで決定された場合にその経路のみを絶対に通ってしまう(ほかのマスは0なのでそちらに移動する方策は選択されない)という欠陥がある。そこで、方策決定の際にある確率εでランダムに行動をとるようにして、だんだんとεの値を減らしていく計算方法がとられる。これがε‐greedy法の簡単な説明である。

研究背景

　安全工学のの中では火災という災害は1つの大きな研究対象である。火災時の避難について、既往の研究においては実験と計算から様々な報告がなされている。例としては、迷路を用いた火災避難行動の模擬などがある。計算においては

• 人間行動を粒子運動と解釈して運動方程式を解くモデル
• セルオートマトンモデル

などが頻繁に議論の俎上に上がるが、どちらも環境に対する情報や環境依存の顕著なルールが計算に用いられる現状がある。そのため、多くの研究が実際の火災事例の検証とともに論じられており、避難行動の予測に関しては疑問が浮かび上がる。

　そこで、ここで考えるのはQ学習による迷路問題を応用して火災発生から避難までの最適経路の計算とその定量的な考察をしてみようというアイデアに基づく研究である。
　この手法の一つの利点としては、事前に設定するパラメータの環境依存が少ないという特徴がある。また、報酬や方策の設定如何によりアルゴリズムのルール設定を増やすことなく大きな拡張性を持つことが予想される。

Q学習による迷路問題

　コードを張り付けることが早いだろう。

Q学習による解法

plain_Q_model.py

import numpy as np
import matplotlib.pyplot as plt


#decide the direction to move by Q table and random probability epsilon
#and convert it as movement on the map.
def decide_action(status, maze_row, q_table, maze_map, epsilon):

    direction=["up", "right", "down", "left"]
    if(np.random.rand() < epsilon):
        #at random choice
        direction_to=np.random.choice(direction, p=maze_map[status])
    else:
        #direction is selected at max Q value direction
        direction_to=direction[np.nanargmax(q_table[status])]


    #convert direction to map information at matrix
    if(direction_to=="up"):
        status=status-maze_row
        action=0
    elif(direction_to=="right"):
        status=status+1
        action=1
    elif(direction_to=="down"):
        status=status+maze_row
        action=2
    elif(direction_to=="left"):
        status=status-1
        action=3

    return status, action


#q_learning function to update the Q_value
def q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward):

    #setting of reward
    if(next_status==goal):
        r=reward
    else:
        r=0

    #update fomula of Q_value
    q_table[status][action]+=alfa*(r+gamma*(np.nanmax(q_table[next_status])-q_table[status][action]))

    return q_table


#solve and update the maze at once
def goal_once(start, goal, maze_row, maze_map, q_table, alfa, gamma, reward, epsilon):

    flag=True
    history_move=[]

    #initialize
    status=start

    #solve maze until it gets the goal
    while(flag):

        next_status, action=decide_action(status, maze_row, q_table, maze_map, epsilon)
        q_table=q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward)

        #record the history of action
        history_move.append([status, action])

        #flag of goal
        if(next_status==goal):flag=False

        #status update
        status=next_status

    return q_table, history_move



move_0=np.array([0, 0, 0, 0])
move_w=np.array([1, 0, 0, 0])
move_d=np.array([0, 1, 0, 0])
move_s=np.array([0, 0, 1, 0])
move_a=np.array([1, 0, 0, 1])
move_wd=np.array([1, 1, 0, 0])/2
move_ws=np.array([1, 0, 1, 0])/2
move_wa=np.array([1, 0, 0, 1])/2
move_ds=np.array([0, 1, 1, 0])/2
move_da=np.array([0, 1, 0, 1])/2
move_sa=np.array([0, 0, 1, 1])/2
move_wds=np.array([1, 1, 1, 0])/3
move_wda=np.array([1, 1, 0, 1])/3
move_wsa=np.array([1, 0, 1, 1])/3
move_dsa=np.array([0, 1, 1, 1])/3
move_wdsa=np.array([1, 1, 1, 1])/4


###input form###

maze_map=np.array([move_ds, move_dsa, move_dsa, move_dsa, move_sa, \
                   move_wds, move_wdsa, move_wdsa, move_wdsa, move_wsa,\
                   move_wds, move_wdsa, move_wdsa, move_wdsa, move_wsa,\
                   move_wd, move_wda, move_wda, move_wda, move_wa])

q_table=np.where(maze_map==0.0, np.nan, 0)

maze_row=5
maze_columns=4

start=0
goal=19
reward=1
time_of_episode=100
alfa = 0.10  # 学習率
gamma = 0.92 # 時間割引率
epsilon = 0.99  # ε-greedy法の初期値
probability_reduce_rate=1.04

###input form end###



history_move=[]
size_of_epi=[]
episode = 1



flag=True
while(flag):
    q_table, history_move=goal_once(start, goal, maze_row, maze_map, q_table, alfa, gamma, reward, epsilon)
    print("this is episode: {0:5d}, steps to goal are {1:5d}".format(episode, len(history_move)))
    size_of_epi.append(len(history_move))
    if(time_of_episode==episode):
        flag=False
        episode=episode-1
    episode+=1
    epsilon=epsilon/probability_reduce_rate
    q_table=q_table/np.nanmax(q_table)

direcion=["↑", "→", "↓", "←"]
for i in range(len(history_move)):
    print(direcion[history_move[i][1]])

plt.plot(size_of_epi)
plt.show()



q_table[goal]=1.0

np.set_printoptions(suppress=True, precision=4, floatmode='maxprec')
#print(maze_map)
print(q_table)


q_table_max=np.zeros(goal+1)
for i in range(len(q_table)):
    q_table_max[i]=np.nanmax(q_table[i])

print(q_table_max.reshape(maze_columns, maze_row))

q_table_max=q_table_max.reshape(maze_columns, maze_row)

plt.figure(figsize=(10, 5))
plt.imshow(q_table_max, interpolation='nearest', vmin=0 ,cmap='YlOrRd')
plt.colorbar()
plt.show()

　下に計算結果を示してあるが、左上から右下にゴールする迷路で極めて明瞭に行動価値が伝播してGoalまでの道筋ができていることがわかる。

火災の模擬

　これを拡張して、火災発生時の避難行動の学習を模擬してみる。
　ここではGoalに報酬を置いただけのモデルであるが、簡単な拡張として火災に見立てたマスを用意してそこにたどり着いた時に負の報酬を与えるものとする。また、負の報酬を持つマスについた場合もゲームを1セット終了とする。すなわち、エージェントはStartから知識0の状態で出発して、何度も死に戻りをしながらGoalを目指すわけである。

結果

　上がその計算結果であるが、なかなか面白い結果が得られた。Q学習の更新式をもう一度見てみよう。

$$Q(s,a)\leftarrow Q(s,a) + \alpha[r+\gamma*max_{a'}Q(s',a')-Q(s,a)]$$

以上の式に基づいて各マス各方策の行動価値が更新されるが、上の式ではすべての更新が行動先の最大値を反映させるようになっているので、負の報酬を与えても周辺の1マス以外はMax関数で無視されてしまう。
　Q学習の上の更新式は楽観的な行動価値の計算式なので、簡単に言えば隣に大きな負の報酬が存在しても最良の経路をとる。隣で炎が燃え盛っていても、そこが最短経路ならそこを通るように計算してしまうという問題点がある。

悲観的な更新式

　ここで少し悲観的なエージェントを考えてみる。Pessimismというパラメーターを与えて、

$$Q(s,a)\leftarrow Q(s,a) + \alpha[r+\gamma*max_{a'}Q(s',a')-Q(s,a)]$$

$$Q(s,a)\leftarrow Q(s,a) + \alpha[r+\gamma*(max_{a'}Q(s',a')/(1+pessimism)+min_{a'}Q(s',a')*pessimism/(1+pessimism))-Q(s,a)]$$

上の式を下の式のように改変する。つまり一定の割合で行動先の行動価値の最低値を見積もるように改変する。pessimism=0なら元の更新式と同じに、pessimism→∞なら各マスの行動価値の最低値のみを評価して学習するプログラムになる。
　具体的には、

q_learning

#q_learning function to update the Q_value
def q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward, pesimism):

    r=0

    #setting of reward
    for i in range(len(goal)):
        if(next_status==goal[i]):
            r=reward[i]

    #update fomula of Q_value
    q_table[status][action]+=alfa*(r+gamma*(np.nanmax(q_table[next_status])-q_table[status][action]))


    return q_table

該当箇所の関数を

q_learning

#q_learning function to update the Q_value
def q_learning(status, action, next_status, goal, q_table, alfa, gamma, reward, pesimism):

    r=0

    #setting of reward
    for i in range(len(goal)):
        if(next_status==goal[i]):
            r=reward[i]

    #update fomula of Q_value
    q_table[status][action]+=alfa*(r+gamma*(np.nanmax(q_table[next_status])/(1+pesimism)\
           +np.nanmin(q_table[next_status])*pesimism/(1+pesimism)-q_table[status][action]))


    return q_table

と書き換える。
これで計算をしてみると。

きちんと火災発生個所を回避するような経路が選択されていることがわかる。

中規模迷路の行動価値マップ(ポテンシャル)

　以上の知見を踏まえて、迷路の規模をさらに拡大した状態で、迷路の各マスからGoalまでの道順を学習させ、さらにそこから得られた行動価値を平均化して、迷路全体からGoalまでのヒートマップを作製した。
　ヒートマップ自体に本質的な意味はないが、火災の発生時にどの程度のリスクが生じて、どのような経路の選択の変化が起きるのかを分かりやすく示すうえで有用であると考えられる。

上部中央をゴールとしている。

火災なし：

火災あり：

　フロア右側で火災を発生させた場合、右側のスペースの行動価値が著しく下がることがわかる。一方で中央下部の2本の経路のうち左側の通路がより行動価値が高く選好されることがわかる。
　火災を単一の負の報酬マスとみなした場合でもなかなか面白い結果が得られた。

問題点

　冒頭で自主研究と宣言したが、これがまだ具体的な形にならないのには以下の問題点がある。

マルチエージェント化

　火災発生時の人の流動は言うまでもなくマルチエージェントなタスクを解く必要がある。また、実際の避難行動の特徴として

1. 避難者はリーダー(知識のある係員)などに従う。(これは行動価値関数の共有とみなせる)
2. 案内板や避難誘導などは一定の効果がある。(特定のマスに報酬や方策を設定する必要がある)
3. 出口付近では混雑が発生して人の流動性が落ちる。(もちろん、逃げるのが遅れるので、あとから脱出する人ほど報酬を漸減するように設定する必要がある)

　このような実際の避難行動の特性を考慮に入れたうえで学習を行う必要がある。それに比べると今回のプログラムはQ学習の改良で終わっている。

火災の特徴の組み込み

　火災時の避難行動では火災それ自体が時間とともに大きく変化する。避難行動における一番の大きな要因は煙である。
　煙の横方向の移動速度は大体人間の歩行速度程度といわれるが、拡散の特性、移動速度や方向などはさらに吟味する必要がある。ターンごとに負の報酬領域を時間発展させることが有効なアルゴリズムとして考えられるが、実際の火災の避難行動の実験では、火災の煙が人の視界を遮ること、歩行速度を低下させることなどが指摘されており、その効果を負の報酬だけで表現していいものかは不明である。

人間の避難行動のジレンマ

　先ほど述べたように、人間の避難行動には実験から観測された特徴的な行動がある。影響力のあるリーダーについていくこと、とりあえず人についていく群集行動なども知られている。たとえ出口が狭くほかの出口に向かうほうが効率的でもこのような行動は起こりうる。
　問題は強化学習で学習した最適な経路が、人間の非合理性や本能といった部分を鑑みたときに最適とは限らないということである。パニックに陥る人もいる中で果たしてどこまでの非合理的な行動を報酬に落とし込めば、それが人間行動にとって最適といえるのかが最大の問題となってくる。

展望

　結局計算のほうはサーバー側で高速に処理して、避難者それぞれに最適な避難経路を提示できるようになったら面白いかも程度に考えている。既往のセルオートマトン法などに比べて環境依存のアルゴリズムが少ないというのはこのあたりの拡張性にも効いてきそう。
　都市交通や駅の乗り換えなど、この辺りの分野ではすでに実用化されているのだろうか？

　何か有益な文献があれば教えていただけると幸いです。

結び

※参考文献の数が多いので略させていただきます。参考文献に興味があれば御一報ください

はじめに

新型コロナウイルス感染症 (COVID-19) の影響でマスクが入手しづらい状況が続いています。
私は花粉症ですがマスクの手持ちが少なくなってきてこの春を無事に過ごせるか心配しています。
薬を飲めばいいって話もありますが、薬はあまり好きではないです。

そこでAmazonをちょこちょこ見ていたら、出品者がAmazonのマスクが常識的な値段で稀に出品されて、即売り切れになることを発見しました。
もしかして発見が早ければAmazonで常識的な値段でマスクが買えるのでは、、、と思った私が作成した「出品者がAmazonのマスクが出品されたら通知するプログラム」を公開いたします。

前提

• ここに記載する「出品者がAmazonのマスク」とは、マスクのカテゴリで出品者がAmazonになっているものを指します
• APIを使ってスマートにやる方法があると思いますが、他の人も簡単に使えるようにWebスクレイピング+slackでやることにします
• マスクを買うことが目的のため、必要最低限の機能にします

方針を決める

どのようなものを作るか以下の流れで方針を検討し、決めました。

1. 私は50枚とか入っている使い捨てのマスクが欲しいのですが、余計な検索条件を入れて欲しいマスクが通知されないと悲しい
2. 使い捨てのマスクの中にも寝るときに使用する濡れマスクなどが含まれており、機械的に私が欲しいものだけを通知するのは厳しそう
3. 3月14日時点でAmazonが出品者のマスクは65件しか無く、出品数に変動が少ない
4. 新しく出品されたものを全て通知しても大した件数にならないと思われる
5. マスクカテゴリに出品者Amazonの商品が追加されたらslackで通知する！！

出品者がAmazonのマスクを表示するURLの確認

GUIでマスクのカテゴリに移動して出品者Amazonを選択した場合、URLは以下のようになると思います。
人により若干異なる場合もあります。

https://www.amazon.co.jp/s?bbn=169922011&rh=n:160384011,n:!161669011,n:169911011,n:169922011,p_6:AN1VRQENFRJN5&dc&fst=as:off&qid=1584146361&rnid=388336011&ref=sr_in_-2_p_6_5

上記のURLを使っても良いのですが余計な文字が含まれていそうなため、もう少しシンプルにできないか試してみます。
ドキュメントを探すのが面倒だったのでURLを変えながら試した結果、以下のことがわかりました。

• n:160384011,n:!161669011,n:169911011,n:169922011はカテゴリを絞るところのようで、大カテゴリ→中カテゴリ→小カテゴリ、という感じで指定されているようです（たぶん）
• p_6:AN1VRQENFRJN5は出品者Amazonの意味のようです（たぶん）
• 他のst qid rnid refは無くてもよいようです（たぶん）

ということでマスクカテゴリに出品されている出品者がAmazonのマスクを表示するには、以下のURLでOKでした。
https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5

作成

0. 準備

必要に応じて以下のコマンドで必要なものをインストールしてください。

sudo apt install python3-pip
sudo pip3 install beautifulsoup4
sudo pip3 install lxml

私はMacでAnacondaを使用しているので記事内では省略していますが、Linux上でファイルを作成する場合などは以下のようにプログラムの先頭にpython3の場所を記載してください。

#!/usr/bin/python3

1. 必要なものをインポート

BeautifulSoupを使用します。

import requests
from bs4 import BeautifulSoup
import re
import urllib.parse

2. ページ全体を取得

target_url = 'https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5'
headers = {'User-Agent': ''}
response = requests.get(target_url, headers=headers)
soup = BeautifulSoup(response.text, 'lxml')

なお、headersを付けないとHTML内に以下のメッセージが記載されて、商品一覧が取得できませんでした。

To discuss automated access to Amazon data please contact api-services-support@amazon.com.
For information about migrating to our APIs refer to our Marketplace APIs at https://developer.amazonservices.jp/ref=rm_c_sv, or our Product Advertising API at https://affiliate.amazon.co.jp/gp/advertising/api/detail/main.html/ref=rm_c_ac for advertising use cases.

3. 商品名と商品URLの要素を確認

商品名と商品URLの2つを取得したいのでソースを確認したところ、class="a-size-mini a-spacing-none a-color-base s-line-clamp-4"で取得できることがわかりました。

※要素名の簡単な取得方法は以下に記載しています。
https://qiita.com/hanzawak/items/58553017e107fce2f34c#3-操作したい要素を確認する

4. 商品名と商品URLの要素を取得

find_allで先ほど得られた要素名の中身を取得します。
find_allを使うと全要素が取得できます。

product_info= soup.find_all(class_='a-size-mini a-spacing-none a-color-base s-line-clamp-4')

取得したproduct_infoの中身を確認すると以下のようになっています。

<h2 class="a-size-mini a-spacing-none a-color-base s-line-clamp-4">
 <a class="a-link-normal a-text-normal" href="/%E3%82%81%E3%81%90%E3%82%8A%E3%82%BA%E3%83%A0-%E3%80%90%E5%A4%A7%E5%AE%B9%E9%87%8F%E3%80%91%E3%82%81%E3%81%90%E3%82%8A%E3%82%BA%E3%83%A0-%E8%92%B8%E6%B0%97%E3%81%A7%E3%83%9B%E3%83%83%E3%83%88%E3%81%86%E3%82%8B%E3%81%8A%E3%81%84%E3%83%9E%E3%82%B9%E3%82%AF-%E7%84%A1%E9%A6%99%E6%96%99-10%E6%9E%9A%E5%85%A5/dp/B07ZTDR2Q1/ref=sr_1_1?dchild=1&amp;m=AN1VRQENFRJN5&amp;qid=1584167047&amp;refinements=p_6%3AAN1VRQENFRJN5&amp;s=hpc&amp;sr=1-1" target="_blank">
 <span class="a-size-base-plus a-color-base a-text-normal">【大容量】めぐりズム 蒸気でホットうるおいマスク 無香料 10枚入</span>
 </a>
 </h2>,
<h2 class="a-size-mini a-spacing-none a-color-base s-line-clamp-4">
 <a class="a-link-normal a-text-normal" href="/%E3%82%B9%E3%82%BA%E3%83%A9%E3%83%B3-%E3%83%AA%E3%83%AA%E3%83%BC%E3%83%99%E3%83%AB-%E3%81%BE%E3%82%8B%E3%81%94%E3%81%A8%E3%83%89%E3%83%A9%E3%82%A4%E3%83%8F%E3%83%BC%E3%83%96%E3%83%9E%E3%82%B9%E3%82%AF-%E3%83%AD%E3%83%BC%E3%82%BA%E3%83%9E%E3%83%AA%E3%83%BC-%E6%98%BC%E7%94%A8/dp/B0857HY5NC/ref=sr_1_2?dchild=1&amp;m=AN1VRQENFRJN5&amp;qid=1584167047&amp;refinements=p_6%3AAN1VRQENFRJN5&amp;s=pantry&amp;sr=1-2" target="_blank">
 <span class="a-size-base-plus a-color-base a-text-normal">リリーベル まるごとドライハーブマスク ローズマリー 昼用</span>
 </a>
 </h2>,
略

a-link-normal a-text-normalの後ろが商品URL、a-size-base-plus a-color-base a-text-normalの後ろが商品名となっているようです。
ただよく見ると商品URLの中身にも商品名が含まれていそうなのでデコードしてみたところ、以下のように商品名が含まれていました。
そのためa-link-normal a-text-normalだけを取得すれば商品URLと商品名が取得できるようです。

/めぐりズム-【大容量】めぐりズム-蒸気でホットうるおいマスク-無香料-10枚入/dp/B07ZTDR2Q1/ref=sr_1_1?dchild=1&m=AN1VRQENFRJN5&qid=1584167047&refinements=p_6:AN1VRQENFRJN5&s=hpc&sr=1-1

また、商品URLは/めぐりズム-【大容量】めぐりズム-蒸気でホットうるおいマスク-無香料-10枚入/dp/B07ZTDR2Q1/までで機能しますので、その後ろの余計な文字列は後の工程で削除しようと思います。

5. 商品URLを抽出

product_infoの中身から商品URLのみ抽出します。
product_infoはリスト型なのですが正規表現でサクッと抽出したいため、strに変換して抽出しています。

product_url = []
product_info = str(product_info)
for line in product_info.split('\n'):
    if '<a class="a-link-normal a-text-normal" href="'  in line:  # URLリンクの含まれている行であれば
        pattern = '<a class="a-link-normal a-text-normal" href="(.+)/ref=.*'  # URLリンクの必要な部分のみ抽出
        result = re.match(pattern, line)
        result_decode = urllib.parse.unquote(result.group(1))  # デコード
        product_url.append(result_decode)  # デコードした結果をproduct_urlに追加

product_urlの中身は以下のようになりました。

['/めぐりズム-【大容量】めぐりズム-蒸気でホットうるおいマスク-無香料-10枚入/dp/B07ZTDR2Q1',
 '/スズラン-リリーベル-まるごとドライハーブマスク-ローズマリー-昼用/dp/B0857HY5NC',
 '/プロフェッショナルマスク-シールド付-51417-25ﾏｲ-ｺﾞﾑﾋﾓﾌﾞﾙｰ-オオサキメディカル/dp/B0797JWNV4',
略

いっそのことリンクの形にしてしまおうと思いますので、https://www.amazon.co.jp/を先頭につけます。

product_url_amazon = ['https://www.amazon.co.jp' + i for i in product_url]

product_urlの中身は以下のようになりました。

['https://www.amazon.co.jp/めぐりズム-【大容量】めぐりズム-蒸気でホットうるおいマスク-無香料-10枚入/dp/B07ZTDR2Q1',
 'https://www.amazon.co.jp/スズラン-リリーベル-まるごとドライハーブマスク-ローズマリー-昼用/dp/B0857HY5NC',
 'https://www.amazon.co.jp/プロフェッショナルマスク-シールド付-51417-25ﾏｲ-ｺﾞﾑﾋﾓﾌﾞﾙｰ-オオサキメディカル/dp/B0797JWNV4',
略

ここまでで1ページ目のURLを取得することができました。

6. 2ページ目以降の商品URL取得方法の検討

まず商品ページ下の「次へ」ボタンのソースを確認します。

ソースは以下の通りです。
じーっと見てるとどうやらURLの末尾に&page=2という感じでページ指定ができるような気がします。

試しに以下のようにURLを組み立ててみると想定通り2ページ、3ページと表示できました。
ちなみに1ページ目も表示できました。

https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5&page=1
https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5&page=2
https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5&page=3

本来であれば「全何ページあるのでそのページ数分ループを繰り返す」方法が良いと思いますが、以下のようにページ数が3ページ以内のものと3ページより多いもので若干リンクの形式が異なるため、全何ページかは取得しないことにします。
代わりにURL末尾をpage=1 page=2 page=3.... と数字を増やしていき、商品がなくなったら終了という処理にします。

7. 全ページの商品URL取得

今まで作成した部分を結合して、全ての商品URLが取得できるように変更していきます。
全ページをループして確認しても良いのですがとりあえず9ページまでしか見ないようにしておきます。

import requests
from bs4 import BeautifulSoup
import re
import urllib.parse

product_url = []

for page_num in range(1,10):  # 1〜9ページを確認
    target_url = 'https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5&page=' + str(page_num)  # ページ番号を末尾に追加
    headers = {'User-Agent': ''}
    response = requests.get(target_url, headers=headers)
    soup = BeautifulSoup(response.text, 'lxml')

    product_info= soup.find_all(class_='a-size-mini a-spacing-none a-color-base s-line-clamp-4')
    if len(product_info) == 0:  # 商品が0個の場合（商品が存在しないページの場合）
        break

    product_info = str(product_info)
    for line in product_info.split('\n'):
        if '<a class="a-link-normal a-text-normal" href="'  in line:  # URLリンクの含まれている行であれば
            pattern = '<a class="a-link-normal a-text-normal" href="(.+)/ref=.*'  # URLリンクの必要な部分のみ抽出
            result = re.match(pattern, line)
            result_decode = urllib.parse.unquote(result.group(1))  # デコード
            product_url.append(result_decode)  # デコードした結果をproduct_urlに追加

product_url_amazon = ['https://www.amazon.co.jp' + i for i in product_url]

これで全商品のURLを抽出することができました。

8. 前回抽出時と今回抽出時を比較し、追加分を抽出

比較にはいろいろな方法がありますが、ここではテキストに書き込んだ内容で比較しようと思います。

まず取得した商品URLを改行区切りでファイルに書き込みます。

tmp = "\n".join(product_url_amazon)

with open('before_mask_url.txt', 'w') as f:
    f.write(tmp)

以下のように書き込まれます。

https://www.amazon.co.jp/COZEE-CRITTERS-コージークリッター-防寒マスク-フリーサイズ/dp/B000CED4F2
https://www.amazon.co.jp/EXECUTE-エクゼキュート-ストレッチエナメル口開きマスク/dp/B07KYG8FYR
https://www.amazon.co.jp/EXECUTE-エクゼキュート-ストレッチエナメル目口開きマスク/dp/B07KYW8XZY
略

改行区切りのファイルをリストで読み込むには以下のようにします。

with open('before_mask_url.txt', 'r') as f:
    before_mask_url = [tmp.strip() for tmp in f.readlines()]

リストを比較するには以下のようにします。

before = ['aaa', 'bbb', 'ccc']
after = ['aaa', 'bbb', 'ddd']
diff = set(after) - set(before)  
print(diff)  # {'ddd'}

上記を踏まえて、今回は以下の流れで比較しようと思います。

1. 1回目のプログラム実行で、商品URLを取得し、ファイルに書き込み
2. 2回目のプログラム実行で、商品URLを取得し、ファイルに書き込まれた内容と比較し、追加分を出力
3. 以降、2の繰り返し

9. 前回抽出時と今回抽出時を比較し、追加分を出力するプログラム

今までの内容を全て結合します。

import requests
from bs4 import BeautifulSoup
import re
import urllib.parse
import os

product_url = []
sava_filename = 'before_product_url_amazon.txt'  # 商品URL一覧を保存するファイル名を指定

for page_num in range(1,10):  # 1〜9ページを確認
    target_url = 'https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5&page=' + str(page_num)  # ページ番号を末尾に追加
    headers = {'User-Agent': ''}
    response = requests.get(target_url, headers=headers)
    soup = BeautifulSoup(response.text, 'lxml')

    product_info= soup.find_all(class_='a-size-mini a-spacing-none a-color-base s-line-clamp-4')
    if len(product_info) == 0:  # 商品が0個の場合（商品が存在しないページの場合）
        break

    product_info = str(product_info)
    for line in product_info.split('\n'):
        if '<a class="a-link-normal a-text-normal" href="'  in line:  # URLリンクの含まれている行であれば
            pattern = '<a class="a-link-normal a-text-normal" href="(.+)/ref=.*'  # URLリンクの必要な部分のみ抽出
            result = re.match(pattern, line)
            result_decode = urllib.parse.unquote(result.group(1))  # デコード
            product_url.append(result_decode)  # デコードした結果をproduct_urlに追加

product_url_amazon = ['https://www.amazon.co.jp' + i for i in product_url]

if os.path.exists(sava_filename):  # 商品URLを記録したファイルがあれば
    with open(sava_filename, 'r') as f:  # 商品URLを読み込み
        before_product_url_amazon = [tmp.strip() for tmp in f.readlines()]

    added_product_url_amazon = set(product_url_amazon) - set(before_product_url_amazon)  # 差分取得（Python実行時に取得した商品URL - 商品URLを記載したファイル）

tmp = "\n".join(product_url_amazon)  # Python実行時に取得した商品URLをファイルに保存
with open(sava_filename, 'w') as f:
    f.write(tmp)

if(added_product_url_amazon):
    print('\n'.join(added_product_url_amazon))

今までのプログラムを結合しただけなので可読性に欠けますが、上記のプログラムを実行すると、前回実行時から追加されたURLがあれば出力されます。

10. slackで通知

WebHookで通知するのが簡単なのでその方法を記載します。

WebHookの設定ページにアクセス

https://slack.com/services/new/incoming-webhook

通知先のchannelを選択

通知先のchannelを選択した後、Add Incoming WehHooks integrationをクリックします。

次の画面で表示されるWebhook URLをメモします。

slackに通知するプログラム

以下のプログラムを実行するとslackに通知されます。

import json
webhook_url = '<Webhook URL>'
requests.post(webhook_url, data = json.dumps({
    'text': str('\n'.join(added_product_url_amazon)),  # メッセージ内容
    'username': 'Amazon Mask',  # ユーザー名
}))

slackでは以下のように表示されます。

11. 前回実行時から追加されたURLがあればslack通知

以下を実行すると前回実行時から追加されたURLがあればslack通知されます。

import requests
from bs4 import BeautifulSoup
import re
import urllib.parse
import os
import json

product_url = []
sava_filename = 'before_product_url_amazon.txt'  # 商品URL一覧を保存するファイル名を指定
webhook_url = '<Webhook URL>'

for page_num in range(1,10):  # 1〜9ページを確認
    target_url = 'https://www.amazon.co.jp/s?rh=n:169922011,p_6:AN1VRQENFRJN5&page=' + str(page_num)  # ページ番号を末尾に追加
    headers = {'User-Agent': ''}
    response = requests.get(target_url, headers=headers)
    soup = BeautifulSoup(response.text, 'lxml')

    product_info= soup.find_all(class_='a-size-mini a-spacing-none a-color-base s-line-clamp-4')
    if len(product_info) == 0:  # 商品が0個の場合（商品が存在しないページの場合）
        break

    product_info = str(product_info)
    for line in product_info.split('\n'):
        if '<a class="a-link-normal a-text-normal" href="'  in line:  # URLリンクの含まれている行であれば
            pattern = '<a class="a-link-normal a-text-normal" href="(.+)/ref=.*'  # URLリンクの必要な部分のみ抽出
            result = re.match(pattern, line)
            result_decode = urllib.parse.unquote(result.group(1))  # デコード
            product_url.append(result_decode)  # デコードした結果をproduct_urlに追加

product_url_amazon = ['https://www.amazon.co.jp' + i for i in product_url]

if os.path.exists(sava_filename):  # 商品URLを記録したファイルがあれば
    with open(sava_filename, 'r') as f:  # 商品URLを読み込み
        before_product_url_amazon = [tmp.strip() for tmp in f.readlines()]

    added_product_url_amazon = set(product_url_amazon) - set(before_product_url_amazon)  # 差分取得（Python実行時に取得した商品URL - 商品URLを記載したファイル）

tmp = "\n".join(product_url_amazon)  # Python実行時に取得した商品URLをファイルに保存
with open(sava_filename, 'w') as f:
    f.write(tmp)

if(added_product_url_amazon):
    requests.post(webhook_url, data = json.dumps({
        'text': str('\n'.join(added_product_url_amazon)),  # メッセージ内容
        'username': 'Amazon Mask',  # ユーザー名
    }))

12. プログラムの定期実行

「11. 前回実行時から追加されたURLがあればslack通知」のプログラムをcronなどで定期的に実行します。
これで「出品者がAmazonのマスクが出品されたらslack通知するプログラム」が完成です。

その他

変数名、コメント、そもそもの書き方、が雑すぎました。。
後日綺麗に書き換えようと思います。

はじめに

伊坂幸太郎の小説「アイネクライネナハトムジーク」という作品をご存知でしょうか。
小説好きな人なら分かるかもしれませんね。
割と日常っぽい感じの短編集なのですが、
その作品には「斉藤さん」という人物が登場します。
百円を払って「今、こんな気持ちです」「こんな状況です」と話をすると、
斉藤さんがパソコンでその客の気分にマッチする曲の一部を流してくれます。
曲は斉藤さんだけあって斉藤和義の曲の一部が流れるようになっています。

そこで感情分析を使って同じようなことができるのではないかと考え、
今回作ってみることにしました。
アーティストは何でも良いですが、私自身がミスチルファンということで
桜井さんというキャラクターにして作りました。

今回はCOTOHA APIの感情分析を使います。
ちょうどキャンペーンもやってるみたいですし、参加も兼ねて。

どんなものを作ったか

説明するよりまずはものを作ったのかを見たほうが早いということで。

• 入力前

あなた：

• 入力

あなた：毎日が単調でつまらない。何かいいことないかな。

• 出力

あなた：毎日が単調でつまらない。何かいいことないかな。
桜井さん：東京―パリ間を行ったり来たりして 順風満帆の20代後半だね バブリーな世代交代の波押し退けて クライアントに媚び売ったりなんかして [デルモ]

なんとでもとれますが、
パリにしょっちゅう行くような仕事をし、順風満帆な人生が来ることがあるよと解釈できそうです。
これはミスチルの楽曲「デルモ」の歌詞の一部となります。

システム概要

大きく①データ構築と②フレーズ検索の処理の２つに分かれます。

①データ構築
歌ネットから歌詞をスクレイピングして、
フレーズに分割する。（歌詞全体のうちの１段落を１フレーズとする）
各フレーズを感情分析APIにかけて分析結果をDBに保存。

②フレーズ検索
客が状況を説明してその内容を感情分析APIにかけて分析結果を取得。
その後、スコアが近いフレーズをDBから検索する。
検索は、スコアの範囲検索を、範囲を広めながら実施し、
複数のフレーズが取得できた場合はランダムに１つ選択し、客に返信する。

実行結果

いくつか実行して面白かったのを載せます。

• 仕事でいいことあったよ

あなた：今日仕事でめっちゃ褒められて嬉しい！
桜井さん：イライラして過ごしてんなら愛を補充 君へと向かう恋の炎が燃ゆる 向かいの家の柴犬にも「ハイ ポンジュール!」 あぁ世界は薔薇色 ここは そう CENTER OF UNIVERSE 僕こそが中心です あぁ世界は素晴らしい [CENTER OF UNIVERSE]

前半だけ見ると、あれイライラしてる？ってなったけど、
後半めっちゃ陽気なことを歌ってます。
仕事うまくいってる俺は世界の覇者なり！的な。

• 受験勉強に失敗しちゃった

あなた：受験勉強失敗した。また来年頑張ろうかな。。。
桜井さん：思い切り息を吸い込んで この想いを空に放ちたい 自分の世界に閉じこもった 冴えない気分から抜け出して どんなときだってサンライズ この胸に輝かせていたいんだ [SUNRISE]

とりあえず息吸い込んで冴えない気分から抜け出せよ的な。ネガティブな感じでてるけど、結構励ます感じも出てますね。

• とある曲のタイトルをそのまま気持ちにして伝えてみた

あなた：もう恋なんてしないなんて言わないよ絶対
桜井さん：聞こえてくる 流れてくる 君を巡る 抑えようのない想いがここにあんだ 耳を塞いでも鳴り響いてる [365日]

好きでたまらない気持ちがマッチしてますね。

• 小説に出てくる日高さんと同じ心境を伝えてみた

あなた：実は付き合っている彼女と別れようと思ってるんだ
桜井さん：もう いいでしょう!? これで終わりにしよう ねぇ どうでしょう!? 君だってそう思うでしょ!? [I]

もう終わらせていいよと伝えてるのかもしれません。

コード

興味ある方はみてみてください。
とりあえず動くものを作ったのであまり整理されていないのはご承知の上で。。。

DBスキーマ

MYSQLを使っています。
今回は事前にMr.Childrenをアーティスト情報として登録します。

create database sakurai;

create table artist
  (artist_id smallint auto_increment not null primary key,
  artist_name varchar(100));

insert into artist (artist_name) values('Mr.Children');

create table title
  (title_id smallint auto_increment not null primary key,
  title varchar(100),
  artist_id smallint);

create table lyric
 (title_id smallint,
  phrase_id int auto_increment not null primary key,
  phrase varchar(1000),
  score float,
  sentiment tinyint);

Pythonコード

sakuraisan.py

# -*- coding: utf-8 -*-

import random, requests, json, sys, time
import urllib.request
import mysql.connector as mydb
import pandas as pd

from bs4 import BeautifulSoup

ARTIST_ID = 1 # DBに事前に登録するアーティストのID
AGENT_NAME = '桜井さん' # 答えてくるエージェントの名前

# COTOHA APIクラス
class CotohaApi():
    def __init__(self):
        self.COTOHA_ACCESS_INFO = {
            "grantType": "client_credentials",
            "clientId": "<ご自身のClient ID>",
            "clientSecret": "<ご自身のClient Secret>"
        }
        self.ACCESS_TOKEN_PUBLISH_URL = '<ご自身のAccess Token Publish URL>'
        self.BASE_URL = '<ご自身のAPI Base URL'

        self.ACCESS_TOKEN = self.get_access_token()

    # アクセストークンの取得
    def get_access_token(self):
        headers = {
            "Content-Type": "application/json;charset=UTF-8"
        }
        access_data = json.dumps(self.COTOHA_ACCESS_INFO).encode()
        request_data = urllib.request.Request(self.ACCESS_TOKEN_PUBLISH_URL, access_data, headers)
        token_body = urllib.request.urlopen(request_data)
        token_body = json.loads(token_body.read())
        self.access_token = token_body["access_token"]
        self.headers = {
            'Content-Type': 'application/json;charset=UTF-8',
            'Authorization': 'Bearer {}'.format(self.access_token)
        }

    # 感情分析APIを実施、分析結果を返却
    def sentiment_analysis(self, text):
        request_body = {
            'sentence': text
        }
        url = self.BASE_URL + 'nlp/v1/sentiment'
        text_data = json.dumps(request_body).encode()
        request_data = urllib.request.Request(url, text_data, headers=self.headers, method='POST')
        sentiment_result = urllib.request.urlopen(request_data)
        sentiment_result = json.loads(sentiment_result.read())
        return sentiment_result

    # Positive:1, Negative:-1, Neutral:0 に変換
    def convert_sentiment(self, sentiment_in_word):
        if sentiment_in_word == 'Positive':
            return 1
        elif sentiment_in_word == 'Neutral':
            return 0
        elif sentiment_in_word == 'Negative':
            return -1

# DB操作クラス
class DBHandler():
    def __init__(self):
        self.conn = mydb.connect(
            host = '<DBのホスト名>',
            port = '<DBのポート番号>',
            user = '<DBのユーザ名>',
            password = '<DBのパスワード>',
            database = '<DB名>',
            charset='utf8'
        )

        self.conn.ping(reconnect=True)
        self.cur = self.conn.cursor()

# データ構築クラス
class Learn():
    def __init__(self):
        self.FILE_NAME = 'list.csv'
        self.ARTIST_NUMBER = '684' # 歌ネットのアーティストNo.（Mr.Childrenは684）
        self.MAX_PAGE = 2 # 歌ネットのアーティストの曲数一覧のページ数（Mr.Childrenは２ページ存在）

    # 歌詞を歌ネットから収集
    def gather_lyric(self):
        #スクレイピングしたデータを入れる表を作成
        list_df = pd.DataFrame(columns=['曲名', '歌詞'])

        for page in range(1, self.MAX_PAGE + 1):
            #曲ページ先頭アドレス
            base_url = 'https://www.uta-net.com'

            #歌詞一覧ページ
            url = 'https://www.uta-net.com/artist/' + self.ARTIST_NUMBER + '/0/' + str(page) + '/'
            response = requests.get(url)
            soup = BeautifulSoup(response.text, 'lxml')
            links = soup.find_all('td', class_='side td1')

            for link in links:
                a = base_url + (link.a.get('href'))

                #歌詞詳細ページ
                response = requests.get(a)
                soup = BeautifulSoup(response.text, 'lxml')
                title = soup.find('h2').text
                print(title)
                song_lyrics = soup.find('div', itemprop='text')

                for lyric in song_lyrics.find_all("br"):
                    lyric.replace_with('\n')
                song_lyric = song_lyrics.text

                #サーバーに負荷を与えないため1秒待機
                time.sleep(1)

                #取得した歌詞を表に追加
                tmp_se = pd.DataFrame([title, song_lyric], index=list_df.columns).T
                list_df = list_df.append(tmp_se)

        #csv保存
        list_df.to_csv(self.FILE_NAME, mode = 'a', encoding='utf8')

    # 歌詞をフレーズに分割し、DBに感情分析結果も含めたデータを登録
    def add_lyric(self):
        db = DBHandler()
        df_file = pd.read_csv(self.FILE_NAME, encoding='utf8')
        song_titles = df_file['曲名'].tolist()
        song_lyrics = df_file['歌詞'].tolist()

        # 注意：曲数が多いとCOTOHAの1日に実行できるAPIの上限にひっかかかる（1日100曲程度が目安）
        for i in range(len(song_titles)):

            # タイトルの追加
            title = song_titles[i]

            print("Info: Saving {}...".format(title), end="")
            db.cur.execute(
                """
                insert into title (title, artist_id)
                values (%s, %s);
                """,
                (title, ARTIST_ID)
            )
            db.conn.commit()
            db.cur.execute(
                """
                select title_id from title
                where title= %s
                and artist_id = %s;
                """,
                (title, ARTIST_ID)
            )
            title_id = db.cur.fetchall()[-1][0]

            # 歌詞のフレーズの感情分析結果を登録
            # 二回改行が出現した場合をフレーズ区切りにする
            lyric = song_lyrics[i]
            lyric_phrases = lyric.split('\n\n')
            lyric_phrases = [lyric.replace('\u3000', ' ').replace('\n', ' ') for lyric in lyric_phrases]

            # フレーズごとに感情分析APIを利用し、感情分析結果をDBに登録
            cotoha_api= CotohaApi()
            for phrase in lyric_phrases:
                sentiment_result = cotoha_api.sentiment_analysis(phrase)['result']
                sentiment = cotoha_api.convert_sentiment(sentiment_result['sentiment'])
                score = sentiment_result['score']

                db.cur.execute(
                    """
                    insert into lyric (title_id, score, sentiment, phrase)
                    values (%s, %s, %s, %s);
                    """,
                    (title_id, score, sentiment, phrase)
                )
                db.conn.commit()

            print("Done")

        db.conn.close()
        if db.conn.is_connected() == False:
            print("Info: DB Disonnected")

    def execute(self):
        print("Info: 歌詞を収集中...")
        self.gather_lyric()
        print("Info: 歌詞をDBに追加中...")
        self.add_lyric()

# フレーズ検索クラス
class Search():
    def __init__(self):
        self.SEARCH_SCOPE = [0.01, 0.1, 0.3] # 検索するスコアの幅 SCORE±SEARCH_SCOPEの範囲でリストの順に検索

    def execute(self):
        print("あなた：", end="")
        input_data = input()
        print("{}：".format(AGENT_NAME), end="")

        cotoha_api= CotohaApi()
        sentiment_result = cotoha_api.sentiment_analysis(input_data)['result']
        sentiment = cotoha_api.convert_sentiment(sentiment_result['sentiment'])
        score = sentiment_result['score']

        db = DBHandler()

        find_flag = 0
        # 検索範囲を徐々に広げながらスコアの近いフレーズを検索
        for scope in self.SEARCH_SCOPE:

            # 最低1件あることを確認
            db.cur.execute(
                """
                select count(phrase_id) from lyric
                join title on lyric.title_id = title.title_id
                where sentiment = %s
                and score between %s and %s
                and artist_id = %s;
                """,
                (sentiment, score-scope, score+scope, ARTIST_ID)
            )
            hit_num = db.cur.fetchall()[-1][0]
            if hit_num > 0:
                find_flag = 1
                break

        # 検索結果が１件でも存在すれば、検索結果を取得し、客に返信
        if find_flag == 1:
            db.cur.execute(
                """
                select phrase,title from lyric
                join title on lyric.title_id = title.title_id
                where sentiment = %s
                and score between %s and %s
                and artist_id = %s;
                """,
                (sentiment, score-scope, score+scope, ARTIST_ID)
            )
            search_result = db.cur.fetchall()
            phrase_chosen = random.choice(search_result)
            print("{} [{}]".format(phrase_chosen[0], phrase_chosen[1]))
        else:
            print("いい歌詞が見つからなかった。")

        db.conn.close()


if __name__ == "__main__":
    args = sys.argv
    if len(args) == 2:
        process = args[1] # コマンドライン引数　learn: DBに歌詞情報を登録、search: DBから似た感情のフレーズを抽出
        if process == 'search':
            searcher = Search()
            searcher.execute()
        elif process == 'learn':
            learner = Learn()
            learner.execute()
        else:
            print("Error: コマンドライン引数を1つ指定 [learn/search]")
    else:
        print("Error: コマンドライン引数を1つ指定 [learn/search]")

実行方法は２通りあります。

• データ構築時

python sakuraisan.py learn

• フレーズ検索時

python sakuraisan.py search

おわりに

今回は感情分析結果のスコアが近い歌詞のフレーズをとってくるというシンプルなアルゴリズムで実装しましたが、
COTOHA APIには単語の感情を取ることもできます。
例えば公式の例にあるように、
「謳歌」という単語には「喜ぶ」「安心」といった感情を付与してくれます。
このあたりの情報もうまく検索に埋め込めたらもっと良い結果が返ってくるのではないかなと思ってます。

また、LINE Botとかにしたら面白いのかなと思ったりしてます。

参考

以下の記事を参考にさせていただきました！

• 自然言語処理を簡単に扱えると噂のCOTOHA APIをPythonで使ってみた
• 【Python】嵐の歌詞をWordCloudで可視化して、結成20年でファンに伝えたかったことを紐解いてみた
• Python + mysql-connector-python の使い方まとめ

エラー

Quickstart: Compose and Djangoを見ながらdockerでDjangoの開発環境を構築しようとして、docker-compose upしたときに以下のエラーが出た。

django.db.utils.OperationalError: could not translate host name "db" to address: Name or service not known

setting.py

setting.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'postgres',
        'USER': 'postgres',
        'PASSWORD': 'postgres',
        'HOST': 'db',
        'PORT': 5432,
    }
}

修正前のdokcer-compose.yml

Docker-compose.yml

version: '3'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/code
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: postgres

修正後のdocker-compose.yml

docker-compose.yml

version: '3'

services:
    web:
        build: .
        command: python3 manage.py runserver 0.0.0.0:8000
        volumes:
            - .:/code
        ports:
            - "8000:8000"
        depends_on:
            - db
    db:
        image: postgres
        ports: 
            - "5432"
        environment:
          - POSTGRES_DB=postgres
          - POSTGRES_USER=postgres
          - POSTGRES_PASSWORD=postgres

これで、エラーが解消しました。
Docker内でpostgresを使用するには、データベースユーザー、パスワード、db-nameなどの情報を構成する必要があります。これは、修正後のdokcer-compose.ymlにあるenvironmentにおいてコンテナの環境変数を設定することにより行うことができる。

For文

for seireki in range(1989, 2017):
    print("西暦" + str(seireki) + "年", end="")
    heisei = seireki - 1988
    print("平成" + str(heisei) + "年です。")

<出力>
西暦1989年平成1年です。
西暦1990年平成2年です。
西暦1991年平成3年です。
西暦1992年平成4年です。
....

While文

import random
hp = 20
while hp > 0:
    hit = random.randint(1, 10)
    print("スライムに" + str(hit) + "のダメージを与えた!")
    hp -= hit
    print("残りのHPは" + str(hp) + "です！")
print("スライムを倒しました")

<出力値>
スライムに1のダメージを与えた!
残りのHPは19です！
スライムに9のダメージを与えた!
残りのHPは10です！
スライムに5のダメージを与えた!
残りのHPは5です！
スライムに3のダメージを与えた!
残りのHPは2です！
スライムに2のダメージを与えた!
残りのHPは0です！
スライムを倒しました

はじめに

サンプル

result

「オバケ」は「お前」で韻踏める[類似度:0.24651645]

本題

ツールを作るにあたり利用させていただいた外部API

• COTOHA API
• Qiita API

ソースコード

• https://github.com/kE-sakai/rhyming-app-v1

作ったもの

• ① 韻を踏める単語検索ツール
  • 使用したAPI
    • COTOHA 類似度判定API
• ② 検索用単語プール生成ツール
  • 使用したAPI
    • COTOHA 構文解析API
    • Qiita 投稿記事取得API

① 韻を踏める単語検索ツール

役割

• 指定した単語と韻を踏める単語をCSVファイルから抽出するツール
• オプションとしてCOTOHA APIを使い単語間の類似度判定

図

仕組み

• 指定した単語とCSVファイルにある単語を pykakashiを使用してローマ字に変換

converter

    def convert_hiragana_to_roma(self, target_word_hiragana):
        # 促音の場合
        # 「つ」と「っ」が同じ「tsu」に変換されるため特殊文字として「x」とする
        if target_word_hiragana == "っ":
            return "x"
        else:
            kakasi_lib = kakasi()
            # 平仮名をローマ字に
            kakasi_lib.setMode('H', 'a')
            conv = kakasi_lib.getConverter()

            target_word_roma = conv.do(target_word_hiragana)
            return target_word_roma

• ローマ字から母音のパターンを抽出し、同じパターンであるかを比較

条件	元の単語	変換前	変換後
母音のみ	オバケ	obake	oae
促音が含まれている	いっぱい	ippai	ixai
「ん」が含まれている	秋刀魚	sanma	ana
「ー」が含まれている	サンダー	sanda-	anaa

converter

    # 読み仮名を音韻のパターンに変換
    def convert_roma_to_phoneme_pattern(self, target_char_roma_list):
        pre_phoneme = None
        hit_list = []
        for target_char_roma in target_char_roma_list:
            # 母音のケース
            # 「あ、い、う、え、お」のどれか
            vowel_char = self.__find_vowel_char(
                target_char_roma
            )
            specific_char = self.__find_specific_char(
                pre_phoneme,
                target_char_roma
            )

            if vowel_char:
                hit_list.append(vowel_char)
                pre_phoneme = vowel_char
            elif specific_char:
                # 母音ではないが、対象とするケース
                # 「っ」
                # 「ん」
                # 「ー」
                hit_list.append(specific_char)
                pre_phoneme = specific_char
            else:
                continue

        phoneme_pattern = "".join(hit_list)
        return phoneme_pattern

    def __find_vowel_char(self, char_roma):
        # 母音の場合
        vowel_list = ["a", "i", "u", "e", "o"]
        for vowel in vowel_list:
            if char_roma.find(vowel) > -1:
                return vowel
            else:
                continue
        # 母音でない場合
        return None

    def __find_specific_char(self, pre_phoneme, char_roma):
        # 「ん」の場合
        # 「っ」の場合:
        if char_roma == "n" or char_roma == "x":
            return char_roma
        # 「ー」の場合
        # 前回の母音と同じとみなす
        # 例) だー　-> a
        elif pre_phoneme != None and char_roma == "-":
            return pre_phoneme
        else:
            return None

実行例

execute

$cd src
$python main.py オバケ

result

「オバケ」は「答」で韻を踏める
「オバケ」は「お前」で韻を踏める

類似度判定

• 韻が踏める単語の組み合わせを抽出後、指定した単語を base_word にCSVから抽出した単語を pool_word に設定して解析をかける

cotoha_client.py

    def check_score(self, base_word, pool_word, access_token):
        headers = {
            "Content-Type": COTOHA_CONTENT_TYPE,
            "charset": COTOHA_CHAR_SET,
            "Authorization": "Bearer {}".format(access_token)
        }
        data = {
            "s1": base_word,
            "s2": pool_word,
            "type": "default"
        }
        req = urllib.request.Request(
            f"{COTOHA_BASE_URL}/{COTOHA_SIMILARITY_API_NAME}",
            json.dumps(data).encode(),
            headers
        )
        time.sleep(COTOHA_REQUEST_SLEEP_TIME)
        with urllib.request.urlopen(req) as res:
            body = res.read()
            return json.loads(body.decode())["result"]["score"]

実行例

execute

$cd src
$python main.py オバケ

result

「オバケ」は「答」で韻踏める[類似度:0.063530244]
「オバケ」は「お前」で韻踏める[類似度:0.24651645]

課題

元となるCSVファイルが固定

• 元々開発中はmecabに付属している名詞リストを単語プールとして使わせて頂いていました。
• ただ語彙の数や種類を増やす仕組みを作ることができたら、より面白そうだと思い単語プールを生成するツールを作るに至りました。

② 単語プール生成ツール

役割

• ① 韻を踏める単語検索ツールで使用する単語検索用のCSVを生成するツール

図式

仕組み

• Qiitaの投稿記事取得APIで得た投稿記事のタイトルを取得

qiita_client.py

    def list_articles(self):
        req = urllib.request.Request(
            f"{QIITA_BASE_URL}/{QIITA_API_NAME}?page={QIITA_PAGE_NUMBERS}&per_page={QIITA_ITEMS_PAR_PAGE}"
        )
        with urllib.request.urlopen(req) as res:
            body = res.read()
            return json.loads(body.decode())

• 取得したタイトルをCOTOHAの構文解析APIにかけて品詞に分類

cotoha_client.py

    # target_sentence にQiitaの記事タイトルを入れる
    def parse(self, target_sentence, access_token):
        headers = {
            "Content-Type": COTOHA_CONTENT_TYPE,
            "charset": COTOHA_CHAR_SET,
            "Authorization": "Bearer {}".format(access_token)
        }
        data = {
            "sentence": target_sentence,
        }
        req = urllib.request.Request(
            f"{COTOHA_BASE_URL}/{COTOHA_PARSE_API_NAME}",
            json.dumps(data).encode(),
            headers
        )
        time.sleep(COTOHA_REQUEST_SLEEP_TIME)
        with urllib.request.urlopen(req) as res:
            body = res.read()
            return json.loads(body.decode())["result"]

• 品詞から名詞のみを抽出しCSVファイルに出力

finder.py

    # 構文解析の結果から名詞のみを抽出し、そのリストを返す
    def find_noun(self, target_sentence_element):
        noun_list = []
        for element_num in range(len(target_sentence_element)):
            tokens = target_sentence_element[element_num]["tokens"]

            for tokens_num in range(len(tokens)):
                target_form = tokens[tokens_num]["form"]
                target_kana = tokens[tokens_num]["kana"]
                target_pos = tokens[tokens_num]["pos"]

                # 名詞であればリストに格納する
                if target_pos == TARGET_CLASS:
                    # 英語や数字、記号の単語は読み仮名を代わりに格納する
                    # TODO:判定に改善の余地あり。
                    if re.match(FINDER_REGEX, target_form):
                        noun_list.append(target_kana)
                    else:
                        noun_list.append(target_form)

        return noun_list

実行例

execute

$cd tool
$python word_pool_generator.py

word_pool.csv

バックアップ
ツール
エービーシー
ストリング
ビジュアル
スタジオ
コード
ノート
管理
拡張
まとめ
論文
解説

課題

• 正直重いです。投稿記事40本でも5分ほど処理にかかってしまいます。

  • 1つの記事タイトルで抽出できる名詞数はおよそ2〜5個です。
  • ただCSVファイルへの出力にあたり pandas を初めてさわっていることもあり、もっとロジックの改善はできると思ってます。
  • まだとりあえず動くものを作ったというレベルです。

• 英単語の判定の改善

  • 今のロジックでは「Raspberry Pi」は「ラズベリーパイ」ではなく「アールエーエスピービーイーアールアールワイピーアイ」になります。
  • 例えば「Raspberry」だけを構文解析APIに渡して「ラズベリー」と判定できるのであれば単語の受け渡し方を工夫すればもう少しいい感じにできそうです。
  • ちなみに「Google」は「グーグル」でした。

• 単語のバリエーションを増やせるようにする

  • 他のサイトなどでスクレイピングすると他の分野の単語も集めることができそうです。

終わりに

• 誤字脱字や内容に不備や不適切な部分が、ありましたら遠慮なくコメント・ご指摘ください。
• 万が一、何か問題がありましたら記事の削除、リポジトリの破棄を致します。

参考にさせていただいた記事

• https://note.com/junkawashima/n/n146874f827bc
• https://qiita.com/komorin0521/items/8cd1eb0cdb4a9ede217e

その他

作った動機について

• そもそも何でこんなものを作ったかというと、半年ほど前にこの記事を見て、友人と「自然言語処理を使って韻を踏める単語を探せないか」という会話をしたのがきっかけでした。
• ただ私は、当時(今も)自然言語処理についての分野は全然分かっておらず、たまたま今回の企画を見て、何か近いものが作れるのではないかと思いたち、このツールを作成することにしました。

記事の内容

友達の友達の友達と友達・・と辿っていく誰に辿り着くのか？
意外な所でこの人とこの人が繋がってるんだ！みたいなことありますよね。

この記事ではTwitterの相互フォローしている人同士を可視化してみました。

やったこと

やったことは大きく分けると２つです。
- フォローしているユーザーの情報を取得する
- 可視化する

フォローしているユーザー情報を取得する

get_follower_info.py

import json
import config
from requests_oauthlib import OAuth1Session
from time import sleep
from mongo_dao import MongoDAO
import datetime

# APIキー設定(別ファイルのconfig.pyで定義しています)
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATS = config.ACCESS_TOKEN_SECRET

# 認証処理
twitter = OAuth1Session(CK, CS, AT, ATS)  

mongo = MongoDAO("db", "followers_info")

get_friends_url = "https://api.twitter.com/1.1/friends/list.json" # フォローしているアカウントを取得
get_user_info_url = "https://api.twitter.com/1.1/users/show.json" # ユーザー情報を取得する
count = 200
targets = ['yurinaNECOPLA']
registed_list = []
depth = 2 # 潜る深さ
max_friends_count = 1000 # フォローアカウントがめちゃくちゃ多い人が居るので一定数を超えてると除外する

# フォローアカウントが一定数を超えていないか判定する
def judge_friends_count(screen_name):
    params = {'screen_name': screen_name}
    while True:
        res = twitter.get(get_user_info_url, params=params)
        result_json = json.loads(res.text)
        if res.status_code == 200:
            # フォローしている人数は「friends_count」、フォローされている人数は「followers_count」
            if result_json['friends_count'] > max_friends_count:
                return False
            else:
                return True
        elif res.status_code == 429:
            # 15分間で15回しかリクエストを送信出来ないので上限に達していたら待つ
            now = datetime.datetime.now()
            print(now.strftime("%Y/%m/%d %H:%M:%S") + ' 接続上限のため待機')
            sleep(15 * 60) # 15分待機
        else:
            return False

# 指定したscreen_nameのフォロワーを取得する
def get_followers_info(screen_name):
    followers_info = []
    params = {'count': count,'screen_name': screen_name}
    while True:
        res = twitter.get(get_friends_url, params=params)
        result_json = json.loads(res.text)

        if res.status_code == 200 and len(result_json['users']) != 0:
                for user in result_json['users']:
                    # APIから取得した情報のうち、必要な情報だけをdict形式で設定　（このPGでidは使ってない・・）
                    followers_info.append({'screen_name': user['screen_name'], 'id': user['id']})
                # パラメーターに次の取得位置を設定する
                params['cursor'] = result_json['next_cursor']
        # APIの接続上限を超えた場合の処理           
        elif res.status_code == 429:
            now = datetime.datetime.now()
            print(now.strftime("%Y/%m/%d %H:%M:%S") + ' 接続上限のため待機')
            sleep(15 * 60) # 1分待機
        else:
            break
    return followers_info

# dictのlistからscreen_nameのみのlistを取得する
def followers_list(followers_info):
    followers_list = []
    for follower in followers_info:
        followers_list.append(follower['screen_name'])
    return followers_list

# 再帰処理
def dive_search(target_list, d):
    for name in target_list:
        if name in registed_list or not judge_friends_count(name):
            continue
        print(name)
        followers_info = get_followers_info(name)
        mongo.insert_one({'screen_name': name, 'followers_info': followers_info})
        registed_list.append(name)
        if depth > d:
            dive_search(followers_list(followers_info), d + 1)
        else:
            return

dive_search(targets, 0)

このプログラムでは起点となるアカウントを決めておきます。
（//ネコプラ//というアイドルグループの碧島ゆりなさんのアカウントを起点としています）

その後、以下の流れで再帰的に処理していきます。
① フォローしているユーザーの情報を取得する
② ①の情報をmongoDBに登録する
③ ①で取得したユーザー情報を1件ずつ取得し、①から実行する

depthの値を変えるとどれだけ再帰的に潜っていくのかを変更出来ます。

2だと友達の友達までを取得するイメージです。
本当はもっとデータを取得したかったのですが、フォロー関係の情報を取得するAPIが15分間で15リクエストしか送れません。
起点としているアカウントは現時点で100アカウントをフォローしていますが、このアカウントから始めても処理が完了するのに３時間ほどかかりました。
しかも、途中で「既存の接続はリモート ホストに強制的に切断されました。」というエラーが発生して処理が落ちてしまいました。

この時点でフォローしているユーザー100アカウントのうち、60ほどしか完了していません。
うまく動いたとしても、６時間ほどは掛かっていたと思います。

mongoDBへのデータ登録などは以下のコードを使っています。

MongoDao

可視化する

前項で記載した通り、データは全て集まったとは言えない状況ですが、とりあえず集まったデータで可視化してみます。

可視化に使用するライブラリはNetworkXというものを使いました。
インストールは以下のコマンドで出来ます。

pip install networkx

create_network.py

import json
import networkx as nx
import matplotlib.pyplot as plt
from requests_oauthlib import OAuth1Session
from mongo_dao import MongoDAO

mongo = MongoDAO("db", "followers_info")
start_screen_name = 'yurinaNECOPLA'

#新規グラフを作成
G = nx.Graph()
 #ノードを追加
G.add_node(start_screen_name)

depth = 3
processed_list = []

def get_followers_list(screen_name):
    result = mongo.find(filter={"screen_name": screen_name})
    followers_list = []
    try:
        doc = result.next()
        if doc != None:
            for user in doc['followers_info']:
                followers_list.append(user['screen_name'])
        return followers_list
    except StopIteration:
        return followers_list

def dive(screen_name, d):
    if depth > 0:
        if screen_name in processed_list:
            return
        followers_list = get_followers_list(screen_name)
        for follower in followers_list:
            f = get_followers_list(follower)
            if start_screen_name in f:
                G.add_edge(screen_name, follower)
                processed_list.append(screen_name)
                dive(follower, d + 1)
    else:
        return

dive(start_screen_name, 0)

#図の作成。figsizeは図の大きさ
plt.figure(figsize=(10, 8))

#図のレイアウトを決める。kの値が小さい程図が密集する
pos = nx.spring_layout(G, k=0.8)

#ノードとエッジの描画
# _color: 色の指定
# alpha: 透明度の指定
nx.draw_networkx_edges(G, pos, edge_color='y')
nx.draw_networkx_nodes(G, pos, node_color='r', alpha=0.5)

#ノード名を付加
nx.draw_networkx_labels(G, pos, font_size=10)

#X軸Y軸を表示しない設定
plt.axis('off')

plt.savefig("mutual_follow.png")
#図を描画
plt.show()

フォロワーの取得手順とロジックは似ています。
再帰的にフォロワーを取得していき、相互フォローしているアカウントが見つかったらエッジを追加しています。

結果

こんな感じになりました。

ライブラリの詳しい仕組みまでは理解出来ていないのですが、繋がりが多いアカウント同士が密集していますね。
この密集しているあたりのアカウントは同じ事務所所属のアイドルなので納得の結果になりました。

感想

なかなか面白い結果になりました。
Twitter APIのリクエスト発行上限が15／分となっているため、あまりデータ量を増やせませんでした。
時間を見つけてデータをもっと収集出来れば、友達の友達の友達の・・・という繋がりが見えてくるかもしれません。