この記事を読んで習得できること

・プログラミングを初めてまだ「return」の使い方が分からない方々
・3年前の私

経緯

大学院でプログラムを書いていた3年前のボク。
大学の研究で実験の解析で必要だったため、必死で書いていたのをなんとなく覚えている。

ひとまず、自分の行いたい解析プログラムは動くようになり、
喜びながらそのプログラムを使って解析を行っていた。

ひと段落してから、プログラムを見てみると、
「結構ソース汚いな…」と思い、修正しようと試みた。

しかし、ソースのスパゲッティ感*が半端なく、
なかなか修正が出来ずに、前回と同じようなソースなのに、
一から書き直したのを覚えている。

3年前のソースで何が起こっていたのか

おおよそのイメージだが、こんな感じ。

sample.swift

func yabaiCode() {
    if 条件1 {
        処理1(15行以上）
        処理A(10行以上)
        処理4(10行以上)
    } else if 条件2 {
        処理2(15行以上）
        処理A`(10行以上)
        処理5(10行以上)
    }  if 条件3 {
        処理3(15行以上)
        処理A``(10行以上)
        処理6(10行以上)
    } else {
        処理7(20行以上)
    }
}

何が言いたいかって、条件分岐の中の処理がとんでもなく長いのだ。
しかし、処理を分けたいのだが、分け方がイマイチ分からない。
どうやら、メソッドで分割していけば、もっと簡単に処理ができるとのことだ。

でも、メソッドで分けることが出来なかった。
メソッド間での、値の受け渡しが分からなかったのだ…

んで、結局分からないまま、このままのコードを残して卒業してしまったわけだが（後輩ちゃんごめん）、
今になって（流石に）return文がある程度分かった自分が、過去の自分にreturnを教えるために、この記事を書いたってわけです。

returnの主な使い方は2つ

1.メソッドを終了させる

sample.swift

func return1() {

    num = 5 // 好きな数値を入れる

    if num == 4 {
        print("4です")
        return
    } else if num == 5 {
        print("5です")
        return 
        // このメソッドはここで終了するはず
        // これ以降は処理されない
    }  if num == 6 {
        print("6です")
        return
    } else {
        print("分からない")
        return
    }
}

このreturnは、無駄な処理を省くことができる。
途中で答えが出たら、その時点で処理を終了させればいいし、
また、returnがあるおかげで、if-elseを使わなくてよくなる。

if-elseは、処理が多くなる上に、ifとelseが同時でいることが前提になるため、
１メソッドあたりの処理が多くなることがある。
読みにくくなったりもする。
職場によっては、「if-else禁止！」なんてところもあるだろう。
（自分の部署はそうでした）

どんだけif-elseがないとコードが読みやすくなるか。
FizzBuzz文を参考にしてみたいと思う。

まずは、if-else文を使用したもの。

FizzBuzz.swift

func fizzBuzz() {
    for i in 1...30 {
        judgeFizzBuzz(num: i)
    }
}

func judgeFizzBuzz(num : Int) {
    if num % 15 == 0 {
        print("FizzBuzz")
    } else if num % 3 == 0 {
        print("Fizz")
    } else if num % 5 == 0 {
        print("Buzz")
    } else {
        print(num)
    }
}

めっちゃ悪いわけではないが、もし仮に、7の倍数の時の処理を入れるなんて時は、
気をつけないと、全ての処理がぶっ壊れてしまう。
（return使うときももちろん気をつける必要があるが）

では、return文を使ってみる。

FizzBuzz.swift

func fizzBuzz() {
    for i in 1...30 {
        judgeFizzBuzz(num: i)
    }
}

func judgeFizzBuzz(num : Int) {
    if num % 15 == 0 {
        print("FizzBuzz")
        return
    } 

    if num % 3 == 0 {
        print("Fizz")
        return
    } 

    if num % 5 == 0 {
        print("Buzz")
        return
    }

    print(num)
}

if文がパーツ化されるので、実に見やすい。本当に素晴らしい。
何もなければnumがprintされるってことも一目瞭然だ。

2.値を返してくれる

ここでは、数値を返してくれるメソッドを使用する

sample.swift

func say() {
    num = 5
    doubleNum = doubleNum(num) // 10が返ってくる
}

// 2倍した数値を返してくれる関数
func doubleNum(num :Int) -> Int {
    return num * 2 //数値を返す
}

別のメソッドで計算して、処理結果を返してもらうってことも容易になる。

FizzBuzz使うとさらにお分りいただけるかもしれない。

FizzBuzz.swift

func fizzBuzz() {
    for i in 1...30 {
        print(judgeFizzBuzz(num: i))
    }
}

func judgeFizzBuzz(num : Int) -> String {
    if num % 15 == 0 {
        return "FizzBuzz"
    }

    if num % 3 == 0 {
        return "Fizz"
    }

    if num % 5 == 0 {
        return "Buzz"
    }

    return String(num)

}

1で書いたものよりも、さらに見やすくなったと思う。
judgeFizzBuzzがStringを返すようになったということで、全体としてのコード量も減った（print）

まとめ

returnをうまく使わないとメソッドが盛り盛りになってしまうので、もし使っていない方がいたら是非使って欲しい。
これを知らないで、よく大学卒業できたな、俺…

はじめに

これは前回作成した記事「「アイネクライネナハトムジーク」に出てくる斉藤さんをミスチルの桜井さんとして再現してみた」の続きになります。
気になった方は上記の記事をまず読むことをおすすめします。

作ったもの

まずはどんなものを作ったか紹介します。

こちらで友達登録したら試すことができます！

https://lin.ee/WEqJMO7

使い方はシンプルです。
桜井さんに何か話しかけます。
そうするとその心境に合うようなミスチルの曲の一部を桜井さんが歌ってくれます。（正確にはテキストで返信してくれます）
裏でCOTOHAの感情分析APIを活用していて、
送信した文章と感情スコアの近い歌詞の一部を返すようになっています。
なのであまり内容が一致してないことも多々あることはご了承ください。（お遊び感覚でお使いください。。）

コロナによる自粛疲れを希望がちらつかすといった表現で励ましているような気がします。

システム概要

歌詞フレーズと感情スコアを格納するDBへの登録部分は前回の記事を参照してください。
今回はLINEから送って返信が返ってくるまでの構成を紹介します。
構成はシンプルでLINEのMessaging API、AWSのAPI Gateway、Lambda、RDS、COTOHAのAPIを利用しています。

① - ②：LINE Messaging APIを使ってLINEからWeb HookによりAPI Gatewayを呼び出すようにする
③：API Gatewayの設定により作成したLambda関数を呼び出す
④：COTOHA APIを呼び出して送ったメッセージの感情スコアを取得
⑤：感情スコアの近い歌詞のフレーズをRDS上に作成したDBから取得
⑥ - ⑦：取得したフレーズをLINEの返信としてMessaging APIにより返す

各サービスの詳細説明

設定に手こずりそうなAPI Gateway、Lambda、LINE Messaging APIの説明をします。
RDSとCOTOHAについては特に難しい設定はないため、省略させていただきます。

API Gatewayの設定

(1) API Gatewayから新規にAPIを作成

(2) RESTの新しいAPIとして作成

(3) 新しいメソッドの作成

POSTで作成します。

(4) Lambdaの登録

Lambdaが実行できるように統合タイプを「Lambda関数」、Lambda関数にLambda名を入力

(5) 統合リクエストをクリック

(6) HTTPヘッダーの設定

名前をAuthentication、マッピング元を'Bearer <LINEのアクセストークン>' として登録します。
LINEのアクセストークンの取得については後述します。
登録したらこちらに入力しましょう。

(7) APIのデプロイ

「アクション」→APIのデプロイをクリックし、
ステージ名を入力してデプロイします。（ここではprodとする）

(8) APIのURIの発行

デプロイされると左メニューのステージ→prod→POSTにURLが発行されているはずです。
後のLINE Messaging APIのWebhookとして登録するのでどこかにURLをコピーしておきましょう。

Lambdaの設定

ソースコードはGitHubのlambda/lambda.pyを参照してください。
注意点としては、DBの接続情報、COTOHA APIの接続情報、LINE APIのトークン情報はLambdaの環境変数に登録していることです。

また、デフォルトでmysql-connector-pythonが入っていないためLambda上に入れる必要があります。
今回はLambdaのレイヤーを利用しました。
使い方はここを参照すると良いでしょう。

LINE Messaging APIの設定

初めて使う方は、チャネル作成についてはこちらを参照してください。

最低限必要な設定は以下です。

(1) Webhookの設定

事前にAPI Gatewayで作成したURLを登録します。

(2) アクセストークンの発行

(3) 自動応答の設定をオフにする

これを設定しないと関係ない返信をしてしまいます。

(4) Messaging APIの設定確認

LINE Official Account Managerに飛び、
左メニューのMessaging APIをクリックし、Webhook URLが登録されているか確認してください。
登録されていなければ(1)同様にAPIのURLを入力します。

参考

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

API Gateway + LambdaでLINE Bot開発

ファイルの読み込みと書き込みを同時に行いたい場合

w+を使う場合

"w+"は読み込みと書き込みが可能
sの内容をファイルに書き込み
seekで先頭に戻り、読み込んでいる
ここでseekを用いないとエラーが発生する

qiita.py

s="""\
AAA
BBB
CCC
DDD
"""

with open("test.text", "w+") as f:
    f.write(s)
    f.seek(0)
    print(f.read())

実行結果

AAA
BBB
CCC
DDD

注意点

"w+"で書き込み、読み込みはできるが
実行した時点でファイルの中身が消えてしまう
次のように読み込みのみしようとすると

qiita.py

s="""\
AAA
BBB
CCC
DDD
"""

with open("test.text", "w+") as f:
    # f.write(s)
    # f.seek(0)
    print(f.read())

実行結果

r+を使う場合

wのときとは違い読み込むファイルがないとエラーになるので注意

qiita.py

s="""\
AAA
BBB
CCC
DDD
"""

with open("test.text", "r+") as f:
    print(f.read())
    f.seek(0)
    f.write(s)

私が独断でお勧めの本を紹介します。

Pythonでハードウェア（Raspberry Pi）を触る

ラズパイ4対応 カラー図解 最新 Raspberry Piで学ぶ電子工作 作る、動かす、しくみがわかる!

https://www.amazon.co.jp/dp/4065193397
Pythonでハードウェア（RaspberryPi）を触るならこの一冊です。
難点は、本のサイズが小さい事
読みながらコードを打つのには向いていません・・・

ESP32とArduinoを学ぶなら

ESP32＆Arduino 電子工作 プログラミング入門

https://www.amazon.co.jp/dp/4297112051/
ここ数年の中で一番のArduino本でありながら、ESP32の詳細本でもあります。
Arduino本は、あれどESP32をキチンと取り扱っている本が少ないですが
本書は、ESP32とネイティブなArduinoを比較しながら解説しています。
初心者でプログラムを触りたい人にも満足できると思います。
もっと、深く書いても良いと思いますが、贅沢な悩みな気がします。

C言語でマイコンを深く触ろう

基板付きキット 絵解き マイコンCプログラミング教科書

https://www.amazon.co.jp/dp/4789845273/
マイコンボードをとりあえず触りたい、C言語って難しそう
と言う方や初心者の方には、上のESP32＆Arduino 電子工作 プログラミング入門をお勧めします。
Arduinoを触ったことがあるがもっとマイコンを触りたい、C言語を学びたいと言う人には、本書をお勧めします。
基板もついており、本書だけでC言語を学ぶ事が可能です。
私が経営者ならば、本書を使って新人教育をします。

2020年にはベストなArm本、ROSの本がまだ出ていないのが残念です。

私が独断でお勧めの本を紹介します。

Pythonでハードウェア（Raspberry Pi）を触る

ラズパイ4対応 カラー図解 最新 Raspberry Piで学ぶ電子工作 作る、動かす、しくみがわかる!

https://www.amazon.co.jp/dp/4065193397
Pythonでハードウェア（RaspberryPi）を触るならこの一冊です。
難点は、本のサイズが小さい事
読みながらコードを打つのには向いていません・・・

ESP32とArduinoを学ぶなら

ESP32＆Arduino 電子工作 プログラミング入門

https://www.amazon.co.jp/dp/4297112051/
ここ数年の中で一番のArduino本でありながら、ESP32の詳細本でもあります。
Arduino本は、あれどESP32をキチンと取り扱っている本が少ないですが
本書は、ESP32とネイティブなArduinoを比較しながら解説しています。
初心者でプログラムを触りたい人にも満足できると思います。
もっと、深く書いても良いと思いますが、贅沢な悩みな気がします。

C言語でマイコンを深く触ろう

基板付きキット 絵解き マイコンCプログラミング教科書

https://www.amazon.co.jp/dp/4789845273/
マイコンボードをとりあえず触りたい、C言語って難しそう
と言う方や初心者の方には、上のESP32＆Arduino 電子工作 プログラミング入門をお勧めします。
Arduinoを触ったことがあるがもっとマイコンを触りたい、C言語を学びたいと言う人には、本書をお勧めします。
基板もついており、本書だけでC言語を学ぶ事が可能です。
私が経営者ならば、本書を使って新人教育をします。

2020年にはベストなArm本、ROSの本がまだ出ていないのが残念です。

最近、仕事の都合で「数理最適化」というものに触れる機会に恵まれています。
折角なので、ちょっとだけプライベートで触れてみた結果を載せてみたいと思います。

やったことは、数理最適化の1例、「巡回セールスマン問題」
これを、なんと無料の環境pulpで実装できるということで、その環境を整えつつ、実装までやってみました。

やってみたい問題は以下のもの。

◆2.12 巡回セールスマン問題
https://www.msi.co.jp/nuopt/docs/v19/examples/html/02-12-00.html

以下に簡単に絵を描いて見ました。
A,B,C,Dが地図上のポイント。

Aを出発して、一筆書きをして帰ってくるとき、その距離の総和が一番小さいのはどのルートか???
という最適化問題のことを「巡回セールスマン問題」というらしいです。
NP困難と呼ばれて、結構難しいらしい。

しかし、python環境で触れるpulpというモデラーでのアプローチが無料で!!!簡単に出来るということで、以下の記事を参考にさせていただきます。

◆巡回セールスマン問題から始まる数理最適化
https://qiita.com/panchovie/items/6509fb54e3d53f4766aa

素晴らしいことに、pulpのインストールから、サンプルコードまで置いてあります。
早速、最初の設定をサンプルコードに入れてみます。
とりあえずコンパイルが通りそうな以下のようなコードでどうでしょうか。

import pulp as pp

# 最適化モデルの定義
mip_model = pp.LpProblem("tsp_mip", pp.LpMinimize)

N = 4
BigM = 10000

c_ = [
      [0,6,5,5], # pointA > [pointA,pointB,pointC,pointD]
      [6,0,7,4], # pointB > [pointA,pointB,pointC,pointD]
      [5,7,0,3], # pointC > [pointA,pointB,pointC,pointD]
      [5,4,3,0], # pointD > [pointA,pointB,pointC,pointD]
      ]

# 変数の定義
x = [[pp.LpVariable("x(%s,%s)"%(i, j), cat="Binary") for i in range(N)] for j in range(N)]
u = [pp.LpVariable("u(%s)"%(i), cat="Continuous", lowBound=1.0, upBound=(N)) for i in range(N)]

# 評価指標（式（１））の定義＆登録
objective = pp.lpSum(c_[i][j] * x[i][j] for i in range(N) for j in range(N) if i != j)
mip_model += objective

#　条件式(2)の登録
for i in range(N):
    mip_model += pp.lpSum(x[i][j] for j in range(N) if i != j) == 1

# 条件式(3)の登録
for i in range(N):
    mip_model += pp.lpSum(x[j][i] for j in range(N) if i != j) == 1

for i in range(N):
    mip_model += x[i][i] == 0

# 条件式(4) (MTZ制約)
for i in range(N):
    for j in range(N):
        if i != j:
            mip_model += u[i] + 1.0 - BigM * (1.0 - x[i][j]) <= u[j]


# 最適化の実行
status = mip_model.solve()

# 結果の把握
print("Status: {}".format(pp.LpStatus[status]))
print("Optimal Value [a.u.]: {}".format(objective.value()))

for i in range(N):
    for j in range(N):
        if i != j:
            print("x[%d][%d]:%f" % (i,j,x[i][j].value()))

for i in range(len(u)):
    print("u[%d] %f" % (i,u[i].value()))

この状態で実行すると･･･

Status: Infeasible
Optimal Value [a.u.]: 18.0
x[0][1]:0.000000
x[0][2]:1.000000
x[0][3]:0.000000
x[1][0]:0.999800
x[1][2]:0.000000
x[1][3]:0.000200
x[2][0]:0.000200
x[2][1]:0.000000
x[2][3]:0.999800
x[3][0]:0.000000
x[3][1]:1.000000
x[3][2]:0.000000

と出てきて、どうやら上手く計算できていないようです。
制約条件が上手く満たせていないような感じなので、色々と検討すると、どうやらこのままではMTZ制約の式がおかしくなるようでした。
最終状態のxからuについての式を4本全て書くと以下になります。

u[0] < u[2]\\
u[1] < u[0]\\
u[2] < u[3]\\
u[3] < u[1]

これを全部満たすとなると、

u[0] < u[2] < u[3] < u[1] < u[0] < ...

なんだか無限に増えていきますが、uの有効範囲は1~4の間のため矛盾が出てしまったようです。
そこで、最後にA地点に戻る変数についての制約を取り除くことで、以下のように式を構成しなおしてみます。

u[0] < u[2]\\
u[2] < u[3]\\
u[3] < u[1]

これによって、実装も変わり、MTZ条件の式は以下に変更となります。

# 条件式(4) (MTZ制約)
for i in range(N):
    for j in range(1,N):
        if i != j:
            mip_model += u[i] + 1.0 - BigM * (1.0 - x[i][j]) <= u[j]

ソースコードをまとめると以下になります。

sample_route.py

import pulp as pp

# 最適化モデルの定義
mip_model = pp.LpProblem("tsp_mip", pp.LpMinimize)

N = 4
BigM = 10000

c_ = [
      [0,6,5,5], # pointA > [pointA,pointB,pointC,pointD]
      [6,0,7,4], # pointB > [pointA,pointB,pointC,pointD]
      [5,7,0,3], # pointC > [pointA,pointB,pointC,pointD]
      [5,4,3,0], # pointD > [pointA,pointB,pointC,pointD]
      ]

# 変数の定義
x = [[pp.LpVariable("x(%s,%s)"%(i, j), cat="Binary") for i in range(N)] for j in range(N)]
u = [pp.LpVariable("u(%s)"%(i), cat="Continuous", lowBound=1.0, upBound=(N)) for i in range(N)]

# 評価指標（式（１））の定義＆登録
objective = pp.lpSum(c_[i][j] * x[i][j] for i in range(N) for j in range(N) if i != j)
mip_model += objective

#　条件式(2)の登録
for i in range(N):
    mip_model += pp.lpSum(x[i][j] for j in range(N) if i != j) == 1

# 条件式(3)の登録
for i in range(N):
    mip_model += pp.lpSum(x[j][i] for j in range(N) if i != j) == 1

for i in range(N):
    mip_model += x[i][i] == 0

# 条件式(4) (MTZ制約)
for i in range(N):
    for j in range(1,N):
        if i != j:
            mip_model += u[i] + 1.0 - BigM * (1.0 - x[i][j]) <= u[j]


# 最適化の実行
status = mip_model.solve()

# 結果の把握
print("Status: {}".format(pp.LpStatus[status]))
print("Optimal Value [a.u.]: {}".format(objective.value()))

for i in range(N):
    for j in range(N):
        if i != j:
            print("x[%d][%d]:%f" % (i,j,x[i][j].value()))

for i in range(len(u)):
    print("u[%d] %f" % (i,u[i].value()))

結果は以下になります。

Status: Optimal
Optimal Value [a.u.]: 18.0
x[0][1]:0.000000
x[0][2]:1.000000
x[0][3]:0.000000
x[1][0]:1.000000
x[1][2]:0.000000
x[1][3]:0.000000
x[2][0]:0.000000
x[2][1]:0.000000
x[2][3]:1.000000
x[3][0]:0.000000
x[3][1]:1.000000
x[3][2]:0.000000
u[0] 1.000000
u[1] 4.000000
u[2] 2.000000
u[3] 3.000000

無事に収束してくれました。
結果はグラフィカルに出ていませんが、

A地点　→　C地点　→　D地点　→　B地点　→　A地点

が最短らしく、その距離は18とのことでした。
問題が載っていたところには、

A地点　→　B地点　→　D地点　→　C地点　→　A地点

で、やはり、距離は18で最短らしいので、いくつか答えがあるということになるのですね。

数理最適化は、今まで触れてこなかった分野だけに、とても新鮮です。
気軽に試せる環境があるので、これを機に色々と勉強してみようと思います。

総括

ABC解けました。
D,Eは方針まで立てられたのですが時間内に解けず。
今回は初めてF問題まで考えることができました（解けるか否かはまた別の話・・・）
後日Eは解けましたが、DはWAをつぶしきれずいまだACしていません。

問題

https://atcoder.jp/contests/abc175

A. Rainy Season

回答

S = tuple(input())

if S == ('R', 'R', 'R'):
    print(3)
elif S == ('R', 'R', 'S') or S == ('S', 'R', 'R'):
    print(2)
elif S == ('S', 'S', 'S'):
    print(0)
else:
    print(1)

上手い具合の解き方がないか考えましたが、思いつかず。
全部列挙してif文で解きました。

コンテスト時はわざわざtupleにいれましたが、文字列をそのまま判定してよいですね。

B. Making Triangle

回答

from itertools import combinations

N = int(input())
L = list(map(int, input().split()))

count = 0
for C in combinations(L, 3):
    l_list = list(C)
    l_list.sort()

    if l_list[2] > l_list[1] and l_list[1] > l_list[0]:
        if l_list[2] < l_list[1] + l_list[0]:
            count += 1

print(count)

三角形の条件なので、最大の辺 < その他の2辺の和で解けます。
制約が小さいので全部列挙しました。

C. Walking Takahashi

回答

X, K, D = map(int, input().split())

new_X = abs(X) % D
new_K = K - abs(X) // D

if new_K <= 0:
    answer = abs(X) - K*D
else:
    if new_K % 2 == 0:
        answer = new_X
    else:
        answer = abs(new_X - D)

print(answer)

まず制約がきつすぎるので、for文は絶対に使いたくないです。
これだけ大きい数字を処理するのですから、「大きい数を何かの数で割り算を行う」という処理がどこかに入ってくると予想ができます。

そう考えると、座標Xを移動距離Dでとりあえず割ってみたくなります。
X // Dの意味を考えてみると、「X距離進むために必要な距離Dの移動の回数」であるとわかります。
「移動の回数」ときたらKから引き算をしたくなりますね。

次に、いくつか入力サンプルで実験すると、DがXより十分に大きい場合は原点付近で振動することがわかります。
振動するということは、答えは二通りだなとわかります。

ここまでくるとだいぶ方針が固まってきました。
1. K - X // Dを行い残りの回数を算出
2. 原点付近で振動するのでその2通りの場合分けを行い、答え算出
3. あとは正負の扱いに注意して、XがDより十分に大きい場合の例外を処理

これをコードに落とします。

D. Moving Piece

回答（これは半分WAとなります）

N, K = map(int, input().split())
P = [0] + list(map(int, input().split()))
C = [0] + list(map(int, input().split()))

answer = -float('inf')
for start_p in range(1, N+1):

    cycle_total_score = 0
    cycle_in_score = -float('inf')
    cycle_count = 0
    next_p = P[start_p]
    while True:
        cycle_total_score += C[next_p]
        cycle_in_score = max(cycle_in_score, cycle_total_score)
        cycle_count += 1

        if next_p == start_p:
            # print('start_p:', start_p, ' cycle_total_score:', cycle_total_score, 'cycle_in_score:', cycle_in_score, 'cycle_count:', cycle_count)
            break
        next_p = P[next_p]

    max_score = 0
    if K == cycle_count:
        max_score = cycle_in_score
    else:
        #あふれたK % cycle_count回数分だけスコアを足すためにmaxを探さす
        add_max_count = K % cycle_count
        add_total_score = 0
        add_score = -float('inf')
        add_count = 0
        add_next_p = P[start_p]
        while True:
            add_total_score += C[add_next_p]
            add_score = max(add_score, add_total_score)
            add_count += 1

            if add_count == add_max_count:
                break
            add_next_p = P[add_next_p]

        if K < cycle_count:
            #最大の試行回数がcycle_countよりも小さい場合K % cycle_countまでで一番良いところでbeak
            max_score = add_total_score
        else:
            if cycle_total_score >= 0:
                #1サイクルでプラスの場合はできるだけサイクルを回してK % cycle_countまでで一番良いところでbeak
                max_score = (K // cycle_count) * cycle_total_score + add_total_score
            else:
                #1サイクルでマイナスの場合はサイクルを回さないで、K % cycle_countまでで一番良いところでbreak
                max_score = add_total_score
    # print('max_score', max_score)
    answer = max(answer, max_score)

print(answer)

いまだにACをとることができていません。上記コードではテスト入力はすべて通るのですが、本番では半分がWAとなります。
考え方はあっていると思うのですが、WAの原因を特定しきれていません・・・。

文字だけだと何を言っているかわからないので図を描きます。下記は入力例１を図示化したものです。

この図の特徴を考えると、サイクルを持ったグラフが1つ以上作成できることがわかります。
解く方針は愚直に全通りを試します。
1. まずはスタートする場所を決める=>これをN通り試す
2. スタートから一回りしてみて、下記のスコアを記録しておく
　　2.1 . 1サイクルの合計のスコア
　　2.2. 1サイクル内で最大となる瞬間のスコア
　　2.3. 1サイクルに必要な移動の数
3. Kが1サイクルの移動数の整数倍であれば簡単ですが、中途半端の時があり得るのでその場合に下記スコアを探しに行きます
　　3.1. 中途半端となる数
　　3.2. 中途半端となる数のなかで最大となるときのスコア

たぶんこれで解けるはずなのですが、最後まで解けきれていません（ということはこれで解けないのでは？）。

E. Picking Goods

回答（通常版 TLEです）

R, C, K = map(int, input().split())
scores = [[0] * (C + 1) for _ in range(R+1)]
for _ in range(K):
    r, c, v = map(int, input().split())
    scores[r][c] = v
dp = [[[0] *4 for _ in range(C+1)] for _ in range(R+1)]

for i in range(1, R+1):
    for j in range(1, C+1):
        for k in range(4):
            dp[i][j][k] = max(dp[i][j-1][k],
                              dp[i-1][j][3])
        for k in range(3, 0, -1):
            dp[i][j][k] = max(dp[i][j][k],
                              dp[i][j][k-1] + scores[i][j])

answer = dp[R][C][3]
print(answer)

回答（高速化ver ACです）

from numba import jit
import numpy as np

@jit
def main():
    R, C, K = map(int, input().split())
    scores = np.zeros((R,C), np.int64)
    for _ in range(K):
        r, c, v = map(int, input().split())
        scores[r-1][c-1] = v
    dp = np.zeros((R+1,C+1,4), np.int64)

    for i in range(1, R+1):
        for j in range(1, C+1):
            for k in range(4):
                dp[i][j][k] = max(dp[i][j-1][k],
                                  dp[i-1][j][3])
            for k in range(3, 0, -1):
                dp[i][j][k] = max(dp[i][j][k],
                                  dp[i][j][k-1] + scores[i-1][j-1])

    return dp[R][C][3]

print(main())

これは時間内に解きたかったです。
Pythonで普通に組んでしまうと時間がギリギリ間に合いませんが、numpyと@jitでもとのコードを改良すれば通ります。

まずは問題を読んでDPであることがわかりました。しかし僕が解けるのはまだ2次元のDPまで・・・。
とりあえず「同じ行で3個まで」の制約を無視してDPを書いてみます。
すると下記のようになります。
（2次元のDPテーブルを可視化する際はpandasを使うと縦横が見やすくなるのでデバック用としてpandasとnumpyをいれてます)

R, C, K = map(int, input().split())
scores = [[0] * (C + 1) for _ in range(R+1)]
for _ in range(K):
    r, c, v = map(int, input().split())
    scores[r][c] = v
dp = [[0] *(C+1) for _ in range(R+1)]

for i in range(1, R+1):
    for j in range(1, C+1):
            dp[i][j] = max(dp[i-1][j] + scores[i][j],
                           dp[i][j-1] + scores[i][j])

print(dp[R][C])

# import numpy as np
# import pandas as pd
# show_dp = np.array(dp)
# show_dp = pd.DataFrame(show_dp)
# print(show_dp)

ここまでは簡単です。
（と言いつつ、1週間前の僕ではここまでくるのは不可能でしたが、ここ1週間でここ>>レッドコーダーが教える、競プロ・AtCoder上達のガイドライン【中級編：目指せ水色コーダー！】のDP問題を解いていたのでそう言えるのですが・・・。）

コンテスト時はここから「同じ行で3個まで」の制約を組み込むことができませんでした。
dpテーブルの次元を一つ増やして「何か」すればよいということはわかったのですが、この「何か」を思つくことができませんでした。

「横に行くときは3回目まではscoreを追加し、それ以外は追加しない」をそのまま書いてみます。
僕はdpを解くときは実際にdpテーブルを紙に書いて視覚化しないとうまくイメージがつかないので、3次元のdpテーブルはなかなかしっくりこないです・・・。
習うより慣れろというところでしょうか。

ところで、pythonでは普通にdpでコード化するとTLEになります。
方針としてはnumpyを使ってfor文で書いているところを一括で計算するか、pypyを使うか、jitを使うか、と思います。
強い人は当然にnumpyで上手いこと計算しているようですが、僕はまだそこまでは書けません。
今回のコードではpypyでも通りませんでしたので、関数化して@jitを使ってみました。

すると、下記のように「少量の計算は格段に遅く、大量の計算は格段に速く」なり、なんとかAC通りました。どうしてこうなるのかわかりませんが、とりあえずdpで通らない場合は同じようにjitで試してみます。

【普通のコードの場合】

【@jitを使用したコードの場合】

ファイルをまとめて読み込み

qiita.py

with open("test.text", "r") as f:
    print(f.read())

一行ずつ読み込む

1行ずつ読み込みたい時はreadlineを使う
print関数でend=""とする理由としてはprint関数で改行が行われてしまうから

qiita.py

with open("test.text", "r") as f:
    while True:
        line = f.readline()
        print(line,end="")
        if not line:
            break

実行結果

AAA
BBB
CCC
DDD

end=""を使わないと

qiita.py

with open("test.text", "r") as f:
    while True:
        line = f.readline()
        print(line)
        if not line:
            break

実行結果

AAA

BBB

CCC

DDD

特定の文字数ごと読み込む

chunkを設定する
ネットワークの読み込みに使われる事も

qiita.py

with open("test.text", "r") as f:
    while True:
        chunk = 2
        line = f.read(chunk)
        print(line)
        if not line:
            break

実行結果

AA
A

BB
B

CC
C

DD
D

seekを使った移動

teil　現在の位置を返す
seek　任意の位置に移動することができる

qiita.py

with open("test.text", "r") as f:
    print(f.tell())
    #0
    print(f.read(1))
    #A
    f.seek(5)
    print(f.read(1))
    #B
    f.seek(14)
    print(f.read(1))
    #D

　学習メモです。

やったこと

　画像のコントラストを調整するPythonスクリプトを書きました。

コード

import cv2
import numpy as np
import matplotlib.pyplot as plt

img = cv2.imread('画像.jpg')

#コントラスト
contrast = 128

#コントラスト調整ファクター
factor = (259 *(contrast + 255)) / (255 *(259 - contrast))

#float型に変換
newImage = np.array(img, dtype = 'float64')

#コントラスト調整。（0以下 or 255以上）はクリッピング
newImage = np.clip((newImage[:,:,:] - 128) * factor + 128, 0, 255)

#int型に戻す
newImage = np.array(newImage, dtype = 'uint8')

#出力
cv2.imwrite('out.png', newImage)

結果

　レナさんの画像で試してみます。

オリジナル画像

コントラスト+128で調整後

　

参考URL

IMAGE PROCESSING ALGORITHMS PART 5: CONTRAST ADJUSTMENT
Algorithms for Adjusting Brightness and Contrast of an Image

「続【Python】英文PDF（に限らないけど）をDeepLやGoogle翻訳で自動で翻訳させてテキストファイル、いやHTMLにしてしまおう。」
https://qiita.com/Cartelet/items/a00d4cec8216d04f9274

を試してみました。

環境

• Ubuntu 18.04
• Python 3.6.9
• コード:

記事にはいくつかのバージョンが示されてますが、今回は8/11追記分の「文章分解強化版コード」を使用しました。

Word通さずともある程度段落を分解できるようにしました。
（だいたい）段落ごとに翻訳するため、１文ずつに比べ翻訳速度もだいぶマシになりました。

このコードを pdftrans.py として保存しました。

ライブラリ設定など

$ python3 pdftrans.py 

として実行すると

Traceback (most recent call last):
  File "pdftrans.py", line 1, in <module>
    from selenium import webdriver
ModuleNotFoundError: No module named 'selenium'

と出たので

$ sudo pip3 install selenium

としてインストール。pyperclip も同様に必要だったので、

$ sudo pip3 install pyperclip

としてインストール。

Traceback (most recent call last):
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/common/service.py", line 76, in start
    stdin=PIPE)
  File "/usr/lib/python3.6/subprocess.py", line 729, in __init__
    restore_signals, start_new_session)
  File "/usr/lib/python3.6/subprocess.py", line 1364, in _execute_child
    raise child_exception_type(errno_num, err_msg, err_filename)
FileNotFoundError: [Errno 2] No such file or directory: 'chromedriver.exe': 'chromedriver.exe'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "pdftrans.py", line 165, in <module>
    TranslateFromClipboard(*args)
  File "pdftrans.py", line 75, in TranslateFromClipboard
    chrome_options=options)
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/chrome/webdriver.py", line 73, in __init__
    self.service.start()
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/common/service.py", line 83, in start
    os.path.basename(self.path), self.start_error_message)
selenium.common.exceptions.WebDriverException: Message: 'chromedriver.exe' executable needs to be in PATH. Please see https://sites.google.com/a/chromium.org/chromedriver/home

となったので、

https://sites.google.com/a/chromium.org/chromedriver/homeから
chromedriver_linux64.zip
をダウンロードして展開。

$ ls -alh
合計 16M
drwxrwxr-x  2 nanbuwks nanbuwks 4.0K  8月 17 21:07 .
drwxrwxr-x 91 nanbuwks nanbuwks  56K  8月 17 21:06 ..
-rwxr-xr-x  1 nanbuwks nanbuwks  11M  5月 29 06:05 chromedriver
-rw-rw-r--  1 nanbuwks nanbuwks 5.1M  8月 17 21:06 chromedriver_linux64.zip
-rw-r--r--  1 nanbuwks nanbuwks 8.0K  8月 17 16:53 pdftrans.py

として、pdftrans.py と同じディレクトリに配置しました。

その上で pdftrans.py の9行目

DRIVER_PATH = 'chromedriver.exe'

となっているところを以下のように変更。

DRIVER_PATH = './chromedriver'

PATHの 設定を簡略化してとりあえず pdftrans.py はスクリプトのあるディレクトリで実行することにしました。

Traceback (most recent call last):
  File "pdftrans.py", line 165, in <module>
    TranslateFromClipboard(*args)
  File "pdftrans.py", line 75, in TranslateFromClipboard
    chrome_options=options)
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/chrome/webdriver.py", line 81, in __init__
    desired_capabilities=desired_capabilities)
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/remote/webdriver.py", line 157, in __init__
    self.start_session(capabilities, browser_profile)
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/remote/webdriver.py", line 252, in start_session
    response = self.execute(Command.NEW_SESSION, parameters)
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/remote/webdriver.py", line 321, in execute
    self.error_handler.check_response(response)
  File "/usr/local/lib/python3.6/dist-packages/selenium/webdriver/remote/errorhandler.py", line 242, in check_response
    raise exception_class(message, screen, stacktrace)
selenium.common.exceptions.SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version 84

と出たので Chromeは Version 83 を使用していたのですが、最新版にアップデートしてバージョン: 84.0.4147.125（Official Build） （64 ビット）としました。

実行

$ python3 pdftrans.py 
1. 英語 → 日本語    2. 日本語 → 英語   1
1. DeepL 2.GoogleTranslate　　1
翻訳結果を書き出しますか？　y/n　　y
1. txt 2. HTML 3. both    2
出力ファイルにつける名前を入力してください（デフォルトは'translated_text.html'）　　
（論文の）タイトルを入力してください   zigbeebdb
翻訳経過をここに表示しますか？　y/n　　n
準備ができたらEnterを押してください

1/900  0% done


2/900  0% done


3/900  0% done


4/900  0% done

・
・
・

結果

使ってみて

• 今回は87ページのPDFを試してみました。
• 上記例ではGoogle ChromeでPDFを開きクリップボードにコピーした所900センテンスで処理されました。後ほどevinceでPDFを開きクリップボードにコピーしたところ1249センテンスで処理されました。
• 1249センテンス処理で約30分。
• DeepLだと全体の1/20ぐらいでTimeUpぽくGoogleTranslateで実行しました。
• どうせGoogleTranslateにするなら8/16版の高速版で試した方が方が良かったかも。

8/16追記
マルチスレッドで大量にChromeを開く力技高速化を施しました。
こちらは書き出しはHTMLのみとなっています。
またDeepLの場合、多く開きすぎると制限がかかって翻訳止まりますのでご注意ください。

• 時間かかっても他の作業すればまあいいかと思っていましたが、クリップボードがコントロールされるので並行作業はコツがいる感じ。
• 参照した記事の更に元になった記事に使い方が書いてあったのですが、ちゃんと読まずに使おうとして、あれれーとなりました。 ちゃんと読んで事前にPDF文字情報をクリップボードにコピーしておけばちゃんと動きました！

「【Python】英文PDF（に限らないけど）をDeepLやGoogle翻訳で自動で翻訳させてテキストファイルにしてしまおう。」
https://qiita.com/Cartelet/items/c56477033cda17a2a28a

追記 8/16版の高速版で試してみた

同時並行30にしたら、上記と同じ87ページ1249センテンスの文書が10分程度で翻訳できましたが、ロードアベレージがえらいことになりました。

オーバーヘッドのロスがかからないように環境に応じて工夫するのが良さそうです。

実際に、同時並行10にしてみたら6分程度で処理できました。

Part.2のおさらい

Part2では、主に以下のことを行いました。

• Lambdaに固定引数を渡してみる
• Lambdaに外部からの引数を渡してみる
• Lambdaにコンテキストオブジェクトを渡してみる
• Lambdaの戻り値を、別のTaskの引数に渡してみる

今回は、その続きからはじめてみます。
ここから始める方は、
https://github.com/hito-psv/sam-demo-005
のコードをgit cloneしてもらっても大丈夫ですし、Part2からやってみてもらっても構いません。

今回のターゲット

• Lambdaでランダムな結果を返す
• 結果に応じて、次に実行するタスクを変える
• リトライ時は、しばらく時間が経ってから再実行する

をターゲットにしてみたいと思います。
Lambda部分については、Part2で作成した「HelloWorld」の関数を少しだけいじって、色々試してみたいと思います。

準備

Lambda関数を修正する

現在のコードに、乱数でいくつかのパターンの文字列を返すようにしてみたいと思います。

hello_world/app.py

import logging
import random

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    logger.info(event)

    message_array = [
        "hello world",
        "retry"
    ]
    message = random.choice(message_array)
    logger.info(message)

    return {
        "statusCode": 200,
        "body": {
            "message": message,
        }
    }

これで、結果のメッセージには

• hello_world
• retry

のいずれかの文字列が返されます。

ビルド・デプロイする

この状態で、sam build、sam deploy --guidedを実行し、Lambda関数をデプロイしましょう。

Lambda関数の戻り値によって振る舞いを変える

ステートマシン定義の修正

まずは、ステートマシンの定義を修正します。
修正内容は後ほど説明しますので、まずは、このように修正してみます。

step_functions/state_machine.json

{
  "StartAt": "hello world 1",
  "States": {
    "hello world 1": {
      "Type": "Task",
      "Resource": "${HelloWorldFunction}",
      "Parameters": {
        "p1.$": $.p1,
        "p2.$": "$.p2",
        "p3": {
          "p3-1": 20,
          "p3-2": "xyz"
        },
        "all.$": "$"
      },
      "ResultPath": "$.hello_world_result",
      "OutputPath": "$",
      "Next": "check state"
    },
    "retry lambda": {
      "Type": "Task",
      "Resource": "${HelloWorldFunction}",
      "InputPath": "$",
      "ResultPath": "$.hello_world_result",
      "OutputPath": "$",
      "Next": "check state"
    },
    "check state": {
      "Type" : "Choice",
      "Choices": [
        {
          "Variable": "$.hello_world_result.body.message",
          "StringEquals": "hello world",
          "Next": "hello world 2"
        },
        {
          "Variable": "$.hello_world_result.body.message",
          "StringEquals": "retry",
          "Next": "wait state"
        }
      ],
      "Default": "fail state"
    },
    "wait state": {
      "Type": "Wait",
      "Seconds": 5,
      "Next": "retry lambda"
    },
    "hello world 2": {
      "Type": "Task",
      "Resource": "${HelloWorldFunction}",
      "InputPath": "$",
      "End": true
    },
    "fail state": {
      "Type": "Fail",
      "Cause": "No Matches!"
    }
  }
}

1. 「hello world 1」は次のステートに「check state」のステートを実行する
2. 「check state」は「$.hello_world_result.body.message」の値が「hello world」なら、次のステートに「hello world 2」を実行する
3. 「check state」は「$.hello_world_result.body.message」の値が「retry」なら、次のステートに「wait state」を実行する
4. 「check state」は「$.hello_world_result.body.message」の値が「hello world」「retry」以外なら、次のステートに「fail state」を実行する（今回は起こり得ない）
5. 「wait state」は、5秒経ったら「retry lambda」のステートを実行する
6. 「retry lambda」は、lambda関数をコールした後、「check state」のステートを実行する
7. 「hello world 2」はlambda関数をコールした後、ステート実行を終了する
8. 「fail state」は、異常終了としてステート実行を終了する

という記述になっています。
「Choices」の中で

• Variable：チェック対象
• StringEquals：文字列がこの値と同じなら
• Next：次に実行するステート

を指定します。
なお、StringEqualsの箇所に指定できる演算は、AWS Step Functions開発者ガイドを参照ください。

ビルド・デプロイする

この状態で、sam build、sam deploy --guidedを実行し、デプロイしましょう。

ステートマシンの確認

まずは、ステートマシンの定義更新によって、可視化されたステートマシンがどのようになっているかをみてみましょう。

変更したように、「check state」から分岐し、「retry lambda」の後「check state」に戻っていることが確認できたと思います。

ステートマシンを実行してみる

マネジメントコンソールから、ステートマシンを実行してみましょう。
Part.2からの修正のため、入力値のp1、p2を使用するため、入力蘭を以下のように指定してください。

• p1に、9999数値を指定
• p2に「p2 strings.」という文字列を指定

結果をみてみる

まずは、ビジュアルフローを確認してみましょう。
見事に、全パスが通ってくれてます（ランダムなので、「hello world 1」→「check state」→「hello world 2」という流れもありえます）。

では、Choiceの処理が正しく動作しているのか、確認してみましょう。
まずは、「hello world 1」のステートから呼び出されたLambda関数の戻りがこちらです。

bodyのmessage部が「retry」であることが確認できます。
その結果、次に「wait state」が実行され、5秒後（#10と#11の時間をチェック）「retry lambdaのステートが実行されています。

実は、この後、更に2回連続して「retry」が返ってきますが、3回目に「hello world」が返されます。

その後は「hello world 2」のステートが実行されていることがわかります。

そして、そのままステートが終了します。

新しく追加された「Choice」ステート

2020/8/13に、アップデートされた内容があります。

値のテスト（型チェック）

• IsNull
• IsString
• IsNumeric
• IsBoolean
• IsTimestamp

によって、Variableの型をChoiceで確認することができます。

例

   "Variable": "$.foo",
   "IsNull|IsString|IsNumeric|IsBoolean|IsTimestamp": true|false

存在チェック

• IsPresent

によって、Variableそのものの存在チェックを行うことができます。

例

  "Variable": "$.foo",
  "IsPresent": true|false

ワイルドカードチェック

• StringMatches

によって、ワイルドカードを使用した判定チェックが行えます。

例

  "Variable": "$.foo",
  "StringMatches": "log-*.txt"

別の入力フィールドとの比較

• StringEqualsPath

によって、入力フィールドを別の入力フィールドと比較できます。状態の変更などを確認するときに使用できます。

例

  "Variable": "$.foo",
  "StringEqualsPath": "$.bar"

詳細

こちらから確認できます。

AWS Step Functions adds updates to ‘choice’ state, global access to context object, dynamic timeouts, result selection, and intrinsic functions to Amazon States Language

まとめ

今回はChoiceによる分岐を行なってみましたが、ここまで来ると、ようやくワークフローっぽくなってきた感じがしますね。
ここまでのPart.1〜Part.3の内容だけでも、ある程度のステートマシンが定義できるようになっているかと思います。
次回は、Lambda以外のサービスをタスク定義で呼び出してみたいと思います。

サンプルコードリポジトリ

https://github.com/hito-psv/sam-demo-006

次のように書くとtest.textというファイルが作成されその中にtestと書き込まれる

qiita.py

f = open("test.text", "w")
f.write("test")
f.close()

追加で書き込む際は'w'を'a'と書き換える必要がある
'w'のままにしておくと上書きされてしまう

qiita.py

f = open("test.text", "a")
f.write("test2")
f.close()

ファイルの状態

testtest2

print関数

print関数を使ってもファイルに書き込むことが可能

qiita.py

f = open("test.text", "w")
f.write("test\n")
print("print関数での書き込み", file=f)
f.close()

ファイルの状態

test
print関数での書き込み

,で区切って書くとスペース開けて書き込まれる

qiita.py

f = open("test.text", "w")
f.write("test\n")
print('print','関数','での','書き込み', file=f)
f.close()

ファイルの状態

test
print 関数 での 書き込み

sep,endも使うことが可能

qiita.py

f = open("test.text", "w")
f.write("test\n")
print('print','関数','での','書き込み',sep="#",end="@", file=f)
f.close()

ファイルの状態

test
print#関数#での#書き込み@

withステートメント

ファイルをf.closeを忘れるとメモリが消費されてしまう
withステートメントを使用することでcloseを使わずに済む

qiita.py

with open("test.text", "w") as f:
    f.write("test\n")
    print('print','関数','での','書き込み',sep="#",end="@", file=f)

今回の成績

今回の感想

やはりDを通せないところがまだ安定感のなさを感じます。
非想定解でゴリゴリやろうとして行き詰まってしまいました。
ゴリゴリやろうとする場合も見通しをちゃんと持ってから実装するようにします。

A問題

問題を誤読しかけました。問題は三角形を構成しないような三つの数の組を答えるというもので、数列$a$は昇順ソート済みなので、$a_i+a_j<a_k (i<j<k)$が存在するかを確かめます。これは$a_i+a_j$を小さく$a_k$を大きくすることを考えれば良いので、$(i,j,k)=(1,2,n)$で成り立つかを確かめれば良いです。

A.py

for _ in range(int(input())):
    n=int(input())
    a=list(map(int,input().split()))
    if a[0]+a[1]<=a[-1]:
        print(f"1 2 {n}")
    else:
        print(-1)

B問題

一瞬難しそうで身構えましたが、簡単でした。

どちらも選ぶ1の個数を最大化することを目指すので、長い1の連続部分列から順に交互に選んでいきます。したがって、文字列$S$に含まれる1の連続部分列の長さをansに格納した後に値の降順でソートして、奇数番目のものの合計がAliceのスコアの最大値となります。二つ飛ばしを選ぶのにPythonではans[::2]だけで書けるので非常に便利ですね。

B.py

for _ in range(int(input())):
    s=input()
    n=len(s)
    ans=[0]
    for i in range(n):
        if s[i]=="1":
            ans[-1]+=1
        else:
            if ans[-1]!=0:
                ans.append(0)
    ans.sort(reverse=True)
    print(sum(ans[::2]))

C問題

足し算の遷移としての扱いやすさからDPを疑いましたが、状態の管理ができないのでDPは難しいです(結果的にD問題がDPでした。悔しいです。)。

ここでは、区間を扱うので累積和の差分を考えることにしました。したがって、$x$番目までの和を$S_x$とおきます。この時、題意の条件は$S_r- S_{l-1}=r-l+1 \leftrightarrow S_r-r=S_{l-1}-(l-1)$となります。よって、$S_0-0=0$とすれば、任意の$i(0 \leqq i \leqq n)$について$S_i-i$が等しいもの同士は組になります。したがって、これはCounterなどの辞書を用いて同じになるもの同士に分け、$S_i-i=k$となるような$i$が$l$個ある時は$_l C _2$がそれらの$i$の組み合わせの個数となります。それぞれの$k$でこの計算を行い、和をとったものが答えとなります。

AtCoderでも最近出た気がするので高速に解くことができました。おそらく1ヶ月前は30分くらいかかっているので、精進の大切さと成長を感じました。

C.py

for _ in range(int(input())):
    n=int(input())
    a=list(map(int,input().split()))
    if a==[i+1 for i in range(n)]:
        print(0)
        continue
    #端は除く
    for i in range(n):
        if a[i]!=i+1:
            break
    for j in range(n-1,-1,-1):
        if a[j]!=j+1:
            break
    #インデックス間違い
    for k in range(i,j+1):
        if a[k]==k+1:
            print(2)
            break
    else:
        print(1)

D問題

一つの考察のズレが大きな差を生むと感じました。もっと精度を高めた考察をしたいです。

まず容易に思いつく方針として値の大きいものから貪欲に組みにしていくというものがあります。つまり、$r,g,b$の辺の組ををそれぞれ長い順でpriority_queueに突っ込んで長いものから組にしていきます。しかし、この方法をとった場合は一つの色の辺だけ余ってしまいます。この場合はどうするべきでしょうか。一つ目の方法は、余った辺を後付けで組み込むことです。しかし、貪欲法を行っている(自分で選び順を恣意的に決めている)ので、後付けにより貪欲法が崩れる可能性があります。自分は崩さないように考えたのですが、コーナーケースを踏みそうで実装できませんでした。このようにある程度考えても難しく、他にも方針が立ちうる場合はいったん別の方法を考えてみるべきです。

ここで、先述の貪欲法ではかなり実行時間に対して余裕があるので、貪欲法にこだわらずとも考えることができます。次に考えつく方法としてはDPではないでしょうか。選ぶという遷移を考えることに加え、$r,g,b$は高々200なので$R \times G \times B=8 \times 10^6$程度の状態数しかなさそうというところから、かなりDPは有効な手段ではないかと考えられます。

ここで考えるDPは以下です。また、$r,g,b$はそれぞれ大きいものから選んでいくのが最適なので、降順ソートされているものとして議論を進めます。

$dp[i][j][k]:=$($r$の$i$個,$g$の$j$個,$b$の$k$個を組にした時に最大の長方形の合計の面積)

さらに、通常の遷移では一つずつ要素を加えることを考えますが、今回は組にすることで長方形を作れるので、組を加える遷移を考えます。したがって、以下のようになります。

(1)$i<R$かつ$j<G$の時
$r$及び$g$から組を選ぶことができるので、選べる中で一番大きい$r[i]$と$g[j]$を選びます($i,j$は0-indexedであることに注意が必要です。)。
$dp[i+1][j+1][k]=max(dp[i+1][j+1][k],dp[i][j][k]+r[i]*g[j])$

(2)$i<R$かつ$k<B$の時
$r$及び$b$から組を選ぶことができるので、選べる中で一番大きい$r[i]$と$b[k]$を選びます($i,k$は0-indexedであることに注意が必要です。)。
$dp[i+1][j][k+1]=max(dp[i+1][j][k+1],dp[i][j][k]+r[i]*b[k])$

(3)$j<G$かつ$k<B$の時
$g$及び$b$から組を選ぶことができるので、選べる中で一番大きい$g[j]$と$b[k]$を選びます($j,k$は0-indexedであることに注意が必要です。)。
$dp[i][j+1][k+1]=max(dp[i][j+1][k+1],dp[i][j][k]+g[j]*b[k])$

(4)その他の時
組として選べるものがないので、以下がそれぞれ答えとなります。
[1]$i<R$の時、$dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k])$
[2]$j<G$の時、$dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k])$
[3]$k<B$の時、$dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j][k])$

D.cc

//デバッグ用オプション：-fsanitize=undefined,address

//コンパイラ最適化
#pragma GCC optimize("Ofast")

//インクルードなど
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

//マクロ
//forループ
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
//Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
//FORAは範囲for文(使いにくかったら消す)
#define REP(i,n) for(ll i=0;i<ll(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=ll(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=ll(b);i--)
#define FORA(i,I) for(const auto& i:I)
//xにはvectorなどのコンテナ
#define ALL(x) x.begin(),x.end() 
#define SIZE(x) ll(x.size()) 
//定数
#define INF 1000000000000 //10^12:∞
#define MOD 1000000007 //10^9+7:合同式の法
#define MAXR 100000 //10^5:配列の最大のrange
//略記
#define PB push_back //挿入
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素

signed main(){
    //入力の高速化用のコード
    //ios::sync_with_stdio(false);
    //cin.tie(nullptr);
    ll R,G,B;cin>>R>>G>>B;
    vector<ll> r(R);REP(i,R)cin>>r[i];sort(ALL(r),greater<ll>());
    vector<ll> g(G);REP(i,G)cin>>g[i];sort(ALL(g),greater<ll>());
    vector<ll> b(B);REP(i,B)cin>>b[i];sort(ALL(b),greater<ll>());
    vector<vector<vector<ll>>> dp(R+1,vector<vector<ll>>(G+1,vector<ll>(B+1,0)));
    REP(i,R+1){
        REP(j,G+1){
            REP(k,B+1){
                //pairごとで選ぶ、配るDP
                //思いつければ楽だけど
                //dp[i][j][k]:=i番目j番目k番目まで組にした時の
                bool f=false;
                if(i<R and j<G){
                    dp[i+1][j+1][k]=max(dp[i+1][j+1][k],dp[i][j][k]+r[i]*g[j]);
                    f=true;
                }
                if(i<R and k<B){
                    dp[i+1][j][k+1]=max(dp[i+1][j][k+1],dp[i][j][k]+r[i]*b[k]);
                    f=true;
                }
                if(j<G and k<B){
                    dp[i][j+1][k+1]=max(dp[i][j+1][k+1],dp[i][j][k]+g[j]*b[k]);
                    f=true;
                }
                if(!f){
                    if(i<R)dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k]);
                    if(j<G)dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k]);
                    if(k<B)dp[i][j][k+1]=max(dp[i][j][k+1],dp[i][j][k]);
                }
            }
        }
    }
    cout<<dp[R][G][B]<<endl;
}

E問題以降

今回は飛ばします

qiita.py

class Person(object):

    kind = 'human'

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

    def who_are_you(self):
        print(self.name,self.kind)

a = Person('A')
a.who_are_you()
#A human

b = Person('B')
b.who_are_you()
#B human

注意点

クラス変数は全てのオブジェクトで共有される

qiita.py

class T(object):

    words = []

    def add_word(self,word):
        self.words.append(word)
c = T()
c.add_word('add1')
c.add_word('add2')

d = T()
d.add_word('add3')
d.add_word('add4')
print(c.words)
#['add1', 'add2', 'add3', 'add4']

このように書き換える必要がある
initで初期化する

qiita.py

class T(object):
    def __init__(self):
        self.words = []

    def add_word(self,word):
        self.words.append(word)
c = T()
c.add_word('add1')
c.add_word('add2')
print(c.words)
#['add1', 'add2']

d = T()
d.add_word('add3')
d.add_word('add4')
print(d.words)
#['add3', 'add4']

クラスメソッド

qiita.py

class Person(object):

    kind = 'human'

    def __init__(self):
        self.x = 100

a = Person()
print(a)
b = Person
print(b)

実行すると
aでは『オブジェクトだと表示』され、
bでは『クラスのみを示し、オブジェクト化されていない』と表示される。

<__main__.Person object at 0x7fc0558d6210>
<class '__main__.Person'>

self.xにアクセスしようとすると
aでは100と表示されるが
bではinitが実行されていない為エラーが発生する

qiita.py

class Person(object):

    kind = 'human'

    def __init__(self):
        self.x = 100

a = Person()
print(a.x)
b = Person
print(b.x)

100
Traceback (most recent call last):
  File "/Users/kirinboy96/PycharmProjects/untitled1/lesson_package/NEW1.py", line 11, in <module>
    print(b.x)
AttributeError: type object 'Person'

ただ、この場合でもkindには$\color{red}{\rm アクセス可能}$

qiita.py

class Person(object):

    kind = 'human'

    def __init__(self):
        self.x = 100

a = Person()
print(a.kind)
# 実行結果：human
b = Person
print(b.kind)
# 実行結果：human

クラスメソッド

オブジェクト化されていなくても、アクセスする方法としてクラスメソッドが存在する

qiita.py

class Person(object):

    kind = 'human'

    def __init__(self):
        self.x = 100

    @classmethod
    def what_is_your_kind(cls):
        return cls.kind

a = Person()
print(a.what_is_your_kind())
# 実行結果：human
b = Person
print(b.what_is_your_kind())
# 実行結果：human

スタティックメソッド

スタティックメソッドにはcls,selfなど使わなくてもOK

qiita.py

class Person(object):

    kind = 'human'

    def __init__(self):
        self.x = 100

    @classmethod
    def what_is_your_kind(cls):
        return cls.kind

    @staticmethod
    def about():
        print("about human")

print(Person.about())
# 実行結果：about human

引数をとる事もできる

qiita.py

class Person(object):

    kind = 'human'

    def __init__(self):
        self.x = 100

    @classmethod
    def what_is_your_kind(cls):
        return cls.kind

    @staticmethod
    def about(year):
        print("about human {}".format(year))

print(Person.about(2020))
# 実行結果：about human 2020

はじめに

ここでは、クラウド(Google Colab)でAIプログラミングを「手っ取り早く動かしてイメージをつかみたいと思っている方」向けの手順を説明いたします。

初心者向けのもので、目的は開発環境を整えてプログラム (プログラミングはしません。コピペでOKです^^;) を実行し、「ほぉ、AIプログラミングってこんな感じか～」というところがGOALです。

※ローカルPC版の『【0からはじめる「Python AIプログラミング」 for PC』は、こちらです

どんなことをやるか

まず手書きの数字0～9とその正解ラベル(0～9)がセットになった教師データ60,000枚をAIに学習させます。

その後、手書きの数字0～9とその正解ラベル(0～9)がセットになった検証データ10,000枚をAIに検証させて、認識率や検証データの手書き数字がAIによって0～9のどの数字と認識したのかを試してみます。

(1) AIに学習させる

教師データ(60,000枚)を使用して、手書き画像を正解ラベルに沿って、0～9の数字として覚えさせます。

(2) AIに検証させる

検証データ(10,000枚)`を利用して、手書き画像をAIにより0～9の数字に分類(クラス分類)させ、正解データと比較し当たったかどうかを判定。

※上記データは プログラム実行時に MNISTデータベース から自動的にダウンロードされますので、画像ファイルの収集や正解ラベリング(画像データと正解ラベルの結びつけ)等の前準備は一切不要となっています。

開発環境準備

Google Colabが全部用意してくれるので、今回はインストールなどはありません。
「Google Colabサービス」を利用するのに「googleアカウント」が必要なだけです。

No.	開発環境	説明
1	Googleアカウント	Google Colab利用のためにGoogleアカウントを使用します。無料です。
2	Google Colabサービス	Googleのクラウド仮想マシン上で動くPython実行環境。使用料は無料です。インストール等の作業などは不要です。GPUも無料で使用でき、AI学習も素早く計算が可能です。

作業フロー

1.Googleのサービスから「ドライブ」をクリック

2.ドライブの「新規」->「その他」->「Google Colaboratory」をクリック

3.「ランタイム」->「ランタイムのタイプを変更」をクリック

4.ノートブックの設定でハードウェアアクセラレータを「GPU」を選択し「保存」をクリック

5. AIプログラムをコピペ

以下のプログラムをGoogle Colabのコードのところへコピペしてください。

# ------------------------------------------------------------------------------------------------------------
# CNN(Convolutional Neural Network)でMNISTを試す
# ------------------------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
from keras.datasets import mnist
from keras import backend as ke
from keras.utils import np_utils![PIC006.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/405376/cd3f9925-a147-5547-5384-96161cefb397.png)

from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D


# ------------------------------------------------------------------------------------------------------------
# ハイパーパラメータ
# ------------------------------------------------------------------------------------------------------------
# ハイパーパラメータ ⇒ バッチサイズ、エポック数
# 例えば、訓練データが60,000個で、batch_sizeを6,000とした場合、
# 学習データをすべて使うのに60,000個÷6,000＝10回のパラメータ更新が行われる。
# これを1epochと言う。epochが10であれば、10×10＝100回のパラメータ更新が行われることとなる。
# epoch数は損失関数(コスト関数)の値がほぼ収束するまでに設定する。
batch_size = 6000           # バッチサイズ
epochs = 20                 # エポック数


# ------------------------------------------------------------------------------------------------------------
# 正誤表関数
# ------------------------------------------------------------------------------------------------------------
def show_prediction():
    n_show = 100                                 # 全部は表示すると大変なので一部を表示
    y = model.predict(X_test)
    plt.figure(2, figsize=(10, 10))
    plt.gray()
    for i in range(n_show):
        plt.subplot(10, 10, (i+1))               # subplot(行数, 列数, プロット番号)
        x = X_test[i, :]
        x = x.reshape(28, 28)
        plt.pcolor(1 - x)
        wk = y[i, :]
        prediction = np.argmax(wk)
        plt.text(22, 25.5, "%d" % prediction, fontsize=12)
        if prediction != np.argmax(y_test[i, :]):
            plt.plot([0, 27], [1, 1], color='red', linewidth=10)
        plt.xlim(0, 27)
        plt.ylim(27, 0)
        plt.xticks([], "")
        plt.yticks([], "")


# ------------------------------------------------------------------------------------------------------------
# keras backendの表示
# ------------------------------------------------------------------------------------------------------------
# print(ke.backend())
# print(ke.floatx())


# ------------------------------------------------------------------------------------------------------------
# MNISTデータの取得
# ------------------------------------------------------------------------------------------------------------
# 初回はダウンロードが発生するため時間がかかる
# 60,000枚の28x28ドットで表現される10個の数字の白黒画像と10,000枚のテスト用画像データセット
# ダウンロード場所：'~/.keras/datasets/'
# ※MNISTのデータダウンロードがNGとなる場合は、PROXYの設定を見直してください
#
# MNISTデータ
#  ├ 教師データ (60,000個)
#  │  ├ 画像データ
#  │  └ ラベルデータ
#  │
#  └ 検証データ (10,000個)
#     ├ 画像データ
#     └ ラベルデータ

# ↓教師データ          ↓検証データ
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# ↑画像    ↑ラベル     ↑画像    ↑ラベル


# ------------------------------------------------------------------------------------------------------------
# 画像データ(教師データ、検証データ)のリシェイプ
# ------------------------------------------------------------------------------------------------------------
img_rows, img_cols = 28, 28
if ke.image_data_format() == 'channels_last':
    X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
    X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)
else:
    X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols)
    X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)

# 配列の整形と、色の範囲を0～255 → 0～1に変換
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255


# ------------------------------------------------------------------------------------------------------------
# ラベルデータ(教師データ、検証データ)のベクトル化
# ------------------------------------------------------------------------------------------------------------
y_train = np_utils.to_categorical(y_train)      # 教師ラベルのベクトル化
y_test = np_utils.to_categorical(y_test)        # 検証ラベルのベクトル化


# ------------------------------------------------------------------------------------------------------------
# ネットワークの定義 (keras)
# ------------------------------------------------------------------------------------------------------------
print("")
print("●ネットワーク定義")
model = Sequential()

# 入力層 28×28×3
model.add(Conv2D(16, kernel_size=(3, 3), activation='relu', input_shape=input_shape, padding='same'))     # 01層：畳込み層16枚
model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))                                          # 02層：畳込み層32枚
model.add(MaxPooling2D(pool_size=(2, 2)))                                                                 # 03層：プーリング層
model.add(Dropout(0.25))                                                                                  # 04層：ドロップアウト
model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))                                          # 05層：畳込み層64枚
model.add(MaxPooling2D(pool_size=(2, 2)))                                                                 # 06層：プーリング層
model.add(Flatten())                                                                                      # 08層：次元変換
model.add(Dense(128, activation='relu'))                                                                  # 09層：全結合出力128
model.add(Dense(10, activation='softmax'))                                                                # 10層：全結合出力10

