※当記事は編集中です

IPFactory Advent Calender 2019 5日目

5日目も書かせていただきます。
IPFactory所属、ISC 1年のpycysです。
コード書きながら記事書いていきます。(現在12/5/1:02)
今日中に終わるかはわかりません。
終わらなそうです。(現在18時)
終わりません。(現在23時半)
諦めて前編として投稿します。

プログラムが受け取るデータ

※画像の数字は添字であり、受け取るデータではありません。

0から9までのいずれかの数字81個が空白区切りで渡されるものとします。
ナンプレの左上マス(0, 0)の値は1番目に、右上マス(0, 8)の値は9番目に、
左下マス(8, 0)の値は73番目に、右下マス(8, 8)の値は81番目に記述されています。
0は空白を、1から9はその数字が設定されていることを示します。

どう解いていくか

解法考えていきます。

1. データを受け取って先頭から9個づつに分け、ナンプレにおける横列の配列に加工。
   これを横列グループと呼ぶことにします。

2. 横列グループから縦列グループを作る。
   そのまま縦列グループと呼ぶ。

3. 加工した2次元配列から3×3マスのグループ(上の画像の赤字で書かれたグループ)を9個作り、これを3マスグループと呼びます。
   3マスグループ内で位置が確定している数字と確定していない数字をそれぞれまとめてグループを作る。
   確定したものは3マス確定グループ、未確定のものは3マス未確定グループと呼びます。

4. 縦列、横列も同様に、列ごとに確定した数字と未確定の数字をまとめてグループを作る。
   それぞれ、縦確定グループ、縦未確定グループ、横確定グループ、横未確定グループと呼びます。

問題受け取り

