前回の続き．

numbaでクラスの高速化．
ただし，クラスの継承はできない模様．また，単純にNumbaに対応させようとしても，意外とコードの手直しが必要がなことは難点であるが，一応投稿．

ひとまず，書き方は以下の通り．

spec = [
        ("メンバ変数1", メンバ変数1の型),
        ("メンバ変数2", メンバ変数2の型),
        ....
        ("メンバ変数n", メンバ変数nの型)
    ]

@jitclass(spec)
class ...():
...

from numba import jit, f8, b1, i8, void
from numba import jitclass
import numpy as np
import random

spec = [
        ("width", i8),
        ("array", f8[:,:])
    ]

@jitclass(spec)
class test():
  def __init__(self, w):
    self.width = w
    array = np.array([random.random() for i in range(self.width)])

  def start(self):
    cnt = 0    
    for a in self.array:
      cnt += a

    print(cnt)

if __name__ == "__main__":
  cls = test(10000000)
  cls.start()

前回の記事

[Python]とにかくわかりやすく！Djangoでアプリ開発！ーその７ー

本記事の目的

python初心者の方が、本記事を見たあとに、一人でアプリ開発できることを目的にしております。
※インストールや開発環境については記載しません

環境

macOSX　Sierra
python3.7
django 2.1.5

前回まで

だいぶ長くなってきたので、どのようなことをやってきたか詳細を割愛しますが、たくさんのことをしてきました。
フロントの話やDBの話はまだまだありますが、最低限の機能がついたものとして、公開をしてみたいと思います。
※今回herokuを使いますので事前にherokuのアカウント発行まではしておいてください。

絶対に必要なものをインストール

ここら辺はpipで用意します。

$ pip install dj-database-url gunicorn whitenoise

requirements.txtの用意

requirements.txtを用意して、書き込みを行います。

$ pip freeze > requirements.txt

中身はこんな感じです。

requirements.txt

dj-database-url==0.5.0
Django==2.1.5
django-contrib-comments==1.8.0
gunicorn==19.9.0
psycopg2==2.7.5
whitenoise==4.0

そのほか必要なファイルの用意

Procfileとruntime.txtとlocal_setting.pyを用意しておきます。

web: gunicorn myapp.wsgi

runtime.txt

python-3.6.6

local_setting.py

import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))


DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

DEBUG = True

最終的なtreeはこんな感じ

myapp
├── Procfile #ここ
├── db.sqlite3
├── app1
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── forms.py
│   ├── migrations
│   │   ├── 000x_auto_20190308_2248.py
│   │   └── __init__.py
│   ├── model.txt
│   ├── models.py
│   ├── static
│   │   └── kenko
│   │       └── css
│   │           └── style.css
│   ├── templates
│   │   └── kenko
│   │       ├── create.html
│   │       ├── delete.html
│   │       ├── edit.html
│   │       ├── find.html
│   │       └── index.html
│   ├── tests.py
│   ├── urls.py
│   └── views.py
├── manage.py
├── myapp
│   ├── __init__.py
│   ├── local_settings.py #ここ
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── requirements.txt #ここ
└── runtime.txt #ここ

settings.pyの修正

settings.pyの最後に以下を追加

settings.py

import dj_database_url
DATABASES['default'] = dj_database_url.config()

SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO','https')

ALLOWED_HOSTS = ['*']

STATIC_ROOT = 'staticfiles'

DEBUG = True

try:
    from .local_settings import *
except ImportError:
    pass

STATIC_DIRS = (
    os.path.join(BASE_DIR, "static"),
)

herokuに送る

一応

$ git init

ログインしてアプリを作ります。

$ heroku login
$ heroku create アプリ名

remoteで接続します。

$ git remote add heroku https://git.heroku.com/アプリ名.git

あとはこんな感じで

$ git add -A
$ git commit -m "commit"
$ git push heroku master

https://<< herokuに登録したアプリ名>>.herokuapp.com
にアクセスしたらアプリは自分のPC以外からも見れるようになっています。

補足

デプロイ後にcssが読み込まれなかったので
最後のwhitenoiseを追加したら解決。当然修正のたびにherokuにpushが必要です。

settings.py

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',
]

参照

macでheroku deploy

最後に

約１ヶ月程度をかけてその８まで投稿しました。再度勉強し直したところもありました。
誤字脱字の修正はこれから行います。
本当はバリデーションのこととかDBのこととかまだまだまだまだ内容はありますが、一旦ここで終わりにして、また余裕ができたときに追加をしていきます。
ここまで全部みられたかたがどこまでいらっしゃるかわかりませんが、ありがとうございます。

WindowsでPythonを使い始める

パソコンを新規購入してPythonの環境構築を一からやり直しました．

せっかくなので備忘録として行ったことをまとめておきます．

特にこだわりが無ければ，Anacondaを使いPythonの環境を管理することをお勧めします．

Anacondaをインストールすれば，基本的に環境構築は終了です．

あとはAnaconda promptを使って必要なライブラリを適宜ダウンロード or アップデートするだけです．

以下Anacondaダウンロード先のリンクです．(リンク：Anaconda)

リンクに飛ぶと，上にOSの選択があるのでWindowsを選択してください．

次に2系か3系のPythonの選択がありますが，特にこだわりが無ければ3系を使うことをお勧めします．
（2系と3系ではいくつか書き方を変えないとエラーになるものがあります（e.g. print関数，input関数））

エディタとしてSpyderとJupyterがAnaconda navigatorと一緒にインストールされていると思います．

エディタは好みがわかれると思いますが，Visual Studio Codeは試してみる価値はあると思います．

インストール時に選択するポップアップが現れると思いますので，使ってみたければVisual Studio Codeも一緒にインストールしてみてください．

コーディング作業やデバッグ作業は他のエディターよりもはかどる気がします．

OpenCVを使えるようにする

いろいろな方法が記事で取り上げられていますが，ここでは最も簡単な方法を記しておきます．

anaconda promptを開き，以下のコマンドを入力してやるだけです．

conda install -c conda-forge opencv

site-packageのフォルダを確認すればopencvがインストールされていることが確認できると思います．

ffmpegを使えるようにする

動画処理をする際にffmpegを使用することがあると思います．(リンク：FFmpeg)

Pythonからffmpegを使用できるようにするためには，環境変数のシステム環境変数のPathに

「ffmpeg.exe」が存在するフォルダーのパスを追加する必要があります．

コントロールパネル　=>　システム　=>　システム詳細設定から

環境変数を確認するウィンドウを開くことができるので，そこでPathを追加すれば使えるようになります．

Canteraを使えるようにする

燃焼を科学するにあたって，化学反応を解析することがあると思います．

反応速度解析ツールとしてChemkinやCanteraがよく知られていますが，

CanteraはオープンソフトでPythonで実装することができます．(リンク：Cantera python tutorial)

以下のコマンドをAnaconda promptで入力してCanteraライブラリをダウンロードしてみましょう．

conda install -c cantera cantera

ChemkinのようにGUI化されていないため，使いなれるまでに時間を要しますが無料です．

断熱火炎温度，層流燃焼速度などは簡単に求めることができます．

概要

本記事はfast.aiのwikiのTextページの要約となります。

筆者の理解した範囲内で記載します。

Text モデル、データ、トレーニング

fast.aiライブラリのText モジュールは、DatasetをNLP (Natural Language Processing)目的へ最適化するための関数を多数備えています。具体的には：

• text.transform にてデータの前処理実施し、テキストをidへと変換する
• text.data にて TextDataBunch を用いてNLPに必要なDatasetのクラスを規定する
• text.learner にて素早くlanguage model や RNN classifierを作成できる

上のリンクを辿って各モジュールのAPIを参考にしてみて下さい。

早速やってみる： ULMFiTIでimdbの感情modelを鍛える

早速fast.ai textモジュールを使ってみましょう。以下の例では名の知れたimdbデータを用いて、感情分類モデルを4ステップで鍛えていきます。

1) Imdbデータを読み込み俯瞰する
2) データをモデルに最適化する
3) language modelをfine-tuneする
4) 分類モデルを作成する

1) Imdbデータを読み込み俯瞰する

text に必要なパッケージを読み込みましょう。

from fastai.text import *

画像認識とは異なり、テキストは直接モデルに読み込むことができません。従って、最初にデータを前処理してテキストをトークンへと変換して(tokenization)それを数字へと変換する(numericalization)必要があります。これらの数字 embedding layer へと引き渡されることで浮動小数点の配列へと変換されます。

これらトークンを浮動小数点へと変換するWord Embeddingsはweb上で掲載されています。これらのWord Embeddingsはwikipediaなどの膨大なサイズのcorpusで鍛えられたものです。ULMFiTの手法を用いて、fast.aiライブラリはpre-trained Language Modelsを用いて、fine-tuneすることに焦点を絞っています。Word embeddingsとは、具体的に300から400の小数点を異なる単語を表すために鍛えられたもので、pre-trained language model はこれらの特性を備えているだけではなく、文や文章を表現する性質も備わっております。

注記： ライブラリは以下の3ステップで構成されています。

1. データを最小限のコードで前処理を済ませる
2. pre-trained された language model をベースに、データセットを用いてfine-tuneする
3. 分類器などのモデルをlanguage modelの上に載せる。

1000レビューに抽出されたIMDBデータセットを用いる（陽性または陰性）

path = untar_data(URLs.IMDB_SAMPLE)
path

PosixPath('/home/ubuntu/.fastai/data/imdb_sample')

データセットをテキストから作成するには以下の方法がベストです

• ImageNet スタイルにフォルダへ整理されている
• csv ファイルへラベルの欄とテキスト欄へ整理されている

こちらの例ではimdbをtexts.csvファイルから読み込んで以下のようになっております。

df = pd.read_csv(path/'texts.csv')
df.head()

label	text	is_valid
0	negative	Un-bleeping-believable! Meg Ryan doesn't even ...
1	positive	This is a extremely well-made film. The acting...
2	negative	Every once in a long while a movie will come a...
3	positive	Name just says it all. I watched this movie wi...
4	negative	This movie succeeds at being one of the most u...

2) データをモデルに最適化する

DataBunchを準備するためには、複数のfactory methodsがデータの構成に応じて存在します。詳細はtext.data。こちらではfrom_csvメソッドを用いてTextLMDataBunch(Language Modelのためのデータ処理)とTextClasDataBunch(Text Classifierのためのデータ処理)クラスを用います。

# Language model データ処理
data_lm = TextLMDataBunch.from_csv(path, 'texts.csv')
# Classifier model データ処理
data_clas = TextClasDataBunch.from_csv(path, 'texts.csv', vocab=data_lm.train_ds.vocab, bs=32)

これで必要なデータの前処理がなされます。分類器には、vocabulary(wordからidを引き渡す役目)を引き渡すことによって、data_clasがdata_lmと同じdictionaryを用いる点は注意して下さい。

この処理は時間がかかるため、結果を保存するために以下のコードを実行しましょう。

data_lm.save('data_lm_export.pkl')
data_clas.save('data_clas_export.pkl')

これで全ての結果を保存するためのtmpdirectoryが作成されます。ロードするためには以下のコードを実行しましょう。

data_lm = load_data(path, fname='data_lm_export.pkl')
data_clas = load_data(path, fname='data_clas_export.pkl', bs=16)

注記：DataBunchのパラメータを設定できます。(batch size, bptt,...)

3) language modelをfine-tuneする

data_lmを用いてlanguage modelをfine-tuneしましょう。fast.ai は、AWD-LSTM architectureの英語モデルを用意してるので、それとpretrained weightsをダウンロードし、fine-tuneするためのlearnerオブジェクトを作成しましょう

learn = language_model_learner(data_lm, AWD_LSTM, drop_mult=0.5)
learn.fit_one_cycle(1, 1e-2)

Total time:00:13

epoch	train_loss	valid_loss	accuracy
1	4.514897	3.974741	0.282455

画像認識モデルと同様に、モデルをunfreezeすることでさらにfine-tuneすることができます。

learn.unfreeze()
learn.fit_one_cycle(1, 1e-3)

Total time: 00:17

epoch	train_loss	valid_loss	accuracy
1	4.159299	3.886238	0.289092

モデルを評価するために、以下のLearner.predictを実行することで、単語とその数を指定し予測させることができます。

learn.predict("This is a review about", n_words=10)

'This is a review about dog - twist credited , and that , along with'

あまり意味は通じませんが（小さいvocabularyのため）ここでは基本的な文法をmodelが習得していることは驚愕すべきことです。（pretrained modelが可能にしたもの)

最後にencoderを保存して分類モデルに用いるようにできるようにしましょう。

learn.save_encoder('ft_enc')