# model表示
model.summary()

# コンパイル
# 損失関数 ：categorical_crossentropy (クロスエントロピー)
# 最適化   ：Adam
model.compile(loss='categorical_crossentropy',
              optimizer='Adam',
              metrics=['accuracy'])

print("")
print("●学習スタート")
f_verbose = 1  # 0:表示なし、1：詳細表示、2：表示
hist = model.fit(X_train, y_train,
                 batch_size=batch_size,
                 epochs=epochs,
                 validation_data=(X_test, y_test),
                 verbose=f_verbose)


# ------------------------------------------------------------------------------------------------------------
# 損失値グラフ化
# ------------------------------------------------------------------------------------------------------------
# Accuracy (正解率)
plt.plot(range(epochs), hist.history['accuracy'], marker='.')
plt.plot(range(epochs), hist.history['val_accuracy'], marker='.')
plt.title('Accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='lower right')
plt.show()

# loss (損失関数)
plt.plot(range(epochs), hist.history['loss'], marker='.')
plt.plot(range(epochs), hist.history['val_loss'], marker='.')
plt.title('loss Function')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper right')
plt.show()


# ------------------------------------------------------------------------------------------------------------
# テストデータ検証
# ------------------------------------------------------------------------------------------------------------
print("")
print("●検証結果")
t_verbose = 1  # 0:表示なし、1：詳細表示、2：表示
score = model.evaluate(X_test, y_test, verbose=t_verbose)

print("")
print("batch_size = ", batch_size)
print("epochs = ", epochs)

print('Test loss:', score[0])
print('Test accuracy:', score[1])


print("")
print("●混同行列(コンフュージョンマトリックス) 横：識別結果、縦：正解データ")
predict_classes = model.predict_classes(X_test[1:60000, ], batch_size=batch_size)
true_classes = np.argmax(y_test[1:60000], 1)
print(confusion_matrix(true_classes, predict_classes))


# ------------------------------------------------------------------------------------------------------------
# 正誤表表示
# ------------------------------------------------------------------------------------------------------------
show_prediction()
plt.show()

こんな感じ ↓ になりましたか？

6. AIプログラムを実行

「ランタイム」->「すべてのセルを実行」をクリックして、AIプログラムを実行してください。

7. 実行結果

さすがGPUです?とても処理が早いです！

以上

Google ColabはGPUを使用できるので、AIの学習が比較的早く終わります。
自前のノートPCだと5epocくらいでイライラしちゃうのに、Google Colabだと20epocでもへっちゃらです?

• お疲れ様でした！

セッションから記録情報を引き出す方法

下記のように取得し、定義などは考える必要なし (空の場合は以降の処理で場合分けを行う)。

変数 = request.session.get('セッション記憶情報変数名')

ex) cart = request.session.get('cart')

