第2の敵

今回は前回より難しいB問題を解いていきます！！
では早速、問題どーん！！

...何じゃこれ
難易度一気に上げ過ぎではないでしょうかねぇ...
とりあえず図を描いて何を求めていけば良いのかを整理してみます。

なるほど、この小学生でもまだマシなものを描きそうなこの図を見ると、Lの回数に最初の1回を加えたものがこの問題の解答になると言うことですね。意外と簡単だった！！
では早速、C++で書いていきたと...

Python「(´･ω･`)」

OT「どうしたPython！？」

Python「もう僕は使わないの？(´・ω・)」

OT「だってPython、君を使ってコードを書くスキルが自分にはないんだ...ないんだよ.....」

Python「じゃあ僕はいらない子なの？(´°̥̥̥̥̥̥̥̥ω°̥̥̥̥̥̥̥̥｀)」

OT「そんな悲しい顔しないでくれパイソぉおおおおおおおおおん」

...

...

...はい、と言う訳で今回はPythonでコードを書いていきます。

N, X = map(int, input().split())
L = list(map(int, input().split()))
distance = 0
bounds = 1

とりあえず、使う変数を全て宣言！！

N,X,Lは前回いただいたコメント等を参考に記述、ここさえクリアできればなんとかなるはず！！
boundsはボールが跳ねる回数で、最初から座標D0の文の1回を入れています。
deistanceはボールが跳ねて進んだ距離です。

for i in range(n): 
    distance += l[i]
    if distance <= x:
      bounds += 1
    else:
      break
print(bounds)

この繰り返し文でdistanceがXを超えるまでboundsが加算されるようにします。
これでなんとかACいただきました！！

最後に

今回は前回より早く解けましたが、前回のコメントの力がかなり大きかったです。
コメントしてくださった方、ありがとうございますm(_ _)m
これでもうPythonの泣き顔を見る日はやってこないであろう...
問題Cからはなんか無理めな予感がするぜ...

ご拝読いただき、ありがとうございました。

モンティ・ホール問題は、確率のパラドックスとして有名な問題です。本記事では、私が考えて最も納得できた数式に頼らない直感的な説明をしてみます。

モンティ・ホール問題

Wikipediaより引用

プレーヤーの前に閉じた3つのドアがあって、1つのドアの後ろには景品の新車が、2つのドアの後ろには、はずれを意味するヤギがいる。プレーヤーは新車のドアを当てると新車がもらえる。プレーヤーが1つのドアを選択した後、司会のモンティが残りのドアのうちヤギがいるドアを開けてヤギを見せる。ここでプレーヤーは、最初に選んだドアを、残っている開けられていないドアに変更してもよいと言われる。
ここでプレーヤーはドアを変更すべきだろうか？

答「プレーヤーはドアを変更すべきである。なぜなら変更しなかった場合の当たる確率が$\frac{1}{3}$なのに対し、変更した場合の当たる確率は$\frac{2}{3}$だからだ。」

解説

プレーヤーが最初に1つドアを選んだ段階では、どのドアも当たりである確率は$\frac{1}{3}$であるはずだ。それがなぜ、司会者が外れのドアを1つ見せた後では変わってしまうのだろうか？

これを理解するために、モンティ・ホール問題に似た以下のような問題を考えてみる。

1. プレーヤーはドアを1つ選択する
2. プレーヤーは、「選択しているドア」か、「残り2つのドア」のどちらに当たりがあるか選択を促される。

この場合、誰もが後者の「残り2つのドア」を選択するだろう。なぜなら、当たる確率が前者は$\frac{1}{3}$なのに対し、後者は$\frac{2}{3}$だからだ。

この問題とモンティ・ホール問題の決定的な違いは、「選択していないドアのうち、外れのドアを1つ見せる」という行為の有無である。
モンティ・ホール問題では、この行為により「残り2つのドア」のうちの1つが当たり確率0として確定する。これを整理すると、

• 「残り2つのドア」に当たりがある確率は$\frac{2}{3}$,
• 「残り2つのドア」の一方の当たり確率が0に確定

以上より、最後に残った今選択していないドアが当たりである確率が$\frac{2}{3}$となる。

司会者がドアを開示する前後での当たり確率の変化:

よくある誤解

どのドアも当たる確率は同じであるはずだ。よって、一つ外れのドアが確定したのならば、残り2つのドアが当たりである確率はそれぞれ$\frac{1}{2}$である。

この考えは、以下のような問題であれば正しい。

1. プレーヤーはドアを1つ選択する
2. 司会者は、（プレーヤーが選択中のものも含め）3つのドアのうち外れのドアを1つランダムに見せる
3. プレーヤーは、残った2つのドアのうち1つを選択する

この問題とモンティ・ホール問題の決定的な違いは、「司会者が、プレーヤーが選択中のドアを見せることができるか否か」である。
モンティ・ホール問題では、上記はできないことになっている。プレーヤーが選択しているドアが当たりだった場合はこの違いは関係ないが、外れだった場合に大いに影響する。
プレーヤーが選択しているドアが外れであった場合、モンティ・ホール問題では、必ずもう一方の外れのドアが開示される。対して上記の問題では、どの外れのドアが選ばれるかは完全にランダムで、当たりのドアを当てるための何のヒントも得られない。

以上、直感的な説明ではあるが、とりあえず当たる確率がそれぞれ$\frac{1}{2}$にはならないということには納得できるのではないだろうか。

Pythonによるシミュレーション

Python によるシミュレーション例を載せておく。
1万回ゲームを行い、ドアを変更する場合と変更しない場合の勝率をそれぞれ計算した。

import random
random.seed(1)
doors = ["当たり", "ヤギ", "ヤギ"]
stay_wins, change_wins = 0, 0

# 十分な試行回数繰り返す
loop = 10000
for _ in range(loop):
    # 最初にドアを選ぶ
    choose = random.choice(doors)
    # ドアを変更しない場合と変更する場合で、当たりを引いた方に勝数+1
    if choose == "当たり":
        stay_wins += 1
    else:
        change_wins += 1

print("--- 勝率 ---")
print(f"ドアを変更しない場合: {stay_wins / loop}")
print(f"ドアを変更する場合　: {change_wins / loop}")

出力結果

--- 勝率 ---
ドアを変更しない場合: 0.3323
ドアを変更する場合　: 0.6677

最後に

Qiita初投稿です。
どんなコメントでもお待ちしています！！

AtCoder Beginner Contest 153 参戦記

ABC153A - Serval vs Monster

1分半で突破. 書くだけ.

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

print((H + (A - 1)) // A)

ABC153B - Common Raccoon vs Monster

2分半で突破. 書くだけ.

H, N = map(int, input().split())
A = list(map(int, input().split()))

if sum(A) >= H:
    print('Yes')
else:
    print('No')

ABC153C - Fennec vs Monster

2分半で突破. 書くだけ. できるだけ体力が多いやつを必殺技で倒したいので、ソートして先頭K匹以降を攻撃で倒すものとして集計すればいいだけ.

N, K = map(int, input().split())
A = list(map(int, input().split()))

A.sort(reverse=True)
print(sum(A[K:]))

ABC153D - Caracal vs Monster

7分半で突破. log なので TLE にはならないので、再帰関数で定義通りカウントしていくだけで OK.

from sys import setrecursionlimit

setrecursionlimit(1000000)

H = int(input())


def f(n):
    if n == 1:
        return 1
    else:
        return 1 + (n // 2) * 2


print(f(H))

ABC153E - Crested Ibis vs Monster

55分半で突破. DP で総当り.

package main

import (
    "bufio"
    "fmt"
    "math"
    "os"
    "strconv"
)

func main() {
    H := readInt()
    N := readInt()
    AB := make([]struct{ A, B int }, N)
    for i := 0; i < N; i++ {
        AB[i].A = readInt()
        AB[i].B = readInt()
    }

    dp := make([]int, 100000)
    for i := 0; i < 100000; i++ {
        dp[i] = math.MaxInt64
    }

    dp[0] = 0
    for i := 0; i < H; i++ {
        if dp[i] == math.MaxInt64 {
            continue
        }
        for j := 0; j < N; j++ {
            a := AB[j].A
            b := AB[j].B
            if dp[i]+b < dp[i+a] {
                dp[i+a] = dp[i] + b
            }
        }
    }
    result := math.MaxInt64
    for i := H; i < 100000; i++ {
        if dp[i] < result {
            result = dp[i]
        }
    }
    fmt.Println(result)
}

const (
    ioBufferSize = 1 * 1024 * 1024 // 1 MB
)

var stdinScanner = func() *bufio.Scanner {
    result := bufio.NewScanner(os.Stdin)
    result.Buffer(make([]byte, ioBufferSize), ioBufferSize)
    result.Split(bufio.ScanWords)
    return result
}()

func readString() string {
    stdinScanner.Scan()
    return stdinScanner.Text()
}

func readInt() int {
    result, err := strconv.Atoi(readString())
    if err != nil {
        panic(err)
    }
    return result
}

ABC153F - Silver Fox vs Monster

敗退. AtCoder の Go のバージョンがもっと新しくて、スライスのソートができたら突破していたと思う. そうでなくてももう少し時間が残っていたら C# で書き直したのだが…….

はじめに

量子計算を行う際に初期状態を欲しい形にしたい場合があると思います。
特に量子ニューラルネットワークなどで必要かと思われます。

仮に

\frac{|000>+|001>-|010>+|011>-|100>-|101>+|110>+|111>}{2 \sqrt{2}}

を作るgateの組み合わせがすぐ分かれば便利じゃありませんか？
それを実現する考え方がQuantum Hypergraph Stateです。

詳しくは Quantum Hypergraph statesをご覧ください。

Quantum Hypergraph states

軽くQuantum Hypergraph statesの説明をしたいと思います。

\frac{i_0|000>+i_1|001>+i_2|010>+i_3|011>+i_4|100>+i_5|101>+i_6|110>+i_7|111>}{2 \sqrt{2}}  \\
i_k = -1 \ or \ 1

1. 係数が$-1$である$|0...1...0>$が存在するとき、$1$であるqubitに対してZ gateを作用させる。
2. 係数を更新する。
3. 係数が$-1$である$|0...1...1...0>$が存在するとき、$1$であるqubitに対してCZ gateを作用させる。
4. 係数を更新する。
5. 係数が$-1$である$|0...1...1...1...0>$が存在するとき、$1$であるqubitに対してCCZ gateを作用させる。

3qubitの場合は、これですべての係数が1になります。

例

\frac{|000>+|001>-|010>+|011>-|100>-|101>+|110>+|111>}{2 \sqrt{2}}

1. $|010>$と$|100>$の係数が$-1$なので、第二qubitと第三qubitにZ gateを作用させます。その結果、

\frac{|000>+|001>+|010>-|011>+|100>+|101>+|110>+|111>}{2 \sqrt{2}}

1. $|011>$の係数が$-1$なので、第一qubitと第二qubitにCZ gateを作用させます。その結果、

\frac{|000>+|001>+|010>+|011>+|100>+|101>+|110>-|111>}{2 \sqrt{2}}

1. $|111>の係数が$-1$なので、第一qubitと第二qubitと第三qubitにCCZ gateを作用させます。その結果、

\frac{|000>+|001>+|010>+|011>+|100>+|101>+|110>+|111>}{2 \sqrt{2}}

以上で回路の構築は終わりです。

Code

Codeは以下の通りです。正直Pythonが得意なわけでは無いので、無駄な箇所があるかもしれません。効率的な書き方があったら教えてくださると有難いです。
ちなみに、今回は3qubitまでのものですが、同じようにすればいくらでも増やせると思います。

#matplotlib inline
#coding: utf-8

from math import log2
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.quantum_info.operators import Operator

def count_ones_by_bin(num):
    bin_num = bin(num)[2:]
    count = 0
    for i in bin_num:
        count += int(i)
    return count


class QuantumHypergraphState:

    def __init__(self, numqubits, states, circuit=None, qubit_index=None):
        ''' make Quantum HyperGraph State in circuit
        :param circuit:
        :param numqubits: maximum 3
        :param states:
        '''
        self.numqubits = numqubits
        self.states = states
        if circuit is not None:
            self.qc = circuit
            self.index = range(numqubits)
        else:
            qr = QuantumRegister(self.numqubits)
            self.qc = QuantumCircuit(qr)
            if qubit_index is not None:
                self.index = qubit_index
            else:
                self.index = range(numqubits)

    def bin_length(self, num):
        bin_num = bin(num)[2:]
        dif_len = self.numqubits - len(bin_num)
        for i in range(dif_len):
            bin_num = '0' + bin_num
        return bin_num

    def get_z_tgt(self, num):
        bin_num = self.bin_length(num)[::-1]
        z_tgt = []
        for i in range(len(bin_num)):
            if int(bin_num[i]) == 1:
                z_tgt.append(i)
        return z_tgt

    def tgt_0(self, num, tgt):
        """
        e.g. tgt = [0]
             num = 011

        """
        bin_num = self.bin_length(num)[::-1] # 011
        count = 0
        for i in range(len(bin_num)):
            if i in tgt:
                count += int(bin_num[i])
        if count == len(tgt):
            return True
        else:
            return False

    def renew_states(self, tgt):
        for st in range(len(self.states)):
            if self.tgt_0(st, tgt):
                self.states[st] *= -1


    def construct_circuit(self):
        czz = Operator([[1, 0, 0, 0, 0, 0, 0, 0],
                       [0, 1, 0, 0, 0, 0, 0, 0],
                       [0, 0, 1, 0, 0, 0, 0, 0],
                       [0, 0, 0, 1, 0, 0, 0, 0],
                       [0, 0, 0, 0, 1, 0, 0, 0],
                       [0, 0, 0, 0, 0, 1, 0, 0],
                       [0, 0, 0, 0, 0, 0, 1, 0],
                       [0, 0, 0, 0, 0, 0, 0, -1]])
        self.qc.h(self.index)
        for num in range(1, self.numqubits+1):
            # statesの分だけloop
            if num == 1:
                for st in range(len(self.states)):
                    if count_ones_by_bin(st) == num:
                        if self.states[st] == -1:
                            tgt = int(log2(st))
                            self.qc.z(tgt)
                            self.renew_states([tgt])
            elif num == 2:
                for st in range(len(self.states)):
                    if count_ones_by_bin(st) == num:
                        if self.states[st] == -1:
                            tgt_list = self.get_z_tgt(st)
                            self.qc.cz(tgt_list[0], tgt_list[1])
                            self.renew_states(tgt_list)
            else:
                for st in range(len(self.states)):
                    if count_ones_by_bin(st) == num:
                        if self.states[st] == -1:
                            tgt_list = self.get_z_tgt(st)
                            self.qc.unitary(czz, range(self.numqubits), label='czz')
                            self.renew_states(tgt_list)

    def draw(self):
        print(self.qc.draw(output='mpl'))

以上です。ありがとうございました。

Lambda(Python)でGoogle Vision APIを利用して日本語文字検出する

はじめに

サーバーレスWebアプリ Mosaicを開発して得た知見を振り返り定着させるためのハンズオン記事を書き連ねていて、合計17記事を予定して現在13記事、あと4記事なのですが、少し飽きてきてしまいました。
飽きてきたというか、新しい機能の実装にも着手したくなってきてしまって。
で、着手してしまったわけです。文字検出の機能追加に。

文字検出？文字認識？OCR(Optical Character Recognition)って言うみたいですね。
AWSのRekognitionでも文字検出できるみたいなのですが、残念ながら日本語非対応らしく。(2020年1月現在)
しかしGoogleのVision APIは日本語もサポートしているということで、こちらを利用することにしました。

Cloud Vision API 有効化

ということで、早速やってきましょう。
Google Cloud Platform もしくは Google Developpers のコンソール > APIとサービス にアクセス。
https://console.cloud.google.com/apis
https://console.developers.google.com/apis

画面上部にある「＋APIとサービスを有効化」ボタンを押下。

Cloud Vision API を探して、有効化。

認証情報として、サービスアカウントを追加しますが、こちらの記事と重複しますので、ここでは割愛します。

Lambda(Python3)でGoogle Vision APIを利用する

サービスアカウントでGoogleのAPIを呼ぶために必要なライブラリのインポートについても、先ほど同様、こちらの記事を参照ください。

ローカル画像ファイルをVision APIに渡して、顔とテキストを検出するコードは以下のような感じです。

lambda_function.py

  : 
def detectFacesByGoogleVisionAPIFromF(localFilePath, bucket, dirPathOut):
    try:
        keyFile = "service-account-key.json"
        scope = ["https://www.googleapis.com/auth/cloud-vision"]
        api_name = "vision"
        api_version = "v1"
        service = getGoogleService(keyFile, scope, api_name, api_version)

        ctxt = None
        with open(localFilePath, 'rb') as f:
            ctxt = b64encode(f.read()).decode()

        service_request = service.images().annotate(body={
            "requests": [{
                "image":{
                    "content": ctxt
                  },
                "features": [
                    {
                        "type": "FACE_DETECTION"
                    }, 
                    {
                        "type": "TEXT_DETECTION"
                    }
                ]
            }]
        })
        response = service_request.execute()

    except Exception as e:
        logger.exception(e)

def getGoogleService(keyFile, scope, api_name, api_version):
    credentials = ServiceAccountCredentials.from_json_keyfile_name(keyFile, scopes=scope)
    return build(api_name, api_version, credentials=credentials, cache_discovery=False) 

このサンプルコードでは、FACE_DETECTIONとTEXT_DETECTIONを指定しています。
それ以外にもLABEL_DETECTION, LANDMARK_DETECTION, LOGO_DETECTION などが指定できますが、指定するとその分料金が加算されてきます。なので、目的が文字検出だけの場合にはTEXT_DETECTIONだけ指定するなどしたほうがいいですね。

featuresに指定できるものや返されるjsonの詳細についてはここでは書きません。Cloud Vision API ドキュメントを参照ください。料金の詳細についてはこちら。

本当はGoogle Driveにアップロードしたファイルに対してVisionしたかった

のですが、できませんでした。

test.py

        imageUri = "https://drive.google.com/uc?id=" + fileID
        service_request = service.images().annotate(body={
            "requests": [{
                "image":{
                    "source":{
                      "imageUri": imageUri
                    }
                  },
                "features": [
                    {
                        "type": "FACE_DETECTION"
                    }, 
                    {
                        "type": "TEXT_DETECTION"
                    }
                ]
            }]
        })
        response = service_request.execute()

こんな感じでイケると思ったのですが、以下のようなエラーが返ってきてしまい、色々試したのですが結局できませんでした。

response.json

{"responses": [{"error": {"code": 7, "message": "We're not allowed to access the URL on your behalf. Please download the content and pass it in."}}]}
{"responses": [{"error": {"code": 4, "message": "We can not access the URL currently. Please download the content and pass it in."}}]}ass it in."}}]}

Visionを呼び出すことは出来てるのですが、VisionからWeb上の画像(imageUri)にアクセスできてないみたいですね。S3のPublicバケット上の画像の直リンクを指定してもダメでした。謎です。誰か教えて下さい。

動作確認

TEXT_DETECTIONでは、textAnnotationsとfullTextAnnotationという2つの要素が得られます。
textAnnotationsで検出された領域をブルー、fullTextAnnotationで検出された領域をグリーンで囲った結果は以下のような感じでした。

まずまずの結果が得られていると思うのですが、日本語だからかどうなのか、ブルーの方は若干1文字の範囲がズレているような印象を受けますね。

また、下の画像のように1文字1文字が独立しているような場合に弱そうです。これも日本語特有の問題なのか、はたまた違ったfeaturesだったら検出できるのか、その他パラメータで調整できるのか、深追いはしていませんがとにかく期待した結果は得られていません。
将来的にAPIの学習が進んでこの画像にある文字が漏れなく検出できる日がくることを祈るしか無いのが辛いところです。

AWSのRekognitionが文字検出で日本語をサポートしたあかつきには、まずはこの画像で評価をしようと思っています！

あとがき

記事としてまとめることは大切なことだし必要なことだと分かっているのですが、、やっぱり何か新しい機能を作っている時が一番楽しいですね。
その流れでこのVision APIの記事もサラサラと書くことができました。
記事の作成を後回しにすると面倒になってしまうので、記憶の新しいうちに、そしてテンションが高いうちに、さっさと書いてしまうことは大切なことかもしれないなと思った次第です。

今作ってるMosaicというサーバーレスWebアプリ、基本的にはAWSのインフラを利用しているのですが、ゆくゆくはGCPで同じものを構築するということもやりたいと思っています。2020年内には。
インフラはどちらかに統一して構築したほうが良いだろうなと思いますが、RekognitionやVisionAPIのようなWebAPIサービスは、どちらでも良いというか、やりたいことが実現できる方を選択することになりますね。
どちらもAPIを呼ぶだけなので大した事はなく、結局何のシステムもそうなのかもしれませんが、部品を組み合わせて作っている、プラモデルのような、そんな感じがより強くします。
全てを知っておく必要はないと思いますが、1つにこだわりすぎるのも良くないと思いますね。

機械学習された高精度のサービスをこんなに簡単に利用できるのは喜ばしい限りなのですが、それが期待する結果を返してくれなかった場合に手詰まりになってしまうのは辛いところですね。とはいえ、この先の研究分野で何かできるかというと手も足も出ないわけで、いつの日か学習が進んで期待する結果が出てくるのを正座して待つしかできないワタシです。

PythonでGoogleのCloud Vision APIを利用して画像から日本語文字検出する

はじめに

サーバーレスWebアプリ Mosaicを開発して得た知見を振り返り定着させるためのハンズオン記事を書き連ねていて、合計17記事を予定して現在13記事、あと4記事なのですが、少し飽きてきてしまいました。
飽きてきたというか、新しい機能の実装にも着手したくなってきてしまって。
で、着手してしまったわけです。文字検出の機能追加に。

文字検出？文字認識？OCR(Optical Character Recognition)って言うみたいですね。
AWSのRekognitionでも文字検出できるみたいなのですが、残念ながら日本語非対応らしく。(2020年1月現在。試してないのですが、まだ未サポートらしい。)
しかしGoogleのCloud Vision APIは日本語もサポートしているということで、こちらを利用することにしました。

Cloud Vision API 有効化

ということで、早速やってきましょう。
Google Cloud Platform もしくは Google Developpers のコンソール > APIとサービス にアクセス。
https://console.cloud.google.com/apis
https://console.developers.google.com/apis

画面上部にある「＋APIとサービスを有効化」ボタンを押下。

Cloud Vision API を探して、有効化。

認証情報として、サービスアカウントを追加しますが、こちらの記事と重複しますので、ここでは割愛します。

Lambda(Python3)でGoogle Vision APIを利用する

サービスアカウントでGoogleのAPIを呼ぶために必要なライブラリのインポートについても、先ほど同様、こちらの記事を参照ください。

ローカル画像ファイルをVision APIに渡して、顔とテキストを検出するコードは以下のような感じです。

lambda_function.py

  : 
def detectFacesByGoogleVisionAPIFromF(localFilePath, bucket, dirPathOut):
    try:
        keyFile = "service-account-key.json"
        scope = ["https://www.googleapis.com/auth/cloud-vision"]
        api_name = "vision"
        api_version = "v1"
        service = getGoogleService(keyFile, scope, api_name, api_version)

        ctxt = None
        with open(localFilePath, 'rb') as f:
            ctxt = b64encode(f.read()).decode()

        service_request = service.images().annotate(body={
            "requests": [{
                "image":{
                    "content": ctxt
                  },
                "features": [
                    {
                        "type": "FACE_DETECTION"
                    }, 
                    {
                        "type": "TEXT_DETECTION"
                    }
                ]
            }]
        })
        response = service_request.execute()

    except Exception as e:
        logger.exception(e)

def getGoogleService(keyFile, scope, api_name, api_version):
    credentials = ServiceAccountCredentials.from_json_keyfile_name(keyFile, scopes=scope)
    return build(api_name, api_version, credentials=credentials, cache_discovery=False) 

このサンプルコードでは、FACE_DETECTIONとTEXT_DETECTIONを指定しています。
それ以外にもLABEL_DETECTION, LANDMARK_DETECTION, LOGO_DETECTION などが指定できますが、指定するとその分料金が加算されてきます。なので、目的が文字検出だけの場合にはTEXT_DETECTIONだけ指定するなどしたほうがいいですね。

featuresに指定できるものや返されるjsonの詳細についてはここでは書きません。Cloud Vision API ドキュメントを参照ください。料金の詳細についてはこちら。

本当はGoogle Driveにアップロードしたファイルに対してVisionしたかった

のですが、できませんでした。

test.py

        imageUri = "https://drive.google.com/uc?id=" + fileID
        service_request = service.images().annotate(body={
            "requests": [{
                "image":{
                    "source":{
                      "imageUri": imageUri
                    }
                  },
                "features": [
                    {
                        "type": "FACE_DETECTION"
                    }, 
                    {
                        "type": "TEXT_DETECTION"
                    }
                ]
            }]
        })
        response = service_request.execute()

こんな感じでイケると思ったのですが、以下のようなエラーが返ってきてしまい、色々試したのですが結局できませんでした。

response.json

{"responses": [{"error": {"code": 7, "message": "We're not allowed to access the URL on your behalf. Please download the content and pass it in."}}]}
{"responses": [{"error": {"code": 4, "message": "We can not access the URL currently. Please download the content and pass it in."}}]}ass it in."}}]}

Visionを呼び出すことは出来てるのですが、VisionからWeb上の画像(imageUri)にアクセスできてないみたいですね。S3のPublicバケット上の画像の直リンクを指定してもダメでした。謎です。誰か教えて下さい。

動作確認

TEXT_DETECTIONでは、textAnnotationsとfullTextAnnotationという2つの要素が得られます。
textAnnotationsで検出された領域をブルー、fullTextAnnotationで検出された領域をグリーンで囲った結果は以下のような感じでした。

まずまずの結果が得られていると思うのですが、日本語だからかどうなのか、ブルーの方は若干1文字の範囲がズレているような印象を受けますね。

また、下の画像のように1文字1文字が独立しているような場合に弱そうです。これも日本語特有の問題なのか、はたまた違ったfeaturesだったら検出できるのか、その他パラメータで調整できるのか、深追いはしていませんがとにかく期待した結果は得られていません。
将来的にAPIの学習が進んでこの画像にある文字が漏れなく検出できる日がくることを祈るしか無いのが辛いところです。

AWSのRekognitionが文字検出で日本語をサポートしたあかつきには、まずはこの画像で評価をしようと思っています！

あとがき

記事としてまとめることは大切なことだし必要なことだと分かっているのですが、、やっぱり何か新しい機能を作っている時が一番楽しいですね。
その流れでこのVision APIの記事もサラサラと書くことができました。
記事の作成を後回しにすると面倒になってしまうので、記憶の新しいうちに、そしてテンションが高いうちに、さっさと書いてしまうことは大切なことかもしれないなと思った次第です。

今作ってるMosaicというサーバーレスWebアプリ、基本的にはAWSのインフラを利用しているのですが、ゆくゆくはGCPで同じものを構築するということもやりたいと思っています。2020年内には。
インフラはどちらかに統一して構築したほうが良いだろうなと思いますが、RekognitionやVisionAPIのようなWebAPIサービスは、どちらでも良いというか、やりたいことが実現できる方を選択することになりますね。
どちらもAPIを呼ぶだけなので大した事はなく、結局何のシステムもそうなのかもしれませんが、部品を組み合わせて作っている、プラモデルのような、そんな感じがより強くします。
全てを知っておく必要はないと思いますが、1つにこだわりすぎるのも良くないと思いますね。

機械学習された高精度のサービスをこんなに簡単に利用できるのは喜ばしい限りなのですが、それが期待する結果を返してくれなかった場合に手詰まりになってしまうのは辛いところですね。とはいえ、この先の研究分野で何かできるかというと手も足も出ないわけで、いつの日か学習が進んで期待する結果が出てくるのを正座して待つしかできないワタシです。

Shake-Shake Regularizationとは？

正則化の1つです。
擬似的に学習データを増大させることで、長くゆっくり学習できる利点があります。

データ数が少ないときにdata augmentationとして有効なのかも？
とりあえず今回はCIFAR10で試してみたいと思います。

Shake-Shake Regularizationを簡単に説明すると、上のような図になります。
Resnetにおいてredisual blockを2つ並列に作り、residual blockの出力に対し、以下の操作を加えます。

• 学習時の順伝播では0〜1の乱数αをかける
• 誤差逆伝播させるときは0〜1の乱数βをかける(αとは別に生成する)
• 推論時は乱数でなく、定数0.5をかける

詳しくは他の方の記事を参考にしてみてください。私はこちらの記事を読んで理解できました。
https://qiita.com/masataka46/items/fc7f31073c89b02f8a04

residual blockの作成

resnetではplainアーキテクチャとbottleneckアーキテクチャの2つがありますが、今回はbottleneck アーキテクチャを使いたいと思います。

test.py

class ResidualBottleneckBlock(nn.Module):
    expansion = 4

    def __init__(self, in_channels, out_channels, stride):
        super(ResidualBottleneckBlock, self).__init__()

        bottleneck_channels = out_channels // self.expansion

        self.conv1 = nn.Conv2d(in_channels,  bottleneck_channels, kernel_size=1,  stride=1, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(bottleneck_channels)

        self.conv2 = nn.Conv2d(bottleneck_channels, bottleneck_channels,  kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(bottleneck_channels)

        self.conv3 = nn.Conv2d(bottleneck_channels, out_channels, kernel_size=1, stride=1, padding=0,  bias=False)
        self.bn3 = nn.BatchNorm2d(out_channels)

        self.conv1_2 = nn.Conv2d(in_channels,  bottleneck_channels, kernel_size=1,  stride=1, padding=0, bias=False)
        self.bn1_2 = nn.BatchNorm2d(bottleneck_channels)

        self.conv2_2 = nn.Conv2d(bottleneck_channels, bottleneck_channels,  kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2_2 = nn.BatchNorm2d(bottleneck_channels)

        self.conv3_2 = nn.Conv2d(bottleneck_channels, out_channels, kernel_size=1, stride=1, padding=0,  bias=False)
        self.bn3_2 = nn.BatchNorm2d(out_channels)

        self.shortcut = nn.Sequential()   # identity mapping
        if in_channels != out_channels:   # downsampling
            self.shortcut.add_module('conv',  nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, padding=0, bias=False))
            self.shortcut.add_module('bn', nn.BatchNorm2d(out_channels))

    def forward(self, x):
      if self.training:
        #1つ目のresidual block
          out = F.relu(self.bn1(self.conv1(x)))
          out = F.relu(self.bn2(self.conv2(out)))
          out = self.bn3(self.conv3(out))
        #2つ目のresidual block
          out2 = F.relu(self.bn1_2(self.conv1_2(x)))
          out2 = F.relu(self.bn2_2(self.conv2_2(out2)))
          out2 = self.bn3_2(self.conv3_2(out2))
        #ショートカットと2つのresidual blockの出力(に乱数をかけたもの)を足し合わせる
          output = self.shortcut(x) + ShakeShake.apply(out,out2)
          #通常のresnetならこっち
          #output = out + self.shortcut(x)
          return F.relu(output)
      else:
        #1つ目のresidual block
          out = F.relu(self.bn1(self.conv1(x)), inplace=True)
          out = F.relu(self.bn2(self.conv2(out)), inplace=True)
          out = self.bn3(self.conv3(out))
        #2つ目のresidual block
          out2 = F.relu(self.bn1_2(self.conv1_2(x)), inplace=True)
          out2 = F.relu(self.bn2_2(self.conv2_2(out2)), inplace=True)
          out2 = self.bn3_2(self.conv3_2(out2))
        #ショートカットと2つのresidual blockの出力(に0.5をかけたもの)を足し合わせる
          output = self.shortcut(x) + out*0.5 + out2*0.5
          #通常のresnetならこっち
          #output = out + self.shortcut(x)
          return F.relu(output)

コンストラクタはごちゃごちゃしてますが、forward関数を見ればなんとなく理解できるのではないでしょうか。

forward関数の中身は、
１：受け取ったxを2つのblockに与える
２：out,out2を出力させる
３：out,out2をShakeShake.apply()に処理してもらう
４：ショートカットと３を足し合わせて1つにまとめて出力する

forward関数内の"ShakesShake.apply(out,out2)"って？

ShakeShakeクラスというクラスを定義して、forwardとbackwardでの処理を定義することができます。

test.py

class ShakeShake(torch.autograd.Function):
  @staticmethod
  def forward(ctx, i1, i2):
    alpha = random.random()
    result = i1 * alpha + i2 * (1-alpha)

    return result
  @staticmethod
  def backward(ctx, grad_output):
    beta  = random.random()

    return grad_output * beta, grad_output * (1-beta)

forwardでは乱数alphaを生成してout,out2にかけています。

backwardでは新たに乱数betaを生成して、grad_output(誤差逆伝播により伝わってきた値)にかけています。

調べたところ、こうすることで新しいautograd関数を定義できるみたいです。
（確信がない理由は後述します。）

肝心の精度だが・・・

精度は82%程度でした。

同じ条件で訓練してない（pretrained=Falseの）Resnet50を使ってみると、精度は82%以下だったので、一応成功しているのかな・・・？

しかし、訓練済み（pretrained=True）のResnet50は初めから80%以上の精度を出し、正則化をきちんと行えば95%付近まで到達します。

で、今回は82%...

あまり精度が出てない原因は次のように考えてます。

• ソースコードがどこか間違えている（実装できてない）
• 訓練誤差が早めに収束してしまっている（過学習）

最後に

ShakeShake regularizationは強力な正則化であるため、学習時間が半端なく伸びます。

今回は頑張って1000epochで学習させましたが大変でした笑

最後にソースコードを全文載せておきますので、参考にしてみてください。

また、「ここが不十分だ！」という箇所がありましたらご教授いただけると嬉しいです。

test.py

import torch
import random
import numpy as np
import pandas as pd
import torch.nn as nn
from torch import optim
import torch.nn.functional as F
from torch.autograd import Variable
import torch.nn.init as init

import torchvision.transforms as transforms
from torchvision import models
from torch.utils.data import Dataset,DataLoader
from torch.utils.data.dataset import Subset
import torchvision.datasets as dsets

import os
import sys

import matplotlib.pyplot as plt

import random

class ShakeShake(torch.autograd.Function):
  @staticmethod
  def forward(ctx, i1, i2):
    alpha = random.random()
    result = i1 * alpha + i2 * (1-alpha)

    return result
  @staticmethod
  def backward(ctx, grad_output):
    beta  = random.random()

    return grad_output * beta, grad_output * (1-beta)

class ResidualBottleneckBlock(nn.Module):
    expansion = 4

    def __init__(self, in_channels, out_channels, stride):
        super(ResidualBottleneckBlock, self).__init__()

        bottleneck_channels = out_channels // self.expansion

        self.conv1 = nn.Conv2d(in_channels,  bottleneck_channels, kernel_size=1,  stride=1, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(bottleneck_channels)

        self.conv2 = nn.Conv2d(bottleneck_channels, bottleneck_channels,  kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(bottleneck_channels)

        self.conv3 = nn.Conv2d(bottleneck_channels, out_channels, kernel_size=1, stride=1, padding=0,  bias=False)
        self.bn3 = nn.BatchNorm2d(out_channels)

        self.conv1_2 = nn.Conv2d(in_channels,  bottleneck_channels, kernel_size=1,  stride=1, padding=0, bias=False)
        self.bn1_2 = nn.BatchNorm2d(bottleneck_channels)

        self.conv2_2 = nn.Conv2d(bottleneck_channels, bottleneck_channels,  kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2_2 = nn.BatchNorm2d(bottleneck_channels)

        self.conv3_2 = nn.Conv2d(bottleneck_channels, out_channels, kernel_size=1, stride=1, padding=0,  bias=False)
        self.bn3_2 = nn.BatchNorm2d(out_channels)

        self.shortcut = nn.Sequential()   # identity mapping
        if in_channels != out_channels:   # downsampling
            self.shortcut.add_module('conv',  nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, padding=0, bias=False))
            self.shortcut.add_module('bn', nn.BatchNorm2d(out_channels))

    def forward(self, x):
      if self.training:
        #1つ目のresidual block
          out = F.relu(self.bn1(self.conv1(x)))
          out = F.relu(self.bn2(self.conv2(out)))
          out = self.bn3(self.conv3(out))
        #2つ目のresidual block
          out2 = F.relu(self.bn1_2(self.conv1_2(x)))
          out2 = F.relu(self.bn2_2(self.conv2_2(out2)))
          out2 = self.bn3_2(self.conv3_2(out2))
        #ショートカットと2つのresidual blockの出力(に乱数をかけたもの)を足し合わせる
          output = self.shortcut(x) + ShakeShake.apply(out,out2)
          #通常のresnetならこっち
          #output = out + self.shortcut(x)
          return F.relu(output)
      else:
        #1つ目のresidual block
          out = F.relu(self.bn1(self.conv1(x)), inplace=True)
          out = F.relu(self.bn2(self.conv2(out)), inplace=True)
          out = self.bn3(self.conv3(out))
        #2つ目のresidual block
          out2 = F.relu(self.bn1_2(self.conv1_2(x)), inplace=True)
          out2 = F.relu(self.bn2_2(self.conv2_2(out2)), inplace=True)
          out2 = self.bn3_2(self.conv3_2(out2))
        #ショートカットと2つのresidual blockの出力(に0.5をかけたもの)を足し合わせる
          output = self.shortcut(x) + out*0.5 + out2*0.5
          #通常のresnetならこっち
          #output = out + self.shortcut(x)
          return F.relu(output)

class MyNet(nn.Module):
  def __init__(self):
      super(MyNet,self).__init__()

      self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,bias=False)
      self.bn1 = nn.BatchNorm2d(64)
      self.relu = nn.ReLU(inplace=True)
      self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

      self.layer1 = nn.Sequential(
        ResidualBottleneckBlock(64,64,1),
        ResidualBottleneckBlock(64,64,1),
        ResidualBottleneckBlock(64,64,1)
      )
      self.layer2 = nn.Sequential(
        ResidualBottleneckBlock(64,128,2),
        ResidualBottleneckBlock(128,128,1),
        ResidualBottleneckBlock(128,128,1),
        ResidualBottleneckBlock(128,128,1)
        )
      self.layer3 = nn.Sequential(
        ResidualBottleneckBlock(128,256,2),
        ResidualBottleneckBlock(256,256,1),
        ResidualBottleneckBlock(256,256,1),
        ResidualBottleneckBlock(256,256,1),
        ResidualBottleneckBlock(256,256,1),
        ResidualBottleneckBlock(256,256,1)
        )
      self.layer4 = nn.Sequential(
        ResidualBottleneckBlock(256,512,2),
        ResidualBottleneckBlock(512,512,1),
        ResidualBottleneckBlock(512,512,1)
        )

      self.avgpool = nn.AdaptiveAvgPool2d((2, 2))
      self.fc = nn.Linear(512 * 4, 10)

  def forward(self,x):
    x = self.conv1(x)
    x = self.bn1(x)
    x = self.relu(x)
    x = self.maxpool(x)
    x = self.layer1(x)
    x = self.layer2(x)
    x = self.layer3(x)
    x = self.layer4(x)
    x = self.avgpool(x)
    x = x.view(-1,512*4)
    x = self.fc(x)
    return x
  def weight_initializer(self):
    for m in self.modules():
        if isinstance(m,nn.Conv2d):
           init.kaiming_uniform_(m.weight.data,nonlinearity='relu')


#画像の読み込み
batch_size = 100
train_data = dsets.CIFAR10(root='./tmp/cifar-10', train=True, download=False, transform=transforms.Compose([transforms.RandomHorizontalFlip(p=0.5), transforms.ToTensor(),transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0, inplace=False)]))
train_loader = DataLoader(train_data,batch_size=batch_size,shuffle=True)
test_data = dsets.CIFAR10(root='./tmp/cifar-10', train=False, download=False, transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]))
test_loader = DataLoader(test_data,batch_size=batch_size,shuffle=False)

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

net = MyuNet().to(device)
net.weight_initializer()


criterion = nn.CrossEntropyLoss()


learning_rate = 0.01
optimizer = optim.SGD(net.parameters(),lr=learning_rate,momentum=0.9,weight_decay=0.00005)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[650], gamma=0.1)

loss = 0
loss100 = 0
count = 0
acc_list = []
loss_list = []
max_acc = 0

#訓練・推論
for i in range(1000):

  net.train()

  for j,data in enumerate(train_loader,0):
    optimizer.zero_grad()
    inputs,labels = data

    inputs = inputs.to(device)
    labels = labels.to(device)

    outputs = net(inputs)

    loss = criterion(outputs,labels)

    loss.backward()
    optimizer.step()

    scheduler.step()

    loss100 += loss
    count += 1
    print('%d: %.3f'%(j+1,loss))

  print('%depoch:mean_loss=%.3f\n'%(i+1,loss100/count))
  loss_list.append(loss100/count)

  loss100 = 0
  count = 0
  correct = 0
  total = 0
  accuracy = 0.0
  net.eval()

  for j,data in enumerate(test_loader,0):

    inputs,labels = data

    inputs = inputs.to(device)
    labels = labels.to(device)

    outputs = net(inputs)

    _,predicted = torch.max(outputs.data,1)

    correct += (predicted == labels).sum()
    total += batch_size

  accuracy = 100.*correct / total
  acc_list.append(accuracy)

  print('epoch:%d Accuracy(%d/%d):%f'%(i+1,correct,total,accuracy))
  torch.save(net.state_dict(),'Weight'+str(i+1))

for i in range(len(acc_list)):
  print('epoch:%d Accuracy:%.3f'%(i+1,acc_list[i]))

plt.plot(acc_list)
plt.show(acc_list)
plt.plot(loss_list)
plt.show(loss_list)

目的

AWS IoTへのモノの登録を、AWS IoT Python SDKを用いて行います。
モノが大量になると、コンソールで毎回登録するのが大変なため。

補足

モノの登録と同時に下記のことを行います。

• 各種情報登録
  • "属性"に情報を登録
  • デバイスシャドウに情報を登録
  • モノを"モノのグループ"に追加
• 証明書の発行、アタッチ
  • デバイス証明書・キーを発行して保存
  • ポリシーを証明書にアタッチ
  • モノを証明書にアタッチ

実行

事前準備

• モノを所属させるグループを作成しておきます。（手順は割愛）
  

• 証明書にアタッチするポリシーを作成しておきます。（手順は割愛）
  

コード

import boto3
import json
import os

class AWSIoT():

    # 証明書、キーのファイル名
    FILENAME_PUBLIC_KEY = 'public_key.pem'
    FILENAME_PRIVATE_KEY = 'private_key.pem'
    FILENAME_CERT = 'cert.pem'

    def __init__(self, dirpath_cert):

        # 使用するクラスをインスタンス化
        self.client_iot = boto3.client('iot')
        self.client_iotdata = boto3.client('iot-data')

        # 証明書を保存するディレクトリ
        self.DIRPATH_CERT = dirpath_cert

        return


    def enroll_thing(self, thing_name, dict_attr, group_name, property_desired, property_reported, policy):
        '''
        AWS IoTにモノを登録する
        '''
        # AWS IoTにモノを登録（"属性"にモノの情報を登録）
        self.__create_thing(thing_name, dict_attr)

        # 登録したモノをグループに追加
        self.client_iot.add_thing_to_thing_group(thingGroupName=group_name, thingName=thing_name)

        # デバイスシャドウに情報を登録
        self.__update_shadow(thing_name, property_desired, property_reported)

        # デバイス証明書・キーを発行、保存
        response = self.__create_keys_and_cert(thing_name)

        # ポリシーを証明書にアタッチ
        self.client_iot.attach_policy(policyName=policy, target=response['certificateArn'])

        # デバイスに証明書を紐付け
        self.client_iot.attach_thing_principal(thingName=thing_name, principal=response['certificateArn'])

        return


    def __create_thing(self, thingname, dict_attr):
        '''
        AWS IoTにモノを登録（"属性"にモノの情報を登録）
        '''
        # 登録情報（属性）を生成
        attributePayload = self.__create_attribute_payload(dict_attr)

        # モノを登録
        self.client_iot.create_thing(
            thingName=thingname,
            attributePayload=attributePayload
        )

        return   


    def __create_attribute_payload(self, dict_attr):
        '''
        登録情報（属性）を生成
        '''
        attributePayload = {
                'attributes': dict_attr
        }
        return attributePayload


    def __update_shadow(self, thing_name, property_desired, property_reported):
        '''
        デバイスシャドウに情報を登録
        '''
        # バージョン情報をデバイスシャドウに書き込む形式に整形
        payload = self.__create_payload(property_desired, property_reported)

        # デバイスシャドウに情報を登録
        self.client_iotdata.update_thing_shadow(
            thingName=thing_name,
            payload=payload
        )

        return


    def __create_payload(self, property_desired, property_reported):
        '''
        バージョン情報をデバイスシャドウに書き込む形式に整形
        '''
        payload = json.dumps({'state': 
            {"desired": {"property": property_desired},
            "reported": {"property": property_reported}}})

        return payload


    def __create_keys_and_cert(self, thing_name):
        '''
        デバイス証明書・キーを発行、保存
        '''
        # 証明書、キーを発行
        response = self.client_iot.create_keys_and_certificate(setAsActive=True)

        # 保存先のディレクトリパスを生成
        dirpath_save = self.DIRPATH_CERT + thing_name + '/'

        # ファイルに書き込んで保存
        self.__write_to_file(dirpath_save, self.FILENAME_PUBLIC_KEY, response['keyPair']['PublicKey'])
        self.__write_to_file(dirpath_save, self.FILENAME_PRIVATE_KEY, response['keyPair']['PrivateKey'])
        self.__write_to_file(dirpath_save, self.FILENAME_CERT, response['certificatePem'])

        return response


    def __write_to_file(self, dirpath, filename, contents):
        '''
        ファイルに書き込み
        '''
        os.makedirs(dirpath, exist_ok=True)

        filepath = dirpath + filename
        with open(filepath, mode='w') as f:
            f.write(contents)

        return

実行

• 登録情報を定義
  • 今回は"ThingName"という名前のモノを登録します。
  • 属性には、'BuildingName'として'hogehoge_building'を、'Floor'として'6'を登録します。
  • デバイスシャドウには理想の気温と、現在の気温を登録します。

# モノの名前
thing_name = 'ThingName' 

# モノの属性（属性キー:値）
dict_attr = {'BuildingName':'hogehoge_building', 'Floor':'6'}

# モノを所属させるグループの名前
group_name = 'hogehoge_group'

# デバイスシャドウに登録する情報
temp_desired = 26
temp_reported = 22

# 証明書にアタッチするポリシー
policy = 'policy_thermometer'

# 証明書、キーを保存するディレクトリのパス
dirpath_cert = './cert/'

• クラスをインスタンス化して実行

awsiot = AWSIoT(dirpath_cert)
awsiot.enroll_thing(thing_name, dict_attr, group_name, temp_desired, temp_reported, policy)

結果

デバイスの登録が出来ました。
属性も正しく登録されています。

シャドウも正しく登録されています。（"delta"は自動で作成されます。詳細は割愛。）

証明書も正しく紐付けられていて、

証明書にはポリシーがアタッチされています。

あとがき

めちゃめちゃ初心者なので、本当に些細なことでもご指摘・コメントいただけますと幸いです。
Twitterやってます→@shin_job

Tkinterで画面切り替え

超シンプルなコード紹介。
別記事( ここ )はOpenCV関係のコードで長くなっちゃったんでこっちは短くまとめる。
pillowが入ってれば動くはず。

コード

main.py

# -*- coding: utf-8 -*-
import tkinter as tk
import PIL.Image, PIL.ImageTk

class App(tk.Tk):
    # 呪文
    def __init__(self, *args, **kwargs):
        # 呪文
        tk.Tk.__init__(self, *args, **kwargs)

        # ウィンドウタイトルを決定
        self.title("Tkinter change page")

        # ウィンドウの大きさを決定
        self.geometry("800x600")

        # ウィンドウのグリッドを 1x1 にする
        # この処理をコメントアウトすると配置がズレる
        self.grid_rowconfigure(0, weight=1)
        self.grid_columnconfigure(0, weight=1)
#-----------------------------------main_frame-----------------------------
        # メインページフレーム作成
        self.main_frame = tk.Frame()
        self.main_frame.grid(row=0, column=0, sticky="nsew")
        # タイトルラベル作成
        self.titleLabel = tk.Label(self.main_frame, text="Main Page", font=('Helvetica', '35'))
        self.titleLabel.pack(anchor='center', expand=True)
        # フレーム1に移動するボタン
        self.changePageButton = tk.Button(self.main_frame, text="Go to frame1", command=lambda : self.changePage(self.frame1))
        self.changePageButton.pack()
#--------------------------------------------------------------------------
#-----------------------------------frame1---------------------------------
        # 移動先フレーム作成
        self.frame1 = tk.Frame()
        self.frame1.grid(row=0, column=0, sticky="nsew")
        # タイトルラベル作成
        self.titleLabel = tk.Label(self.frame1, text="Frame 1", font=('Helvetica', '35'))
        self.titleLabel.pack(anchor='center', expand=True)
        # フレーム1からmainフレームに戻るボタン
        self.back_button = tk.Button(self.frame1, text="Back", command=lambda : self.changePage(self.main_frame))
        self.back_button.pack()
#--------------------------------------------------------------------------

        #main_frameを一番上に表示
        self.main_frame.tkraise()

    def changePage(self, page):
        '''
        画面遷移用の関数
        '''
        page.tkraise()

if __name__ == "__main__":
    app = App()
    app.mainloop()

ざっと解説

ポイントはtkraiseというコマンド。tkraiseは指定のフレームを最前面に表示させる。
フレームを重ねて配置して、ボタンを押すたびに裏にあるフレームを持ってくる構成。
ボタンにはなんの装飾もせず超シンプルにしてあります。

図解

こんなイメージ

詳しく説明

コード中のコメントアウトに大体のことは書いてあるけど一応、、

まずメインフレーム(main_frame)と移動先のフレーム(frame1)を作成。
2つのフレームをgridメソッドを使って座標(0,0)に配置
gridを使うことで重ねて配置することが出来る。
タイトルラベルについては特に言うことなし。
ボタンウィジェットはcommandにchangePage関数を指定する。
changePage関数は引数にフレーム名をとる。
因みにボタンウィジェットのcommandに引数(selfはカウントしない)をとる関数を指定する場合、
command=lambda :関数
とする必要がある。

おわり

かなり短いコードにしたので分かりやすいと思う。
今まで僕が見た中で最短だもの。
もちろんtkraiseを使わずその都度ページを表示したり消したりするやり方もあるけど一番簡単なのはtkraiseだと思う。

C

範囲より全探索が難しいことがわかる。何らかの法則性があると考えてごにょごにょしたが、解けなかった。

この問題のポイントは、
1. $A×N+B×d(N)$円が線型性を持つことに気づくこと
2. 二分探索が線形問題を解決できることに気づくこと
である。

1. は自明。
2. は昇順ソートされた配列は線形関数と同義であることを意識しなければいけない

私は、2.について理解していなかった。

A , B , X = map(int,input().split())
ans = 10**9 // 2
diff = ans
digit_ans = len(str(ans))
while not A * ans + B * digit_ans <= X < A * (ans+1) + B * len(str(ans+1)):
    diff = max(diff // 2 , 1)
    if A * ans + B * digit_ans > X:
        ans -= diff
    else:
        ans += diff
    digit_ans = len(str(ans))
    #print(ans)
    if ans >= 10 ** 9:
        print(10**9)
        exit()
    elif ans <= 0:
        print("0")
        exit()
print(ans)

D

ルートを一つ定め、使った色以外を色付けすることで解ける。貪欲法。
配色、探索済みを二次元リストで行おうとしたところTLE。
辞書型を使うことで解決した為、メモリの問題？だと考えられる。
(中盤の大きなコメントアウトは二次元リスト仕様の残党）

from collections import deque
# 入力、初期化
N = int(input())
tree = [[] for _ in range(N)]
input_list = []
for _ in range(N - 1):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    input_list.append([a, b])
    tree[a].append(b)
    tree[b].append(a)


# visitedにノードの色を格納する
# visited_edge = [[0] * N for _ in range(N)]
dict = {}
'''
# bfsによる色付けを行う
def bfs(now_node, max_val=0):
    queue = deque([[tree[now_node], -1, now_node]])
    while queue:
        next_nodes, before_color, now_node = queue.pop()
        now_color = 1
        for next_node in next_nodes:
            if visited_edge[now_node][next_node] != 0:
                continue
            if now_color == before_color:
                now_color += 1
            if max_val < now_color:
                max_val = now_color
            visited_edge[next_node][now_node] = now_color
            visited_edge[now_node][next_node] = now_color
            queue.appendleft([tree[next_node], now_color, next_node])
            now_color += 1
    return max_val
'''
def bfs(now_node, max_val=0):
    queue = deque([[tree[now_node], -1, now_node]])
    while queue:
        next_nodes, before_color, now_node = queue.pop()
        now_color = 1
        for next_node in next_nodes:
            key = tuple(sorted([now_node, next_node]))
            if not dict.get(key) is None:
                continue
            if now_color == before_color:
                now_color += 1
            if max_val < now_color:
                max_val = now_color
            dict[key] = now_color
            # visited_edge[now_node][next_node] = now_color
            queue.appendleft([tree[next_node], now_color, next_node])
            now_color += 1
    return max_val

ans = bfs(0)
print(ans)
for a, b in input_list:
    # print(visited_edge[a][b])
    print(dict[tuple(sorted([a,b]))])

xgboostは、ブースティングの中でも勾配ブースティング(Gradient Boosting)を使う。
イメージしておくポイントをまとめておく。

勾配ブースティング(Gradient Boosting)

ある関数、損失関数を定義したときに損失を最小化する方向を探すことで学習するモデル。

数式でイメージをもっておく。

損失関数

予測値と実績値がどれくらいか、差分があるかを判断するためにある指標を(=関数)を使う。
その指標が最小になるようにモデルのパラメータを動かしていく。

XGBoostの損失関数は、以下。

予測値と目的値の誤差の合計に正則化項を足したもの。

２つ目の式は正則化項を表す。回帰木の重みwがあることで、損失関数の最小化時にwによって考慮され、過学習になることを防ぐ。

各変数の説明は以下。

関数最適化

損失関数が出来上がったので、あとは損失関数を最適化するだけです。

上記損失関数を変形してwで微分すると

となる。

この式を0とした時のwが、損失関数を最小化する。(高校数学レベル)

となる。

これを近似した損失関数に代入すると最小の損失値が求まる。
ここで、XGBoostの構造をq。
これがxgboostを評価する数式。

まとめ

xgboostは、ブースティングによってモデルの作成と学習、学習時に勾配情報でパラメータを決定し更新していくモデル。

参考

XGBoostのアルゴリズムを論文を読んで解説

はじめに

今回は、pythonのフレームワーク flaskでの画像の受け取り方の一つをメモします。
具体的には、画像をbase64にエンコードされた形式で受け取り、flask側でデコードして画像を復元します。
ついでに、open-cvを使用して復元した画像をグレースケールに変換して、再度base64にエンコードして返却するところまでメモします。

ソース

使用するライブラリは下記です。

requirements.txt

flask
flask-cors
opencv-python
opencv-contrib-python

リクエストでもらうデータは、複数枚扱いたいのでjson形式にします。

[
    {
        id : 0
        Image : id4zFjyrkAuSI2vUBKVLP...(base64でエンコードされたイメージ)
    },
    {
        id : 1
        Image : k75GN/oll7KUCulSpSM/S...(base64でエンコードされたイメージ)
    }
]

main.py

from flask import Flask, jsonify, request
from flask_cors import CORS
import cv2
import numpy as np
import base64

app = Flask('flask-tesseract-api')
CORS(app)

@app.route("/image/", methods=["POST"])
def post():
    """
    画像をグレースケールに変換する
    """

    response = []

    for json in request.json:

        # Imageをデコード
        img_stream = base64.b64decode(json['Image'])

        # 配列に変換
        img_array = np.asarray(bytearray(img_stream), dtype=np.uint8)

        # open-cv でグレースケール
        img_gray = cv2.imdecode(img_array, 0)

        # 変換結果を保存
        cv2.imwrite('result.png', img_before)

        # 保存したファイルに対してエンコード
        with open('result.png', "rb") as f:
            img_base64 = base64.b64encode(f.read()).decode('utf-8')

        # レスポンスのjsonに箱詰め
        response.append({'id':json['id'], 'result' : img_base64})

    return jsonify(response)

if __name__ == '__main__':
    app.run(host='0.0.0.0',port=5000,debug=True)

まとめ

複数の画像をエンコードした状態で、json形式としてflaskに送ることができました。
これで、複数枚の画像を同時に扱う機能が実装できますね。

cronにpythonのジョブを登録してvenv環境で周期実行するためには

結論

使いたいvenv環境下のpythonを使えばよい。

$ crontab -e
* * * * * cd [絶対パス]; venv/bin/python foo.py

具体例

一分に一回、日時をjsonline形式でファイルに書き出したい。

OS環境

$ sw_vers
ProductName:    Mac OS X
ProductVersion: 10.14.6
BuildVersion:   18G87

ディレクトリを作り、venv仮想環境作り、今回使うパッケージjsonlinesをインストール。

$ mkdir [場所]
$ cd [場所]
$ python -V
Python 3.7.1
$ python -m venv venv
$ source venv/bin/activate
(venv) $ pip install jsonlines

pythonスクリプトを書く。処理された日時をjsonlineとして、out.jsonlに書き出す、というものです。確認のためprintも。

dt2jsonl.py

import datetime
import jsonlines

dt = datetime.datetime.now()
dict_now = {'date': str(dt.date()), 'time': str(dt.time())}

with jsonlines.open('out.jsonl', mode='a') as writer:
    writer.write(dict_now)

print('updated: '+ str(dt))

処理させるとこんな感じでアウトプットが。

(venv) $ python dt2jsonl.py
updated: 2020-01-26 17:39:23.435616
(venv) $ cat out.jsonl
{"date": "2020-01-26", "time": "17:39:23.435616"}

python dt2jsonl.py のままcronに登録してみる。 * * * * *なので一分に一回処理されるはず。
エラーとprint結果を確認するため、>> /tmp/cron.log 2>&1でstderrとstdoutを/tmp/cron.logに書き出すようにする。

(venv) $ crontab -e
* * * * * python dt2jsonl.py >> /tmp/cron.log 2>&1

待っていると/tmp/cron.logにエラーが

(venv) $ tail -f /tmp/cron.log
python: can't open file 'dt2jsonl.py': [Errno 2] No such file or directory

dt2jsonl.pyが見つからないらしいので、cronがどこにいるのか確認。

(venv) $ crontab -e
* * * * * pwd >> /tmp/cron.log 2>&1

(venv) $ tail -f /tmp/cron.log
/Users/[ユーザ]

ユーザディレクトリにいるので、スクリプトの絶対パスを教えてあげる。

(venv) $ crontab -e
* * * * * python /Users/[ユーザ]/[場所]/dt2jsonl.py >> /tmp/cron.log 2>&1

(venv) $ tail -f /tmp/cron.log
Traceback (most recent call last):
  File "/Users/[ユーザ]/[場所]/dt2jsonl.py", line 2, in <module>
    import jsonlines
ImportError: No module named jsonlines

今度はpythonスクリプトにたどり着いたが、jsonlinesがないと。venv環境で実行されてないので、cronはどのpythonを使っているのか確認。

(venv) $ crontab -e
* * * * * which python >> /tmp/cron.log 2>&1; python -V >> /tmp/cron.log 2>&1

(venv) $ tail -f /tmp/cron.log
/usr/bin/python
Python 2.7.10

システムのpython2.7を使っているので、なんとかするべき。
どのpythonを使うべきかチェック。

(venv) $ which python
/Users/[ユーザ]/[場所]/venv/bin/python

venv下のpythonに書き換える。

(venv) $ crontab -e
* * * * * /Users/[ユーザ]/[場所]/venv/bin/python /Users/[ユーザ]/[場所]/dt2jsonl.py >> /tmp/cron.log 2>&1

ちょっと待つと、/tmp/cron.logにprintの結果がでた。

(venv) $ tail -f /tmp/cron.log
updated: 2020-01-26 17:48:00.924120

(venv) $ cat out.jsonl
{"date": "2020-01-26", "time": "17:39:23.435616"}

out.jsonlにもjsonlineとして書き出されていると思いきや、最初に手動で実行したもので、cronで実行された結果ではない。
ユーザディレクトリで実行されたので、ユーザディレクトリにあった。

(venv) $ cat ~/out.jsonl
{"date": "2020-01-26", "time": "17:48:00.924120"}
{"date": "2020-01-26", "time": "17:49:01.102146"}
{"date": "2020-01-26", "time": "17:50:00.278025"}

アウトプットの場所が違いますが、cronはvenv環境で処理してくれた。
pythonスクリプトのアウトプットを絶対パスで指定するのもいいですが、
今回はcronの実行ディレクトリを変える。

(venv) $ crontab -e
* * * * * cd /Users/[ユーザ]/[場所]; venv/bin/python dt2jsonl.py >> /tmp/cron.log 2>&1

これで期待通りになった。

(venv) $ tail -f /tmp/cron.log
updated: 2020-01-26 17:55:00.837256

(venv) $ cat out.jsonl
{"date": "2020-01-26", "time": "17:39:23.435616"}
{"date": "2020-01-26", "time": "17:55:00.837256"}

ちょっと待つと

(venv) $ cat out.jsonl
{"date": "2020-01-26", "time": "17:39:23.435616"}
{"date": "2020-01-26", "time": "17:55:00.837256"}
{"date": "2020-01-26", "time": "17:56:00.986909"}
{"date": "2020-01-26", "time": "17:57:01.167183"}
{"date": "2020-01-26", "time": "17:58:00.273073"}

所要時間

感想

C問題解くの面倒臭がってたのに結局素直な解法で解けたので、バチャコン中の集中力のなさを感じました。
あと、数式を$で囲んで表示しているのですが、なぜか改行が入るようになってしまいました。有識者の方、対処法を教えていただけるとありがたいです。

A問題

2019年かどうかの場合わけはいらなかった…、誤読…。
splitを使えばバックスラッシュで分割ができる。

answerA.py

s=list(map(int,input().split("/")))
if s[0]<2019:
    print("Heisei")
elif s[0]>2020:
    print("TBD")
else:
    print("TBD" if s[1]>4 else "Heisei")

answerA_better.py

s=list(map(int,input().split("/")))
print("TBD" if s[1]>4 else "Heisei")

B問題

bitコインかどうかで場合わけしながら全てのsumを考えれば良い。

answerB.py

n=int(input())
cnt=0.0
for i in range(n):
    x,u=input().split()
    x=float(x)
    cnt+=(x if u=="JPY" else x*380000.0)
print(cnt)

C問題

Dより難しかったです(白目)。
全通り試せることは明らかですが全通りを書き出すのが面倒だったので工夫する方法を考えていたら時間が途方もなく過ぎていきました。
全通り試す際には、竹の選び方のみにMPは依存してその順番には依存しないことにまず注意します。このもとでA,B,Cのどの竹を作るためにそれぞれの竹を使うのかを考えれば良いです(A,B,C,使わない,の4通りに分けて考えると綺麗に実装することができ、解答はこの方法で実装していました。)。
まず、A,B,Cのどの竹に使うかを考えるために元のn本の竹に対してそれぞれ(A~Cに対応する)0~2の番号をつけます(1)。この時点でA,B,Cそれぞれの竹を作るために使うことのできる(使わなくても良い)竹が決まりました。また、この時点で0~2の番号は少なくとも一つ現れる必要があるので、一つもない番号がある場合は次のループへと処理を移します(2)。このもとでそれぞれのA,B,Cをどの竹で作るのかを考えますが、A,B,Cそれぞれの竹を作るために使うことのできる竹の中から任意の本数を選んで良いので、bit列により部分集合を考えます(3)。ただし、この際も一つも竹を選ばない場合は考えないので、そのような場合は除いて考えます(4)。このように考えることでそれぞれの場合においてA,B,Cの長さを決めるために必要なMPは一意に決めることができる(5)ので、それぞれの最小値を考えていくことで、題意の最小のMPを求めることができます。
以上を実装して以下のようになるのですが、変数名をつけるのが下手すぎて混乱してしまったのと上記の議論をうまく頭の中で整理できておらず、解くのに非常に時間がかかってしまいました。毎回のように頭の中を整理するために書き出すべきと思っているのですが、いざ解くと忘れてしまいます。繰り返して解く際の姿勢を刷り込むしかないかなと思いました。

answerC.py

import itertools
n,*abc=map(int,input().split())
l=[int(input()) for i in range(n)]
inf=100000000000000
mi=inf
for i in list(itertools.product([i for i in range(3)],repeat=n)):#(1)↓
    sub=[[] for j in range(3)]
    for j in range(n):
        sub[i[j]].append(j)
    mi_sub=0
    for j in range(3):
        l_sub=len(sub[j])
        if l_sub==0:#(2)
            mi_sub=inf
            break
        mi_subsub=inf
        for k in range(2**l_sub):#(3)↓
            mi_subsubsub=[0,0]
            for l_subsub in range(l_sub):#(5)↓
                if ((k>>l_subsub) &1):
                    mi_subsubsub[0]+=1
                    mi_subsubsub[1]+=l[sub[j][l_subsub]]
            if mi_subsubsub[0]!=0:#(4)
                mi_subsub=min(mi_subsub,abs(mi_subsubsub[1]-abc[j])+mi_subsubsub[0]*10-10)
        mi_sub+=mi_subsub
    mi=min(mi,mi_sub)
print(mi)

itertools.product

複数のリストの直積を生成することができる関数(多重ループのイテレータを簡潔に書くことができる)。
引数にそのリストを複数指定することで返り値としてitertools.product型のオブジェクトを生成して返す。そして、for文を回すことでその全組み合わせを一つずつ取り出すことができる(リスト化することも可能)。
さらに、repeatに繰り返しの回数を指定することで同じリスト同士の直積を生成することも可能で、この問題ではリストmについてrepeat=nとして直積を生成している。

D問題

初めは区間スケジューリングやいもす法っぽさがあるなと思ったのですが、冷静に考えてそうではありませんでした。アルゴリズムベースではなくその問題ベースで問題を考察すると沼にハマりにくく考察力も上がる気がします。
ここで、あるxにいた時を考えます。すると、xは$s_{i-1}$,$s_i$に囲まれてるかつ$t_{j-1}$,$t_j$に囲まれていることになります($s_0$,$t_0$,$s_{a-1}$,$t_{b-1}$より外側にある場合は少し異なります。)。この時、$s_{i-1}$,$s_i$のどちらかの点、$t_{j-1}$,$t_j$のどちらかの点をそれぞれ通るように移動することで最小の移動距離が達成できることは明らか(このことに気付くまでにちゃんと図を書いて考える)なので、$2\times2$の4通りを全て調べれば良いです(また、$s_0$,$t_0$,$s_{a-1}$,$t_{b-1}$より外側にある場合は通るべき候補の点が少なくなります。)。さらに、xがどの範囲にあるかは二分探索を用いることでlogの計算量で求めることができるので十分高速なプログラムになります。これらを実装して以下のとおりです。また、選んだ二点のうち近い方から訪問することで移動距離は小さくなります。

answerD.py

a,b,q=map(int,input().split())
s=[int(input()) for i in range(a)]
t=[int(input()) for i in range(b)]
x=[int(input()) for i in range(q)]

from bisect import bisect_left

for i in range(q):
    y=bisect_left(s,x[i])
    z=bisect_left(t,x[i])
    k=([0] if y==0 else [a-1] if y==a else [y-1,y])
    l=([0] if z==0 else [b-1] if z==b else [z-1,z])
    mi=100000000000000
    for n in k:
        for m in l:
            if abs(s[n]-x[i])>abs(t[m]-x[i]):
                sub1,sub2=t[m],s[n]
            else:
                sub1,sub2=s[n],t[m]
            mi=min(mi,abs(sub1-x[i])+abs(sub2-sub1))
    print(mi)

bisect

挿入の度にリストをソートすることなく、リストをソートされた順序に保つことをサポートするようなモジュール。
logのオーダーで動作する二分法アルゴリズムを用いているためにbisectと呼ばれる。
bisect_leftとbisect_right,insort_leftとinsort_rightの四つの関数を主に用いる。
まず、bisect_leftとbisect_rightについて考える。調べたい要素をx、調べるソート済みの配列をaとした時、前者であれば既存のxのうちの一番左側のaへの挿入箇所が返され、後者であれば既存のxのうちの一番右側のaへの挿入箇所が返される(以上二つの動作はどちらもソートされた順序を保つ)。すなわち、前者はx以上でもっとも小さい要素のインデックスを返し、後者はxより大きくもっとも小さい要素のインデックスを返す事がわかる(挿入の挙動の図を書けば容易にわかる。)。
また、insort_leftとinsort_rightについては、bisect_leftとbisect_rightでそれぞれ示した位置に挿入を行うような関数であり、ソートされた順序をそのままに保つ。

Djangoでテスト駆動開発 その2

これはDjangoでテスト駆動開発(Test Driven Development, 以下:TDD)を理解するための学習用メモです。

参考文献はTest-Driven Development with Python: Obey the Testing Goat: Using Django, Selenium, and JavaScript (English Edition) 2nd Editionを元に学習を進めていきます。

本書ではDjango1.1系とFireFoxを使って機能テスト等を実施していますが、今回はDjagno3系とGoogle Chromeで機能テストを実施していきます。また一部、個人的な改造を行っていますが(Project名をConfigに変えるなど、、)、大きな変更はありません。

⇒⇒その1はこちら

Part1. The Basics of TDD and Django

Chapter2 Extending Our Functional Test Usinng the unittest Module

Chapter1ではDjangoの環境構築から初めての機能テストを記述し、DjangoのDefaultページが機能しているかどうかを機能テストを通して確認することができました。
今回はToDoアプリケーションを作成しながらこれを実際のフロントページに適用していきたいと思います。

ChromeのWebドライバーとSeleniumをつかったテストはユーザー視点でアプリケーションがどう機能するのかを確認することができるため、機能テストと呼ばれています。
これはユーザーがアプリケーションを使用するときの ユーザーストーリー をなぞるものであり、ユーザーがアプリケーションをどう利用して、それに対してアプリケーションがどうレスポンスを返すのかを決定づけるものと言えます。

Functional Test == Acceptance Test == End-To-End Test

今回参考にしているTest-Driven Development with Python: Obey the Testing Goat: Using Django, Selenium, and JavaScript (English Edition) 2nd Editionではアプリケーションの機能(function)をテストすることをfunctional testsと呼んでいるため、本記事では機能テストと呼んでいます。これは acceptance tests(受け入れテスト) 、End-To-End tests(E2Eテスト、インテグレーションテスト) と呼ばれたりもします。このテストを行うのは外から見てアプリケーション全体がどう機能するのかを確認するためです。

それでは実際のユーザーストーリー想定しながら、機能テストにコメントとして記述していきます。

# django-tdd/functional_tests.py

from selenium import webdriver

browser = webdriver.Chrome()

# のび太は新しいto-doアプリがあると聞いてそのホームページにアクセスした。
browser.get('http://localhost:8000')

# のび太はページのタイトルがとヘッダーがto-doアプリであることを示唆していることを確認した。
assert 'To-Do' in browser.title

# のび太はto-doアイテムを記入するように促され、


# のび太は「どら焼きを買うこと」とテキストボックスに記入した(彼の親友はどら焼きが大好き)


# のび太がエンターを押すと、ページは更新され、
# "1: どら焼きを買うこと"がto-doリストにアイテムとして追加されていることがわかった


# テキストボックスは引続きアイテムを記入することができるので、
# 「どら焼きのお金を請求すること」を記入した(彼はお金に関してはきっちりしている)


# ページは再び更新され、新しいアイテムが追加されていることが確認できた


# のび太はこのto-doアプリが自分のアイテムをきちんと記録されているのかどうかが気になり、
# URLを確認すると、URLはのび太のために特定のURLであるらしいことがわかった


# のび太は一度確認した特定のURLにアクセスしてみたところ、


# アイテムが保存されていたので満足して眠りについた。


browser.quit()

Titleに関するassertを"Django"から"To-Do"に変更しました。このままでは機能テストが失敗することが予想されます。
ということで機能テストを実行してみます。

# ローカルサーバーの起動
$ python manage.py runserver

# 別のコマンドラインを立ち上げて
# 機能テストの実行
$ python functional_tests.py

Traceback (most recent call last):
  File "functional_tests.py", line 11, in <module>
    assert 'To-Do' in browser.title
AssertionError

テストは予想していた通り失敗しました。
したがって、このテストが成功できるように開発を進めて行けばいいことがわかります。

unittest Moduleを使用する

先ほど実行した機能テストでは

• AssertioErrorが親切でない(browser titleが実際に何だったのか知れると嬉しい)

• Seleniumで起動させたブラウザが消されず残っている

という煩わしさがありました。これらはPythonの標準モジュールであるunittestモジュールを使うと解決することができます。

機能テストを下記のように書き換えてみます。

# django-tdd/functional_tests.py

from selenium import webdriver
import unittest


class NewVisitorTest(unittest.TestCase):

    def setUp(self):
        self.browser = webdriver.Chrome()

    def tearDown(self):
        self.browser.quit()

    def test_can_start_a_list_and_retrieve_it_later(self):
        # のび太は新しいto-doアプリがあると聞いてそのホームページにアクセスした。
        self.browser.get('http://localhost:8000')

        # のび太はページのタイトルがとヘッダーがto-doアプリであることを示唆していることを確認した。
        self.assertIn('To-Do', self.browser.title)
        self.fail('Finish the test!')

        # のび太はto-doアイテムを記入するように促され、

        # のび太は「どら焼きを買うこと」とテキストボックスに記入した(彼の親友はどら焼きが大好き)

        # のび太がエンターを押すと、ページは更新され、
        # "1: どら焼きを買うこと"がto-doリストにアイテムとして追加されていることがわかった

        # テキストボックスは引続きアイテムを記入することができるので、
        # 「どら焼きのお金を請求すること」を記入した(彼はお金にはきっちりしている)

        # ページは再び更新され、新しいアイテムが追加されていることが確認できた

        # のび太はこのto-doアプリが自分のアイテムをきちんと記録されているのかどうかが気になり、
        # URLを確認すると、URLはのび太のために特定のURLであるらしいことがわかった

        # のび太は一度確認した特定のURLにアクセスしてみたところ、

        # アイテムが保存されていたので満足して眠りについた。


if __name__ == '__main__':
    unittest.main(warnings='ignore')

機能テストはunittest.TestCaseを継承して書くことができます。
今回のポイントを整理してみます。

• 実行させたいテスト関数は test_ から始めることでテストランナーが自動でテストを走らせる。
• setUp と tearDown はテストが走る前後で実行される特別な関数。
• tearDown はテストエラーでも実行される。
• self.fail()は何がなんでもテストは失敗し、エラーが吐き出される。
• unittest.main()でテストが実行され、自動的にテストケースとそのメソッドが実行される。
• warnings='ignore'のオプションを追加すると過剰なResoureWarningなどを無視することができる。

それでは実行してみましょう。

$ python functional_tests.py
======================================================================
FAIL: test_can_start_a_list_and_retrieve_it_later (__main__.NewVisitorTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "functional_tests.py", line 20, in test_can_start_a_list_and_retrieve_it_later
    self.assertIn('To-Do', self.browser.title)
AssertionError: 'To-Do' not found in 'Django: 納期を逃さない完璧主義者のためのWebフレームワーク'

----------------------------------------------------------------------
Ran 1 test in 7.956s

FAILED (failures=1)

unittestモジュールを使うことで AssertionError の中身がより理解しやすくなりました。

ここで self.assertIn('To-Do', self.brower.title) を self.assertIn('Django', self.brower.title) としたらテストがクリアできるはずです。これを確認してみます。

# django-tdd/functional_tests.py
# ~~省略~~
    def test_can_start_a_list_and_retrieve_it_later(self):
        # のび太は新しいto-doアプリがあると聞いてそのホームページにアクセスした。
        self.browser.get('http://localhost:8000')

        # のび太はページのタイトルがとヘッダーがto-doアプリであることを示唆していることを確認した。
        self.assertIn('Django', self.browser.title)  # 変更
        self.fail('Finish the test!')
# ~~省略~~

$ python functinal_tests.py
======================================================================
FAIL: test_can_start_a_list_and_retrieve_it_later (__main__.NewVisitorTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "functional_tests.py", line 21, in test_can_start_a_list_and_retrieve_it_later
    self.fail('Finish the test!')
AssertionError: Finish the test!

----------------------------------------------------------------------
Ran 1 test in 6.081s

FAILED (failures=1)

実行した結果、テストは成功するはずですが、テストはFAILとされてしましました。
AssertionError を確認すると、self.fail('Finish the test') で設定したメッセージが反映されました。
これは self.fail('message') はエラーが無くても必ず設定したエラーメッセージを吐き出す機能を持っているためです。
ここではテストが終わったことがわかるようにリマインダーとして設定されています。

ということで今度は self.fail('Finish the test!') をコメントアウトして実行してみます。

# django-tdd/functional_tests.py
# ~~省略~~
    def test_can_start_a_list_and_retrieve_it_later(self):
        # のび太は新しいto-doアプリがあると聞いてそのホームページにアクセスした。
        self.browser.get('http://localhost:8000')

        # のび太はページのタイトルがとヘッダーがto-doアプリであることを示唆していることを確認した。
        self.assertIn('Django', self.browser.title)
        # self.fail('Finish the test!')  # コメントアウト
# ~~省略~~

$ python functinal_tests.py

.
----------------------------------------------------------------------
Ran 1 test in 7.698s

OK

確かにエラーは無くテストが成功したことが確認できました。最終的な機能テストの出力はこのような形になるはずです。
functional_tests.py の 変更した箇所を元に戻しておきましょう。

# django-tdd/functional_tests.py
# ~~省略~~
    def test_can_start_a_list_and_retrieve_it_later(self):
        # のび太は新しいto-doアプリがあると聞いてそのホームページにアクセスした。
        self.browser.get('http://localhost:8000')

        # のび太はページのタイトルがとヘッダーがto-doアプリであることを示唆していることを確認した。
        self.assertIn('To-do', self.browser.title)
        self.fail('Finish the test!')
# ~~省略~~

Commit

ユーザーストーリーをコメントで追加しながら作成することで、to-doアプリケーションの機能テストを作成して実行することができました。ここでコミットしておきましょう。git statusをすると変更したファイルを確認することができました。

git diffをすると最後のコミットとの差分を確認することができます。
これを実行するとfunctional_tests.pyが大きく変更されていることがわかります。

それではコミットしておきます。

$ git add .
$ git commit -m "First FT specced out in comments, and now users unittest"

Chapter2まとめ

機能テストをDjangoのプロジェクトの立ち上げを確認するレベルから、To-Doアプリケーションを使用するユーザーストーリに基づいたものに変更することができました。更にunittestを使用することでエラーメッセージをよりうまく活用することができることがわかりました。

8.1 ファイルの入出力

• fileobj=open(filename,mode)でファイルを開く。
  • fileobjはopen()が返すファイルのオブジェクト
  • filenameはファイル名
  • ファイルをどうしたいかの選択。
  • rは読み出し、wは書き込みで上書き及び新規作成も可能、xは書き込みだがファイルが存在しない場合のみ。
  • modeの第二文字目はファイルのタイプを示す。tはテキスト、bはバイナリの意味。

8.1.1 write()によるテキストファイルへの書き込み

>>> poem = """There was a young lady named Bright,
... Whose speed was far faster than light,
... She started one day,
... In a relative way,
... And returned on the previous night."""
>>> len(poem)
151

#write()関数は、書き込んだバイト数を返す。
>>> f=open("relatibity","wt")
>>> f.write(poem)
151
>>> f.close()

#print()でもテキストファイルに書き込み可能。
#print()は個々の引数の後にスペース、全体の末尾に改行を追加している。
>>> f=open("relatibity","wt")
>>> print(poem,file=f)
>>> f.close()

#print()をwrite()と同じように動作させるにはsep,endを使う。
#sep:セパレータ。デフォルトでスペース(" ")になる。
#end:末尾の文字列。デフォルトで改行("\n")になる。
>>> f=open("relatibity","wt")
>>> print(poem,file=f,sep="",end="")
>>> f.close()

#ソース文字列が非常に大きい場合は、chunkに分割してファイルに書き込みできる。
>>> f=open("relatibity","wt")
>>> size=len(poem)
>>> offset=0
>>> chunk=100
>>> while True:
...     if offset>size:
...         break
...     f.write(poem[offset:offset+chunk])
...     offset+=chunk
... 
100
51
>>> f.close()

#xモードにより上書きを防ぐことでファイル破壊を防げる。
>>> f=open("relatibity","xt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'relatibity'

#例外ハンドラとしても使える。
>>> try:
...     f=open("relatibity","xt")
...     f.write("stomp stomp stomp")
... except FileExistsError:
...     print("relativity already exists!. That was a close one.")
... 
relativity already exists!. That was a close one.

8.1.2 read(),readline(),headlines()によるテキストファイルの読み出し

#ファイル全体を一度に読み出すことができる。
>>> fin=open("relatibity","rt")
>>> poem=fin.read()
>>> fin.close()
>>> len(poem)
151

#read()の引数に字数を入れることで一度に返すデータ量を制限できる。
#ファイルを全て読んだ後でさらにread()を呼び出すと、空文字列("")が返される。→if not f:でFalseと評価される。
>>> poem=""
>>> fin=open("relatibity","rt")
>>> chunk=100
>>> while True:
...     f=fin.read(chunk)
...     if not f:
...         break
...     poem+=f
... 
>>> fin.close()
>>> len(poem)
151

#readline()を使えば、ファイルを1行ずつ読み出すことができる。
#ファイルを全て読み込むとread()同様に空文字列を返し、Falseと評価される。
>>> poem=""
>>> fin=open("relatibity","rt")
>>> while True:
...     line=fin.readline()
...     if not line:
...         break
...     poem+=line
... 
>>> fin.close()
>>> len(poem)
151

#イテレータと使って簡単に読み出すことができる。
>>> poem=""
>>> fin=open("relatibity","rt")
>>> for line in fin:
...     poem+=line
... 
>>> fin.close()
>>> len(poem)
151

#readlines()は一度に一行ずつ読み出して、一行文字列のリストを返す。
>>> fin=open("relativity","rt")
>>> lines=fin.readlines()
>>> fin.close()
>>> for line in lines:
...      print(line,end="")
... 
There was a young lady named Bright,
Whose speed was far faster than light,
She started one day,
In a relative way,
And returned on the previous night.>>> 

8.1.3 write()によるバイナリファイルの書き込み

• モード文字列に"b"を追加するとファイルはバイナリモードで開かれる。この場合、文字列ではなくbytesを読み書きすることになる。

#0から255までの256バイトを生成しよう。
>>> bdata=bytes(range(0,256))
>>> len(bdata)
256
>>> f=open("bfile","wb")
>>> f.write(bdata)
256
>>> f.close()

#テキストの場合と同様にchunk単位で書き込むこともできる。
>>> f=open("bfile","wb")
>>> size=len(bdata)
>>> offset=0
>>> chunk=100
>>> while True:
...     if offset>size:
...         break
...     f.write(bdata[offset:offset+chunk])
...     offset+=chunk
... 
100
100
56
>>> f.close

8.1.4 read()によるバイナリファイルの読み出し

#"rb"として開けば良い。
>>> f=open("bfile","rb")
>>> bdata=f.read()
>>> len(bdata)
256
>>> f.close()

8.1.5 withによるファイルの自動的なクローズ

• with以下のコンテキストブロックが終わると自動でファイルを閉じてくれる。
• with expression as variableという形式で使う。

>>> with open("relatibity","wt") as f:
...     f.write(poem)
... 
151

8.1.6 seek()による位置の変更

• tell()関数は、ファイルの先頭から現在地までのオフセットをバイト単位で返す。

• seek()関数はファイルオブジェクトの位置を変更できる。

  • ファイルオブジェクトの位置を変更するには、f.seek(offset, whence)を使う。標準のosモジュールでも定義されている。
  • ファイル位置は基準点にオフセット値を足して計算される。
  • 参照点はwhence引数で選択。0なら先頭からoffsetまでの位置、1なら現在の位置からoffsetバイトまでの位置、2なら末尾からoffsetバイトの位置にそれぞれ移動する。
  • whenceは省略可能で、デフォルト値は0、すなわち参照点としてファイルの先頭を使う。

>>> f=open("bfile","rb")
>>> f.tell()
0

#seek()を使ってファイルの末尾の1バイト手前に移動する。
#場所(255)まで移動して、そこから後ろを読み出した。→最後の1バイトが読み込まれた。
#254と255の間に位置し、最後の読み込みで、255を読み込んだイメージ。
>>> f.seek(255)
255
>>> b=f.read()
>>> len(b)
1
#seek()は移動後のオフセットも返してくる。
>>> b[0]
255


>>> import os
>>> os.SEEK_SET
0
>>> os.SEEK_CUR
1
>>> os.SEEK_END
2


>>> f=open("bfile","rb")
#末尾から-1オフセットした位置に移動した。
>>> f.seek(-1,2)
255
#ファイルの先頭からオフセットをバイト単位で返す。
>>> f.tell()
255
>>> b=f.read()
>>> len(b)
1
>>> b[0]
255

#ファイルの先頭から末尾の2バイト前まで移動
#253と254の間にいるイメージ
>>> f=open("bfile","rb")
>>> f.seek(254,0)
254
>>> f.tell()
254
#ファイルの末尾の2バイト前から1バイト前まで移動
#254と255の間にいるイメージ
>>> f.seek(1,1)
255
>>> f.tell()
255
>>> b=f.read()
>>> len(b)
1
>>> b[0]
255

8.2 構造化されたテキストファイル

• 構造的なデータを作るには以下のような方法がある。
  • セパレータ、区切り子。タブ（"\t"）、カンマ（","）、縦棒（"|"）などで区切る。CSV形式。
  • タグを"<"と">"で区切る。XMLやHTMLがこれにあたる。
  • 記号を駆使するもの。JSONがそう。
  • インデント。例えば、YAMLがこれに当たる。

CSV

• 区切り子によってフィールドに区切られているファイルは、スプレッドシートやデータベースとのデータ交換形式に用いられる。
  • 一部のファイルはエスケープシーケンスを使っている。区切り子の文字がフィールド内で使われる可能性がある場合、フィールド全体をクォート文字で囲むか、区切り子の前にエスケープ文字をつける。

>>> import csv
>>> villains=[
...     ["Doctor","No"],
...     ["R","K"],
...     ["Mister","Big"],
...     ["Auric","Goldfinger"],
...     ["E","B"],
...     ]

>>> with open ("villains","wt") as fout:
#writer()で書き込み
...     csvout=csv.writer(fout)
#villainsというcsvファイルが作られた。
...     csvout.writerows(villains)

実行結果

Docter,No
R,K
Miser,Big
Auric,Goldfinger
E,B

>> import csv
>>> with open("villains","rt") as fin:
#reader()で読み込み
...     cin=csv.reader(fin)
...     villains=[row for row in cin]
... 
>>> print(villains)
[['Doctor', 'No'], ['R', 'K'], ['Mister', 'Big'], ['Auric', 'Goldfinger'], ['E', 'B']]

#DictReader()を使って列名を指定する。
>>> import csv
>>> with open("villains","rt") as fin:
...     cin=csv.DictReader(fin,fieldnames=["first","last"])
...     villains=[row for row in cin]
... 
>>> print(villains)
[{'first': 'Docter', 'last': 'No'}, {'first': 'R', 'last': 'K'}, {'first': 'Miser', 'last': 'Big'}, {'first': 'Auric', 'last': 'Goldfinger'}, {'first': 'E', 'last': 'B'}]


>>> import csv
>>> villains= [
...     {"first":"Docter","last":"No"},
...     {"first":"R","last":"K"},
...     {"first":"Miser","last":"Big"},
...     {"first":"Auric","last":"Goldfinger"},
...     {"first":"E","last":"B"},
...     ]
>>> with open("villains","wt") as fout:
...     cout=csv.DictWriter(fout,["first","last"])
#writeheader()を使ってCSVファイルの先頭に列名も書き込むことができる。
...     cout.writeheader()
...     cout.writerows(villains)
... 

実行結果

first,last
Docter,No
R,K
Miser,Big
Auric,Goldfinger
E,B

#ファイルからデータを読み直す。
#DictReader()呼び出しの中でfieldnames引数を省略すると、ファイルの第一行の値(first,last)を列ラベルの辞書キーとして使えという意味になる。
>>> import csv
>>> with open("villains","rt") as fin:
...     cin=csv.DictReader(fin)
...     villains=[row for row in cin]
... 
>>> print(villains)
[OrderedDict([('first', 'Docter'), ('last', 'No')]), OrderedDict([('first', 'R'), ('last', 'K')]), OrderedDict([('first', 'Miser'), ('last', 'Big')]), OrderedDict([('first', 'Auric'), ('last', 'Goldfinger')]), OrderedDict([('first', 'E'), ('last', 'B')])]

8.2.2 XML

• XMLを簡単に読み取るためにはElementTreeを使う。

menu.xml

<?xml version="1.0"?>
<menu>
#開始タグにはオプションの属性を組み込める。
    <breakfast hours="7-11">
        <item price="$6.00">breakfast burritos</item>
        <item price="$4.00">pancakes</item>
    </breakfast>
    <lunch hours="11-3">
        <item price="$5.00">hamburger</item>
    </lunch>
    <dinner hours="3-10">
        <item price="$8.00">spaghetti</item>
    </dinner>
</menu>

>>> import xml.etree.ElementTree as et
>>> tree=et.ElementTree(file="menu.xml")
>>> root=tree.getroot()
>>> root.tag
'menu'
#tagはタグの文字列、attribはその属性の辞書である。
>>> for child in root:
...     print("tag:",child.tag,"attributes:",child.attrib)
...     for grandchild in child:
...         print("\ttag:",grandchild.tag,"attributes:",grandchild.attrib)
... 
tag: breakfast attributes: {'hours': '7-11'}
    tag: item attributes: {'price': '$6.00'}
    tag: item attributes: {'price': '$4.00'}
tag: lunch attributes: {'hours': '11-3'}
    tag: item attributes: {'price': '$5.00'}
tag: dinner attributes: {'hours': '3-10'}
    tag: item attributes: {'price': '$8.00'}
#menuセクション数
>>> len(root)
3
#breakfastの項目数
>>> len(root[0])
2

8.2.3 JSON

• JavaSciriptという枠を超えて非常に使われているデータ交換形式になっている。
• JSON形式はJavaSciriptのサブセットであり、Pythonで用いられることも多い。
• JSONモジュールのjsonはPythonデータをJSON文字列にエンコード(ダンプ)したり、JSON文字列をPythonデータにデコード(ロード)したりする。

#データ構造を作成
>>> menu=\
... {
... "breakfast":{
...     "hours":"7-11",
...     "items":{
...             "breakfast burritos":"$6.00",
...             "pancakes":"$4.00"
...             }
...         },
... "lunch":{
...         "hours":"11-3",
...         "items":{
...             "hamburger":"$5.00"
...                 }
...         },
... "dinner":{
...     "hours":"3-10",
...     "items":{
...             "spaghetti":"$8.00"
...             }
...     }
... }

#dumps()を使ってこのデータ構造(menu)をJSON文字列(menu_json)にエンコードする。
>>> import json
>>> menu_json=json.dumps(menu)
>>> menu_json
`{"breakfast": {"hours": "7-11", "items": {"breakfast burritos": "$6.00", "pancakes": "$4.00"}}, "lunch": {"hours": "11-3", "items": {"hamburger": "$5.00"}}, "dinner": {"hours": "3-10", "items": {"spaghetti": "$8.00"}}}`

#loads()を使って、JSON文字列のmenu_jsonをPythonデータ構造menu2に戻す。
>>> menu2=json.loads(menu_json)
>>> menu2
{'breakfast': {'hours': '7-11', 'items': {'breakfast burritos': '$6.00', 'pancakes': '$4.00'}}, 'lunch': {'hours': '11-3', 'items': {'hamburger': '$5.00'}}, 'dinner': {'hours': '3-10', 'items': {'spaghetti': '$8.00'}}}

#datetimeなどの一部のオブジェクトをエンコード、デコードしようとすると、以下のような例外が発生する。
#これはJSON標準が日付、時刻型を定義していないため。
>>> import datetime
>>> now=datetime.datetime.utcnow()
>>> now
datetime.datetime(2020, 1, 23, 1, 59, 51, 106364)
>>> json.dumps(now)
#...省略
TypeError: Object of type datetime is not JSON serializable

#datetimeを文字列やUnix時間へ変換すれば良い。
>>> now_str=str(now)
>>> json.dumps(now_str)
'"2020-01-23 01:59:51.106364"'
>>> from time import mktime
>>> now_epoch=int(mktime(now.timetuple()))
>>> json.dumps(now_epoch)
'1579712391'

#通常変換されるデータ型にdatetime型の値が含まれている場合には、都度変換するのは煩わしい。
#そこで、json.JSONEncoderを継承したクラスを作成する。
#defaultメソッドをオーバーライド。
#isinstance()関数はobjがdatetime.datetimeクラスのオブジェクトか確認。
>>> class DTEncoder(json.JSONEncoder):
...     def default(self,obj):
...     #isinstance()はobjの型をチェックする。
...         if isinstance(obj,datetime.datetime):
...             return int(mktime(obj.timetuple()))
...         return json.JSONEncoder.default(self,obj)
... 
#now=datetime.datetime.utcnow()と定義しているのでTrueが返される。
>>> json.dumps(now,cls=DTEncoder)
`1579712391`

>>> type(now)
<class `datetime.datetime`>
>>> isinstance(now,datetime.datetime)
True
>>> type(234)
<class `int`>
>>> type("hey")
<class `str`>
>>> isinstance("hey",str)
True
>>> isinstance(234,int)
True

8.2.4 YAML

• JSONと同様にYAMLはキーと値を持つが、日付と時刻を始めとして、JSONよりも多くのデータ型を処理することができる。

• YAMLの処理をするためにはPyYAMLをというライブラリをインストールする必要がある。

mcintyre.yaml

name:
  first:James
  last:McIntyre
dates:
  birth:1828-05-25
  death:1906-03-31
details:
  bearded:true
  themes:[cheese,Canada]
books:
  url:http://www.gutenberg.org/files/36068/36068-h/36068-h.htm
poems:
  - title: "Motto" #半角スペースがなかったためにエラー発生。
    text: |
        Politeness,perseverance and pluck,
        To their possessor will bring good luck.
  - title: "Canadian Charms" #半角スペースがなかったためにエラー発生。
    text: |
        Here industry is not in vain,
        For we have bounteous crops of grain,
        And you behold on every field
        Of grass and roots abundant yield,
        But after all the greatest charm
        Is the snug home upon the farm,
        And stone walls now keep cattle warm.

>>> import yaml
>>> with open("mcintyre.yaml","rt") as fin:
...     text=fin.read()
... 
>>> data=yaml.load(text)
>>> data["details"]
'bearded:true themes:[cheese,Canada]'
>>> len(data["poems"])
2

8.2.5 pickleによるシリアライズ

• Pythonのデータ階層を取り、文字列表現に変換することをシリアライズという。文字列表現からデータを再構築することをデシリアライズという。

• シリアライズされてからデシリアライズされるまでの間に、オブジェクトの文字列表現はファイルやデータの形で保存したり、ネットワークを通じて離れたマシンに送ったりすることができる。

• Pythonは特別なバイナリ形式で、あらゆるオブジェクトを保存、復元できるpickleモジュールを提供している。

>>> import pickle
>>> import datetime
>>> now1=datetime.datetime.utcnow()
>>> pickled=pickle.dumps(now1)
>>> now2=pickle.loads(pickled)
>>> now1
datetime.datetime(2020, 1, 23, 5, 30, 56, 648873)
>>> now2
datetime.datetime(2020, 1, 23, 5, 30, 56, 648873)

#pickleはプログラム内で定義された独自クラスやオブジェクトも処理できる。
>>> import pickle
>>> class Tiny():
...     def __str__(self):
...         return "tiny"
... 
>>> obj1=Tiny()
>>> obj1
<__main__.Tiny object at 0x10af86910>
>>> str(obj1)
'tiny'
#pickledはobj1オブジェクトからpickleでシリアライズしたバイナリシーケンス。
#dump()を使ってファイルにシリアライズ。
>>> pickled=pickle.dumps(obj1)
>>> pickled
b'\x80\x03c__main__\nTiny\nq\x00)\x81q\x01.'
#obj2に変換し戻して、obj1のコピーを作っている。
#loads()を使ってファイルからオブジェクトをデシリアライズ。
>>> obj2=pickle.loads(pickled)
>>> obj2
<__main__.Tiny object at 0x10b21cdd0>
>>> str(obj2)
'tiny'

感想

ようやく次はRDBMSへ。

参考文献

「Bill Lubanovic著 『入門 Python3』(オライリージャパン発行)」

「Pythonチュートリアル 3.8.1ドキュメント 7.入力と出力」
https://docs.python.org/ja/3/tutorial/inputoutput.html#old-string-formatting