4) 分類モデルを作成する

ここでは、先述して作成したdata_clasオブジェクトを用いて、分類器をencoderを用いて新たに作成します。learnerオブジェクト自体はたった一行のコードで作成できます。

learn = text_classifier_learner(data_clas, AWD_LSTM, drop_mult=0.5)
learn.load_encoder('ft_enc')

data_clas.show_batch()

text	target
xxbos xxmaj raising xxmaj victor xxmaj vargas : a xxmaj review \n \n xxmaj you know , xxmaj raising xxmaj victor xxmaj vargas is like sticking your hands into a big , xxunk bowl of xxunk . xxmaj it 's warm and gooey , but you 're not sure if it feels right . xxmaj try as i might , no matter how warm and gooey xxmaj raising xxmaj	negative
xxbos xxmaj now that xxmaj che(2008 ) has finished its relatively short xxmaj australian cinema run ( extremely limited xxunk screen in xxmaj xxunk , after xxunk ) , i can xxunk join both xxunk of " xxmaj at xxmaj the xxmaj movies " in taking xxmaj steven xxmaj soderbergh to task . \n \n xxmaj it 's usually satisfying to watch a film director change his style /	negative
xxbos i really wanted to love this show . i truly , honestly did . \n \n xxmaj for the first time , gay viewers get their own version of the " xxmaj the xxmaj xxunk " . xxmaj with the help of his obligatory " hag " xxmaj xxunk , xxmaj james , a good looking , well - to - do thirty - something has the chance	negative
xxbos xxmaj to review this movie , i without any doubt would have to quote that memorable scene in xxmaj tarantino 's " xxmaj pulp xxmaj fiction " ( xxunk ) when xxmaj jules and xxmaj vincent are talking about xxmaj mia xxmaj wallace and what she does for a living . xxmaj jules tells xxmaj vincent that the " xxmaj only thing she did worthwhile was pilot " .	negative
xxbos xxmaj how viewers react to this new " adaption " of xxmaj shirley xxmaj jackson 's book , which was promoted as xxup not being a remake of the original 1963 movie ( true enough ) , will be based , i suspect , on the following : those who were big fans of either the book or original movie are not going to think much of this one	negative

learn.fit_one_cycle(1, 1e-2)

Total time: 00:33

epoch	train_loss	valid_loss	accuracy
1	0.650518	0.599687	0.691542

再度modelをunfreezeしてfine-tuneしましょう。

learn.freeze_to(-2)
learn.fit_one_cycle(1, slice(5e-3/2., 5e-3))

Total time: 00:38

epoch	train_loss	valid_loss	accuracy
1	0.628320	0.563579	0.716418

learn.unfreeze()
learn.fit_one_cycle(1, slice(2e-3/100, 2e-3))

Total time: 00:56

epoch	train_loss	valid_loss	accuracy
1	0.533411	0.539693	0.721393

そして、Learner.predictを用いてテキストを予測してみましょう。

learn.predict("This was a great movie!")

(Category positive, tensor(1), tensor([0.0118, 0.9882]))

目的

WebRTCを使って、Web上からPCやスマホのカメラから映像取得して、それをWebサーバに送信。サーバ側で画像処理して、ユーザ側には画像を返すなり何かしらパラメータ返すなりする。
例えばスマホで撮った映像から物体検出等をリアルタイムですることができる。

開発環境

• OS
  • Ubuntu16.04.5(AWSのEC2使用)
• 言語
  • Python3.5.2
    • Flask
    • OpenCV
  • HTML5
  • JavaScript
    • WebRTC
    • JQuery

WebRTCを使用する際はSSL通信化しておく必要があります。flaskのSSL通信化については私が以前書いたものを参考にしてください。
【Ubuntu16.04.5】PythonのFlaskをHTTPS化

処理の流れ

WebRTCによるカメラ映像取得

いつのバージョンからか、WebRTCを使用する際はasyncを使用しなければならないようです。
調べても大体async使ってないソースばっかりで、エラーに悩まされてました。公式のサンプルソースコードをしっかり読みましょう[1]。

映像取得だけなら以下の部分だけで十分です（多分）。（#myvideoはvideoタグ、#startはボタンタグ）
ただし停止ボタンが無いので延々とブラウザにカメラ映像が表示されます。停止するならリロードなり何なりしてください。

$(function(){
    const constraints = window.constraints = {
      audio: false,
      video: {
        facingMode: "environment"
      }
    };

    async function init() {
      try {
        const stream = await navigator.mediaDevices.getUserMedia(constraints);
        const video = document.querySelector('#myvideo');
        const videoTracks = stream.getVideoTracks();
        window.stream = stream; 
        video.srcObject = stream;
        e.target.disabled = true;
      } catch{
        $('#errorMsg').text('カメラの使用を許可してください');
      }
    }

    $('#start').click(init);
});

facingModeでは、デフォルトで使用されるカメラを指定しています。"environment"でフロントカメラ、"user"でインカメラを指します。未指定なら後者になります。

映像を処理用URLに送信

ぶっちゃけ参考文献[2]丸パクリです（リンク先はWebRTCからtensorflowの物体検出してる）。
流れとしては

1. canvasタグに一旦描画する
2. canvasタグから画像バイナリデータ取得する
3. データをAjaxで処理先に送信する

となります。以下のように実装しました。

    var canvas = $('#videocanvas')[0];

    $('#myvideo').on('loadedmetadata', function(){
        // canvasのサイズ合わせ
        var video = $('#myvideo')[0];
        var width = canvas.width = video.videoWidth;
        var height = canvas.height = video.videoHeight;

        // 描画先の指定
        var ctx = canvas.getContext("2d");

        // 送信データの作成
        var fd = new FormData();
        fd.append('video', null);

        //毎フレーム処理
        setInterval(function(){
            ctx.drawImage(video, 0, 0, width, height);
            canvas.toBlob(function(blob){

                fd.set('video', blob);

                $.ajax({
                    url: "/img",
                    type : "POST",
                    processData: false,
                    contentType: false,
                    data : fd,
                    dataType: "text",
                })
                .done(function(data){
                    console.log(data);
                })
                .fail(function(data){
                    console.log(data);
                });
            }, 'image/jpeg');
        },1000);
    });