セッションの情報を追加する方法

下記のように追加情報を変数に追加してからセッションを上書きする。

変数.append(追加情報)
request.session['セッション記憶情報変数名'] = 変数

ex) cart.append(product_id)
    request.session['cart'] = cart

セッションの情報を削除する方法

下記のように削除情報を持たない仮変数を作ってからセッションを上書きする。

for 仮数(何でも良い) in 変数:
    if 仮数 != 削除情報:
        仮変数.append(仮数)
request.session['セッション記憶情報変数名'] = 仮変数

ex) for p in cart:
        if p != product_id:
            filtered.append(p)
    request.session['cart'] = filtered

2000円のLidarって大丈夫？

Aliexpressで2千円のLidarが売っている事を知りましたが、怪しすぎて買うのを躊躇っていました。
そんなところ、買った方のコメントや、Qiita記事を見て自分も購入してみました。

・camsense-X1

https://github.com/Vidicon/camsense-X1

・激安LiDAR(Camsense X1)を使ってみる

https://qiita.com/junp007/items/819aced4d48efd97c79f

届いたのは？

2個購入した所
左はNG品、右は正常品でした。
NGと書いてあったり、本体にCamsense X1のロゴが無いのはNG品です。


NG品は、修正が入っていますね。

動作させる

今回は、USB-Serialアダプタを使って接続します。