nums = [int(i) for i in input().split()]
nampre = [[] for i in range(9)]
for index, i in enumerate(nums):
    nampre[(index)//9].append(i)

入力を受け取って空白で区切って整数に変換したり、2次元配列に格納したりしてます。

縦列生成

# 縦列に整形
def columns_generator(rows):
    columns = [[] for i in range(9)]
    for i in range(9):
        for j in range(9):
            columns[i].append(rows[j][i])
    return columns

3マスグループを作る

# 3マスグループを作る
def cube_generator(rows):
    cubes = [[[] for j in range(3)] for i in range(9)]
    for i in range(9):
        for j in range(9):
            cubes[i//3*3+j//3][i%3].append(rows[i][j])
    return cubes

3マス確定グループを作る

# 3マス確定グループを作る
def confirm_cube_generator(cubes):
    confirm_cubes = [[] for i in range(9)]
    for i in range(9):
        confirms = []
        for j in range(9):
            if cubes[i][j//3][j%3]:
                confirms.append(cubes[i][j//3][j%3])
        confirm_cubes.append(copy.deepcopy(confirms))
    return confirm_cubes

3マス未確定グループを作る

明日の記事に続きます。

本稿ではfastTextを使ってサクッと単語の分散表現を獲得する方法について見ていきます。前日の記事と少しリンクするお話に出来れば良いなあと思って書きました。

fastTextとは

fastTextはFacebookが発表した単語の分散表現（単語を数値で表現したもの）を獲得する手法です。基となっているのはお馴染みWord2Vec（CBOW / skip-gram）です。Word2Vecについては今更も今更なので説明は不要でしょう。

論文：Enriching Word Vectors with Subword Information

Word2VecとfastTextの違いは、ベクトルの取り方です。サブワードという仕組みを入れることによって、活用形等の近い単語同士を汲み取っています。

Word2Vecではgoとgoesは全く別の単語でした。しかしfastTextではこれを考慮し、同じ構成要素としてgoとgoesに意味を持たせます。

当然、未知語にも強くなりますね！

詳細は論文や次の資料をお勧めします。

• FacebookのfastTextでFastに単語の分散表現を獲得する - Qiita
• 高速と噂のfastTextの仕組み - Qiita

FastTextで遊ぼう

今回の目的は「PythonとFastTextを使ってサクッと単語の分散表現で遊ぶ」ことです。

環境構築

え？Pythonの導入すらサクッと出来ない？ではGoogle Colaboratoryを使いましょう。（以下colab）

colabはGoogleアカウントさえあれば誰でも簡単にPythonやGPUが使える最強の無料環境です。

はい、環境構築　終。

サクッとfastText

fastTextを使うには学習モデルが必要になります。これは自分でデータを収集して、学習させても良いのですが、ここでは学習済みモデルを使わせてもらいます。

学習済みモデル：fastTextの学習済みモデルを公開しました - Qiita

モデルはそのままGoogleドライブの中に放りこんでください。せっかくなのでcolabの使い方説明も含めて、ドライブから解凍してしまいましょう！

colabでドライブの中を触るにはマウントが必要です。これは以下のコードを実行すればよいのですが、「ドライブをマウント」ボタンを押せば同じコードが出てくるはずなのでそれを実行してください。

from google.colab import drive
drive.mount('/content/drive')

あとはURLにアクセスして、アカウントにログイン、するとauthorization codeが出てくると思うのでそれをcolabでコピペするだけです。簡単。

あとは解凍するだけ！

%cd /content/drive/My Drive/data
!unzip vector_neologd.zip

pathはドライブに上げた学習済みモデルの場所を指定してくださいね。

それでは類似する言葉を探してみましょう。

import gensim

model = gensim.models.KeyedVectors.load_word2vec_format('model.vec', binary=False)

model.most_similar(positive=['自然言語処理'])

結果。

[('自然言語理解', 0.7600098848342896),
 ('自然言語', 0.7503659725189209),
 ('計算言語学', 0.7258570194244385),
 ('自動プログラミング', 0.6848069429397583),
 ('テキストマイニング', 0.6811494827270508),
 ('コンピュータ言語', 0.6618390083312988),
 ('メタプログラミング', 0.658093273639679),
 ('Webプログラミング', 0.6488876342773438),
 ('形態素解析', 0.6479052901268005),
 ('コーパス言語学', 0.6465639472007751)]

色々遊ぶと意外と楽しい。

model.most_similar(positive=['友人'], negative=['友情'])

[('知人', 0.4586910605430603),
 ('自宅', 0.35488438606262207),
 ('知り合い', 0.329221248626709),
 ('入り浸り', 0.3212822675704956),
 ('親戚', 0.31865695118904114),
 ('知り合っ', 0.3158203959465027),
 ('宅', 0.31503963470458984),
 ('誘わ', 0.302945077419281),
 ('繁く', 0.30250048637390137),
 ('同僚', 0.29792869091033936)]

サクッと？fastText

あまりにサクッとし過ぎたので、続いてボキャブラリーを制限して同じことをしてみます。こんなやり方もあるよというオプションです。

今回扱うのは日本語のテキストですが、日本語は英語と違い各単語がスペース等で分割されていないので、初めに前処理を行わなければなりません。（分かち書き）

尚、実装は書籍「つくりながら学ぶ! PyTorchによる発展ディープラーニングを参考にしています。

ここではjanomeを使います。

!pip install janome

では分かち書きをしましょう。

from janome.tokenizer import Tokenizer

j_t = Tokenizer()

def tokenizer_janome(text):
    return [tok for tok in j_t.tokenize(text, wakati=True)]

janomeだけで分かち書きがサクッと出来ますが、加えて簡単な前処理をしましょう。

import re
import unicodedata
import string


def format_text(text):
    text = unicodedata.normalize("NFKC", text)
    table = str.maketrans("", "", string.punctuation  + "「」、。・")
    text = text.translate(table)

    return text


def preprocessing(text):
    """
    前処理をする関数
    """
    text.translate(str.maketrans({chr(0xFF01 + i): chr(0x21 + i) for i in range(94)}))  # 全角→半角

    text = text.lower()  # 大文字→小文字

    text = re.sub('\r', '', text)
    text = re.sub('\n', '', text)
    text = re.sub(' ', '', text)
    text = re.sub('　', '', text)

    text = re.sub(r'[0-9 ０-９]', '', text)  # 数字の除去
    text = re.sub(r'[!-/:-@[-`{-~]', '', text)  # 半角記号の除去
    text = re.sub(r'/[！-／：-＠［-｀｛-～、-〜”’・]', '', text)  # 全角記号の除去
    text = format_text(text)  # 全角記号の除去

    return  text


def tokenizer_with_preprocessing(text):
    text = preprocessing(text)
    text = tokenizer_janome(text)

    return text

コメントに書いた通りですが、いくつかの前処理を行っています。もちろんタスクや用途によって前処理で行うべきことは変わるはずです。

では試しに適当な文章を入れてみましょう。

text = '今回は　fastTextを　使って 分散表現を獲得したい！！！?'
print(tokenizer_with_preprocessing(text))

結果。

['今回', 'は', 'fasttext', 'を', '使っ', 'て', '分散', '表現', 'を', '獲得', 'し', 'たい']

上手くいっているようですね。

続いてtorchtextを使って諸々を楽にします。torchtextについてはtorchtextで簡単にDeepな自然言語処理 - Qiitaが詳しいです。

import torchtext

max_length = 25
TEXT = torchtext.data.Field(sequential=True, tokenize=tokenizer_with_preprocessing,
                            use_vocab=True, lower=True, include_lengths=True,
                            batch_first=True, fix_length=max_length)
LABEL = torchtext.data.Field(sequential=False, use_vocab=False)

train_ds, val_ds, test_ds = torchtext.data.TabularDataset.splits(
    path='./tsv/', train='train.tsv',
    validation='val.tsv', test='test.tsv', format='tsv',
    fields=[('Text', TEXT), ('Label', LABEL)])

train.tsv / test.tsv / val.tsvを用意しました。これは本稿の「fastTextとは」の文章を適当に3分割してtsvファイルとしました。これも上記のリンクが詳しいのでそちらをお勧めします。

from torchtext.vocab import Vectors

vectors = Vectors(name='model.vec')

# ベクトル化したバージョンのボキャブラリーを作成します
TEXT.build_vocab(train_ds, vectors=vectors, min_freq=1)

# ボキャブラリーのベクトルを確認します
print(TEXT.vocab.vectors.shape)  # 52個の単語が300次元のベクトルで表現されている
TEXT.vocab.vectors

# ボキャブラリーの単語の順番を確認します
TEXT.vocab.stoi

これで準備が出来たのでボキャブラリーの各単語の類似度を計算してみます。「単語」に3つの単語が類似するか見てみましょう。

import torch.nn.functional as F

tensor_calc = TEXT.vocab.vectors[TEXT.vocab.stoi['単語']]

# コサイン類似度
print("論文", F.cosine_similarity(tensor_calc, TEXT.vocab.vectors[TEXT.vocab.stoi['論文']], dim=0))
print("ワード", F.cosine_similarity(tensor_calc, TEXT.vocab.vectors[TEXT.vocab.stoi['ワード']], dim=0))
print("ベクトル", F.cosine_similarity(tensor_calc, TEXT.vocab.vectors[TEXT.vocab.stoi['ベクトル']], dim=0))

結果。

論文 tensor(0.3089)
ワード tensor(0.3704)
ベクトル tensor(0.3265)

もっと詳しくやりたい人は

fastTextについてはWord2Vecほどではありませんが、色んな記事がありますので、特におすすめなもの（参考文献）を紹介して締めます。

fastTextで分類

• pythonでfasttextを使って文書分類してみた - Qiita
• テキスト分類器fastTextを用いた文章の感情極性判定 - Qiita
• 【python】fastText用の学習データ作成とモデルの生成 - Qiita
• keras + fastText(学習済み)で文書のジャンル分類してみた - Qiita
• fastTextで自然言語(日本語)の学習モデルを生成する手順まとめ

fastText以外の単語埋め込み

• いますぐ使える単語埋め込みベクトルのリスト - Qiita

もっと最近の単語埋め込みを知りたい方はELMoとかBERTでググって貰えれば沢山出ると思います。

次回は？

@takashi1029さんです！本稿は当日ぎりぎりに投稿しているので（申し訳ない）すぐ投稿されるかもしれません。

次回リンク：まだ

この記事は古川研究室 Advent_calendar4日目の記事です。

はじめに

PyTorch、Chainer、Keras、TensorFlowなど色々なフレームワークが登場し、誰でも簡単にDeep Learningが使えるようになったと言われています。
実際Deep Learningを使っている人たちからすると単に動かすだけなら簡単に思えるかもしれません。しかしDeep LearningというよりPythonをあまり使ってない人からするとメチャクチャ難しいです。
私の感覚としてはDeep Learningを動かすのは自転車に乗るのに似ていると思います。
一度、自転車に乗れた人は「自転車に乗ることなんて簡単だよ」とか「他の自転車も同じようすれば乗れるでしょ？」とか好き勝手言いますが、乗ったことない人や乗れない人からは「何言っているんだ」って感じです。

さらにDeep Learningを使う場合、下図のような感じでどこまでしたいかで求められるスキルが違いますのもDeepを使うハードルを上げている一因かと思います。

この記事ではDeep Learningと言う名の自転車に乗る手助けとして、私が実際にやった2nd Stepの道のりを解説していきます。

とりあえずDeepで物体認識をやってみる

準備

今回はChainerを使います。
そのためにChainerを入れてあげましょう。

$ pip install chainer
$ pip install chainercv

実行

以下みたいな感じで動かします。

import matplotlib.pyplot as plt
import numpy as np

from PIL import Image
from chainercv.visualizations import vis_bbox
from chainercv.datasets import voc_bbox_label_names
from chainercv.links import FasterRCNNVGG16

# 使用するラベル（今回はデフォルトのやつ）
label_names = voc_bbox_label_names

# データの読み込み「'./fish/test.jpeg」は好きな画像ファイルにしてね
test_data = Image.open('./fish/test.jpg')
test_data = np.asarray(test_data).transpose(2, 0, 1).astype(np.float32)

# モデルの構築、とりあえずモデルは学習済みvoc07を使用
model_frcnn = FasterRCNNVGG16(n_fg_class=len(voc_bbox_label_names), pretrained_model='voc07')

# 予測
bboxes, labels, scores = model_frcnn.predict([test_data])
predict_result = [test_data, bboxes[0], labels[0], scores[0]]

# 結果の描画
res = predict_result
fig = plt.figure(figsize=(6, 6))
ax = fig.subplots(1, 1)
line = 0.0
vis_bbox(res[0], res[1][res[3]>line], res[2][res[3]>line], res[3][res[3]>line], label_names=label_names, ax=ax)
plt.show()

結果

うまく認識できました！

次に、のどぐろ画像を入れてやってみました。

当然だけどデフォルトのままだとノドグロのラベルもないし、上手くいきません。
なのでノドグロ特化識別器のにするためにFine-turningをします。
Fine-turningの詳細な説明は飛ばしますが、要は学習済みのモデルに追加学習させる感じです。

データの準備

追加学習するにもそもそも学習データが必要なので学習データをつくりましょう。
labelImgっていうやつがおすすめです。
入れ方や使い方は↑のgithubサイトのREADMEに書いてあるので、とりあえず簡単な簡単な流れだけ説明します。
まず、labelImgを動かすために必要なやつをいれます。

$ brew install qt  # Install qt-5.x.x by Homebrew
$ brew install libxml2
$ pip3 install pyqt5 lxml # Install qt and lxml by pip
$ make qt5py3

実行します。
気をつける点とかはないと思いますが、しいて言えばクローンしたディレクトリ内で操作するところですね。No such file or directoryとか出てエラーになります

$ python3 labelImg.py

labelImg.pyを実行すると以下のような画面がでます。

openで画像を開いて、右側のlabelに「nodoguro」って入力します
wキーを押すと範囲を選択できるので、ノドグロを選択します。

すると、こんな感じでラベルをつけることができます。

こんな感じで2つ付けることもできます。

最後にsaveのボタンを押すとxmlファイルができます。このファイルにラベルとか枠線がどの座標にあるかの情報が入ってます。
あとはclasses.txtって名前のラベル名が箇条書きで書かれたファイルを作ります。

classes.txt

nodoguro
iwashi
cat

学習データ作りはこれで終了です！
気をつける点としては「画像サイズを揃えること」と「ラベルを2種類以上にすること」です。
ラベルの種類が1種類だと学習の際にうまくいきませんでした。

NODOGURO turning

学習データができたので実際に学習させてみましょう。学習済みモデルにはImagenetを使用しました。
今回は7枚の画像を追加学習します。

またディレクトリ構造は以下の感じにしています。

sample/
　├ fish/
　│　├ res_images/
　│　│　　├ images.npy
　│　│　　├ bounding_box_data.npy
　│　│　　└ object_ids.npy
　│　├ classes.txt
　│　├ image_1.jpg
　│　├ image_1.xml 
　│　├    ...
　│　├ image_7.xml
　│　└ test.jpg
　├ out/
　├ learn.py
　├ predict.py
　└ xml2numpyarray.py

データ整形

今回学習させる前にnumpyarrayの形にしておいた方が都合よかったため、以下のコードを使ってその変換をしました。
import errorが起きる場合はpipで入れてください。

xml2numpyarray.py

import matplotlib.pyplot as plt
import numpy as np
import glob
import os
import cv2
from PIL import Image
import xmltodict

# Global Variables

classes_file = 'fish/classes.txt'
data_dir = 'fish'

classes = list()
with open(classes_file) as fd:
    for one_line in fd.readlines():
        cl = one_line.split('\n')[0]
        classes.append(cl)
print(classes)

def getBBoxData(anno_file, classes, data_dir):
    with open(anno_file) as fd:
        pars = xmltodict.parse(fd.read())
    ann_data = pars['annotation']

    print(ann_data['filename'])
    # read image
    img = Image.open(os.path.join(data_dir, ann_data['filename']))
    img_arr = np.asarray(img).transpose(2, 0, 1).astype(np.float32)
    bbox_list = list()
    obj_names = list()
    for obj in ann_data['object']:
        bbox_list.append([obj['bndbox']['ymin'], obj['bndbox']['xmin'], obj['bndbox']['ymax'], obj['bndbox']['xmax']])
        obj_names.append(obj['name'])
    bboxs = np.array(bbox_list, dtype=np.float32)
    obj_names = np.array(obj_names)
    obj_ids = np.array(list(map(lambda x:classes.index(x), obj_names)), dtype=np.int32)
    return {'img':img, 'img_arr':img_arr, 'bboxs':bboxs, 'obj_names':obj_names, 'obj_ids':obj_ids}

def getBBoxDataSet(data_dir, classes):
    anno_files = glob.glob(os.path.join(data_dir, '*.xml'))
    img_list = list()
    bboxs = list()
    obj_ids = list()
    # imgs = np.zeros([4, 3, 189, 267])
    # num = 0
    for ann_file in anno_files:
        ret = getBBoxData(anno_file=ann_file, classes=classes, data_dir=data_dir)
        print(ret['img_arr'].shape)
        img_list.append(ret['img_arr'])
        # imgs[num] = ret['img_arr']
        bboxs.append(ret['bboxs'])
        obj_ids.append(ret['obj_ids'])

    imgs = np.array(img_list)
    return (imgs, bboxs, obj_ids)

imgs, bboxs, obj_ids = getBBoxDataSet(data_dir=data_dir, classes=classes)

np.save(os.path.join(data_dir, 'images.npy'), imgs)
np.save(os.path.join(data_dir, 'bounding_box_data.npy'), bboxs)
np.save(os.path.join(data_dir, 'object_ids.npy'), obj_ids)

学習

以下のコードで実行

learn.py

import os
import numpy as np
import chainer
import random
from chainercv.chainer_experimental.datasets.sliceable import TupleDataset
from chainercv.links import FasterRCNNVGG16
from chainercv.links.model.faster_rcnn import FasterRCNNTrainChain
from chainer.datasets import TransformDataset
from chainercv import transforms
from chainer import training
from chainer.training import extensions

HOME = './'

data_dir = os.path.join(HOME, './fish/res_images')
file_img_set = os.path.join(data_dir, 'images.npy')
file_bbox_set = os.path.join(data_dir, 'bounding_box_data.npy')
file_object_ids = os.path.join(data_dir, 'object_ids.npy')
file_classes = os.path.join(data_dir, 'classes.txt')

# データセットの読み込み
imgs = np.load(file_img_set)
bboxs = np.load(file_bbox_set, allow_pickle=True)
objectIDs = np.load(file_object_ids, allow_pickle=True)

# ラベル情報の読み込み
classes = list()
with open(file_classes) as fd:
    for one_line in fd.readlines():
        cl = one_line.split('\n')[0]
        classes.append(cl)

dataset = TupleDataset(('img', imgs), ('bbox', bboxs), ('label', objectIDs))

N = len(dataset)
N_train = (int)(N*0.9)
N_test = N - N_train
print('total:{}, train:{}, test:{}'.format(N, N_train, N_test))

# ネットワーク構築
faster_rcnn = FasterRCNNVGG16(n_fg_class=len(classes), pretrained_model='imagenet')
faster_rcnn.use_preset('evaluate')
model = FasterRCNNTrainChain(faster_rcnn)

# GPUの設定(今回は使用しない)
gpu_id = -1
# chainer.cuda.get_device_from_id(gpu_id).use()
# model.to_gpu()

# 何の手法で最適化するか設定
optimizer = chainer.optimizers.MomentumSGD(lr=0.001, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005))


# データの用意
class Transform(object):

    def __init__(self, faster_rcnn):
        self.faster_rcnn = faster_rcnn

    def __call__(self, in_data):
        img, bbox, label = in_data
        _, H, W = img.shape
        img = self.faster_rcnn.prepare(img)
        _, o_H, o_W = img.shape
        scale = o_H / H
        bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W))

        # horizontally flip
        img, params = transforms.random_flip(
            img, x_random=True, return_param=True)
        bbox = transforms.flip_bbox(
            bbox, (o_H, o_W), x_flip=params['x_flip'])

        return img, bbox, label, scale

idxs = list(np.arange(N))
random.shuffle(idxs)
train_idxs = idxs[:N_train]
test_idxs = idxs[N_train:]

# 学習するためのいろいろな設定
train_data = TransformDataset(dataset[train_idxs], Transform(faster_rcnn))
train_iter = chainer.iterators.SerialIterator(train_data, batch_size=1)
test_iter = chainer.iterators.SerialIterator(dataset[test_idxs], batch_size=1, repeat=False, shuffle=False)

updater = chainer.training.updaters.StandardUpdater(train_iter, optimizer, device=gpu_id)

n_epoch = 20
out_dir = './out'
trainer = training.Trainer(updater, (n_epoch, 'epoch'), out=out_dir)

step_size = 100
trainer.extend(extensions.snapshot_object(model.faster_rcnn, 'snapshot_model.npz'), trigger=(n_epoch, 'epoch'))
trainer.extend(extensions.ExponentialShift('lr', 0.1), trigger=(step_size, 'iteration'))

log_interval = 1, 'epoch'
plot_interval = 1, 'epoch'
print_interval = 1, 'epoch'

trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport(['iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss', 'validation/main/map', ]), trigger=print_interval)
trainer.extend(extensions.PlotReport(['main/loss'], file_name='loss.png', trigger=plot_interval), trigger=plot_interval)
trainer.extend(extensions.dump_graph('main/loss'))

# 学習
trainer.run()

こちらが設定するパラメータとしては
　・gpuのところ（今回はgpuは使用していません）

# chainer.cuda.get_device_from_id(gpu_id).use()
# model.to_gpu()

　・最適化(optimizer)のところ

optimizer = chainer.optimizers.MomentumSGD(lr=0.001, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005))