.on('loadedmetadata'はvideoタグの読み込みが終わった時に実行する処理ということです。つまりはカメラに正常にアクセスできた場合ということですね。
そこからsetIntervalを使って定期的に送信していきます。

処理部

@api.route("/img", methods=["POST"])
def img():
    img = request.files["video"].read()

    # pillow から opencvに変換
    imgPIL = Image.open(io.BytesIO(img))
    imgCV = np.asarray(imgPIL)

    imgCV = cv2.bitwise_not(imgCV)

    # 好きな処理を入れる

    return "success"

まあぶっちゃけここはお好きにしてください。私はOpenCV使うので変換挟んでます。

処理後の画像を描画したい

Flaskにはもともとimgタグでストリーミングできる仕組みが存在します[3]。
なのでそれを使えば実現できます。

app.py(一部)

@api.route('/feed')
def feed():
    return Response(gen(), mimetype='multipart/x-mixed-replace; boundary=frame')

def gen():
    while True:
        with open('./templates/dst/test.jpg', 'rb') as f:
            img = f.read()

        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' + img + b'\r\n')

index.html(一部)

    <img id="preview" src="{{ url_for('feed') }}"><br>

こうして、あとは処理した画像をtest.jpgに保存すれば解決。

まとめ

（ぶっちゃけWebでやる必要ある？）
メリットとしては同じ精度や処理速度をスペックの異なるスマホ等で実現できる・・・ということくらいですかね。ただAWSのデフォルトサーバ程度では大した利点は無いです。
特徴点マッチング使った処理で、大体5アクセスの時点でCPU100%になってレスポンス遅くなりましたね。よっぽどのつよつよサーバじゃないとネイティブアプリで実現する方がいいかと思います。

ちなみにそもそもレスポンスは遅いです。大体1秒くらい。

参考文献

[1]getUserMedia(Sample Code)
[2]Computer Vision on the Web with WebRTC and TensorFlow - webrtcHacks
[3]FlaskとOpenCVを使ってWEBカメラで撮影した画像をストリーミングする - Qiita

ゴール

GCNを使ってSUUMOからお買い得物件TOP30を見つけちゃいます

背景

ReNomというサイトでこんなGCNを使った不動産関連のチュートリアルがあり、簡単にできそうだったので勉強がてらやってみました。全ソース公開します。

対象読者

python始めたばかりの方
東京都内の中古不動産購入予定者

方法

肝心なGCN部分はチュートリアルをまんまパクって、データはSUUMOの東京中古不動産情報から引っ張ってくるというやり方です。
大まかな流れは以下の通り。

1. スクレイピング
2. 前処理
3. 学習
4. 結果確認
5. appendix

環境

python3
jupyter lab

ライブラリ

ReNom,ReNomRG,BeautifulSoup等

ポイント

今回は、駅名・路線名のような情報を単純にワンホット化（数値データでないデータを0,1のみで表現する方法）するのではなく、
ターゲットエンコーディングという方法を使用しました。
ワンホットだと駅の数、路線の数に応じて変数の数が増えてしまうので、計算に時間かかります。
ワンホットで試しにやってみたところ、変数が多すぎて自分のMacbook air '11 メモリ4GB （貧弱...）では標準化できずにフリーズしました。
具体的には、suumoさんは駅毎の坪単価と路線毎の坪単価を持っているので、駅名と路線名をこの坪単価で置き換えます。

1. スクレイピング

東京都内のSUUMOに掲載されている中古不動産全件を取得します。

まずは上図のページ情報を取得します。

#必要なライブラリをインポート
from bs4 import BeautifulSoup
import requests
import pandas as pd
from pandas import Series, DataFrame
import time
import datetime
import numpy as np
import scipy.stats
from sklearn import preprocessing
from tqdm import tqdm

#東京都の中古マンション一覧
url = 'https://suumo.jp/jj/bukken/ichiran/JJ010FJ001/?ar=030&bs=011&ta=13&jspIdFlg=patternShikugun&kb=1&kt=9999999&mb=0&mt=9999999&ekTjCd=&ekTjNm=&tj=0&cnb=0&cn=9999999'

#データ取得
result = requests.get(url)
c = result.content

#HTMLを元に、オブジェクトを作る
soup = BeautifulSoup(c)

soupにこのページ（1ページ目の）情報が格納されました。

このページからid='js-bukkenList'（このページの不動産情報全件）を取得し、そこから各物件の価格を予想する際の説明変数名を取得します。

#物件リストの部分を切り出し
summary = soup.find("div", id='js-bukkenList') #1ページ分を取得
dt = summary.find("div",class_='ui-media').find_all('dt') #dtを全て取得
cols = [t.text for t in dt]
cols.insert(0, 'url') #後ほど物件情報詳細を確認するためurl列を追加

次にページ数を取得し、２ページ目以降のurlを生成していきます。

#ページ数を取得
body = soup.find("body")
page = body.find("div",class_='pagination pagination_set-nav')
li = page.find_all('li')
pg_length = int(li[-1].text)

#URLを入れるリスト
urls = []

#1ページ目を格納
urls.append(url)

#2ページ目から最後のページまでを格納
for i in range(pg_length)[:-1]:
    pg = str(i+2) #2ページ目から
    url_page = url + '&pn=' + pg #ページ数に合わせたurl
    urls.append(url_page)

全ページのurlを生成出来ました。
ここから全ページ
の物件情報（aタグとddタグ情報）を取得していきます。

#各ページで以下の動作をループ
bukkens =[]
for url in tqdm(urls):
    #物件リストを切り出し
    result = requests.get(url)
    c = result.content
    soup = BeautifulSoup(c)
    summary = soup.find("div",id='js-bukkenList')

    #マンション名、住所、立地（最寄駅/徒歩~分）、築年数、建物高さが入っているproperty_unitsを全て抜き出し
    property_units = summary.find_all("div",class_='property_unit-content')

    #各property_unitsに対し、以下の動作をループ
    for item in property_units:
        l = []
        #マンションへのリンク取得
        h2 = item.find("h2",class_='property_unit-title')
        href = h2.find("a").get('href')
        l.append(href)
        for youso in item.find_all('dd'):
            l.append(youso.text)
        bukkens.append(l)
    time.sleep(0.5)

東京都内の不動産情報全件をbukkensに格納しました。これを一旦csvに出力します。

#列名を設定し、csvに一旦export 
df = pd.DataFrame(bukkens,columns=cols)
df.to_csv('bukken.csv')

#csvのimportと中身の確認
df = pd.read_csv('bukken.csv')
df[0:5]

ここまででスクレイピングは完了です。取得したデータはこんな感じでDataFrameに格納されています。

2.前処理

各列のデータから余分な文字列を除去していきます。

#販売価格に「〜」が含まれている行を削除
df = df[~df['販売価格'].str.contains('～')]
#価格を値のみへ
# _df = df['販売価格'].str.extract('\n([億0-9]+)万円') #seriesじゃないとstr使えない
_df = df['販売価格'].str.extract('(.+)[億]+').astype(float).fillna(0)*10000
_df2 = df['販売価格'].str.extract('[\n|億]([0-9]+)万円').astype(float).fillna(0)
df['price'] = _df + _df2
#price列に欠損があれば、drop
df.dropna(subset=['price'],inplace=True)
df['price'] = df['price'].astype(int)
df = df[df['price'] != 0]

#市区最寄り駅を求める
df['市区'] = df['所在地'].str.extract('都(.+)[市|区]')
df[['line','station','distance']] = df['沿線・駅'].str.extract('(.+)「(.+)」(.+)')
#専有面積
df['m2'] = df['専有面積'].str.extract('([\d\.]+)m2').astype('float')
#間取り
df['room'] = df["間取り"].str.extract('(\d+).+').fillna(1).astype('int')
df['living'] = df["間取り"].str.count('L')
df['Dining'] = df["間取り"].str.count('D')
df['kitchen'] = df["間取り"].str.count('K')
df['others'] = df["間取り"].str.count('S')
#バルコニー
df['balcony'] = df['バルコニー'].str.extract('([\d\.]+)m2').fillna(0).astype('f4')
#築年数
year = datetime.date.today().year
df['age'] = year - df['築年月'].str.extract('(.+)年').astype('int')

#不要列削除
df2 = df.drop(['販売価格','所在地','沿線・駅','専有面積','間取り','バルコニー','築年月'],axis=1)

#バスと徒歩の時間を抽出
df2['bus'] = df2['distance'].str.extract('バス(\d+)分').astype(float)
df2['walk'] = df2['distance'].str.extract('歩(\d+)分').astype(float)
#それぞれ欠損を穴埋め
df2[['bus','walk']] = df2[['bus','walk']].fillna(0)
df2[0:5]

一旦df2に余分な文字が除去されたデータを格納しました。

ここであらかじめSUUMOから取得しておいた市区毎の平均坪単価、駅毎の平均坪単価を説明変数に加えます。これがターゲットエンコーディングです! 取得方法についてはappendixを見てください。

#区毎の坪単価の読み込み
lp = pd.read_csv('land_price.csv')
lp['市区'] = lp['itemName'].str.extract('(.+)[市|区|郡]')
lp = lp.drop(['Unnamed: 0', 'itemName'],axis=1)
lp.columns = ['ld_price','市区']

#駅毎の坪単価の読み込み
sp = pd.read_csv('station_price.csv')
sp['station'] = sp['itemName']
sp = sp.drop(['Unnamed: 0', 'itemName'],axis=1)
sp.columns = ['st_price','station']

#市区毎、駅毎の坪単価平均をマージ
df2 = pd.merge(df2, lp, on='市区')
df2 = pd.merge(df2, sp, on='station')
df2[0:5]

マージした結果がこちらです。

再右列にデータが追加されています。駅毎の平均坪単価が算出されていないケースについては市区毎の平均坪単価を代用します。

#駅の平均坪単価が算出されていない場合は市区平均坪単価を代用
df2.loc[df2['st_price'].isnull(), 'st_price'] = df2['ld_price']

ワンホット化（路線名のみ）、標準化を行います。

#不要列を削除し、ワンホット化
df3 = pd.get_dummies(df2.drop(['url','物件名','市区','station','distance'],axis=1))
df3.info()

#標準化
temp = df3.iloc[:,2:]
df4 = (temp - temp.mean()) / temp.std(ddof=0)
print(df4.isnull().any(axis=0).sum())
df4[-10:]

前処理が完了しました。
結果がこちらです。路線名がワンホットされており、その他についても標準化されています。

ようやく準備完了！

3.学習

学習用とテスト用にデータを分けます。
後から行番号を使いたいので、indicesをtrain_test_splitの引数に設定します。

#学習用(`~train`)とテスト用(`~test`)にデータ分割
from sklearn.model_selection import train_test_split
X = df4.values
y = df3['price'].values
indices = df3['Unnamed: 0'].values
X_train, X_test, y_train_org, y_test_org, i_train, i_test = train_test_split(X, y, indices, test_size=0.2)
y_train = np.log(y_train_org)#logにすることにより不動産価格の差異が小さくなり、精度が上がる
y_test = np.log(y_test_org)

ここからはGCNを使ったチュートリアルをそのまま使っています。

#ハイパーパラメータの設定（参考元チュートリアルのまま）
epoch = 100
batch_size = 16
num_neighbors = 5
channel = 10

#ReNomのGCNNを使用
import renom as rm
from renom.optimizer import Adam
from renom_rg.api.regression.gcnn import GraphCNN
from renom_rg.api.utility.feature_graph import get_corr_graph, get_kernel_graph, get_dbscan_graph
#インデックス行列の取得
index_matrix = get_corr_graph(X_train, num_neighbors)

#GCNNのレイヤーの定義
model = rm.Sequential([
    GraphCNN(feature_graph=index_matrix, channel=channel, neighbors=num_neighbors),
    rm.Relu(),
    rm.Flatten(),
    rm.Dense(1)
])

#最適化関数はAdam
optimizer = Adam()

#学習
train_loss_list = []
valid_loss_list = []

for e in range(epoch):
        N = X_train.shape[0]

        perm = np.random.permutation(N)
        loss = 0
        total_batch = N // batch_size

        for j in range(total_batch):
            index = perm[j * batch_size: (j + 1) * batch_size]
            train_batch_x = X_train[index].reshape(-1, 1, X_train.shape[1], 1)
            train_batch_y = y_train[index]

            # Loss function
            model.set_models(inference=False)
            with model.train():
                batch_loss = rm.mse(model(train_batch_x), train_batch_y.reshape(-1, 1))

            # Back propagation
            grad = batch_loss.grad()

            # Update
            grad.update(optimizer)
            loss += batch_loss.as_ndarray()

        train_loss = loss / (N // batch_size)
        train_loss_list.append(train_loss)

        # validation
        model.set_models(inference=True)
        N = X_test.shape[0]

        valid_predicted = model(X_test.reshape(-1, 1, X_test.shape[1], 1))
        valid_loss = float(rm.mse(valid_predicted, y_test.reshape(-1, 1)))
        valid_loss_list.append(valid_loss)

        if e % 5 == 0 and valid_loss < valid_loss_list[e - 1]:
            model.save("model1.h5")
            print('save at', e, 'epoch')

        if e % 10 == 0:
            print("epoch: {}, valid_loss: {}".format(e, valid_loss))

学習結果はこのようになりました。

4.結果確認

テスト(test)用のデータ（実際の不動産価格）とGCNNが予測した不動産価格(predict)を比較します。

#予測と実際の価格の比較
test = np.exp(y_test)
predict = np.exp(valid_predicted)
plt.figure(figsize=(8, 8))
plt.plot([0, 80000], [0, 80000], c='k', alpha=0.6, label = 'diagonal line') # diagonal line
plt.scatter(test, predict)
# plt.scatter(registered_true, registered_pred,label='registered')
plt.xlim(0, 80000)
plt.ylim(0, 80000)
plt.xlabel('actual estate price', fontsize=16)
plt.ylabel('predicted estate price', fontsize=16)
plt.legend()
plt.grid()

概ね予測した不動産価格と実際の不動産価格の差異が小さいことがわかります。

モデルは完成したので、全データに対して予測をしてみましょう！

#一度モデルのパラメータをリセット
for layer in model:
    setattr(layer, "params", {})    

#学習時に保存したweightを読み込み
model.load("model1.h5")

#全物件に対しGCNNで予測を行う。
log_predict = model(X.reshape(-1, 1, X.shape[1], 1))

GCNNの予測結果を確認しましょう。

#実際の価格と予測の比較
import matplotlib.pyplot as plt
predict = np.exp(log_predict)

plt.figure(figsize=(8, 8))
plt.plot([0, 80000], [0, 80000], c='k', alpha=0.6, label = 'diagonal line') # diagonal line
plt.scatter(y, predict)
plt.xlim(0, 80000)
plt.ylim(0, 80000)
plt.xlabel('actual estate price', fontsize=16)
plt.ylabel('predicted estate price', fontsize=16)
plt.legend()
plt.grid()

全データに対しての予測結果はこちらです。若干ばらつきが出てますね〜。。

ここからお待ちかねのお買い得物件リストアップです！

#実際の価格に対して予測がどれだけ乖離しているか（どれだけお得かどうか）の算出
df5 = pd.DataFrame([indices, predict, y]).T
df5.columns=['Unnamed: 0', 'pred', 'actual']
df5['Unnamed: 0'] = df5['Unnamed: 0'].astype(int)
df6 = pd.merge(df5, df2, on='Unnamed: 0')
df6['diff'] = df6['pred'] - df6['actual']
df6['proportion'] = df6['diff'] / df6['actual']

#予測が実際の価格から50%以上乖離している物件
df7 = df6[abs(df6['proportion']) > 0.5].sort_values('proportion', ascending=False)
#お買い得物件TOP10
df7[0:9]

上位はこれです!predが不動産価格の予測結果,actualが実際の価格を表しています。
１番お買い得な物件は実際の価格の約６倍との結果となっています。確かに125万円は安いのでは？

TOP30の結果をみてみましょう。
No.3戸越銀座とNo.4千歳船橋は上の図にも出てますが、35LDK,32LDKあることになってますね〜それは予測が４億になる。
こういう記載誤りにも気づけますね

個人的に気になったNo.29の新宿の物件レグノ・セレーノを見てみましょう

似た条件（新宿区、100平米以上、3K以上、駅徒歩7分以内）で検索してみました。
こちら

この広さ、築年数、駅徒歩分数でこの値段は安い気がしませんか？決して買えないですが、、、

5.まとめ

ReNomを使い、こんなに簡単にお得な物件を見つけることができました！
お金のある方はNo.29の新宿の物件レグノ・セレーノを買っちゃうのはありではないでしょうか。笑
一切責任は追えませんが、、

まだ階数や複数の最寄駅情報のようなそのほかの定量的情報は取れていないので、精度向上の余地はまだまだあります。内装の雰囲気、治安のような定性的情報も追加できれば、まさに不動産テックといえるレベルになりますね。

Appendix

市区毎の平均坪単価と駅毎の坪単価平均を取得します。

市区毎の坪単価平均

こちらもSUUMOから情報を取得します。

#必要なライブラリをインポート
from bs4 import BeautifulSoup
import requests
import pandas as pd
from pandas import Series, DataFrame

#東京都市区毎の坪単価情報掲載ページ
url = 'https://suumo.jp/tochi/soba/tokyo/area/'

#データ取得
result = requests.get(url)
c = result.content

#HTMLを元に、オブジェクトを作る
soup = BeautifulSoup(c)

#市区毎のデータ平均坪単価情報はid='js-graphData'から取得
#scriptタグ内にjson形式でデータが存在する
body = soup.find("script", id='js-graphData')

#取得したbodyに含まれる余分な'\r\n'を削除
body_text = body.text.replace('\r\n', '')

json形式のデータを読み込む

import json
body_json = json.loads(body_text)

#dataframeにつっこむ
landPrice = pd.DataFrame(body_json)
#itemNum（平均坪単価の値）がnullなところには0で補間
landPrice['itemNum'][landPrice['itemNum']=='']=0
#itemNumが0より大きい市区のみのデータを利用
landPrice = landPrice[landPrice['itemNum'].astype(int)>0]

#csvに出力
landPrice[['itemName','itemPrice']].to_csv('land_price.csv')

landPriceの中身はこんな感じ。

駅毎の坪単価平均

こちらもSUUMOから情報を取得します。

このページのJR山手線をクリックすると、

のページが開き、市区毎の平均坪単価を取得する際と同じような流れで駅毎の平均坪単価を取得可能。

#必要なライブラリをインポート
from bs4 import BeautifulSoup
import requests
import pandas as pd
from pandas import Series, DataFrame
import json
from tqdm import tqdm

#東京都の沿線一覧
url = 'https://suumo.jp/tochi/soba/tokyo/ensen/'

#データ取得
result = requests.get(url)
c = result.content

#HTMLを元に、オブジェクトを作る
soup = BeautifulSoup(c)

body = soup.find("tbody")
link = body.find_all("a")

各沿線へのurlのリストを作成する。

urls = []
for l in link:
    urls.append(l.get('href'))

市区毎の平均坪単価を取得した際のjsonデータを取得する処理を関数化する。

def get_json(url):

    #データ取得
    result = requests.get(url)
    c = result.content

    #HTMLを元に、オブジェクトを作る
    soup = BeautifulSoup(c)

    #ページ内容取得(json)
    body = soup.find("script", id='js-graphData')
    body_text = body.text.replace('\r\n', '')
    body_json = json.loads(body_text)
    stPrice = pd.DataFrame(body_json)
    return stPrice

各沿線へのページにアクセスし、上記に定義した関数を使い、jsonデータをconcatしていく

suumo = 'https://suumo.jp'
stPrices = pd.DataFrame()
for url in tqdm(urls):
    url = suumo + url
    stPrice = get_json(url)
    stPrices = pd.concat([stPrices,stPrice])

stPricesの中身はこちら

#重複削除
stPrices.drop_duplicates(subset='itemName', inplace=True)

実は東京都内以外の駅も含まれているので、東京のデータのみをcsvに出力

stPrices[(stPrices['itemPrice'].isnull())&(stPrices['itemListUrl'].str.contains('tokyo'))]
stPrices[['itemName','itemPrice']].to_csv('station_price.csv')

これで市区毎の平均坪単価と駅毎の平均坪単価を取得できました。

目的

Chainerをpipでインストールする。
Cupyも入れてGPU込で学習ができるか確認する。

Installation guidelineを参考にする。
https://docs.chainer.org/en/stable/install.html#install-chainer

環境

Ubuntu 16.04.
GPUはRTX2080.

インストール

Anacondaでchainer仮想環境を作っておく。
pythonは3.6を使用。

conda create -n chainer python=3.6
conda activate chainer

下準備でpipを最新にしておく。

pip install -U setuptools pip


そしてChainerをpipで入れる。

pip install chainer


そしてCupyをインストール。
事前にCUDA, CuDNNのインストールが必要なのは注意。

(For CUDA 8.0)
# pip install cupy-cuda80

(For CUDA 9.0)
# pip install cupy-cuda90

(For CUDA 9.1)
# pip install cupy-cuda91

(For CUDA 9.2)
# pip install cupy-cuda92

(For CUDA 10.0)
pip install cupy-cuda100

全て正常に入ったか確認する。
Chainerがインポートできるか、そしてCUDA使用フラグが出ているか確認する。

python
> import chainer as chainer
> chainer.backends.cuda.available
# True
> chainer.backends.cuda.cudnn_enabled
# True

上記のように返ってきていれば環境設定はオッケー。
なんて簡単なんだ！^o^

CIFAR10で学習を試す。

TBD

まとめ

pipで全てインストールできるのでCUDAが入っていれば簡単だった（5分位？）。
Chainerチームありがとうございます。。！
早速学習を試してみたい。

概要

なんだか思いがけず色々と苦労したので、Let’s Encryptで証明書を得るのに必要な手続き/知識を整理しておこうと思います。

Let’s Encryptの仕組み

以下の３サイトを参考にさせていただき理解いたしました。

【15秒でわかるLet's Encryptのしくみ～無料で複数ドメイン有効な証明書作成～】
　https://qiita.com/S-T/items/7ede1ccfae6fc7f08393
【Let's Encrypt 総合ポータル (非公式解説サイト)】
　https://free-ssl.jp/technology/
【ACMEプロトコルの仕組み】
　https://http2.try-and-test.net/letsencrypt.html

【まとめ】
[１]秘密鍵とCSRを用意、秘密鍵をローカルに保存
[２]Let’s EncryptのエージェントがLet'sEncryptのACMEサーバに接続しCSRを送付
[３]ACMEサーバは、認証情報をエージェントに返す
[４]エージェントは、認証情報からファイルを生成し、ローカルのhtdocs配下の特定ディレクトリにファイルを配置する
[５]準備が整ったところで、エージェントは、ACMEサーバに認証チャレンジを要求
[６]ACMEサーバは、指定のドメインに認証用のファイルが設置されているか、Webサーバ(HTTPD)に確認
[７]ACMEサーバが、期待した通りの認証用ファイルをダウンロードできれば、サーバ証明書を発行
[８]発行された証明書をエージェントに送付

上記、まとめの通り、Let’s Encryptという無償の証明書発行機関が用意したサーバに対して、エージェントソフトを利用（githubにある）し、自分の用意しているWebサーバとLet’s Encryptが用意している証明書発行用のサーバとが通信することで公的証明書が発行される仕組みということです。
秘密鍵とCSRについてはOpenSSLを利用して自分で用意しても大丈夫です。
なぜかというとLet’s Encryptは証明書の証明/発行がメインのお仕事ですので、証明される元を自分が用意しても構わないということです。
ちなみにLet’s Encryptが発行する証明書の有効期間は3ヶ月です、期間を過ぎた場合、コマンドで更新していく必要があります。

ここでさらに用語を整理すると以下になります。
　・エージェント　
　　certbot,certbot-autoコマンド（Let’s Encryptが用意したサーバと通信できるCLIツール）
　・認証用のファイル
　　デフォルトではhtdocs配下に保存されるが、certbot-autoのオプションで--webrootで出力するパスを指定すると${webroot-path}/.well-known/acme-challengeの形でLet’s Encryptの認証ファイル出力先を変更することができる

前提条件

[1]この記事ではApacheをSSL化する前提で記載します。
[2]Webサーバは存在していることを前提で記載します。
[3]以下のパッケージはダウンロード済みであることを前提で記載します。
　　(1)git
　　(2)certbot
　　(3)python2-certbot-apache

実施した環境

【マシン】
　AWS EC2 t2.micro
【OS】
　CentOS 7.6.1810 (Core)

通信要件

以下、全てインバウンドのみに適用することを前提とする。

HTTP 80 0.0.0.0/0(::/0)
HTTPS 443 0.0.0.0/0(::/0)
※mod_sslでhttps化している場合、mod_rewriteを利用して、httpでアクセスがきたら、httpsへリダイレクトする設定を追加しておく考慮が必要です。

やること

以下、どちらかのパターンで実装することが可能です。

[1]git経由で導入する
以下のコマンドでリポジトリをダウンロードできます

コマンド

git clone https://github.com/letsencrypt/letsencrypt.git

以下のコマンドで証明書の導入を行うことが可能です。

コマンド

cd ./letsencrypt/
./letsencrypt-auto certonly --webroot --webroot-path <認証用の一時ファイルを作成するパス> -d <Webサーバドメイン>

[2]certbotコマンドで導入する
以下のコマンドで証明書の導入を行うことが可能です。

コマンド

certbot certonly --standalone -d <Webサーバドメイン>

一見、certbotコマンドが１コマンドで導入できて便利そうな印象なのですが、gitのリポジトリで使えるコマンドのほうがオプションが充実していて、Webサーバ上の証明書まで一気通貫で更新できるものあるようです。
※certonlyのオプションを別のオプションに変更すれば良いようです。

両パターンに共通して言える注意点として、上記のコマンドを実行する際に以下の条件を満たしている必要があります。
そうでないとエラーが発生して、証明書を取得できない場合があります。
最低限、以下の条件を満たしておく必要があります。

【注意点】
　(1)コマンド実行前にポート80番と443番が使われていないことを確認する
　　　※httpd、nginx、rails、phoenixとかのwebサーバは停止しておいてください。
　(2)名前解決できるようDNSレコードを登録しておく
　　　→上記に記載した通り、Let’s EncryptサーバがWebサーバにアクセスしてくるため、
　　　 外部から名前解決できるようにAレコードを登録しておいてください。
　　　 IPv6のAAAAレコードはなくても証明書は取得できます。

上記、紹介したコマンドではWebサーバで指定している証明書の情報は更新されないため、Webサーバの設定にて証明書の指定を変更しておく必要があります。

102,103c102
< # SSLCertificateFile /etc/pki/tls/certs/localhost.crt
< SSLCertificateFile  /etc/letsencrypt/live/<Webサーバドメイン名>/cert.pem
---
> SSLCertificateFile /etc/pki/tls/certs/localhost.crt
110,111c109
< # SSLCertificateKeyFile /etc/pki/tls/private/localhost.key
< SSLCertificateKeyFile /etc/letsencrypt/live/<webサーバドメイン名>/privkey.pem
---
> SSLCertificateKeyFile /etc/pki/tls/private/localhost.key

IPv6用のAAAAレコードを登録しておくとLet’s EncryptサーバからIPv6でアクセスしてくるので、Webサーバ上ででもIPv6でのアクセス処理ができるように工夫しておく必要があります。

具体的にはhttpd.confファイルのListen設定などを変更しておく必要があります。

<参考：Apache HttpdのIPv6の設定と確認>
https://http2.try-and-test.net/ipv6httpd.html

はじめに

機械学習のための特徴量エンジニアリングで取り上げられているテクニックについて、Sparkでも同様の処理をまとめます。
そのため、下記のpandas版のコードは引用がメインになります。
あまり慣れてないものもあるので、間違いを見つけ方は是非ご指摘頂ければと思います。

後、ここでは各処理の効用については触れません。

本記事での表記について

各処理サンプルは、以下の規則で書いていきます。

以下サンプルで参照する変数

import numpy as np
import pandas as pd

feature  # PandasのSeries / SparkDataFrameの変数名
df  # PandasDataFrame / SparkDataFrame

数値型

離散化

固定長の離散化

pandasで固定長の離散化

np.floor_divide(feature, 10)

pysparkで固定長の離散化

from pyspark.sql.functions import col, floor

df.withColumn('discretized', floor(col('feature') / 10))

対数階級による離散化

pandasで対数階級による離散化

np.floor(np.log10(feature))

pysparkで対数階級による離散化

from pyspark.sql.functions import floor, log10

df.withColumn('discretized', floor(log10('feature')))

分位数による離散化

pandasで分位数による離散化

# 10分位数への変換
pd.qcut(feature, 10, labels=False)
# 10分位数の計算
feature.quantile(np.linspace(0, 1, num=10+1))

pysparkで分位数による離散化

from pyspark.ml.feature import QuantileDiscretizer

# 10分位数への変換
qds = QuantileDiscretizer(numBuckets=10, inputCol='feature', outputCol='quantile')
qds.fit(df).transform(df)

# 10分位数の計算
df.approxQuantile('feature', list(np.linspace(0, 1, num=10+1)), 0)

スケーリング

Min-Maxスケーリング

pandasでMin-Maxスケーリング

from sklearn.preprocessing import minmax_scale

minmax_scale(feature)

pysparkでMin-Maxスケーリング

from pyspark.sql import functions as F
from pyspark.sql.window import Window

(
    sdf
    .withColumn('min', F.min('feature').over(Window.orderBy()))
    .withColumn('max', F.max('feature').over(Window.orderBy()))
    .withColumn('scaled', (F.col('feature') - F.col('min'))/(F.col('max') - F.col('min')))
)

※SparkMLのMinMaxScalerは、Vector型に変換する必要があり、列単位での処理の正規化には取り扱いにくい

(参考)SparkMLのMinMaxScaler

from pyspark.ml.feature import MinMaxScaler
from pyspark.ml.feature import VectorAssembler

vector_assembler = VectorAssembler(
    inputCols=['feature'],
    outputCol='feature_vector',
)
vector_df = vector_assembler.transform(df)

minmax_scaler = MinMaxScaler(inputCol='feature_vector', outputCol='scaled_vector').fit(vector_df)
scaled_df = minmax_scaler.transform(vector_df)

zスコア変換

pandasでzスコア変換

from sklearn.preprocessing import StandardScaler

StandardScaler().fit_transform(feature)

pysparkでzスコア変換

from pyspark.sql.window import Window

(
    df
    .withColumn('mean', F.mean('feature').over(Window.orderBy()))
    .withColumn('std', F.stddev('feature').over(Window.orderBy()))
    .withColumn('scaled', (F.col('feature') - F.col('mean')) / F.col('std'))
)

※SparkMLのStandardScalerは、Vector型に変換する必要があり、列単位での処理の正規化には取り扱いにくい

L2正規化

pandasでL2正規化

from sklearn.preprocessing import normalize

normalize(feature, axis=0)

pysparkでL2正規化

from pyspark.sql import functions as F

df.withColumn('scaled', F.col('n_tokens_content') / F.sqrt(F.sum(F.pow(F.col('n_tokens_content'), 2)).over(Window.orderBy())))

※SparkMLのNormalizerは、列方向の正規化に対応しておらず、自力で計算する必要がある？

カテゴリ型

One-Hotエンコーディング

pandasでOne-Hotエンコーディング

one_hot_df = pd.get_dummies(df,
                            dummy_na=False,  # 欠損を含めるか
                            drop_first=False)  # Trueでダミーコーディング
one_hot_df.head()

pysparkでOne-Hotエンコーディング

from pyspark.ml.feature import OneHotEncoder, StringIndexer

stringIndexer = StringIndexer(inputCol="category", outputCol="categoryIndex")
model = stringIndexer.fit(df)
indexed = model.transform(df)

encoder = OneHotEncoder(inputCol="categoryIndex", outputCol="categoryVec")
encoded = encoder.transform(indexed)

pysparkでOne-Hotエンコーディング

from pyspark.sql.functions import when

def spark_onehot(df, feature):
  d = df
  for c in [c[feature] for c in df.select(feature).distinct().collect()]:
    d = d.withColumn('{}_{}'.format(feature, c), when(df[feature] == c, 1).otherwise(0))
  return d

spark_onehot(df, 'category')

特徴量ハッシング

pandasで特徴量ハッシング

from sklearn.feature_extraction import FeatureHasher

h = FeatureHasher(n_features=m, input_type='string')
hashed = h.transform(df['feature'])

pysparkで特徴量ハッシング

from pyspark.ml.feature import FeatureHasher

hasher = FeatureHasher(numFeatures=m,  # ハッシュテーブルのサイズ
                       inputCols=features,  # 特徴量名のリスト
                       outputCol="hashed")

featurized = hasher.transform(df)

その他

交互作用

pandasで交互作用特徴量の作成

from sklearn.preprocessing import PolynomialFeatures

# 数値のみのDFに対して、2次の交互作用特徴量を作成
# interaction_onlyはべき乗演算を含めないか
# include_biasは定数項の有無
df = PolynomialFeatures(degree=2, interaction_only=False, include_bias=False).fit_transform(df)

pysparkで交互作用特徴量の作成

from pyspark.ml.feature import PolynomialExpansion, VectorAssembler

vector_assembler = VectorAssembler(
    inputCols=features,  # 特徴量名のリスト
    outputCol='feature_vector',
)
vector_df = vector_assembler.transform(df)

polyExpansion = PolynomialExpansion(degree=2, inputCol="feature_vector", outputCol="polyFeatures")
polyDF = polyExpansion.transform(vector_df)

参考

• O'Reilly Japan - 機械学習のための特徴量エンジニアリング
• Extracting, transforming and selecting features - Spark 2.4.0 Documentation

各種インストール

• python
  • https://www.python.org/
• Migu 2M (font)
  • http://mix-mplus-ipa.osdn.jp/migu/
• Mery(Editor)
  • https://www.haijin-boys.com/wiki/%E3%83%A1%E3%82%A4%E3%83%B3%E3%83%9A%E3%83%BC%E3%82%B8

コマンドプロンプトのフォントを変える

• コンピューター\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Console\TrueTypeFont
• キー 932.1
• 値 *Migu 2M*

コマンドプロンプトで以下を実行

• python -m pip install virtualenv
• python -m pip install --upgrade pip
• pip install Flask
• pip install pysqlite3
• pip install sqlalchemy

テスト

• sqlalchemy ファイルから実行

import sqlalchemy
print(sqlalchemy.__version__)

参考

• android flask
  http://neilkarwasra.blogspot.com/2017/08/how-to-install-and-run-python-flask-web_15.html
• windows flask
  https://qiita.com/akiraabe/items/48045d00cc4ea28ca4e9

前回の記事

[Python]とにかくわかりやすく！Djangoでアプリ開発！ーその5ー

本記事の目的

python初心者の方が、本記事を見たあとに、一人でアプリ開発できることを目的にしております。
※インストールや開発環境については記載しません

環境

macOSX　Sierra
python3.7
django 2.1.5

前回まで
プロジェクトを立ち上げ(startproject)
→アプリの作成(startapp)
→view.pyを変更してレスポンスを書く
→urls.pyを修正する
→アプリの登録する
→index.html作る
→views.pyを直す
→htmlに変数入れる
→views.pyを直す
→複数ページ作るためにリンクつける
→views.pyを直す
→cssで装飾できるようにする
→htmlでフォームを作る
→views.pyを直す
→urls.pyを修正する
→やっぱりFormクラスでフォームを作る
→views.pyを直す
→index.html直す
→Viewクラスでview.pyをスッキリさせる
→Fieldをいじってみる
→models.pyでテーブルを定義してみる
→管理者を作成する、登録する

とここまででした。

ここからはDBとのアプリとの連携についてを記載していきます。

その前にモデル定義を変更

わかりやすくするためにモデルを修正したいと思います。
今までのTourokuクラスを修正します。

models.py

from django.db import models

class Touroku(models.Model):

    date = models.DateField()
    name = models.CharField(max_length=30)
    breakfast = models.BooleanField()
    lunch = models.BooleanField()
    dinner = models.BooleanField()
    eatout = models.BooleanField()
    drinking = models.BooleanField()
    workout = models.BooleanField()
    stretch = models.BooleanField()
    studying = models.BooleanField()
    awaketime = models.TimeField()
    asleeptime = models.TimeField()
    kenkobody = models.CharField(max_length=30)
    workcond = models.CharField(max_length=30)

    def __str__(self):
        return '<ID:'+str(self.id)+'>  名前:'+self.name

作り直しているのでお決まりのマイグレートを行います。

$ python manage.py makemaigrations
$ python manage.py migrate

問題ないと思いますが、admin.pyが以下になっていることを確認します。

admin.py

from django.contrib import admin
from .models import Touroku

admin.site.register(Touroku)

ログインしてテストデータ登録を登録しておきます。３つくらいあるといいかと。（別に幾つでもいいです）

レコードを表示できるようにする

Tourokusの全レコードを取得できるようにします。表示できるような処理にするのでviews.pyを修正します。
最初にmodelsからTourokuをインポートしておきます。今までのTemplateviewは一旦無くします。
index関数の中身は、とても簡単で、dataという変数の中にTouroku.objects.all()とすることでDBのデータ全てを代入します。
モデルクラスを使っているわけですが、objectsという属性が用意されており、さらにメソッドとしてall()を使うことで、全てのレコードをモデルのインスタンスにしてまとめて呼び出しています。

views.py

from django.shortcuts import render
from django.http import HttpResponse
from .models import Touroku

def index(request):
    data = Touroku.objects.all()#ここ
    params = {
        'title':'生活データ',
        'msg':'all records',
        'data':data,#ここ
    }
    return render(request,'kenko/index.html', params)

処理を変えたので、今度は表示そのものを修正します。

タグを用意して、その中に<tr>と<th>で表のカラムを用意します。
そのあとは{% for item in data %}...{% endfor %}というfor文で纏めて取り出したデータを一つずつ取り出し、itemの中の情報を一つずつ{{item.name}}のように取り出しを行います。
Booleanのものに関しては、それぞれ分岐した文言を埋め込んでいます。

index.html

{% load static %}
<!doctype html>
<html lang="ja">
    <head>
        <meta charset="utf-8">
        <title>{{title}}</title>
        <link rel="stylesheet" type="text/css"
        href="{% static 'kenko/css/style.css' %}"/>
    </head>
    <body>
        <h1>{{title}}</h1>
        <p>{{msg|safe}}</p>　　　<!--ここから-->
        <table>
            <tr>
                    <th>no</th>
                    <th>日付</th> 
                    <th>名前</th> 
                    <th>朝食</th> 
                    <th>昼食</th> 
                    <th>夕食</th> 
                    <th>外食</th> 
                    <th>飲酒</th> 
                    <th>運動</th> 
                    <th>ストレッチ</th> 
                    <th>勉強</th> 
                    <th>起床時間</th> 
                    <th>就寝時間</th> 
                    <th>健康</th> 
                    <th>仕事の調子</th> 
            </tr>
            {%for item in data %}
            <tr>
                    <td>{{item.id}}</td> 
                    <td>{{item.date}}</td> 
                    <td>{{item.name}}</td> 
                    <td>{% if item.bf == False %}No{% endif %} 
                        {% if item.bf == True %}Yes{% endif %}</td> 
                    <td>{% if item.lunch == False %}No{% endif %} 
                        {% if item.lunch == True %}Yes{% endif %}</td> 
                    <td>{% if item.dinner == False %}No{% endif %} 
                        {% if item.dinner == True %}Yes{% endif %}</td> 
                    <td>{% if item.eatout == False %}No{% endif %} 
                        {% if item.eatout == True %}Yes{% endif %}</td> 
                    <td>{% if item.drinking == False %}No{% endif %} 
                        {% if item.drinking == True %}Yes{% endif %}</td> 
                    <td>{% if item.workout == False %}No{% endif %} 
                        {% if item.workout == True %}Yes{% endif %}</td> 
                    <td>{% if item.stretch == False %}No{% endif %}
                        {% if item.stretch == True %}Yes{% endif %}</td> 
                    <td>{% if item.studying == False %}No{% endif %}
                        {% if item.studying == True %}Yes{% endif %}</td> 
                    <td>{{item.awaketime}}</td> 
                    <td>{{item.asleeptime}}</td> 
                    <td>{{item.kenkobody}}</td> 
                    <td>{{item.workcond}}</td> 

            </tr>
            {% endfor %}<!--ここまで-->
        </table>
    </body>
</html>

urls.pyは以下のように修正をします。viewを使わなくなったので元に戻した感じです。

urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index,name="index"),
]