電源は5V、USB-Serialの接続先はRXです。
（TX⇒RX)
こういう時に使用するのは
スルホール用テストワイヤ　ＴＴ－２００　（１０本入）
http://akizukidenshi.com/catalog/g/gC-09831/

TeraTermの受信内容

接続します。
ボーレート：115200
TeraTermの表示内容はこんな感じです。
これを見て壊れていると思ってしまいますよね・・・

使えるようにしてみよう

「激安LiDAR(Camsense X1)を使ってみる」に
https://qiita.com/junp007/items/819aced4d48efd97c79f
「距離と強度データが8ステップずつ入った36バイトのパケットになっていて」と記載されています。
つまり、このままではダメです。
記載されているとおり、Pythonで動かしてみましょう。

Windowsで動かす・・・camsenseX1.py

必要なのはpython、pyserial、matplotlibです。
これらをインストールします。
私は、Windows標準のコマンドプロンプトを使用しており
まずは、pipをインストールし、Python、pyserial、matplotlibをインストールしていきます。
最後に、こちらのプログラムを起動します。
コマンドプロンプトの最後に、シリアルポートを選択します

C:\Users\user\Desktop\camsenseX1.py COM2

シリアルポートを指定しないと、こんなメッセージが出ます。

無事起動

ちょっと、怪しい挙動がありますが、動きました。