　・学習回数のところ

n_epoch = 20
step_size = 100

になります。
他にもbatch_sizeやテストデータを何個にするか（N_train = (int)(N*0.9) N_test = N - N_train）など他にもいろいろありますが、とりあえずは上の3つぐらいです。

ちなみに学習済みのネットワークはout/snapshot_model.npzってファイルに保存されます。

予測

実際にノドグロを認識してみました。
Scoreが0.9以上のやつだけ認識するようにしました。

import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
from chainercv.visualizations import vis_bbox
from chainercv.links import FasterRCNNVGG16

# ラベル読み込み
classes = list()
with open('./fish/classes.txt') as fd:
    for one_line in fd.readlines():
        cl = one_line.split('\n')[0]
        classes.append(cl)

# テストデータの読み込み
test_data = Image.open('./fish/test.jpg')
test_data = np.asarray(test_data).transpose(2, 0, 1).astype(np.float32)

# 学習したモデルを読み込み
pretrain_model = 'out/snapshot_model.npz'

# ネットワーク構築
model_frcnn = FasterRCNNVGG16(n_fg_class=len(classes), pretrained_model=pretrain_model)

# 予測
bboxes, labels, scores = model_frcnn.predict([test_data])
predict_result = [test_data, bboxes[0], labels[0], scores[0]]

# スコアが0.9以下のやつを認識しないようにスレッショルド設定
line = 0.9

# 描画
res = predict_result
fig = plt.figure(figsize=(6, 6))
ax = fig.subplots(1, 1)
vis_bbox(res[0], res[1][res[3]>line], res[2][res[3]>line], res[3][res[3]>line], label_names=classes, ax=ax)
plt.show()

結果がこちらになります。

ちゃんと認識できました！
print(np.sum(labels[0] == 0))で認識した数を表示することもできます。

さいごに

今回はエイヤッでfine-turningをしてノドグロ検出をしてみました。
終わってみるとけっこう簡単でしたね。次はノドグロを好きな画像に変えればいいだけなので比較的楽に実装できますね。
ただ実際高精度な検出やカウントを実現する場合は、重なりの部分をどうするかや回転をどうするかなど、そもそものネットワーク構造や問題設定から練り直したりしなくちゃいけないので大変です。
研究レベルや商品レベルにもっていくには難しいですが、今回の実装を通して「とりあえずDeepを使って遊んでみる」ってところまでは比較的簡単にできるってことは分かってもらえたんじゃないかなと思います。

参考サイト

ほとんど、このサイトを参考にしてやりました。
http://chocolate-ball.hatenablog.com/entry/2018/05/23/012449

はじめに

PythonのCLIフレームワークの一つでCliffというものがあります。そこで少しハマったことをお話しようと思います。

Cliffについて

詳細はこちらを見てください。簡単にCLIツールを作れるフレームワークです。
ちょろっと書くだけで、プログラムの値の返却とか--helpとかをよしなにやってくれます。
main.pyを作ってそこからsetup.pyなどで各コマンドのクラスにマッピングするだけです。

Cliffのコマンドクラスについて

一番基礎となるコマンドのクラスはCommandクラスです。
これを継承してコマンド作る感じです。

sample.py

from cliff.command import Command

class SampleCommand(Command):
    #~~コマンドにさせたい処理~~

デフォルトでもいくつかCommandクラスを継承したクラスがあり、１つだけのオブジェクトを返却したければShowOne、オブジェクトのリストを返したければListerクラスを継承すると、クラスの関数内でkeyとvalue配列を返せば、勝手に表にしてくれたり、オプション指定でJSONやYAMLにしてくれたりします。

基本的にはコマンドは以下のように実装します。

sample.py

from cliff.command import Command

class SampleCommand(Command):

    def get_parser(self, prog_name)
        parser = super().get_parser(prog_name)
        #引数を追加
        parser.add_argument('something')    #必須の引数
        parser.add_argument('--some')       #オプション引数
        parser.add_argument('--so', '-s')   #短縮系も追加できる
        return parser

    def take_action(self, parsed_args):
        #処理を実行
        return something

上記のtake_action内での返り値が基本的には実行時に返却されることになります。
（厳密にはrun関数でtake_actionがwrapされてるので色々やればほにゃららします）

何にハマったか

上記のCommandクラスを継承したコマンドクラスのtake_action内で、JSONやdictを返そうとしたら、コマンドの出力が標準エラー出力にしか出なかったよという話です。

sample.py

import json
from cliff.command import Command

class SampleCommand(Command):

    def get_parser(self, prog_name)
        parser = super().get_parser(prog_name)
        parser.add_argument('arg1')
        return parser

    def take_action(self, parsed_args):
        #処理を実行
        return json.dumps(something)

shell.sh

samplecommand arg1 > log
#なぜか出力がターミナルに出てくる！
samplecommand arg1 2> log
#出力がでなくなるよ

理由はとしては、Commandクラスを継承しているコマンドクラスでのtake_actionの戻り値は、コマンドの終了ステータスとなっているからでした。
つまり

sample.py

from cliff.command import Command

class SampleCommand(Command):

    def get_parser(self, prog_name)
        parser = super().get_parser(prog_name)
        parser.add_argument('arg1')
        return parser

    def take_action(self, parsed_args):
        #処理を実行
        return 100

となっていると

shell.sh

samplecommand arg1
echo $?
#100が出力

となります。JSONやdictやその他諸々のオブジェクトは基本的にTrueとして判定されるので、全てコマンドの戻り値が1となってしまい、終了ステータスが１だとエラー判定なので標準エラー出力に出力されちゃいます。

なんでやねん。

（元気があればプルリク投げます）

はじめに

この記事はTF2.0AdventCalendarで、tf.data.Datasetを使うことによる副作用的な物を検証したものになります。
実際、tf.data.Datasetを使ってmodel.fit_generatorがどれくらいの速度になるのかを検証しました。

CIFAR10で検証

データセットを用意しましょう。

データセットの用意

import tensorflow as tf
import tensorflow.keras as keras
import matplotlib.pyplot as plt
import sklearn
import numpy as np
from tqdm import tqdm

(tr_x,tr_y),(te_x,te_y)=keras.datasets.cifar10.load_data()
tr_x, te_x = tr_x/255.0, te_x/255.0
tr_y, te_y = tr_y.reshape(-1,1), te_y.reshape(-1,1)

tr_ds = tf.data.Dataset.from_tensor_slices((tr_x,tr_y)).batch(128)

for img,label in tr_ds:
    print(img.shape,label.shape)
    break

結果

(128, 32, 32, 3) (128, 1)

正常に出力されているようです。

モデルに入れる

検証用のモデルを作りましょう。

テキトーに重いモデルを作る