cssは適当につけておきます。

table {
    margin:10px;
    font-size:14pt;
}

table tr th {
    background-color: rgb(43, 139, 204);
    color:black;
    padding:2px 10px;
    border-width:2px;
}

table tr td {
    background-color: rgb(43, 139, 204);
    color:black;
    padding:2px 10px;
    border-width:2px;
}

検索機能を実装

せっかくなので検索機能を実装します。
今回はIDでデータを検索できるようにします。
それようのフォームを設定する必要があるので、forms.pyを修正します。

forms.py

from django import forms

class IdKensaku(forms.Form):
    id = forms.IntegerField(label = "ID")

Formをhtmlに実装します。
POSTで投げるようにするにmethodで指定をします。
※以下bodyの開始からtableの冒頭までの部分

index.html

・
・
・
<body>
        <h1>{{title}}</h1>
        <p>{{msg|safe}}</p>
        <table>
            <form aciton = "{%url 'index' % }" method = "POST">
                {% csrf_token %}
                {{form.as_table}}
            <tr><td></td><td><input type = "submit" value = "検索"></td></tr>
            </form>
        </table>
        <hr>
        <table>
            <tr>
                    <th>id</th>
・
・
・

埋め込みができたので、表示できるような処理にするためviews.pyを修正。
formsからインポートしてます。
POSTデータからidを受け取り、numberに代入を行なって、objects.get()の引数に代入を行なっています。先ほどはobjects.all(）でしたが、getにすることで特定のものだけを抽出します。allと違うのは、getではモデルのインスタンスを一つだけ取り出しているので、params['data'] = [item]で代入をしています。

views.py

from django.shortcuts import render
from django.http import HttpResponse
from .models import Touroku
from .forms import IdKensaku

def index(request):

    params = {
        'title':'生活データ',
        'msg':'all records',
        'form':IdKensaku(),
        'data':[],
    }

    if (request.method =='POST'):
        number = request.POST['id']
        item = Touroku.objects.get(id = number)
        params['data'] = [item]
        params['form'] = IdKensaku(request.POST)
    else:
        params['data'] = Touroku.objects.all()
    return render(request, 'kenko/index.html', params)

ここまでやったら、
$ python manage.py runserverをしてhttp://127.0.0.1:8000/app1/
にアクセスしてみましょう。
やってみましょう。このような感じになっていたらOKです。※実際にはyes/noが付いてたらOKです。

メソッドチェーン

特段ここでの用途はないですが、
objects属性でメソッドチェーンを使えば表示するものを制限できます。先ほどのgetのように、valuesというものを使えば、特定の要素だけ取り出すこともできます。また詳細は割愛しますが、メソッドにはcountやfirstなどの便利なものも用意されています。

views.py

from django.shortcuts import render
from django.http import HttpResponse
from .models import Touroku
from .forms import KenkoForm

def index(request):

    params = {
        'title':'生活データ',
        'msg':'all records',
        'form':KenkoForm(),
        'data':[],
    }

    if (request.method =='POST'):
        nametxt = request.POST['name']
        item = Touroku.objects.get(name = nametxt)
        params['data'] = [item]
        params['form'] = KenkoForm(request.POST)
    else:
        params['data'] = Touroku.objects.values("id","name")#ここ
    return render(request, 'kenko/index.html', params)

この記事はここまで

続きはこちら→[Python]とにかくわかりやすく！Djangoでアプリ開発！ーその７ー

この記事、何?

前回記事を深めるつもり・・・だったんだけど、ほとんど深まらなかった。
再利用するかもしれないのでいったん挙げておこうかと。

前回記事

■Python機械学習手遊び(GridSearchCVミニマムコード)
https://qiita.com/siinai/items/1aae9462d5e0c9c57344

やりたかったこと

f(x, y, z) = ax + by + cz + k + rand()
f(x, y, z) = ax^2 + bx + cy + dz + k + rand()
f(x, y, z) = ax^2 + bx + cy^2 + dy + ez + k + rand()

とかいくつか作って、いくつかの予測アルゴリズムを用意して、それぞれにパラメータを与えて試そうかと思った。
こんな感じ。

for X, y in dataset:
    for models, parameter in list:
        ....

ただ、データをまとめようとする時点で迷走してしまって、どれもこれも似たような結果ばかりで・・・

やっぱ駄目ですね。
あまりちゃんとはわかっていないことをわかったつもりで、その「確認」のコーディングをすると。
とりあえずできたところまで上げてコードサンプルにしておこうかと。
全く初めてだと、numpyの列の選択とかも惑う感じなので。。。

#31-01.py
from sklearn.cross_decomposition import PLSRegression
from sklearn.svm import SVR
from sklearn.model_selection import GridSearchCV
import numpy as np

def get_filepath():
    return '26-11.txt'

def load_data(file):
    tmp = np.loadtxt(file, delimiter='\t', skiprows=1)
    X = tmp[:,1:]
    Y = tmp[:,0:1]
    return X, Y

resultlist = []

def get_model_params(model_flg):
    if modelflg == 0:
        modelname = 'PLS'
        model = PLSRegression()
        params = [{'n_components':(1, 2, 3)}]
        raven_flg = False
    else:
        modelname = 'SVR'
        model = SVR()
        params = [{'kernel':('linear', 'rbf')}]
        raven_flg = True
    return modelname, model, params, raven_flg

for modelflg in range(2):
    file = get_filepath()
    X, Y = load_data(file)
    modelname, model, params, raven_flg = get_model_params(modelflg)
    if raven_flg:
        Y = np.ravel(Y)
    clf = GridSearchCV(model, params)
    clf.fit(X, Y)
    resultlist.append((file, modelname, clf.best_params_, clf.best_score_))

print('----------------------------------------------------------')

for result in resultlist:
    print(result)

----------------------------------------------------------
('26-11.txt', 'PLS', {'n_components': 3}, 0.9999995659126992)
('26-11.txt', 'SVR', {'kernel': 'linear'}, 0.9999995686274493)

いや0.9999..って。
乱数強くしすぎるとなんかおかしくなるし・・・

ひとまず、書き方自体はわかったので、次は別なことやってみます。
やっぱり、求めたいと思うものをちゃんと定めないと、「やってみた」を超えられない。
意味のある記事にならない。。。

selenium動作用の基底クラス 利用例

概要

以前の記事のクラスを使った例を作ってみました。
seleniumのテスト用のサイトを使用しています。今回は旧サイトを対象にしています。

必要なもの

• python 3.7.2

ライブラリとして

• selenium
• numpy
• pandas
• openpyxl
• xlrd

ブラウザは

• Chrome

を使用しています。

公開場所

githubで公開しいます。

使い方

1. data/予約データ.xlsxに各入力内容に応じて値を入れてください。
   • 日付についてはランダムで入るように指定しているので固定したい場合は修正してください。
2. seleniumTestSite1を実行します。
3. 終了するのを待ちます。screenShot/reserveに結果は出力されます。

内容の説明

• data/予約データ.xlsxの一行ずつ登録を行っていきます。一つのクラスにまとめているが、必要に応じてクラスを分けるなど対応を行います。
• data/予約データ.xlsxにデータを登録すればまとめて入力できます。CSVなどによる一括登録ができず画面からの入力のみという場合に業務効率化のきっかけにできれば
• アラートダイアログに関しては基底クラスに定義していませんが今後定義するかも・・・
• 実際にはこの機能を応用して勤務表の入力やとあるシステムの業務支援として使っています。
• logの設定など見よう見まねでやっているのでベストプラクティスではないかもしれません・・・

目的

rebuildfm の Miyagawa さんがGoogle の Cloud Speech-to-Text API を用いてマルチチャンネル音声の文字起こし（コードはこちら）をされていたので、以前自身で書いたブログ（Google Cloud Speech API を使った音声の文字起こし手順）を参考にマルチチャンネル音声の文字起こしにトライ してみました。

Google Cloud-to-Speech マルチチャンネルで 1/2 わけて transcribe するのできた。チャンネルごとに書き出して sox -M でマージ、あとは チャンネル数指定してあげるだけでできた。2ch だったらL/R でやるのでもいいのかも。

ただチャンネルごとに書き出すのちょっと面倒。 pic.twitter.com/EtqtNW47f5

— Tatsuhiko Miyagawa (@miyagawa) 2019年2月22日

事前準備

• 先の記事（Google Cloud Speech API を使った音声の文字起こし手順） の事前準備は実施済みとします
• マルチチャンネル音声データは Google Cloud Platform リポジトリの commercial_stereo.wav をローカルPCにダウンロードしておきます（一応 こちら にも置いておきます）。

手順

0. 準備

先の記事（Google Cloud Speech API を使った音声の文字起こし手順）の手順1 ~ 5 とまで実施し、上記の commercial_stereo.wav を GCP のストレージにアップロードします。

また今回利用するマルチチャンネル音声の文字起こしには、Cloud Speech-to-Text API のベータ版の利用が必要となるため、下記コマンドで Google Cloud Shell上 google-cloud-speech をアップグレードしておきます。

GoogleCloudShell上でgoogle-cloud-speechアップグレード

sudo pip install --upgrade google-cloud-speech

1. マルチチャンネル音声向けの文字起こしPythonスクリプトの作成

Google Cloud Shell上で文字起こし実行用のPythonスクリプトを作成します。

Pythonファイル編集コマンド（エディタは好きに）

$ nano transcribe.py

文字起こし用のPythonスクリプト（英語音声用）：

multichannel_transcribe.py

# !/usr/bin/env python
# coding: utf-8
import argparse
import io
import sys
import codecs
import datetime
import locale

def transcribe_gcs(gcs_uri):
    from google.cloud import speech_v1p1beta1 as speech
    from google.cloud.speech_v1p1beta1 import enums
    from google.cloud.speech_v1p1beta1 import types
    client = speech.SpeechClient()

    audio = types.RecognitionAudio(uri=gcs_uri)
    config = types.RecognitionConfig(
        sample_rate_hertz=44100,
        encoding=enums.RecognitionConfig.AudioEncoding.LINEAR16,
        language_code='en-US',
        audio_channel_count=2,
        enable_separate_recognition_per_channel=True)

    operation = client.long_running_recognize(config, audio)

    print('Waiting for operation to complete...')
    operationResult = operation.result()

    d = datetime.datetime.today()
    today = d.strftime("%Y%m%d-%H%M%S")
    fout = codecs.open('output{}.txt'.format(today), 'a', 'shift_jis')

    for result in operationResult.results:
      for alternative in result.alternatives:
        fout.write(u'ChannelTag: {}\n'.format(result.channel_tag))
        fout.write(u'Transcript: {}\n'.format(alternative.transcript))
    fout.close()

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument(
        'path', help='GCS path for audio file to be recognized')
    args = parser.parse_args()
    transcribe_gcs(args.path)

ポイントとしては下記3点です：

• マルチチャンネル音声認識の設定として、マルチチャンネル音声のチャンネル数（今回の音源は2チャンネル）の設定、チャンネルごとの音声認識フラグを True にします。

multichannel_transcribe.py（抜粋）

        audio_channel_count=2,
        enable_separate_recognition_per_channel=True

• チャンネルごとに分けてテキスト書き出しをします。

multichannel_transcribe.py（抜粋）

for result in operationResult.results:
      for alternative in result.alternatives:
        fout.write(u'ChannelTag: {}\n'.format(result.channel_tag))
        fout.write(u'Transcript: {}\n'.format(alternative.transcript))

• 今回新機能利用のためCloud Speech-to-Text APIベータ版をインポートしています（将来的に正規版に組み込まれた場合は下記正規版のインポートへと記述を変更する必要があると思われます）。

multichannel_transcribe.py（抜粋）

    from google.cloud import speech_v1p1beta1 as speech
    from google.cloud.speech_v1p1beta1 import enums
    from google.cloud.speech_v1p1beta1 import types

また、日本語の文字起こしをしたい場合は下記1行を修正します：

language_code='en-US')