これで2000円なら満足ですね。

配線するよ

それでは、キチンと使えるようにしましょう。
というのは、コネクタの品種がわからず、使えないからです。
本来はL型のピンヘッダが必要ですが無いので普通のを曲げました。

買う人は、秋月電子のこちらなど
ピンヘッダ　（Ｌ型）　１×６　（６Ｐ）
http://akizukidenshi.com/catalog/g/gC-05336/

はんだ付け

脚をつけるよ

M2.5X20を選択しました。

今や6ドル未満

今は6ドル未満で売っています。
送料がかかるので実際は1000円です。

この価格は何でしょうか？
非常に困ってしまいますね・・・

お勧めはしない

ここまで見ると動きそうだと思われますね
ですが、正直お勧めできません
ふつうの人であれば、動かない商品を買うのは嫌でしょう
私ですら嫌です。
なので、動かない可能性が高い本商品は、2個のうち1個動けばいいやと思えるかが重要です。

2000円の時に2個買った私は、6ドルならば６個買ってもほぼ一緒ですが・・・
動かない前提で試してみる気があるならば・・・

https://www.udemy.com/course/ds_for_python/
をやってるなかで、コマンド忘れそうなので

import

import numpy as np

flatten()

flatten

array1=np.array([[1,2,3],[4,5,6],[7,8,9]])
array1.flatten()