model = keras.models.Sequential()
model.add(keras.layers.Convolution2D(32,3,padding="same",activation="relu",input_shape=(32,32,3)))
model.add(keras.layers.Convolution2D(32,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(32,3,padding="same",activation="relu"))
model.add(keras.layers.MaxPooling2D())
model.add(keras.layers.Convolution2D(128,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(128,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(128,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(128,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(128,3,padding="same",activation="relu"))
model.add(keras.layers.MaxPooling2D())
model.add(keras.layers.Convolution2D(256,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(256,3,padding="same",activation="relu"))
model.add(keras.layers.Convolution2D(256,3,padding="same",activation="relu"))
model.add(keras.layers.GlobalAveragePooling2D())
model.add(keras.layers.Dense(1000,activation="relu"))
model.add(keras.layers.Dense(128,activation="relu"))
model.add(keras.layers.Dense(10,activation="softmax"))
model.compile(loss="sparse_categorical_crossentropy",metrics=["accuracy"])
model.summary()

結果

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 32, 32, 32)        896       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 32, 32, 32)        9248      
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 32, 32, 32)        9248      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 16, 16, 32)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 16, 16, 128)       36992     
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 16, 16, 128)       147584    
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 16, 16, 128)       147584    
_________________________________________________________________
conv2d_6 (Conv2D)            (None, 16, 16, 128)       147584    
_________________________________________________________________
conv2d_7 (Conv2D)            (None, 16, 16, 128)       147584    
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 8, 8, 128)         0         
_________________________________________________________________
conv2d_8 (Conv2D)            (None, 8, 8, 256)         295168    
_________________________________________________________________
conv2d_9 (Conv2D)            (None, 8, 8, 256)         590080    
_________________________________________________________________
conv2d_10 (Conv2D)           (None, 8, 8, 256)         590080    
_________________________________________________________________
global_average_pooling2d (Gl (None, 256)               0         
_________________________________________________________________
dense (Dense)                (None, 1000)              257000    
_________________________________________________________________
dense_1 (Dense)              (None, 128)               128128    
_________________________________________________________________
dense_2 (Dense)              (None, 10)                1290      
=================================================================
Total params: 2,508,466
Trainable params: 2,508,466
Non-trainable params: 0
_________________________________________________________________

いい感じに重そうですね。

データセットを入れてみる。

まずは通常の入れ方

通常の入れ方

%%time
model.fit(tr_x,tr_y,batch_size=128,epochs=5)

time

Train on 50000 samples
Epoch 1/5
50000/50000 [==============================] - 7s 145us/sample - loss: 0.6238 - accuracy: 0.7833
Epoch 2/5
50000/50000 [==============================] - 7s 135us/sample - loss: 0.5584 - accuracy: 0.8104
Epoch 3/5
50000/50000 [==============================] - 7s 136us/sample - loss: 0.4936 - accuracy: 0.8303
Epoch 4/5
50000/50000 [==============================] - 7s 139us/sample - loss: 0.4467 - accuracy: 0.8479
Epoch 5/5
50000/50000 [==============================] - 7s 136us/sample - loss: 0.4016 - accuracy: 0.8631
CPU times: user 35.5 s, sys: 4.15 s, total: 39.6 s
Wall time: 35.1 s

nvtopでの画像がこちら

結構いい感じにGPUを使ってるように見えます。

tf.data.Datasetで入れる

次にtf.data.Datasetでデータを入れましょう。

datasetを入れる

%%time
model.fit_generator(tr_ds,epochs=5)

結果

Epoch 1/5
391/391 [==============================] - 12s 31ms/step - loss: 2.3748 - accuracy: 0.1219
Epoch 2/5
391/391 [==============================] - 12s 31ms/step - loss: 1.9375 - accuracy: 0.2519
Epoch 3/5
391/391 [==============================] - 12s 31ms/step - loss: 1.6902 - accuracy: 0.3601
Epoch 4/5
391/391 [==============================] - 12s 31ms/step - loss: 1.5300 - accuracy: 0.4300
Epoch 5/5
391/391 [==============================] - 12s 30ms/step - loss: 1.3649 - accuracy: 0.4988
CPU times: user 58.7 s, sys: 1.63 s, total: 1min
Wall time: 1min 1s

あら。倍かかっちゃってますね。
nvtopを見てみましょう

あまり実力を発揮できていませんね?

keras.preprocessing.image.ImageDataGenerator()でチャレンジ

めちゃめちゃ遅かったこいつ、keras.preprocessing.image.ImageDataGenerator()はどうでしょうか

%%time
datagen = keras.preprocessing.image.ImageDataGenerator()
model.fit_generator(datagen.flow(tr_x, tr_y, batch_size=128),
                    steps_per_epoch=len(tr_x) / 128, epochs=5)

結果

Epoch 1/5
391/390 [==============================] - 16s 40ms/step - loss: 14.5061 - accuracy: 0.1000
Epoch 2/5
391/390 [==============================] - 16s 40ms/step - loss: 14.5057 - accuracy: 0.1000
Epoch 3/5
391/390 [==============================] - 16s 40ms/step - loss: 14.5065 - accuracy: 0.1000
Epoch 4/5
391/390 [==============================] - 16s 40ms/step - loss: 14.5067 - accuracy: 0.1000
Epoch 5/5
391/390 [==============================] - 16s 40ms/step - loss: 14.5067 - accuracy: 0.1000
CPU times: user 1min 3s, sys: 1.37 s, total: 1min 4s
Wall time: 1min 18s

さらに遅い・・・通常モードですらこんな重いんですね。

これはtf.data.Datasetが重いってこと？

実はtf.data.Datasetが重いというより、Kerasのfit_gerenatorが重いっぽいんですよね。
tf.data.Datasetはフルバッチにすることもできるため、それでfitさせてみましょう。

フルバッチDataset

%%time
tr_ds = tf.data.Dataset.from_tensor_slices((tr_x,tr_y)).batch(tr_x.shape[0]).repeat(5)
for x,y in tr_ds:
    model.fit(x,y,batch_size=128)

結果

Train on 50000 samples
50000/50000 [==============================] - 9s 178us/sample - loss: 2.4252 - accuracy: 0.1054
Train on 50000 samples
50000/50000 [==============================] - 7s 134us/sample - loss: 2.1042 - accuracy: 0.2025
Train on 50000 samples
50000/50000 [==============================] - 7s 137us/sample - loss: 1.7758 - accuracy: 0.3369
Train on 50000 samples
50000/50000 [==============================] - 7s 134us/sample - loss: 1.5804 - accuracy: 0.4166
Train on 50000 samples
50000/50000 [==============================] - 7s 136us/sample - loss: 1.3802 - accuracy: 0.4969
CPU times: user 38.2 s, sys: 6.05 s, total: 44.2 s
Wall time: 39.6 s

あら、めっちゃ早いじゃないっすか！nvtopもこの通り

それ、tf.data.Dataset使う意味ある？

意味あります。なぜって・・・それはDataAugmentationに決まってるじゃないっすか！！
通常、フルバッチデータに個々にランダムなTransformをして、それをepoch分連続して出力なんて骨が折れる作業です。
でも、先日のAdventCalendarを思い出してください。こいつはそれがフルバッチでできるんです。素敵すぎませんか？

なら、速度検証だ！

やることは以下の2つです。

• random rotate
• random flip(h,v)

速度検証していきましょう。

ImageDataGeneratorでやる

データ確認

ImageDataGen

%%time
datagen = keras.preprocessing.image.ImageDataGenerator(
    horizontal_flip=True,
    vertical_flip=True,
    rotation_range=30,
)

labels = np.array([
    'airplane',
    'automobile',
    'bird',
    'cat',
    'deer',
    'dog',
    'frog',
    'horse',
    'ship',
    'truck'])
plt.figure(figsize=(10,10),facecolor="white")
for b_img,b_label in datagen.flow(tr_x,tr_y,batch_size=25):
    for i, img,label in zip(range(25),b_img,b_label):
        plt.subplot(5,5,i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(img)
        plt.xlabel(labels[label])
    break
plt.show()

速度検証

speedtest

%%time
datagen = keras.preprocessing.image.ImageDataGenerator(
    horizontal_flip=True,
    vertical_flip=True,
    rotation_range=30,
)
model.fit_generator(datagen.flow(tr_x, tr_y, batch_size=128),
                    steps_per_epoch=len(tr_x) / 128, epochs=5)

結果

Epoch 1/5
391/390 [==============================] - 18s 47ms/step - loss: 1.5626 - accuracy: 0.4296
Epoch 2/5
391/390 [==============================] - 18s 46ms/step - loss: 1.4149 - accuracy: 0.4894
Epoch 3/5
391/390 [==============================] - 18s 46ms/step - loss: 1.3278 - accuracy: 0.5236
Epoch 4/5
391/390 [==============================] - 18s 47ms/step - loss: 1.2493 - accuracy: 0.5516
Epoch 5/5
391/390 [==============================] - 18s 46ms/step - loss: 1.1884 - accuracy: 0.5787
CPU times: user 2min, sys: 4.74 s, total: 2min 5s
Wall time: 1min 30s

うーむ、遅いですね。

フルバッチtf.data.Datasetでやる

まずデータ確認をしましょう

データ確認

import tensorflow_addons as tfa
@tf.function
def rotate_tf(image,label):
    if image.shape.__len__() ==4:

        random_angles = tf.random.uniform(shape = (tf.shape(image)[0], ), minval = -30*np
        .pi / 180, maxval = 30*np.pi / 180)
    if image.shape.__len__() ==3:
        random_angles = tf.random.uniform(shape = (), minval = -30*np
        .pi / 180, maxval = 30*np.pi / 180)

    return tfa.image.rotate(image,random_angles),label

@tf.function
def flip_left_right(image,label):
    return tf.image.random_flip_left_right(image),label

@tf.function
def flip_up_down(image,label):
    return tf.image.random_flip_up_down(image),label

tr_ds = tf.data.Dataset.from_tensor_slices((tr_x,tr_y)).shuffle(40000)
tr_ds = tr_ds.batch(25).map(flip_up_down).map(flip_left_right).map(rotate_tf)

plt.figure(figsize=(10,10),facecolor="white")
for b_img,b_label in tr_ds:
    for i, img,label in zip(range(25),b_img,b_label):
        plt.subplot(5,5,i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(img)
        plt.xlabel(labels[label])
    break
plt.show()

うーん、なんか荒い？

これでフルバッチでやってみましょう。

速度検証

speedtest

tr_ds = tf.data.Dataset.from_tensor_slices((tr_x,tr_y)).shuffle(40000)
tr_ds = tr_ds.batch(tr_x.shape[0]).map(flip_up_down).map(flip_left_right).map(rotate_tf).repeat(5)

for img,label in tr_ds:
    model.fit(x=img,y=label,batch_size=128)

結果

Train on 50000 samples
50000/50000 [==============================] - 8s 153us/sample - loss: 2.3030 - accuracy: 0.1447
Train on 50000 samples
50000/50000 [==============================] - 7s 133us/sample - loss: 2.0370 - accuracy: 0.2188
Train on 50000 samples
50000/50000 [==============================] - 7s 133us/sample - loss: 1.8615 - accuracy: 0.2985
Train on 50000 samples
50000/50000 [==============================] - 7s 133us/sample - loss: 1.7357 - accuracy: 0.3570
Train on 50000 samples
50000/50000 [==============================] - 7s 133us/sample - loss: 1.6400 - accuracy: 0.3976
CPU times: user 1min 42s, sys: 15.8 s, total: 1min 58s
Wall time: 42.2 s

DataAugmentationしているのにも関わらず、このスピードが出てます。素晴らしい・・・

注意点

スピードの一番の要は、4Dイメージをバッチで一気に処理することによってオーバヘッドが減らせるっていうだけなので、
ImageDataGeneratorのようなバッチを排出するタイプだと遅いってことです。

おわりに

まとめると
- 一気にまとめると早いのでtf.data.Datasetはおすすめ
- だけど画像は荒いし、画像処理できるtf系はかなり限られている
- Augmentationの機能は今後に期待するしかない（自分が実装してTFAにプルリクしてもいいんですが...)

今後時間があれば、tf.data.Datasetに対応した画像処理系を作ろうかと思ってます。

追記

普通にこう書けばええんちゃう？

ImageDataGen

%%time
datagen = keras.preprocessing.image.ImageDataGenerator(
    horizontal_flip=True,
    vertical_flip=True,
    rotation_range=30,
)
for i,(x,y) in zip(range(5),datagen.flow(tr_x, tr_y, batch_size=tr_x.shape[0])):
    model.fit(x,y,batch_size=128,epochs=1)

確かに学習中は早いみたいです。

結果

Train on 50000 samples
50000/50000 [==============================] - 7s 132us/sample - loss: 0.9494 - accuracy: 0.6730
Train on 50000 samples
50000/50000 [==============================] - 7s 140us/sample - loss: 0.9275 - accuracy: 0.6797
Train on 50000 samples
50000/50000 [==============================] - 7s 132us/sample - loss: 0.9019 - accuracy: 0.6894
Train on 50000 samples
50000/50000 [==============================] - 7s 132us/sample - loss: 0.8842 - accuracy: 0.6968
Train on 50000 samples
50000/50000 [==============================] - 7s 132us/sample - loss: 0.8769 - accuracy: 0.6957
CPU times: user 1min 20s, sys: 4.96 s, total: 1min 25s
Wall time: 1min 24s

でも、Wall Time(実際にかかった時間)をみると遅いんですよこれが。
毎回Batchごとに負荷が1CPUにかかってしまっていて、ボトルネックになっている関係で重いです。
同じ処理でもtf.data.Datasetの方が早かったりします。

setup.py, argparse, GitHub Actions あたりの技術を学ぶのに、Python でコマンドラインアプリを作ると良さそうだと思ったのでやってみました。ここでは個々の技術を詳しく解説しないので、記事中で紹介する公式ドキュメントや解説記事を参照してください。

成果物

To-Do リストアプリ を作りました。と言っても、

todo add "ほげ"
todo complete "ほげ"
todo remove "ほげ"

などで To-Do を追加、完了、削除するだけのものです。また、

todo complete --all
todo remove -a

で全て完了や全て削除ができます。To-Do リストは ~/.todo.json に保存され、

$ todo show
□ ほげ
☑ ほげほげ

のように表示できます。

コマンドラインインターフェイスの作成

argparse を使ってコマンドライン引数の処理を定義します。

• argparse --- コマンドラインオプション、引数、サブコマンドのパーサー — Python 3.8.0 ドキュメント
• ArgumentParserの使い方を簡単にまとめた - Qiita

argparse は機能が多過ぎて把握しきれないですが、今回使ったのは以下です。コード全体はこちら。

parser = argparse.ArgumentParser()

# git commit とか docker run などの commit や run のようなもの
# をサブコマンドと名付けて追加
parser.add_argument('subcommand', help='add, complete, or remove')

# サブコマンドより後ろに来る引数を content とする。
# nargs は引数の数で、1つの場合は nargs=1
# nagrgs='*' とすると0以上の可変長引数になる
# nargs='+' は1以上の可変長引数
# nargs='?' は0または1個
# https://docs.python.org/ja/3/library/argparse.html#nargs
parser.add_argument('content', help='Content of To-Do', nargs='?')

# --all オプション (短縮形 -a) を追加
# 引数を取るオプションではなく、フラグなので、`store_true=True` を指定
parser.add_argument('-a', '--all', action='store_true', help='remove or complete all To-Dos')

なお、サブコマンドが show のときや、remove --all などのときは引数 'content' は必要ないのですが、指定できてしまいます。指定できないように argparse で書く方法が分からなかったため、引数が指定されても内部で無視するようにしています。

これを用いて、指定された引数に応じた処理を呼び出せば良いです（処理については特筆すべき知見はないのでソースコード参照）。

パッケージ化

setup.py を書いてコマンドラインアプリを自動でインストールされるようにします。

• 2. setup スクリプトを書く — Python 3.8.0 ドキュメント
• （インターン向けに書いた）Pythonパッケージを作る方法 - Qiita

書いた setup.py はこちらにあります (書き方は pip や numpy のものを参考にしました) が、この中で肝心なのは以下の部分かと思います。

    entry_points={
        "console_scripts": [
            "todo=todo.main:main"
        ]
    },

このようにすることで、python3 setup.py install したときに OS の PATH にコマンドがインストールされます。私の環境では以下のようになりました¹。

$ which todo
/home/linuxbrew/.linuxbrew/bin/todo

 $ cat $(which todo)
#!/home/linuxbrew/.linuxbrew/opt/python/bin/python3.7
# EASY-INSTALL-ENTRY-SCRIPT: 'todo==0.1.0','console_scripts','todo'
__requires__ = 'todo==0.1.0'
import re
import sys
from pkg_resources import load_entry_point

if __name__ == '__main__':
    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
    sys.exit(
        load_entry_point('todo==0.1.0', 'console_scripts', 'todo')()
    )

これで、どのディレクトリにいようとも、ターミナルで todo と叩くと todo パッケージの main モジュール内の main という関数が呼ばれて、書いた処理が実行されます。

pip でインストール

先程は setup.py を実行してインストールしましたが、以下のように pip を用いて Git リポジトリからもインストールできます。汎用性のあるものコマンド、パッケージであれば PyPI に登録するのも良いでしょう。

pip3 install git+https://github.com/pn11/python-command-line-sample

GitHub Actions を用いた自動テスト

いつの間にか² GitHub に追加されていた Actions というのを使ってみたいと思ったのが本記事執筆のきっかけです³。今回は無難に自動テストをしてみます。

とりあえず、ToDo リストを全部消してから追加するだけのクソみたいなテストを書きました。

import todo.main

def test_add():
    todo.main._remove_todo('', all_flag=True)
    todo.main._add_todo('foo')
    dic = todo.main._load_todos()
    assert dic['foo'] == 'Not Yet'

これを GitHub Actions を使って nose で実行してみたいと思います。

Action 用 YAML 作成

リポジトリの Actions のタブに行くと、以下のような画面になるので、とりあえず Python package でやってみます。

以下のような画面になるので、何も考えずとりあえず Start Commit を押してみます。

テストに失敗します。

YAML を見てみると以下のようになっています。

name: Python package

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      max-parallel: 4
      matrix:
        python-version: [2.7, 3.5, 3.6, 3.7]

    steps:
    - uses: actions/checkout@v1
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v1
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Lint with flake8
      run: |
        pip install flake8
        # stop the build if there are Python syntax errors or undefined names
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
    - name: Test with pytest
      run: |
        pip install pytest
        pytest

何となく、steps: 以下の

- name: やること
  run: |
  コマンド1
  コマンド2 

みたいなところをいじれば良さそうです。ということで、以下のような処理を書きました。

    - name: Install Package
      run: |
        python setup.py install
    - name: Test with nose
      run: |
        pip install nose
        nosetests

setup.py で To-Do のパッケージをインストールした後、nose もインストールしてテストを実行します。

これをコミットすると無事にテストが通りました。実行ディレクトリとかは特に意識しませんでしたが、リポジトリのルートで実行されているようです。また、何となく nose を使いましたが、特にライブラリに依存したテストではないので元のまま pytest でも動くはず？

今後はコミットする度にテストが走ります。テストに通ると マークがついて良い感じです。

まとめ

以上、argparse でコマンド作成、setup.py でパッケージ化、GitHub Actions で自動テストをやってみました。今後はこの方法でクソコマンドを量産していきたい所存です。

その他

この記事では取り上げませんでしたが、コマンドラインツール作成の際には argparse 以外にも、click 等を使うのも良いかも知れません。

• Clickで手軽にPythonのコンソールアプリケーションを作る - Qiita
• Awesome Python：素晴らしい Python フレームワーク・ライブラリ・ソフトウェア・リソースの数々 - Qiita

---

1. Linuxbrew で入れた Python を使用しています。 ↩

2. ［速報］GitHub Actionsが正式版に。GitHub内でビルド／テスト／デプロイなど実行、CI/CDを実現。GitHub Universe 2019 － Publickey ↩

3. MS に買収されてからどんどん新機能が追加されていてしゅごい。。 ↩

Groupbyしたgroupに関して条件抽出したい。

Pythonでgroupbyしたgroupの中から条件を満たすgroupの要素を全て取得する方法を解説する。

例えば、以下のデータがあり、最高スコアが80以上だった場合その人のデータを全て取得するということを目指すとする。

import pandas as pd
import numpy as np

df = pd.DataFrame({"name":["Yamada","Yamada","Yamada","Suzuki","Suzuki","Hayashi"],
                   "score":[60,70,80,60,70,80]})
print(df)

#       name  score
# 0   Yamada     60
# 1   Yamada     70
# 2   Yamada     80
# 3   Suzuki     60
# 4   Suzuki     70
# 5  Hayashi     80

この時、groupbyをしたgroupごとに条件を満たすキーを取得して、そのキーに元々のデータフレームを左外部結合すれば良い。
具体的には、以下のコードとなる。

group_df = df.groupby('name').max().reset_index()
key = group_df[group_df['score'] >= 80]['name']
new_df = pd.merge(key, df, on = 'name', how = 'left')
print(new_df)

#       name  score
# 0  Hayashi     80
# 1   Yamada     60
# 2   Yamada     70
# 3   Yamada     80

組み込み関数で条件抽出ができない場合

場合によってはGroupに対する条件が複雑で.max()のような組み込み関数では表現ができない場合がある。その場合はラムダ式で条件を書くこともできる。

ここではgroupの長さが2以上のgroupを全て抽出することを目指す。（この操作は、組み込み関数.count()で実現することができるが、例示のためラムダ式表記とした。）

group_df = df.groupby('name').apply(lambda x: len(x)).reset_index().rename(columns = {0:'length'})
key = group_df[group_df['length'] >= 2]['name']
new_df = pd.merge(key, df, on = 'name', how = 'left')
print(new_df)

#      name  score
# 0  Suzuki     60
# 1  Suzuki     70
# 2  Yamada     60
# 3  Yamada     70
# 4  Yamada     80

ポイントとして、ラムダ式表記の時、ラムダ式の結果が出力される列が0となるので、適当な名前（ここでは'length'）にリネームしている。

条件を満たすキーを取り出し、そこからgroupbyの操作で消してしまったスコアの情報を復元するために、左外部結合をするという一連の流れを私は頭に描けず苦戦したため、ここに残しておきます。。。

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

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

Go

package main

import "fmt"

func template(x,y,z string) string {
    return fmt.Sprintf("%s時の%sは%s",x,y,z)
}

func main() {
    fmt.Println(template("12","気温","22.4"))
}

python

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

def template(x,y,z):
    return '{0}時の{1}は{2}'.format(x,y,z)

print template(12,"気温",22.4)

Javascript

function template(x,y,z) {
    return "x時のyはz".replace("x",x).replace("y",y).replace("z",z);
}

console.log(template(12,"気温",22.4));

まとめ

これは、こんなでいいのかしら？。

トップ

Pythonは、初めてのプログラミングではない。以前（高校生のころだから15年くらい前）少しだけVisual C#を使ったことがある。数文字打つだけでコードが補完されたりして便利だったけど、数ある機能の上澄みしか使っていないなという印象があった。
また、大学時代には数値計算の初歩の初歩を学ぶ授業でFortranを学んだこともあった。miで正しいのか正しくないのかよくわからないコードを書いて、コマンドプロンプトからコンパイルしてエラーを食らったりしていた。なんとも見通しが悪かった。

PythonにはJupyter Notebookという強力なエディタがある（語弊がありそう）。起動も簡単で、コマンドプロンプトでJupyter notebookと打ち込むだけだ！前回覚えた表記を使うと↓こういうこと

$ Jupyter notebook

そうするとブラウザでJupyter notebookが起動する。なんとこのエディタはブラウザ上で動く。

こんなかんじ。右上のNewからPython3をクリックすると、そこにはもうプログラムを書く枠が表示されていた。

こちょこちょとプログラムを書いて（書き方は適当に検索した）、Cellの下付近にある再生ボタン的なやつを押すと、書いたコードのすぐ下に文字列が表示された。

今回はここまで。

初投稿です

自己紹介

tax_freeです。
普段はhatenaで参加した勉強会とかを書いています。
学校の期末テストと記事の日が被って苦しい
高校一年生です

環境

自分の開発環境

• Mac OS Catalina 10.15.1
• Python 3.7.4

モチベーション

今は高校生なのですが、大学では量子コンピューティングの研究をしたいと考えていたら、今回のアドベントカレンダーを見つけたので参加しました。

タイトルにも書いているように超絶初心者なので、間違えていたりしたら教えてください!
量子コンピュータについての知識はネットの初心者向け記事くらいのレベルです。

Qiskitとは

Qiskitは、量子コンピュータ用のオープンソースのフレームワークである。量子回路（英語版）を作成し、プロトタイプの量子デバイスやシミュレーション上で実行するためのツールを提供する。量子チューニングマシン（英語版）の量子回路（英語版）に対応しており、これに従う量子ハードウェアに使用することができる。(wikipediaより)

なぜQiskitなのか

私が知っているPythonで動く量子コンピューティング関連のライブラリは、QiskitとQgateの二つでした。最初は、Qgateを使おうと思っていた(PyConJPで聞いた)のですが、私の環境では、CUDA関係でうまく使うことができなかったので、代りにQiskitを使いました。
また、QiskitはIBMQを使えるのも選んだ理由です。
Qgateは分かりませんが、QiskitはJupyter notebookをサポートしています。

準備

前置きはこれくらいにして、準備をしていきます。
まずは、Qiskitをインストールします。適当な環境を作って

pip install qiskit

で、インストールできます。詳しくは公式ドキュメントを見てださい。 丸投げ

また、IBMQのアカウントを作っておくと後からクラウドに接続する時に、楽です。

実装

まず、sample.pyファイルを作って

import qiskit

print(2)

です!!!!!!!!!!
簡単に書けますよね。
あとは、

python3 sample.py

を実行すれば

2

返ってきます。 1+1の結果は2なので、正解ですね。

まとめ

いかがでしたか?
量子コンピュータと聞くと難しく感じますが、簡単に書くことができましたね。ニッコリ

茶番終了

盛大な茶番で、すみませんでした。後悔はしていない

本番開始

上に書いたようにQiskitをインストールします。

実装

適当な環境を作ります。今回は、Jupyter notebookを使います。ほとんど、公式チュートリアルなので、我慢できなかったら、こっちを見て癒されてください。

1. 最初に必要なライブラリをimportします。

from qiskit import IBMQ #IBMQに接続するため
from qiskit.tools.monitor import backend_overview
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.qasm import pi
from qiskit.tools.visualization import plot_histogram, circuit_drawer
from qiskit.providers.ibmq import least_busy
import numpy as np

2.IBMQアカウントを登録して、アカウントをロードします。ここでwarningが出ましたが無視します。

IBMQ.save_account('IBMQのtoken')
provider = IBMQ.load_account()

3.回路を登録していきます。

q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)

これで、2個ずつ量子ビットと2個の古典ビットを登録しました。
なんで量子ビットだけじゃないのと思ったかもしれませんが、この古典ビットに量子ビットの計算結果を保存します。

4.ゲートを追加します

qc.h(q[0])
qc.cx(q[0],q[1])

これで、HゲートとCxゲートを回路に追加できます。
簡単に二つのゲートを説明します。
Hゲートは量子ビットを重ね合せ状態にして、
CxゲートはNOT回路みたいなもので、エンタングルさせます。

qc.measure(q[0], c[0])
qc.measure(q[1], c[1])

measureはとても大切で、3で書いたようにn番目の量子ビットの状態をn番目の古典ビットに保存します。
ここまで書いたら、

qc.draw()

を使って回路を見てみましょう。しっかり、ゲートが適用されているはずです。

5.最適なBackendを選択
ここは完全に他の人のコピペです。許して

large_enough_devices = IBMQ.backends(filters=lambda x: x.configuration().n_qubits > 3 \
                                     and not x.configuration().simulator)
backend = least_busy(large_enough_devices)
print("The best backend is " + backend.name())

実際に最適なbackendが表示されるはずです。

6.実際にjobを投げる

backends = ['xxxxx','xxxx','least_busyだったbackend']
backend_q = IBMQ.get_backend(backend[1])
result = execute(qc,backend_q,shots='1024').result()

backendsで複数個のbackendを設定して、backend_qのbackend[n]で要素を指定しています。
executeでjobを投げています。shotsは何回計算させるかで、数を大きくすると結構時間がかかります。最大で4096だったような。

7.結果を見る
最後に結果を確認します。

print(result.get_counts(qc))
plot_histogram(result.get_counts(qc))

これで、確認することができます。
plot_histogramがあると視覚化できるので良い!
ここで、おもしろいのが理論的には得られない計算結果が入っていることで、これはノイズが原因なんだそう。

まとめ

量子コンピュータを使うためには、もっと数学をガリガリする必要があると思っていたけど意外と簡単だった。
とりあえず、手を動かしてみることは大切だと思った。
来年のカレンダーでは数式の説明ができるように一年勉強します。

はじめに

近畿大学 Advent Calendar 2019の5日目担当のniyaです.
今回は, 近畿大学で毎年行われている生駒祭を紹介するゲームをRen'pyで作ったので, その時に覚えた文法等共有できたらなあと思います.

成果物は以下のurlにあります.
https://drive.google.com/drive/u/2/folders/1CVx17S12MDS8VLIsH4Q2Iu4C5U93vYC_

また, githubは以下です.
https://github.com/niya1123/Short-Novel/tree/dev

Ren'pyのゲーム作りの基礎

今回はRen'py自体のDLとプロジェクトの作り方などは前回の記事で紹介しているので, そちらの方を見ていってください.

セリフの書き方

セリフの書くには以下の手順を踏めば良いでしょう.

1. キャラクターのセリフなのか独白やナレーションなのかを考える.
2. 前者ならキャラクターを定義する. 後者は特に定義する必要なし.
3. script.pyにその定義を書き込む.

具体的には以下のようになります.

script.rpy

# キャラクターの定義 define キャラ名 = Character("キャラ名", color="カラーを16進数で設定")
# define直後のキャラ名は基本的には1文字やキャラ名の短縮名で定義することをお勧めする.
# colorはテキストボックスに表示されるキャラ名の色.
define character = Character("キャラクター", color="#c8ffc8")

# ゲーム起動時はlabel startから始まる.
label start:
    # キャラの短縮名 "セリフ"でセリフの表示
    character "こんにちは！"

    # キャラ名を設定しないと, ナレーション.
    "ナレーションですこんにちは"

    # returnでlabelの終了.
    return

キャラクター画像の設定

キャラクター画像の設定は以下のように行います.

script.rpy

# 略
label start:

    show character default
    with fade

    character "こんにちは！"

    return

ここで注意すべきはshow以降の文字列です.ここでは任意の画像のファイル名を指定することで画像を表示します.

そして, 画像の名前には推奨される命名規則があり, 例えばbg green.jpg (Bg Green.jpgでも可)のように"bg"がタグ, "green"が属性という風になっています.他に以下のような命名が考えられます.

script.rpy

# bgがタグでgreenとhouseが属性
show bg green house

また, 同じタグの画像が同時に指定された場合一番最後に指定された画像が表示されます.

次にwith fadeとありますがこれはトランジションというものです.

詳細は以下を参考にしてください(数が多いので).

https://ja.renpy.org/doc/html/quickstart.html#transitions

pythonスクリプトの使用

Ren'pyではpythonのスクリプト(python2系)が使用することができます. まだ正式に発表されていませんが今後は3系のpythonが利用できる可能性はあります.(参考: https://twitter.com/renpytom/status/1196203607252709376?s=20)

では, 使い方を説明していきます.

script.rpy

default flag = False

label start:

    menu:
        "想いを伝えますか?"
        "はい":
            $ flag = True
        "いいえ":
    jump flag
    return

label flag:
    if not flag:
        "Bad End"
    else:
        "Good End"

    return

色々新しい要素が出てきましたね. 順番に説明します.

まず, default文がありますがこれはstartラベルの前に使いたい変数を初期化するためのものです.
なくてもいいですが, その場合label内で変数を用いるとFlaseが初期値として自動的に付与されます.

次にstartラベル内のmenuというものがあります.

script.rpy

略
    menu:
        "選択肢を選んでね"
        "はい":
            jump yes
        "いいえ":
            jump no

使い方はこのような感じで,ナレーション部分はなくてもいいです."選択肢":という風に記述していきます.その後インデントして処理を書くことができます.この辺りはpythonと同じです.jumpはjump 飛ばしたいラベル名という風に設定できてその飛びたいラベルに処理が飛び, そのラベルがreturnで終了するとまた処理が戻ってきます.

次に$ flag = True ですが, $以降に１行のみでpythonのコードが書けます.
複数行にわたってコードを書きたい場合は次のように書けます.

script.rpy

python:
    life = 100
    damage = 50
    my_life = life - damage

次にif文ですが, if文は$やpythonを用いずにそのまま使用することができます.

以上の基礎を押さえておけば, 皆さんもRen'pyを用いてノベルゲームが作れます!!!!

Ren'pyのゲーム作り応用

ここからはちょっとした応用です.

まずはRen'pyのデフォルトの起動画面を変更しましょう.

デフォルトの画面はこんな感じです.

右下の青文字のtestをRen'pyにして色をオレンジ色(#f59e11)にしてみましょう.

変更する点は以下です.

options.rpy(16行目あたり)

define config.name = _("test")
# これを以下に変更
define config.name = _("Ren'py")

gui.rpy(28行目あたり)

define gui.accent_color = '#0099cc'
# これを以下に変更
define gui.accent_color = '#f59e11'

続いてmenuの画像を変更します.

gui.rpy(96行目あたり)

define gui.main_menu_background = "gui/main_menu.png"
# これを以下に変更
define gui.main_menu_background = "gui/main_susuki.png"

変更したらこうなります.(今回は画像サイズ合ってないけど本番は画像の方をゲームのサイズに合わせましょう)

最後に

正直色々端折ったのですが基本的にここまで理解していれば, 自分の作った成果物くらいは作れると思います.
皆さんも是非Ren'pyで何か作ってみてください！

参考サイト

https://ja.renpy.org/doc/html/index.html

Kintone初心者アドベントカレンダー四日目です。

ごめんなさい。昨日だったのをつい忘れてしまいました。

あぁ、やってしまった〜。
って感じです。
今日に四日目をかいてしまっています。
申し訳ございません。
よくハマりがちな罠についてかいていきたいと思います。

なぜこのテーマなのか。

実はヒーローズリーグ大垣Pythonハッカソンで実はこの問題にハマりました。
それはAPIトークンとURLの場所を間違え実装してしまう。
これが一番の罠です。
Kintoneは実際言うとアプリを作るフレームワークに近いということを最初に認識していないといけません。
実際Pythonで今回は実装したのですが一番簡単なのはNode.jsです。
Python縛りがあったため自分は前職のC#の職場が実は本業はPythonなので学んでいたおかげでスイスイと組めました。
ですがここで間違えたのがAPIキーの場所です。
@RyBBさんも指摘していますが。
皆さん急ぐと間違えてしまいます。

kintone_output.py

#ここまでは順調です。
#ここからが問題です。
#何処を見るのでしょうか。
#APIトークンのCurlが書かれている後ろのURLです。
URL = 
#APIトークンもよく間違えます。
#注意が必要です。
#自分もNode.jsで教えていただいたときに間違えました。
#APIトークンの部分をコピーするのですよ。
API_TOKEN = 

#此処から先は通常コードで問題ないです。
#上の2つを間違えると痛い目見ます。
def get_kintone(url, api_token):
    "kintoneのレコードを全件取得する関数"
    headers = {"X-Cybozu-API-Token": api_token}
    resp = requests.get(url, headers=headers)
    return resp

if __name__ == "__main__":
    RESP = get_kintone(URL, API_TOKEN)

    print(RESP.text)

nodejs：kintone.js

const kintone = require('@kintone/kintone-js-sdk');
//ここですよ。
//気をつけてください。
//自分もハマりました。
const domainName = 'SUB_DOMAIN.cybozu.com'; // Your kintone URL
//ここですよ。
//気をつけてください。
const APIToken = 'YOUR_API_TOKEN'; // Your API Token
const appId = ○○; // AppID
const record = {
  text: {
    value: '追加したいテキスト'
  }
};

// Connection
const kintoneAuth = new kintone.Auth();
kintoneAuth.setApiToken({apiToken: APIToken});
const kintoneConnection = new kintone.Connection({domain: domainName, auth: kintoneAuth});

const kintoneRecord = new kintone.Record({connection: kintoneConnection});

// Add Record
kintoneRecord.addRecord({app: appId, record: record}).then((rsp) => {
  console.log(rsp);
}).catch((err) => {
  console.log(err.get());
});

この二点を気をつければハッカソンでKintoneは無敵の武器になります。
下手にデータベースをいじるより楽になります。
みんなクラウドに走りがちですが自分の場合だったらハッカソンは断然Kintoneです。
ハッカソンの地図系マッシュアップにも無敵です。

うーん。
来年もハッカソンではKinetone使います。
@RyBBさん。

前書き

3日前に、Django3.0正式にリリースされました。
リリースノードリンク
沢山変更点がある中で、ASGIのサポートが追加されたことに非常に興味あります、
実際使ってみたいと思うます。

補足:ASGIは何でしょう?

ASGI（非同期サーバーゲートウェイインターフェイス）は、WSGIの精神的な後継者であり、非同期対応のPython Webサーバー、フレームワーク、およびアプリケーション間の標準インターフェイスを提供することを目的としています。

WSGIが同期Pythonアプリの標準を提供したのに対し、ASGIは、WSGIの下位互換性の実装と複数のサーバーとアプリケーションフレームワークを備えた非同期アプリと同期アプリの両方を提供します。

ドキュメントリンク

新規プロジェクト

テスト用の仮想環境を作ります

 mkvirtualenv django3.0

Djangoをインストールします

 pip3 install django

インストール終了後、Django3.0入ってることを確認します

(django3.0) ~ $ pip3 list
Package    Version
---------- -------
asgiref    3.2.3  
Django     3.0    
pip        19.3.1 
pytz       2019.3 
setuptools 42.0.2 
sqlparse   0.3.0  
wheel      0.33.6

適当に新規プロジェクトを作って、サーバーを立ち上げて見ましょう

mkdir django-test
&&
django-admin startproject newtest
&&
cd newtest/
&&
python3 manage.py runserver

8000番にアクセスしてみよう、馴染みのロケットが確認できます。

ここまでは ヨシッ!

公式ドキュメント見てみよう

How to deploy with ASGI¶
As well as WSGI, Django also supports deploying on ASGI, the emerging Python standard for asynchronous web servers and applications.

Django’s startproject management command sets up a default ASGI configuration for you, which you can tweak as needed for your project, and direct any ASGI-compliant application server to use.

Django includes getting-started documentation for the following ASGI servers:

How to use Django with Daphne
How to use Django with Uvicorn
The application object¶
Like WSGI, ASGI has you supply an application callable which the application server uses to communicate with your code. It’s commonly provided as an object named application in a Python module accessible to the server.

The startproject command creates a file <project_name>/asgi.py that contains such an application callable.

It’s not used by the development server (runserver), but can be used by any ASGI server either in development or in production.

ASGI servers usually take the path to the application callable as a string; for most Django projects, this will look like myproject.asgi:application.

Warning

While Django’s default ASGI handler will run all your code in a synchronous thread, if you choose to run your own async handler you must be aware of async-safety.

Do not call blocking synchronous functions or libraries in any async code. Django prevents you from doing this with the parts of Django that are not async-safe, but the same may not be true of third-party apps or Python libraries.

Configuring the settings module¶
When the ASGI server loads your application, Django needs to import the settings module — that’s where your entire application is defined.

Django uses the DJANGO_SETTINGS_MODULE environment variable to locate the appropriate settings module. It must contain the dotted path to the settings module. You can use a different value for development and production; it all depends on how you organize your settings.

If this variable isn’t set, the default asgi.py sets it to mysite.settings, where mysite is the name of your project.

Applying ASGI middleware¶
To apply ASGI middleware, or to embed Django in another ASGI application, you can wrap Django’s application object in the asgi.py file. For example:

from some_asgi_library import AmazingMiddleware
application = AmazingMiddleware(application)

リンク

ざっくりまとめると

• python manage.py runserverでサーバー起動してはいけない、いつものwsgiのサーバー起動することになります。
• サーバー起動時にDaphneかUvicorn使用することお勧めします。

Daphneは何なのか、公式のリンク開いて見てみよう リンク

How to use Django with Daphne¶
Daphne is a pure-Python ASGI server for UNIX, maintained by members of the Django project. It acts as the reference server for ASGI.

Installing Daphne¶
You can install Daphne with pip:

python -m pip install daphne
Running Django in Daphne¶
When Daphne is installed, a daphne command is available which starts the Daphne server process. At its simplest, Daphne needs to be called with the location of a module containing an ASGI application object, followed by what the application is called (separated by a colon).

For a typical Django project, invoking Daphne would look like:

daphne myproject.asgi:application
This will start one process listening on 127.0.0.1:8000. It requires that your project be on the Python path; to ensure that run this command from the same directory as your manage.py file.

訳すと
- pip で daphneをインストール
- daphne myproject.asgi:applicationを実行して、ASGIサーバー起動
- 127.0.0.1:8000へアクセス

やってみよう

ASGIサーバー起動

daphneインストール

 pip3 install daphne

daphne [プロジェクト名].asgi:application

8000番アクセスしたら、またロケット見れました、文字少し変わってますが。

WebSocketテスト

　ブラウザ開いて、websocketメッセージ送ってみようと思います。

500が返ってきました、エラーメッセージは以下になります。

2019-12-05 11:02:09,533 ERROR    Exception inside application: Django can only handle ASGI/HTTP connections, not websocket.
  File "/Envs/django3.0/lib/python3.7/site-packages/daphne/cli.py", line 30, in asgi
    await self.app(scope, receive, send)
  File "/Envs/django3.0/lib/python3.7/site-packages/django/core/handlers/asgi.py", line 146, in __call__
    % scope['type']
  Django can only handle ASGI/HTTP connections, not websocket.

asgi.pyの146行に何かありそうですね、見てみましょう。

asgi.py

 async def __call__(self, scope, receive, send):
        """
        Async entrypoint - parses the request and hands off to get_response.
        """
        # Serve only HTTP connections.
        # FIXME: Allow to override this.
        if scope['type'] != 'http':
            raise ValueError(
                'Django can only handle ASGI/HTTP connections, not %s.'
                % scope['type']
            )
        # Receive the HTTP request body as a stream object.
        try:
            body_file = await self.read_body(receive)
        except RequestAborted:
            return
        # Request is complete and can be served.
        set_script_prefix(self.get_script_prefix(scope))

以下の二行コメントに注目してください。

 # Serve only HTTP connections.
 # FIXME: Allow to override this.

現時点でhttp通信のみを許可しています。 必要に応じてご自身で直してください!

最後

推測としては以下の原因が考えられます。

• 多分私はDjangoのことまたわかっていない
• Websocketではなくて、他の手段でASGI通信を実現している
• ASGIの完全サポートはこれから

現在のDjango3.0、もしwebsocket使用したければ、django-channelパッケージ使用することをお勧めします。

　Blenderを使って、FBXデータから頂点座標のみを抜き出し配列化するスクリプトを作成したので、解説がてら紹介します。

Blenderのデータ構造

　まずは見慣れたこの図（初期状態）について。

　さて、Blenderの3Dビューは以下のような形で管理されています。

　Pythonスクリプトで言うと

bpy.context.scene.collection

　にあたるところです。

　GUIでいうとここですね。

　大元にシーン　→　コレクションがあり、コレクションの中にオブジェクトがあります。シーンとコレクションの違いはよくわかりません。ただ、オブジェクト（いわゆるキューブやカメラ等）はデータとして存在するものを、リンクという紐づけによってコレクションに呼んでいます。つまり、ビューに現れるのはリンクされたオブジェクトだけで、見えなくともデータとして存在するオブジェクトもありえる、ということです。こうすることで同じデータを使いまわせたりするようです。操作する方としてはややこしいですけど。

　そしてオブジェクトと同様に、それに付随するメッシュやマテリアルにもデータリストがあって、それをリンクすることによって必要な分だけ使う、ということになります。

　例えばここで、

bpy.data.objects.new("hoge", bpy.data.meshes.new("fuga"))

　という命令をすると、見かけ上のシーンには何も変化が起きませんが、

for i in bpy.data.objects:
    print(i)

　で、

Output

<bpy_struct, Object("Camera")>
<bpy_struct, Object("Cube")>
<bpy_struct, Object("hoge")>
<bpy_struct, Object("Light")>

　が返ってくるので、hogeという謎のオブジェクトが追加されていることがわかります。また、

bpy.data.objects['hoge'].to_mesh()

　で、

Output

bpy.data.meshes['fuga']

　と返ってくるので、このオブジェクトはfugaというメッシュにリンクされていることがわかります。もちろんこれはただ名前をつけただけの空データですので、今ここでhogeをコレクションにリンクしても、何も頂点を持たない名前だけの無が召喚されます。

　メッシュについて詳しく見ています。メッシュの頂点情報は以下のような形で管理されています。

　オブジェクトがメッシュをリンクしています。

　GUIでいうとここですね。

　メッシュデータが更に頂点データを格納しているので、頂点の情報が欲しい場合はそこにアクセスすることになります。今度はちゃんと形のあるキューブを対象にやっていきましょう。

bpy.data.objects['Cube'].to_mesh().vertices

　これは上の絵をほぼそのままなぞったものです。

Output

bpy.data.meshes['Cube'].vertices

　この中身を見ていくと、

for i in bpy.data.meshes['Cube'].vertices:
    print(i)

Output

<bpy_struct, MeshVertex at 0x0000024A9FA28038>
<bpy_struct, MeshVertex at 0x0000024A9FA2804C>
<bpy_struct, MeshVertex at 0x0000024A9FA28060>
<bpy_struct, MeshVertex at 0x0000024A9FA28074>
<bpy_struct, MeshVertex at 0x0000024A9FA28088>
<bpy_struct, MeshVertex at 0x0000024A9FA2809C>
<bpy_struct, MeshVertex at 0x0000024A9FA280B0>
<bpy_struct, MeshVertex at 0x0000024A9FA280C4>

　とひたすらバイナリデータを返されます。ちゃんと8個あるのでキューブで間違いなさそうですが、できれば数値を返してほしいところです。リファレンスを見るとcoという属性で数値が得られることがわかります。

for i in bpy.data.meshes['Cube'].vertices:
    print(i.co)

Output

<Vector (1.0000, 1.0000, 1.0000)>
<Vector (1.0000, 1.0000, -1.0000)>
<Vector (1.0000, -1.0000, 1.0000)>
<Vector (1.0000, -1.0000, -1.0000)>
<Vector (-1.0000, 1.0000, 1.0000)>
<Vector (-1.0000, 1.0000, -1.0000)>
<Vector (-1.0000, -1.0000, 1.0000)>
<Vector (-1.0000, -1.0000, -1.0000)>

　これでやっと頂点座標の配列が得られました。

fbxに適用

　インポートしたfbxについても同じことをやっていきます。

　原理的には、すべてのメッシュデータに対して頂点を取り出せば上と同じ形が得られるはずです。

for i in bpy.data.meshes:
    print(i)

Output

<bpy_struct, Mesh("Cube")>
<bpy_struct, Mesh("Mesh")>
<bpy_struct, Mesh("Mesh.001")>
<bpy_struct, Mesh("Mesh.002")>
<bpy_struct, Mesh("Mesh.003")>
<bpy_struct, Mesh("Mesh.004")>
<bpy_struct, Mesh("Mesh.005")>
<bpy_struct, Mesh("Mesh.006")>
<bpy_struct, Mesh("Mesh.007")>

　……。謎のCubeがあります。
　そう、Blenderを立ち上げた時に最初に存在するキューブ。あれはシーンから削除（正確にはアンリンク）しても中のデータは消えないのです。このままではキューブの頂点まで拾ってしまいます。消えてもらいましょう。

bpy.data.meshes.remove(bpy.data.meshes['Cube'])
for i in bpy.data.meshes:
    print(i)

Output

<bpy_struct, Mesh("Mesh")>
<bpy_struct, Mesh("Mesh.001")>
<bpy_struct, Mesh("Mesh.002")>
<bpy_struct, Mesh("Mesh.003")>
<bpy_struct, Mesh("Mesh.004")>
<bpy_struct, Mesh("Mesh.005")>
<bpy_struct, Mesh("Mesh.006")>
<bpy_struct, Mesh("Mesh.007")>

　
　消えました。
　後はこれらのメッシュデータすべてに対し頂点座標を抽出するようなスクリプトを書きます。

import bpy
import numpy as np

vts = []

for m in bpy.data.meshes:
    for v in m.vertices:
        vts.append(v.co)

vts = np.array(vts)

　coで得られる数字がVectorという型なので、扱いやすくするためnp.arrayで変換しています。

　ここで得られた配列が、本当に元の形を表しているのかを検証します。頂点が3次元情報を正確に保持しているなら、単に散布図にするだけで元の形を表してくれるはずです。

　先ほど得られた配列vtsを

np.savetxt(r'任意のパス\vts.txt', vts)

　でエクスポートします。別のPythonファイルで（Blenderの内蔵Pythonにはmatplotlibがないため……）散布図を描画します。

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

data = np.loadtxt('vts.txt')

X = data[:,0]
Y = data[:,1]
Z = data[:,2]

fig = plt.figure()
ax = Axes3D(fig)
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.plot(X,Y,Z,marker="o",linestyle='None',ms=0.2)

plt.show()

　元の3Dデータの頂点を正確に配列化できていることがわかりました。

0.1 + 0.2 = 0.30000000000000004!? ②

プロローグ: 研究動機

1

書いた日: 2019:11/21

2018/??/?? 夏? 忘れた

Pythonを習ったので、いつものように放課後にコンピュータ室で、Pythonをやっていた。

Pythonを開いて、えーと...んーと?

なんだっけ

なんかのプログラムを書いてた

なんか思った通りに動かなくて、print()を使ってデバックしたら、誤差が出て、、、

1年前のことなんて覚えてないよ!

んんんんんんん

ちょっと待って、もしかしたら...

あ、あれ???やっぱり捨てちゃったかな

あ、奇跡にあった!!!

月日: 2018/9/10 (第1章まで約1年)

その時のコードがこちら(空白含めて原文ママ)

def longmi(A):
  count=0
  while True:
    A*=10
    count+=1
    print(A)
    if A % 10==0:
      break
  A/=10
  count-=1
  return count

longmi(0.111)

おそらく代入した小数の小数点の位置(?)を調べる関数と思われる

<結果>

1.11
11.100000000000001
111.00000000000001
1110.0000000000002
11100.000000000002
111000.00000000001
1110000.0000000002
11100000.000000002
111000000.00000001
1110000000.0000002
11100000000.000002
111000000000.00002
1110000000000.0002
11100000000000.002
111000000000000.02
1110000000000000.1
1.1100000000000002e+16
1.1100000000000002e+17
1.1100000000000001e+18
1.1100000000000002e+19
1.1100000000000002e+20
1.1100000000000001e+21
1.11e+22
1.1100000000000001e+23
23

これがボクとFloatingPointError(海外ではそう言うらしい)との出会いである

これを先生に聞いたら仕様であること、直すのは難しいということが分かった

2

書いた日: 2019/11/24

2018/9

直すのはあきらめた

でもやっぱりもやもやする

その時は実際に自分が直せるようになるとは思っていなかったねぇ

2.5

書いた日: 2019/11/24

やっぱり1年前のことなんて忘れるよ...

なんでやろうと思ったのかとか、いつそれに思い出したとか、細かいことは忘れたので、少し繋がりがおかしかったりするかもしれません

3

書いた日: 2019/11/24

2018 冬

小数のことは諦めてMathToolというモジュール(まだパッケージにするという考えはなかった)を作っていた

3.1

書いた日: 2019/12/5

思い出せないっ...

---

続く

① → https://qiita.com/PYTHONISTA/items/adfa3f9a961e3abfb718

はじめに

今年もAlexa Developerスキルアワードに参加しました。
社内有志３人で、ハッカソンのような短期集中開発を行い、「業界用語変換」というスキルができました。

＿人人人人人人人人人人＿
＞　ザギンでシースー　＜
￣Y^Y^Y^Y^Y^Y^Y^Y^Y^Y￣

担当パートざっくり

スキル全体 @daisukeArk
形態素解析部分 @ryosukeeeee
APL部分 @sr-mtmt

技術的なキャッチアップの機会にしようということで、私はAPLを触ってみることにしました。
さらに、以前Alexaスキルを作ったときはNode.js（TypeScript）で書いていたけれど、
今回はPythonで書いてみようということに。

APLとは

Alexaを始めとする音声アシスタントたちにいよいよ当たり前に画面が付き始め、
視覚情報も提供できるようになりました。

Alexa Presentation Language（APL)は、
アニメーション、グラフィック、画像、スライドショー、ビデオを含んだ視覚要素を
スキルのやりとりに合わせて変えていくことで様々な演出をすることができます。