↓

language_code='ja-JP')

2. マルチチャンネル音声文字起こしの実行

Google Cloud Console 上で下記コマンドにて文字起こしを実行します。

$ python multichannel_transcribe.py gs://バケット名/音声データ名.wav

3. 結果

今回注目したいのが、2人の会話（お店にChromecast を買いに来た人とその店員との会話）が分離された形でチャンネルタグ1 とチャンネルタグ2 として音声認識できている という点です。

これまでの音声ファイルからの文字起こしではこうしたチャンネルごとに分けられずテキストが出力されていました。

今回Cloud Speech-to-Text APIベータ版のマルチチャンネル音声の文字起こし機能を利用することで、電話の受け答えのような複数のチャンネルを含んだ音声についてチャンネルを分けた形で文字起こしができそうという手ごたえを得られました。

ChannelTag: 1
Transcript: hi I'd like to buy a Chromecast I was wondering whether you could help me with that
ChannelTag: 2
Transcript: certainly which color would you like we have blue black and red
ChannelTag: 1
Transcript:  let's go with the black one
ChannelTag: 2
Transcript:  would you like the new Chromecast Ultra model or the regular Chromecast
ChannelTag: 1
Transcript:  regular Chromecast is fine thank you
ChannelTag: 2
Transcript:  okay sure would you like to ship it regular or Express
ChannelTag: 1
Transcript:  express please
ChannelTag: 2
Transcript:  terrific it's on the way thank you
ChannelTag: 1
Transcript:  thank you very much bye