結果

array([1, 2, 3, 4, 5, 6, 7, 8, 9])

squeeze

squeeze

array1=np.array([[1,2,3]])
array1.shape

(1, 3)

squeeze

np.squeeze(array1)

(3,)

次元を減らす。

expand_dims

expand_dims

ndarray1=np.array([1,2,3])
ndarray1.shape
expand_axis=np.expand_dims(ndarray1, axis=-1)
expand_axis.shape
expand_axis

(3,)

(3, 1)

array([[1],
       [2],
       [3]])

逆に、次元を増やす。
axisの引数で増やす場所が変わる。

はじめに

MLOpsという、「機械学習モデルが陳腐化してシステムがゴミにならないように、ちゃんと機械学習の技術が含まれたシステムを運用するための基盤をつくりましょうね」というような話がある。
参考記事：小さく始めて大きく育てるMLOps2020

その助けになるように作られたツールとしてMLFlowというものがある。
MLflowの一つの機能、MLflow Trackingを使う機会があったので、いろいろ調べながら使ってみたらこれは良いものだなぁ、と思ったのでここに記す。まあ使い方自体は他にたくさん記事があるのでそれを見ていただくとして、「こういう感じでモデル作成の記録を残していくのはどうよ？」とモデル構築のログの残し方のアイデアの種にでもなればハッピー。MLflowはバージョン1.8.0を使った。
MLflowについては以下の記事がわかりやすい。
　mlflowを使ってデータ分析サイクルの効率化する方法を考える
　MLflow 1.0.0 リリース！機械学習ライフサイクルを始めよう！