例としてAlexaのイベントで展示されていたりするのはPIZZA SALVATORE CUOMOのスキルですね。
体験版で実際には購入しなくてもスキルの操作だけ試すことができます。

つくってみた

ちなみにNode.js版はこちらのシリーズを参考にさせていただきました。
https://qiita.com/Mount/items/72d9928ff2c0ae5de737

スキル開発コンソール画面の使い方やJSONの話とかはPythonも同じなので割愛します。

# Launch Requestのhandle
def handle(self, handler_input):
    # type: (HandlerInput) -> Response

    session_attr = AttributesManager.session_attributes
    logger.info(session_attr)

    speak_output = "いらっしゃいませ。\nあなたの言葉を業界人の言葉に変換します。\n「”銀座で寿司”ってなんていうの」というふうに聞いてください"

    builder = (
        handler_input.response_builder
        .speak(speak_output)
        .ask(speak_output)
    )

    # APL対応デバイスのときだけbuilderにAPL情報を追加
    if(is_apl_supported(handler_input.request_envelope)):
        builder.add_directive(
            RenderDocumentDirective(
                document=GetAplJsonDocument.get_apl_json("launch"),
                datasources=GetAplJsonDatasources.get_apl_json("launch")
            )
        )

    return builder.response

# APL情報の入ってるJSONファイルを取ってくる
class GetAplJsonBase(object):
    _document_type = None

    @classmethod
    def get_apl_json(cls, intent_name):
        # このファイルの場所からの相対パスではなくLambdaから見た絶対パス指定なので注意
        file_path_base = '/var/task/'

        with open(file_path_base + cls._document_type + '/' + intent_name + '.json', 'r', encoding="utf-8") as f:
            return json_load(f)