参考

• https://twitter.com/miyagawa/status/1098815809701347328
• https://gist.github.com/miyagawa/7624f237f103554fdfbdad44f8857355
• https://cloud.google.com/speech-to-text/docs/multi-channel?hl=ja#speech-multi-channel-python
• https://stackoverflow.com/questions/50773013/importerror-cannot-import-name-speech-v1p1beta1

所感

• 今回本当は rebuildfm #131 の「年の割に無責任 」 の回（自分の好きな回）をチャンネルを分けた形で文字起こししてみたいと考えてトライしたのがきっかけでした。
• しかし、結果として Podcastサイトの mp3 をそのままダウンロードした場合、音源データ自体が複数チャンネル情報を含んでいなかったため、上記 Python スクリプト実行時に「設定されらチャンネル数が間違っている」という意味のエラーで複数のチャンネル音声の文字起こしはできませんでした。。( ；∀；)
• そのため、適用範囲としては複数人の声が入った音声データではなく、あくまで音声データ自体がマルチチャンネル音声である必要がある 点、注意点として強調しておきたいと感じました。

はじめに

私が所属しているサークルでは、部屋の出入りをいちいちLINEとslackで報告しなくてはならず、これがめんどい。。。。
ならば、監視カメラ的な物をつくってLINEbotとslackbotに代わりに報告してもらおう！というのがコレを作った動機です。

流れは、
１．webカメラを起動する
２．カメラで顔を認識したら、顔の部分だけをトリミングして保存
３．保存した画像を学習済みモデルに通して分類する
４．分類結果をLINE,slackbotからメッセージとして送信する
という感じです。

サークルメンバー10人の顔を見分けたい！！

目次

1.環境
2.画像収集
3.画像の水増し
3.転移学習
4.webカメラの起動・LINE,slackとの連携
5.終わりに

環境

・python 3.6.5
・opencv-python 3.4.4.19
・Keras 2.2.4
・Flask 1.0.2
・line-bot-sdk 1.8.0
・slackbot 0.5.3

画像収集

画像はLINEグループのアルバムから丸ごともってきました。
学習データ用に、これらの画像から顔だけを切り出していきます！
学習済みの検出器をこちらから持ってきて、face_cut.pyと同じ階層においておきました。

face_cut.py

import cv2
import glob
import numpy as np

model = "./models/haarcascade_frontalface_alt.xml"
faceCascade = cv2.CascadeClassifier(model)#顔検出器を生成