使用データ

KaggleのTelco Customer Churnのデータを使用する。
https://www.kaggle.com/blastchar/telco-customer-churn
これは電話会社の顧客に関するデータであり、解約するか否かを目的変数とした2値分類問題。
各行は顧客を表し、各列には顧客の属性が含まれている。

使うパッケージと関数の定義

集計結果を可視化する関数や、モデルを作る関数などを作成。
本題ではないので説明は省略。

使用パッケージ

# package
import numpy as np
import scipy
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import seaborn as sns
import pandas as pd
from pandas.plotting import register_matplotlib_converters
import xgboost
import xgboost.sklearn as xgb
import sklearn
from sklearn.model_selection import train_test_split
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import f1_score
from sklearn.metrics import auc
from sklearn.metrics import roc_curve
from sklearn.metrics import log_loss
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import cross_validate
from sklearn.cluster import KMeans
from sklearn.metrics import confusion_matrix
from sklearn.metrics import make_scorer
from sklearn.metrics import precision_recall_curve
import time
import os
import glob
from tqdm import tqdm
import copy
import mlflow
from mlflow.sklearn import log_model
from mlflow.sklearn import load_model

定義した関数群

# ヒストグラム作成
def plot_many_hist(df_qiita,ex_col,ob_col,clip=[0, 99.],defalt_bin=10,png='tmp.png', visual = True):
    fig=plt.figure(figsize=(15,10))
    for i in range(len(ex_col)):
        df_qiita_clip=df_qiita.copy()
        col=ex_col[i]
        # クリッピング
        upperbound, lowerbound = np.percentile(df_qiita[col].values, clip)
        col_clip = np.clip(df_qiita[col].values, upperbound, lowerbound)
        df_qiita_clip['col_clip']=col_clip
        # ビンの数調整
        if len(df_qiita_clip['col_clip'].unique())<10:
            bins=len(df_qiita_clip['col_clip'].unique())
        else:
            bins=defalt_bin
        # ヒストグラムプロット
        ax=plt.subplot(3,3,i+1)
        for u in range(len(df_qiita_clip[ob_col].unique())):
            ln1=ax.hist(df_qiita_clip[df_qiita_clip[ob_col]==u]['col_clip'], bins=bins,label=u, alpha=0.7)
            ax.set_title(col)
        h1, l1 = ax.get_legend_handles_labels()
        ax.legend(loc='upper right')
        ax.grid(True)
    plt.tight_layout()
    fig.suptitle("hist", fontsize=15)
    plt.subplots_adjust(top=0.92)
    plt.savefig(png)
    if visual == True:
        print('Cluster Hist')
        plt.show()
    else:
        plt.close()

# 標準化
def sc_trans(X):
    ss = StandardScaler()
    X_sc = ss.fit_transform(X)
    return X_sc

# kmeansモデル作成
def km_cluster(X, k):
    km=KMeans(n_clusters=k,\
              init="k-means++",\
              random_state=0)
    y_km=km.fit_predict(X)
    return y_km,km

# 円グラフ作成
def pct_abs(pct, raw_data):
    absolute = int(np.sum(raw_data)*(pct/100.))
    return '{:d}\n({:.0f}%)'.format(absolute, pct) if pct > 5 else ''

def plot_chart(y_km, png='tmp.png', visual = True):
    km_label=pd.DataFrame(y_km).rename(columns={0:'cluster'})
    km_label['val']=1
    km_label=km_label.groupby('cluster')[['val']].count().reset_index()
    fig=plt.figure(figsize=(5,5))
    ax=plt.subplot(1,1,1)
    ax.pie(km_label['val'],labels=km_label['cluster'], autopct=lambda p: pct_abs(p, km_label['val']))#, autopct="%1.1f%%")
    ax.axis('equal')
    ax.set_title('Cluster Chart (ALL UU:{})'.format(km_label['val'].sum()),fontsize=14)
    plt.savefig(png)
    if visual == True:
        print('Cluster Structure')
        plt.show()
    else:
        plt.close()

# 表作成
def plot_table(df_qiita, cluster_name, png='tmp.png', visual = True):
    fig, ax = plt.subplots(figsize=(10,10))
    ax.axis('off')
    ax.axis('tight')
    tab=ax.table(cellText=np.round(df_qiita.groupby(cluster_name).mean().reset_index().values, 2),\
                 colLabels=df_qiita.groupby(cluster_name).mean().reset_index().columns,\
                 loc='center',\
                 bbox=[0,0,1,1])
    tab.auto_set_font_size(False)
    tab.set_fontsize(12)
    tab.scale(5,5)
    plt.savefig(png)
    if visual == True:
        print('Cluster Stats Mean')
        plt.show()
    else:
        plt.close()

# XGBモデル作成
def xgb_model(X_train, y_train, X_test):
    model = xgb.XGBClassifier()
    model.fit(X_train, y_train)
    y_pred=model.predict(X_test)
    y_pred_proba=model.predict_proba(X_test)[:, 1]
    y_pred_proba_both=model.predict_proba(X_test)
    return model, y_pred, y_pred_proba, y_pred_proba_both

# 学習データとテストデータ作成
def createXy(df, exp_col, ob_col, test_size=0.3, random_state=0, stratify=True):
    dfx=df[exp_col].copy()
    dfy=df[ob_col].copy()
    print('exp_col:',dfx.columns.values)
    print('ob_col:',ob_col)

    if stratify == True:
        X_train, X_test, y_train, y_test = train_test_split(dfx, dfy, test_size=test_size, random_state=random_state, stratify=dfy)
    else:
        X_train, X_test, y_train, y_test = train_test_split(dfx, dfy, test_size=test_size, random_state=random_state)
    print('Original Size is {}'.format(dfx.shape))
    print('TrainX Size is {}'.format(X_train.shape))
    print('TestX Size is {}'.format(X_test.shape))
    print('TrainY Size is {}'.format(y_train.shape))
    print('TestY Size is {}'.format(y_test.shape))
    return X_train, y_train, X_test, y_test

# 分類評価指標の結果返す
def eval_list(y_test, y_pred, y_pred_proba, y_pred_proba_both):
    # eval
    log_loss_=log_loss(y_test, y_pred_proba_both)
    accuracy=accuracy_score(y_test, y_pred)
    precision=precision_score(y_test, y_pred)
    recall=recall_score(y_test, y_pred)
    # FPR, TPR, thresholds
    fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
    # AUC
    auc_ = auc(fpr, tpr)
    # roc_curve
    fig, ax = plt.subplots(figsize=(10,10))
    ax.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %.2f)'%auc_)
    ax.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
    plt.legend()
    plt.title('ROC curve')
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.grid(True)
    plt.savefig('ROC_curve.png')
    plt.close()
    return log_loss_, accuracy, precision, recall, auc_

# Recall-Precision曲線返す
def threshold_pre_rec(test, prediction, save_name='threshold_pre_rec.png'):
    precision, recall, threshold = precision_recall_curve(test, prediction)
    thresholds = threshold
    user_cnt=[prediction[prediction>=i].shape[0] for i in thresholds]
    fig=plt.figure(figsize=(10,6))
    ax1 = plt.subplot(1,1,1)
    ax2=ax1.twinx()
    ax1.plot(thresholds, precision[:-1], color=sns.color_palette()[0],marker='+', label="precision")
    ax1.plot(thresholds, recall[:-1], color=sns.color_palette()[2],marker='+', label="recall")
    ax2.plot(thresholds, user_cnt, linestyle='dashed', color=sns.color_palette()[6], label="user_cnt")
    handler1, label1 = ax1.get_legend_handles_labels()
    handler2, label2 = ax2.get_legend_handles_labels()
    ax1.legend(handler1 + handler2, label1 + label2, loc='lower left')
    ax1.set_xlim(-0.05,1.05)
    ax1.set_ylim(-0.05,1.05)
    ax1.set_xlabel('threshold')
    ax1.set_ylabel('%')
    ax2.set_ylabel('user_cnt')
    ax2.grid(False)
    plt.savefig(save_name)
    plt.close()