class GetAplJsonDocument(GetAplJsonBase):
    _document_type = 'document'


class GetAplJsonDatasources(GetAplJsonBase):
    _document_type = 'datasources'


def is_apl_supported(request):
    apl_interface = request.context.system.device.supported_interfaces.alexa_presentation_apl
    return apl_interface is not None

APL情報のJSONはテキストファイルじゃなくて、jsで定義したほうが使い勝手が良いかも、という指摘もあったのですが
色々試していて形式が定まらなかったこともあり、今回はテキストファイルからJSONを読み込んで渡しています。

jsで定義する場合の参考はこちら

function createDatasource(attributes) {
  return {
    "riddleGameData": {
        "properties": {
            "currentQuestionSsml": "<speak>" 
                + attributes.currentRiddle.question
                + "<speak>",
            "currentLevel": attributes.currentLevel,
            "currentQuestionNumber": (attributes.currentIndex + 1),
            "numCorrect": attributes.correctCount,
            "currentHint": attributes.currentRiddle.hints[attributes.currentHintIndex]
        },
        "transformers": [
            {
                "inputPath": "currentQuestionSsml",
                "outputName": "currentQuestionSpeech",
                "transformer": "ssmlToSpeech"
            },
            {
                "inputPath": "currentQuestionSsml",
                "outputName": "currentQuestionText",
                "transformer": "ssmlToText"
            }
        ]
    }
  };
}

参考元）https://github.com/alexa-labs/skill-sample-nodejs-level-up-riddles/blob/master/Step%203%20-%20Add%20APL/lambda/custom/index.js#L461-L487

終わり

これであとはJSONを工夫すればいろいろ出せるはず

VUIの個性を活かしながら視覚情報とタッチパネルにも対応していくことを考えるのはむずかしいなと感じています。
スマホとどう使い分けていくのか、エンジニアだけでなくいろいろなひととコラボレーションして模索していきたいと思いました。

スマートスピーカー Advent Calender 2019 空き枠ありますので、興味のある方ぜひご投稿ください