PHOTOS_PATH = "./input_done"
SAVE_PATH = "./detected_faces"
files = glob.glob(PHOTOS_PATH + "/*.jpg") 
detect_count= 0
undetect_count= 0
read_count = 0

for i,file in enumerate(files):
    img = cv2.imread(file)#第二引数に0指定しろよ
    img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    h, w = img.shape[:2]
    img = cv2.resize(img, (w,h))#結局リサイズしてない。
    face = faceCascade.detectMultiScale(img)#顔として認識した正方形の左上の座標がx,yに、横、縦幅がw,hに格納されている

    read_count += 1
    if len(face)>0:#顔を認識したら、      
        for  rect in face:#認識したすべての顔を切り出す
            cv2.imwrite(SAVE_PATH + "/" +str(read_count) + "_" + str(detect_count) +".jpg", img[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]])
            detect_count += 1
            print("detect!",detect_count)
    else:
        undetect_count += 1
        print("undetect...", undetect_count)

print("detect_count", detect_count)
print("undetect_count", undetect_count)

PHOTOS_PATHで指定したフォルダの画像を読み込み、切り出した画像はSAVE_PATHで指定したフォルダに保存します。

この後、画像を使いやすいようにクラス（人物）ごとにフォルダに分類しました。この作業で6時間くらいかかった。。。

......さあ、各クラス150枚準備できました！

画像の水増し

さっそく学習！...といきたいのですが、これだけでは足りないのでトレーニングデータを水増ししていきます！
トレーニングデータには120枚をあてました。

それぞれの画像に対して左右反転、コントラスト調整、平滑化、γ変換をして2^4倍に増やします。
この際、水増しをするのはトレーニングデータのみにします。

face_aug.py

import cv2
import os,glob
import numpy as np
from sklearn import model_selection

#クラスごとのフォルダ名をリストにまとめる
classes = ["member1","menber2","member3","member4","member5","member6","member7","member8","member9","member10","others"]
num_classes = len(classes)
image_size = 50

X_train = []
X_test = []
y_train = []
y_test = []

#-----------------------------------------------------------
#~水増しする関数のみなさん~

#左右反転
def flip(img):
    #第二引数を正でｙ軸対象
    flip_images  = cv2.flip(img, 1)
    return flip_images
#コントラスト
def cont(img):
    #ルックアップテーブルの生成
    min_table=50
    max_table=205
    diff_table=max_table - min_table

    LUT_HC = np.arange(256, dtype = "uint8")

    #ハイコントラストLUT作成
    for i in range(0, min_table):
        LUT_HC[i] = 0
    for i in range(min_table, max_table):
        LUT_HC[i] = 255 * (i - min_table) / diff_table
    for i in range(max_table, 255):
        LUT_HC[i] = 255

    #変換
    #cv2.LUTで適用
    high_cont_imgs = cv2.LUT(img, LUT_HC)
    return high_cont_imgs

#ぼかし
def blur(img):
    blur_images = cv2.GaussianBlur(img, (5, 5), 0)
    return blur_images
#γ変換
def gamma(img):
    # ガンマ変換ルックアップテーブル
    gamma1 = 0.75
    LUT_G1 = np.arange(256, dtype="uint8")
    for i in range(256):
        LUT_G1[i] = 255 * pow(float(i) / 255, 1.0 / gamma1)
    #変換
    gamma1_images = cv2.LUT(img, LUT_G1)
    return gamma1_images
#-----------------------------------------------------------------
for index, classlabel in enumerate(classes): 
    photos_dir = "./" + classlabel
    files = glob.glob(photos_dir + "/*.jpg") 
    for i,file in enumerate(files):
        if i >= 150: #ラベルごとの画像の枚数をそろえる
            break
        img = cv2.imread(file)
        img = cv2.resize(img, (image_size,image_size))

        if i < 30: #この番号以下の写真のデータはテスト用になる
            data = np.asarray(img)
            X_test.append(data)
            y_test.append(index)
        else: #それ以外はトレーニング用になる
            #1枚の画像ずつ処理する
            images = [img]
            images.extend(list(map(flip, images)))#倍倍に増えていく~
            images.extend(list(map(cont, images)))
            images.extend(list(map(blur, images)))
            images.extend(list(map(gamma, images)))

            for _ in range(len(images)):#imagesの枚数分だけ正解ラベルを作成
                y_train.append(index)
             #処理した全ての画像を格納する
            X_train.extend(images)
    print(classlabel , "done!")

X_train = np.array(X_train)#nparrayに変換する
X_test = np.array(X_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
xy = (X_train,X_test,y_train,y_test)#これらをxyにまとめ、
np.save("./face_aug.npy", xy)#画像データを保存する

#ちゃんとデータができているか確認した
X_train, X_test, y_train, y_test = np.load("face_aug.npy") 
print(len(X_train),len(X_test),len(y_train),len(y_test))

for i in range(len(classes)):
    count = 0
    for j in range(len(y_train)):
        if y_train[j] == i:
            count += 1
    print(count)

各クラス約2000枚のデータがそろったので、いよいよ転移学習させていきましょう?

VGG16で転移学習させる

vgg16.py

from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input, BatchNormalization, Activation
from keras.models import Model, Sequential
from keras.callbacks import EarlyStopping
from keras.utils import plot_model, np_utils
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

classes = ["member1","menber2","member3","member4","member5","member6","member7","member8","member9","member10","others"]
num_classes = len(classes)
epochs=20
batch_size=64


X_train, X_test, y_train, y_test = np.load("face_aug.npy") 
X_train = X_train.astype("float") / 255 #X_trainの各チャンネルの値は0~255だがそれを255で割ることですべての値を0~1にする(正規化)
X_test = X_test.astype("float") / 255
y_train = np_utils.to_categorical(y_train, num_classes) #one_hotベクトルに変換
y_test = np_utils.to_categorical(y_test, num_classes) 

input_tensor = Input(shape=(50, 50, 1))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)

top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))

#top_model.add(Dense(128))
#top_model.add(BatchNormalization())
#top_model.add(Activation('sigmoid'))
#top_model.add(Dropout(0.5))

#top_model.add(Dense(64))
#top_model.add(BatchNormalization())
#top_model.add(Activation('sigmoid'))
#top_model.add(Dropout(0.5))

top_model.add(Dense(32))
#top_model.add(BatchNormalization())
top_model.add(Activation('sigmoid'))
#top_model.add(Dropout(0.5))

top_model.add(Dense(num_classes, activation="softmax"))

model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))

for layer in model.layers[:6]:#VGGの層の重みの固定を調整する
  layer.trainable = False

model.compile(optimizer=optimizers.SGD (lr=1e-4, momentum=0.9),loss='categorical_crossentropy', metrics=['accuracy'])

es = EarlyStopping(monitor='val_loss', patience=0, verbose=0, mode='min')#バリデーションデータ（テストデータ）の損失関数の値が大きくなると早期終了する

history = model.fit(X_train, y_train, validation_data=(X_test, y_test), batch_size=batch_size, epochs=epochs, callbacks=[es])

model.save("faces.h5")

#モデルの評価
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss: ', scores[0])
print('Test accuracy: ', scores[1])
print()

#学習曲線の表示
plt.plot(history.history['acc'], label='acc', ls='-')
plt.plot(history.history['val_acc'], label='val_acc', ls='-')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(loc='best')
plt.show()

結果は75%くらい。
グラフ見た感じもっと精度あげられそう。
実用化するなら95%くらい欲しいけど、妥協しました。。
いろんなサイズのモデルで学習させてみましたが、１番精度が良かったのはごく小さなモデルでした。

考察してみた

・今回は50x50にリサイズしたが、元画像がそれよりも小さい画像があった。そのため、かなりぼやけてしまい上手く学習できなかったのではないか。

・今回はサークルメンバー以外の人も分類できるように、othersクラスを設けた。このクラスだけ異なる多数の人の顔で学習させたので、上手く重みの調整ができなかったのかもしれない。

・重みを固定するVGGの層を減らした方が精度がよかった。初期の層でよりプリミティブな特徴を捉え、残りの層で今回扱ったデータ特有の特徴を捉えたためだろう。こういう結果が出たのは、imagenetが人の顔を含んでいないためだろうか。

webカメラの起動・LINEとslackとの連携

いよいよ、先ほど作成したモデルと、LINEとslackとの連携部分を書いていきます！
長々とディープラーニングについて書いてきましたが、メインはこれからですね！

came.pyでwebカメラを起動して、顔を認識したらdetect_pushモジュールを呼び出してLINEbotとslackbotからメッセージを送っています。

（以前はsubprocess.check_call()を使っていました。モジュール化すると見やすいですね。）

came.py

import cv2
import numpy as np
from keras.models import load_model
from detect_push import detectFace, pushToLine, pushToSlack
import time

SAVE_PATH = "./input/face.jpg"
model = load_model('faces.h5')
face_cascade = cv2.CascadeClassifier('./models/haarcascade_frontalface_default.xml')

cap = cv2.VideoCapture(0)#webカメラをキャプチャーする
while True:
    ret, img = cap.read()
    img = cv2.flip(img, 1)#反転
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)#グレースケール化
    cv2.imshow("img",img)
    faces = face_cascade.detectMultiScale(gray, 1.9, 5)
    if len(face)>0:      
        for rect in face:
            cv2.imwrite(SAVE_PATH, img[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]])
            print("recognize face !!")

            member = detectFace(SAVE_PATH, model)#上で保存した画像を読み込み、モデルでの予測結果をmemberに代入
            pushToLine(member)#予測結果を受け取り、LINEbotから送信
            pushToSlack(member)#予測結果を受け取り、slackbotから送信

            time.sleep(10)
    if cv2.waitKey(30) == 27:#Escキーを押すとbreak
        break

# キャプチャをリリースして、ウィンドウをすべて閉じる
cap.release()
cv2.destroyAllWindows()

detect_push.py

import os
import tensorflow as tf
import cv2
import numpy as np
from linebot import LineBotApi
from linebot.models import TextSendMessage, ImageSendMessage
from linebot.exceptions import LineBotApiError
from slackbot.slackclient import SlackClient

def detectFace(filepath, model):#指定されたパスの画像を読み込んで,予測結果を返す
    image = cv2.imread(filepath)
    image = cv2.resize(image,(50,50))
    data = np.expand_dims(image, axis=0)
    result = model.predict(data)
    predicted = result.argmax()
    members = ["member1","member2","member3","member4","member5","member6","member7","member8","member9","member10","others"]

    return members[predicted]

def pushToLine(member):#LINEbotからメッセージを送信する
    channel_access_token = os.getenv('LINE_CHANNEL_ACCESS_TOKEN', None)#環境変数に設定したchannel_access_tokenを取得
    line_bot_api = LineBotApi(channel_access_token)
    try:
        line_bot_api.push_message("メッセージを送信したいトークルームのid", TextSendMessage(text = member + "が開けました"))
    except LineBotApiError as e:
        # error handle
        ...

def pushToSlack(member):#slackbotからメッセージを送信する
    #slackclientのインスタンスを作成
    bot = SlackClient("slackbotのid")
    bot.send_message("メッセージを送信したいチャンネル名", member + "が開けました")

これだけの記述でbotからメッセージが送れる!!!
各アカウント登録は最後にリンクを張っておくので、そのサイトを参考にしてみてください。
公式ドキュメントを見た感じ、LINEbotでもっといろんなことができそうですね...！

まとめ

kerasでめちゃめちゃ簡単にモデルが作れて、転移学習であまり考えずにそこそこの精度がでる。

ただ学習データの準備がものすごく大変です。。。

LINEbotもslackbotも簡単に作れたので、他に面白いbotを作ったら紹介したいですね！

参考にしたサイト

Kerasでアニメ 「けいおん！」を画像認識させてみた
openCVで複数画像ファイルから顔検出をして切り出し保存
Messaging APIを利用するには-LINE Developers
Pythonを使ったSlackBotの作成方法

はじめに

私が所属しているサークルでは、部屋の出入りをいちいちLINEとslackで報告しなくてはならず、これがめんどい。。。。
ならば、監視カメラ的な物をつくってLINEbotとslackbotに代わりに報告してもらおう！というのがコレを作った動機です。

流れは、
１．webカメラを起動する
２．カメラで顔を認識したら、顔の部分だけをトリミングして保存
３．保存した画像を学習済みモデルに通して分類する
４．分類結果をLINE,slackbotからメッセージとして送信する
という感じです。

サークルメンバー10人の顔を見分けたい！！

目次

1.環境
2.画像収集
3.画像の水増し
3.転移学習
4.webカメラの起動・LINE,slackとの連携
5.終わりに

環境

・python 3.6.5
・opencv-python 3.4.4.19
・Keras 2.2.4
・Flask 1.0.2
・line-bot-sdk 1.8.0
・slackbot 0.5.3