# 予測確率－実測確率曲線を返す
def calib_curve(y_tests, y_pred_probas, save_name='calib_curve.png'):
    y_pred_proba_all=y_pred_probas.copy()
    y_tests_all=y_tests.copy()
    proba_check=pd.DataFrame(y_tests_all.values,columns=['real'])
    proba_check['pred']=y_pred_proba_all
    s_cut, bins = pd.cut(proba_check['pred'], list(np.linspace(0,1,11)), right=False, retbins=True)
    labels=bins[:-1]
    s_cut = pd.cut(proba_check['pred'], list(np.linspace(0,1,11)), right=False, labels=labels)
    proba_check['period']=s_cut.values
    proba_check = pd.merge(proba_check.groupby(['period'])[['real']].mean().reset_index().rename(columns={'real':'real_ratio'})\
                            , proba_check.groupby(['period'])[['real']].count().reset_index().rename(columns={'real':'UU'})\
                            , on=['period'], how='left')
    proba_check['period']=proba_check['period'].astype(str)
    proba_check['period']=proba_check['period'].astype(float)
    fig=plt.figure(figsize=(10,6))
    ax1 = plt.subplot(1,1,1)
    ax2=ax1.twinx()
    ax2.bar(proba_check['period'].values, proba_check['UU'].values, color='gray', label="user_cnt", width=0.05, alpha=0.5)
    ax1.plot(proba_check['period'].values, proba_check['real_ratio'].values, color=sns.color_palette()[0],marker='+', label="real_ratio")
    ax1.plot(proba_check['period'].values, proba_check['period'].values, color=sns.color_palette()[2], label="ideal_line")
    handler1, label1 = ax1.get_legend_handles_labels()
    handler2, label2 = ax2.get_legend_handles_labels()
    ax1.legend(handler1 + handler2, label1 + label2, loc='center right')
    ax1.set_xlim(-0.05,1.05)
    ax1.set_ylim(-0.05,1.05)
    ax1.set_xlabel('period')
    ax1.set_ylabel('real_ratio %')
    ax2.set_ylabel('user_cnt')
    ax2.grid(False)
    plt.savefig(save_name)
    plt.close()

# 混合行列を出力
def print_cmx(y_true, y_pred, save_name='tmp.png'):
    labels = sorted(list(set(y_true)))
    cmx_data = confusion_matrix(y_true, y_pred, labels=labels)

    df_cmx = pd.DataFrame(cmx_data, index=labels, columns=labels)

    plt.figure(figsize = (10,6))
    sns.heatmap(df_cmx, annot=True, fmt='d', cmap='coolwarm', annot_kws={'fontsize':20},alpha=0.8)
    plt.xlabel('pred', fontsize=18)
    plt.ylabel('real', fontsize=18)
    plt.savefig(save_name)
    plt.close()

データの読み込み

本題ではないので、欠損行はそのまま削除。

# データ読み込み
df=pd.read_csv('WA_Fn-UseC_-Telco-Customer-Churn.csv')
churn=df.copy()
# 半角空白をNanに変更
churn.loc[churn['TotalCharges']==' ', 'TotalCharges']=np.nan
# floatに変更
churn['TotalCharges']=churn['TotalCharges'].astype(float)
# 面倒なので欠損行がある場合、その行は削除する
churn=churn.dropna()
print(churn.info())
display(churn.head())

MLflowでクラスタリング結果を記録

kmenasなどでクラスタリングした後は、クラスタごとの特徴を見て、人間がクラスタリング結果の解釈を行う。しかし試行錯誤していく中で毎回可視化したり表を作ったりしてクラスタの特徴を見るのは面倒だし、前の結果がどんなものだったのか忘れてしまうかもしれない。この問題を解決するためにMLflowを活用できる。説明変数を連続値の'tenure', 'MonthlyCharges', 'TotalCharges'に絞ってクラスタリングを実施して、その結果をMLflowに記録する。

#### クラスタリング実施
exp_col=['tenure','MonthlyCharges','TotalCharges']
df_km=churn.copy()[exp_col]
df_cluster=df_km.copy()
cluster_name = 'My_Cluster'
k=5
ob_col = cluster_name

# クラスタリング結果をmlflowに記録
mlflow.set_experiment('My Clustering')# 実験の名前を定義
with mlflow.start_run():# mlflow記録開始
    # 標準化
    X=sc_trans(df_cluster)
    # kmeansモデル作成
    y_km, km=km_cluster(X, k)
    # paramsをmlflowに記録
    mlflow.log_param("method_name",km.__class__.__name__)
    mlflow.log_param("k", k)
    mlflow.log_param("features", df_cluster.columns.values)
    # modelをmlflowに保存
    log_model(km, "model")

    df_cluster[cluster_name]=y_km

    # クラスタリング結果を可視化
    # クラスタ構成比
    plot_chart(y_km, png='Cluster_Chart.png', visual = False)# カレントディレクトリに図を保存
    mlflow.log_artifact('Cluster_Chart.png')# カレントディレクトリにある図を記録
    os.remove('Cluster_Chart.png')# 記録した後にカレントディレクトリの図は削除した

    # クラスタごとの平均値
    plot_table(df_cluster, ob_col, png='Cluster_Stats_Mean.png', visual = False)# カレントディレクトリに図を保存
    mlflow.log_artifact('Cluster_Stats_Mean.png')# カレントディレクトリにある図を記録
    os.remove('Cluster_Stats_Mean.png')# 記録した後にカレントディレクトリの図は削除した

    # クラスタごとのヒストグラム
    plot_many_hist(df_cluster,exp_col,ob_col,clip=[0, 99.],defalt_bin=20, png='Cluster_Hist.png', visual = False)# カレントディレクトリに図を保存
    mlflow.log_artifact('Cluster_Hist.png')# カレントディレクトリにある図を記録
    os.remove('Cluster_Hist.png')# 記録した後にカレントディレクトリの図は削除した

上記のように、アルゴリズム名や、説明変数名、ハイパラの値、クラスタごとの特徴を可視化した図表を記録するように記述したコードを実行すると、カレントディレクトリに"mlruns"というフォルダが作成される。記録した結果はすべてこの"mlruns"というフォルダに保存されている。
"mlruns"フォルダがあるディレクトリでターミナルを開き"mlflow ui"と記述して実行すると、localhostの5000番が立ち上がる。ブラウザでlocalhostの5000番にアクセスすると、MLflowのリッチなUIを通して作ったモデルの記録を確認できる。

"mlruns"フォルダ

"mlruns"というフォルダがあるディレクトリで"mlflow ui"と記述

mlflow uiトップ画面

　
　

My Clusteringという名前の部屋にクラスタリング結果は記録されている。記録した内容を見るため、記録日時が書かれたリンクの中を確認してみる。

Parameters， Metrics

Artifacts

Artifacts

Artifacts

記録するように設定したアルゴリズム名や、説明変数名、ハイパラの値はParametersに記録されていることが確認できる。また図表などはArtifactsに記録されている。
このように記録していくと、説明変数を変えたり、kの値を変えたりした時も、以前のモデルの結果と比較することが容易くなる。

予測結果をMLflowに記録

分類モデルを作るときも同様に記録できる。

#### 予測モデルを構築
exp_col=['tenure','MonthlyCharges','TotalCharges']
ob_col = 'Churn'
df_pred=churn.copy()
df_pred.loc[df_pred[ob_col]=='Yes', ob_col]=1
df_pred.loc[df_pred[ob_col]=='No', ob_col]=0
df_pred[ob_col]=df_pred[ob_col].astype(int)
df_pred[cluster_name]=y_km
X_tests, y_tests, y_preds, y_pred_probas, y_pred_proba_boths = [],[],[],[],[]

for cluster_num in np.sort(df_pred[cluster_name].unique()):
    # 1つのクラスタのデータを抽出
    df_n=df_pred[df_pred[cluster_name]==cluster_num].copy()

    # 学習データとテストデータ作成
    X_train, y_train, X_test, y_test=createXy(df_n, exp_col, ob_col, test_size=0.3, random_state=0, stratify=True)

    # モデル作成
    model, y_pred, y_pred_proba, y_pred_proba_both = xgb_model(X_train, y_train, X_test)

    # 評価指標計算
    log_loss_, accuracy, precision, recall, auc_ = eval_list(y_test, y_pred, y_pred_proba, y_pred_proba_both)

    # データを空のリストに挿入
    X_tests.append(X_test)
    y_tests.append(y_test)
    y_preds.append(y_pred)
    y_pred_probas.append(y_pred_proba)
    y_pred_proba_boths.append(y_pred_proba_both)

    # 混合行列
    print_cmx(y_test.values, y_pred, save_name='confusion_matrix.png')

    # Recall-Precision曲線
    threshold_pre_rec(y_test, y_pred_proba, save_name='threshold_pre_rec.png')

    # Pred Prob曲線
    calib_curve(y_test,y_pred_proba, save_name='calib_curve.png')

    # 予測結果をmlflowに記録
    mlflow.set_experiment('xgb_predict_cluster'+str(cluster_num))# 実験の名前を定義
    with mlflow.start_run():# mlflow記録開始
        mlflow.log_param("01_method_name", model.__class__.__name__)
        mlflow.log_param("02_features", exp_col)
        mlflow.log_param("03_objective_col", ob_col)
        mlflow.log_params(model.get_xgb_params())
        mlflow.log_metrics({"01_accuracy": accuracy})
        mlflow.log_metrics({"02_precision": precision})
        mlflow.log_metrics({"03_recall": recall})
        mlflow.log_metrics({"04_log_loss": log_loss_})
        mlflow.log_metrics({"05_auc": auc_})
        mlflow.log_artifact('ROC_curve.png')
        os.remove('ROC_curve.png')
        mlflow.log_artifact('confusion_matrix.png')
        os.remove('confusion_matrix.png')
        mlflow.log_artifact('threshold_pre_rec.png')
        os.remove('threshold_pre_rec.png')
        mlflow.log_artifact('calib_curve.png')
        os.remove('calib_curve.png')
        log_model(model, "model")

# クラスタごとのデータをconcatして全データをまとめる
y_pred_all=np.hstack((y_preds))
y_pred_proba_all=np.hstack((y_pred_probas))
y_pred_proba_both_all=np.concatenate(y_pred_proba_boths)
y_tests_all=pd.concat(y_tests)
# 評価指標計算
log_loss_, accuracy, precision, recall, auc_ = eval_list(y_tests_all.values, y_pred_all, y_pred_proba_all, y_pred_proba_both_all)
# 混合行列
print_cmx(y_tests_all.values, y_pred_all, save_name='confusion_matrix.png')
# Pred Prob曲線
calib_curve(y_tests_all, y_pred_proba_all, save_name='calib_curve.png')

# 全データでの予測結果をmlflowに記録
mlflow.set_experiment('xgb_predict_all')# 実験の名前を定義
with mlflow.start_run():# mlflow記録開始
    mlflow.log_param("01_method_name", model.__class__.__name__)
    mlflow.log_param("02_features", exp_col)
    mlflow.log_param("03_objective_col", ob_col)
    mlflow.log_params(model.get_xgb_params())
    mlflow.log_metrics({"01_accuracy": accuracy})
    mlflow.log_metrics({"02_precision": precision})
    mlflow.log_metrics({"03_recall": recall})
    mlflow.log_metrics({"04_log_loss": log_loss_})
    mlflow.log_metrics({"05_auc": auc_})
    mlflow.log_artifact('ROC_curve.png')
    os.remove('ROC_curve.png')
    mlflow.log_artifact('confusion_matrix.png')
    os.remove('confusion_matrix.png')
    mlflow.log_artifact('calib_curve.png')
    os.remove('calib_curve.png')

上記のコードを実行すると、先ほどのクラスタごとにモデルが作られ、MLflowに記録される。
アルゴリズム名や、説明変数名、ハイパラの値、損失関数、様々な指標の分類精度、ROCカーブ、Calibrationカーブ、Recall, Precisionカーブ、混合行列などを記録できる。

mlflowトップ画面

Parameters

Metrics

Artifacts

このように記録していくと、説明変数を変えたり、ハイパラ調整をしたり、アルゴリズムを変えたりした時などに、以前のモデルの結果と比較することが容易くなる。

おわりに

備忘録的なことも兼ねているが、MLflowの説明は一切せず、こんな感じで使えるよという活用方法をメインに示した。これから使おうかなと考えている人の活用イメージが湧くような内容になっていたら嬉しい。興味が湧いた人は他の記事などでも調べて使ってみることをオススメ。

おまけ

"mlruns"フォルダの中身

1をクリック

b3fa3eb983044a259e6cae4f149f32c8をクリック

artifactsをクリック

図が保存されている

mlflow uiで確認できるものはこのようにLocalに保存されている。
クラウドサービスと連携していろんな人とモデルの記録を共有することもできるみたい。
個人で使う分にはLocalで問題ないかな。

以上！