画像収集

画像はLINEグループのアルバムから丸ごともってきました。
学習データ用に、これらの画像から顔だけを切り出していきます！
学習済みの検出器をこちらから持ってきて、face_cut.pyと同じ階層においておきました。

face_cut.py

import cv2
import glob
import numpy as np

model = "./models/haarcascade_frontalface_alt.xml"
faceCascade = cv2.CascadeClassifier(model)#顔検出器を生成

PHOTOS_PATH = "./input_done"
SAVE_PATH = "./detected_faces"
files = glob.glob(PHOTOS_PATH + "/*.jpg") 
detect_count= 0
undetect_count= 0
read_count = 0

for i,file in enumerate(files):
    img = cv2.imread(file)#第二引数に0指定しろよ
    img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    h, w = img.shape[:2]
    img = cv2.resize(img, (w,h))#結局リサイズしてない。
    face = faceCascade.detectMultiScale(img)#顔として認識した正方形の左上の座標がx,yに、横、縦幅がw,hに格納されている

    read_count += 1
    if len(face)>0:#顔を認識したら、      
        for  rect in face:#認識したすべての顔を切り出す
            cv2.imwrite(SAVE_PATH + "/" +str(read_count) + "_" + str(detect_count) +".jpg", img[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]])
            detect_count += 1
            print("detect!",detect_count)
    else:
        undetect_count += 1
        print("undetect...", undetect_count)

print("detect_count", detect_count)
print("undetect_count", undetect_count)

PHOTOS_PATHで指定したフォルダの画像を読み込み、切り出した画像はSAVE_PATHで指定したフォルダに保存します。

この後、画像を使いやすいようにクラス（人物）ごとにフォルダに分類しました。この作業で6時間くらいかかった。。。

......さあ、各クラス150枚準備できました！

画像の水増し

さっそく学習！...といきたいのですが、これだけでは足りないのでトレーニングデータを水増ししていきます！
トレーニングデータには120枚をあてました。

それぞれの画像に対して左右反転、コントラスト調整、平滑化、γ変換をして2^4倍に増やします。
この際、水増しをするのはトレーニングデータのみにします。

face_aug.py

import cv2
import os,glob
import numpy as np
from sklearn import model_selection

#クラスごとのフォルダ名をリストにまとめる
classes = ["member1","menber2","member3","member4","member5","member6","member7","member8","member9","member10","others"]
num_classes = len(classes)
image_size = 50

X_train = []
X_test = []
y_train = []
y_test = []

#-----------------------------------------------------------
#~水増しする関数のみなさん~

#左右反転
def flip(img):
    #第二引数を正でｙ軸対象
    flip_images  = cv2.flip(img, 1)
    return flip_images
#コントラスト
def cont(img):
    #ルックアップテーブルの生成
    min_table=50
    max_table=205
    diff_table=max_table - min_table

    LUT_HC = np.arange(256, dtype = "uint8")

    #ハイコントラストLUT作成
    for i in range(0, min_table):
        LUT_HC[i] = 0
    for i in range(min_table, max_table):
        LUT_HC[i] = 255 * (i - min_table) / diff_table
    for i in range(max_table, 255):
        LUT_HC[i] = 255

    #変換
    #cv2.LUTで適用
    high_cont_imgs = cv2.LUT(img, LUT_HC)
    return high_cont_imgs

#ぼかし
def blur(img):
    blur_images = cv2.GaussianBlur(img, (5, 5), 0)
    return blur_images
#γ変換
def gamma(img):
    # ガンマ変換ルックアップテーブル
    gamma1 = 0.75
    LUT_G1 = np.arange(256, dtype="uint8")
    for i in range(256):
        LUT_G1[i] = 255 * pow(float(i) / 255, 1.0 / gamma1)
    #変換
    gamma1_images = cv2.LUT(img, LUT_G1)
    return gamma1_images
#-----------------------------------------------------------------
for index, classlabel in enumerate(classes): 
    photos_dir = "./" + classlabel
    files = glob.glob(photos_dir + "/*.jpg") 
    for i,file in enumerate(files):
        if i >= 150: #ラベルごとの画像の枚数をそろえる
            break
        img = cv2.imread(file)
        img = cv2.resize(img, (image_size,image_size))

        if i < 30: #この番号以下の写真のデータはテスト用になる
            data = np.asarray(img)
            X_test.append(data)
            y_test.append(index)
        else: #それ以外はトレーニング用になる
            #1枚の画像ずつ処理する
            images = [img]
            images.extend(list(map(flip, images)))#倍倍に増えていく~
            images.extend(list(map(cont, images)))
            images.extend(list(map(blur, images)))
            images.extend(list(map(gamma, images)))

            for _ in range(len(images)):#imagesの枚数分だけ正解ラベルを作成
                y_train.append(index)
             #処理した全ての画像を格納する
            X_train.extend(images)
    print(classlabel , "done!")

X_train = np.array(X_train)#nparrayに変換する
X_test = np.array(X_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
xy = (X_train,X_test,y_train,y_test)#これらをxyにまとめ、
np.save("./face_aug.npy", xy)#画像データを保存する

#ちゃんとデータができているか確認した
X_train, X_test, y_train, y_test = np.load("face_aug.npy") 
print(len(X_train),len(X_test),len(y_train),len(y_test))

for i in range(len(classes)):
    count = 0
    for j in range(len(y_train)):
        if y_train[j] == i:
            count += 1
    print(count)

各クラス約2000枚のデータがそろったので、いよいよ転移学習させていきましょう?

VGG16で転移学習させる

vgg16.py

from keras import optimizers
from keras.applications.vgg16 import VGG16
from keras.datasets import cifar10
from keras.layers import Dense, Dropout, Flatten, Input, BatchNormalization, Activation
from keras.models import Model, Sequential
from keras.callbacks import EarlyStopping
from keras.utils import plot_model, np_utils
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

classes = ["member1","menber2","member3","member4","member5","member6","member7","member8","member9","member10","others"]
num_classes = len(classes)
epochs=20
batch_size=64


X_train, X_test, y_train, y_test = np.load("face_aug.npy") 
X_train = X_train.astype("float") / 255 #X_trainの各チャンネルの値は0~255だがそれを255で割ることですべての値を0~1にする(正規化)
X_test = X_test.astype("float") / 255
y_train = np_utils.to_categorical(y_train, num_classes) #one_hotベクトルに変換
y_test = np_utils.to_categorical(y_test, num_classes) 

input_tensor = Input(shape=(50, 50, 1))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)

top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))

#top_model.add(Dense(128))
#top_model.add(BatchNormalization())
#top_model.add(Activation('sigmoid'))
#top_model.add(Dropout(0.5))

#top_model.add(Dense(64))
#top_model.add(BatchNormalization())
#top_model.add(Activation('sigmoid'))
#top_model.add(Dropout(0.5))

top_model.add(Dense(32))
#top_model.add(BatchNormalization())
top_model.add(Activation('sigmoid'))
#top_model.add(Dropout(0.5))

top_model.add(Dense(num_classes, activation="softmax"))

model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))

for layer in model.layers[:6]:#VGGの層の重みの固定を調整する
  layer.trainable = False

model.compile(optimizer=optimizers.SGD (lr=1e-4, momentum=0.9),loss='categorical_crossentropy', metrics=['accuracy'])

es = EarlyStopping(monitor='val_loss', patience=0, verbose=0, mode='min')#バリデーションデータ（テストデータ）の損失関数の値が大きくなると早期終了する

history = model.fit(X_train, y_train, validation_data=(X_test, y_test), batch_size=batch_size, epochs=epochs, callbacks=[es])

model.save("faces.h5")

#モデルの評価
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss: ', scores[0])
print('Test accuracy: ', scores[1])
print()

#学習曲線の表示
plt.plot(history.history['acc'], label='acc', ls='-')
plt.plot(history.history['val_acc'], label='val_acc', ls='-')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(loc='best')
plt.show()

結果は75%くらい。
グラフ見た感じもっと精度あげられそう。
実用化するなら95%くらい欲しいけど、妥協しました。。
いろんなサイズのモデルで学習させてみましたが、１番精度が良かったのはごく小さなモデルでした。

考察してみた

・今回は50x50にリサイズしたが、元画像がそれよりも小さい画像があった。そのため、かなりぼやけてしまい上手く学習できなかったのではないか。

・今回はサークルメンバー以外の人も分類できるように、othersクラスを設けた。このクラスだけ異なる多数の人の顔で学習させたので、上手く重みの調整ができなかったのかもしれない。

・重みを固定するVGGの層を減らした方が精度がよかった。初期の層でよりプリミティブな特徴を捉え、残りの層で今回扱ったデータ特有の特徴を捉えたためだろう。こういう結果が出たのは、imagenetが人の顔を含んでいないためだろうか。

webカメラの起動・LINEとslackとの連携

いよいよ、先ほど作成したモデルと、LINEとslackとの連携部分を書いていきます！
長々とディープラーニングについて書いてきましたが、メインはこれからですね！

came.pyでwebカメラを起動して、顔を認識したらdetect_pushモジュールを呼び出してLINEbotとslackbotからメッセージを送っています。

（以前はsubprocess.check_call()を使っていました。モジュール化すると見やすいですね。）

came.py

import cv2
import numpy as np
from keras.models import load_model
from detect_push import detectFace, pushToLine, pushToSlack
import time

SAVE_PATH = "./input/face.jpg"
model = load_model('faces.h5')
face_cascade = cv2.CascadeClassifier('./models/haarcascade_frontalface_default.xml')

cap = cv2.VideoCapture(0)#webカメラをキャプチャーする
while True:
    ret, img = cap.read()
    img = cv2.flip(img, 1)#反転
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)#グレースケール化
    cv2.imshow("img",img)
    faces = face_cascade.detectMultiScale(gray, 1.9, 5)
    if len(face)>0:      
        for rect in face:
            cv2.imwrite(SAVE_PATH, img[rect[1]:rect[1] + rect[3], rect[0]:rect[0] + rect[2]])
            print("recognize face !!")

            member = detectFace(SAVE_PATH, model)#上で保存した画像を読み込み、モデルでの予測結果をmemberに代入
            pushToLine(member)#予測結果を受け取り、LINEbotから送信
            pushToSlack(member)#予測結果を受け取り、slackbotから送信

            time.sleep(10)
    if cv2.waitKey(30) == 27:#Escキーを押すとbreak
        break

# キャプチャをリリースして、ウィンドウをすべて閉じる
cap.release()
cv2.destroyAllWindows()

detect_push.py

import os
import tensorflow as tf
import cv2
import numpy as np
from linebot import LineBotApi
from linebot.models import TextSendMessage, ImageSendMessage
from linebot.exceptions import LineBotApiError
from slackbot.slackclient import SlackClient

def detectFace(filepath, model):#指定されたパスの画像を読み込んで,予測結果を返す
    image = cv2.imread(filepath)
    image = cv2.resize(image,(50,50))
    data = np.expand_dims(image, axis=0)
    result = model.predict(data)
    predicted = result.argmax()
    members = ["member1","member2","member3","member4","member5","member6","member7","member8","member9","member10","others"]

    return members[predicted]

def pushToLine(member):#LINEbotからメッセージを送信する
    channel_access_token = os.getenv('LINE_CHANNEL_ACCESS_TOKEN', None)#環境変数に設定したchannel_access_tokenを取得
    line_bot_api = LineBotApi(channel_access_token)
    try:
        line_bot_api.push_message("メッセージを送信したいトークルームのid", TextSendMessage(text = member + "が開けました"))
    except LineBotApiError as e:
        # error handle
        ...

def pushToSlack(member):#slackbotからメッセージを送信する
    #slackclientのインスタンスを作成
    bot = SlackClient("slackbotのid")
    bot.send_message("メッセージを送信したいチャンネル名", member + "が開けました")

これだけの記述でbotからメッセージが送れる!!!
各アカウント登録は最後にリンクを張っておくので、そのサイトを参考にしてみてください。
公式ドキュメントを見た感じ、LINEbotでもっといろんなことができそうですね...！

まとめ

kerasでめちゃめちゃ簡単にモデルが作れて、転移学習であまり考えずにそこそこの精度がでる。

ただ学習データの準備がものすごく大変です。。。

LINEbotもslackbotも簡単に作れたので、他に面白いbotを作ったら紹介したいですね！

参考にしたサイト

Kerasでアニメ 「けいおん！」を画像認識させてみた
openCVで複数画像ファイルから顔検出をして切り出し保存
Messaging APIを利用するには-LINE Developers
Pythonを使ったSlackBotの作成方法