同じエラーで躓いた人の調べる時間が少しでも減りますように、メモとして記事に起こしておきます。

以下はGoogle Colab上で実行しています。

こちらを参考にColab上でMeCabとhuggingfaceのtransformersをインストールします。

!apt install aptitude swig
!aptitude install mecab libmecab-dev mecab-ipadic-utf8 git make curl xz-utils file -y
!pip install mecab-python3
!pip install transformers

日本語用BERTのtokenizerで分かち書きを試みます。

from transformers.tokenization_bert_japanese import BertJapaneseTokenizer

# 日本語BERT用のtokenizerを宣言
tokenizer = BertJapaneseTokenizer.from_pretrained('cl-tohoku/bert-base-japanese-whole-word-masking')

text = "自然言語処理はとても楽しい。"

wakati_ids = tokenizer.encode(text, return_tensors='pt')
print(tokenizer.convert_ids_to_tokens(wakati_ids[0].tolist()))
print(wakati_ids)

以下のようなエラーがでてしまいました。

----------------------------------------------------------

Failed initializing MeCab. Please see the README for possible solutions:

    https://github.com/SamuraiT/mecab-python3#common-issues

If you are still having trouble, please file an issue here, and include the
ERROR DETAILS below:

    https://github.com/SamuraiT/mecab-python3/issues

issueを英語で書く必要はありません。

------------------- ERROR DETAILS ------------------------
arguments: 
error message: [ifs] no such file or directory: /usr/local/etc/mecabrc
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-3-f828f6470517> in <module>()
      2 
      3 # 日本語BERT用のtokenizerを宣言
----> 4 tokenizer = BertJapaneseTokenizer.from_pretrained('cl-tohoku/bert-base-japanese-whole-word-masking')
      5 
      6 text = "自然言語処理はとても楽しい。"

4 frames
/usr/local/lib/python3.6/dist-packages/MeCab/__init__.py in __init__(self, rawargs)
    122 
    123         try:
--> 124             super(Tagger, self).__init__(args)
    125         except RuntimeError:
    126             error_info(rawargs)

RuntimeError: 

エラー出力に親切にこちらを見るように言ってくれているので、URL先の指示通りに、mecab-python3をインストールするときに

pip install unidic-lite

も実行すればMeCabのinitializingで落ちることはなくなりました。が、今度はencodeでValueError: too many values to unpack (expected 2)と怒られてしまいました。

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-f828f6470517> in <module>()
      6 text = "自然言語処理はとても楽しい。"
      7 
----> 8 wakati_ids = tokenizer.encode(text, return_tensors='pt')
      9 print(tokenizer.convert_ids_to_tokens(wakati_ids[0].tolist()))
     10 print(wakati_ids)

8 frames
/usr/local/lib/python3.6/dist-packages/transformers/tokenization_bert_japanese.py in tokenize(self, text, never_split, **kwargs)
    205                 break
    206 
--> 207             token, _ = line.split("\t")
    208             token_start = text.index(token, cursor)
    209             token_end = token_start + len(token)

ValueError: too many values to unpack (expected 2)

このエラーについてはこちらでmecab-python3の開発者？の方が言及されている通り、mecab-python3のバージョンを0.996.5に指定してやれば解決しました。

まとめると、pipであれこれインストールするときは以下のように宣言すればエラーでなくなると思います。

!apt install aptitude swig
!aptitude install mecab libmecab-dev mecab-ipadic-utf8 git make curl xz-utils file -y
!pip install mecab-python3==0.996.5
!pip install unidic-lite
!pip install transformers

↑を実行する前に既にpipでmecab-python3の最新版をインストールしてしまっている場合は、一度colabのセッションを再接続するのをお忘れなく。セッションの切断の仕方はcolab画面の右上のRAMとかディスクとか書いてる▼をクリックして、セッションの管理から行えます。

from transformers.tokenization_bert_japanese import BertJapaneseTokenizer

# 日本語BERT用のtokenizerを宣言
tokenizer = BertJapaneseTokenizer.from_pretrained('cl-tohoku/bert-base-japanese-whole-word-masking')

text = "自然言語処理はとても楽しい。"

wakati_ids = tokenizer.encode(text, return_tensors='pt')
print(tokenizer.convert_ids_to_tokens(wakati_ids[0].tolist()))
print(wakati_ids)

#Downloading: 100%
#258k/258k [00:00<00:00, 1.58MB/s]
#
#['[CLS]', '自然', '言語', '処理', 'は', 'とても', '楽しい', '。', '[SEP]']
#tensor([[    2,  1757,  1882,  2762,     9,  8567, 19835,     8,     3]])

無事にBertJapaneseTokenizerで分かち書きできました。

おわり

背景

会社でDI（Dependency Injection)についての話が出たが、
イマイチちゃんと分かっていなかったのでお勉強することにした

そもそもDIって何よ

・依存性の注入（直訳）
・結合度の低下によるコンポーネント化の促進
・単体テストの効率化
・特定のフレームワークへの依存度低下
・DIコンテナってのがあるらしい（へぇ）

個人的には、単体テストがしやすくなるってところに惹かれた。

後、実装時に（見かけ上）コンポーネント化されたとしても、
各々依存しあってたらあまりメリットないもんね。

（筋子じゃダメなんだ、いくらでないとダメだ、というイメージは本当に無駄）

早速書いてみる

何はともあれ、書いてみる。

まずは、依存しまくっている例。

no_di.py

class Country:
    def getCountry(self):
        return "Japanese"


class Position:
    def getPosition(self):
        return 'SuperStar'


class HorseName:
    def getName(self):
        return 'Caesario'


class GreatRealCondition:
    def __init__(self):
        self.c = Country()
        self.p = Position()
        self.h = HorseName()

    def getGreatRealCondition(self):
        return self.c.getCountry() + "\n" + self.p.getPosition() + "\n" + self.h.getName() + "!"


if __name__ == '__main__':
    g = GreatRealCondition()
    print(g.getGreatRealCondition())

実行結果.

Japanese
SuperStar
Caesario!

何の文章か分からない方はyoutubeで
「ジャパニーズスーパースターシーザリオ！」で検索。

GreatRealConditionクラスは、

・Countryクラス
・Positionクラス
・HorseNameクラス

これらのクラスと密な関係（三密）になっている。

ということは、これらのクラスは、バラバラに見えて、実はほぼ一つのクラスである、と言える。

再利用も出来ないし、そもそもテストも出来ない（値を変えてみたり、なんてことは今のところ出来ない）。
Countryクラスなどにセッターを入れれば値を変えることはできるが、もはやGreatRealConditionクラスのテストではないよね。

なので、依存度を下げてみる。

on_di.py

class Country:
    def getCountry(self):
        return "Japanese"


class Position:
    def getPosition(self):
        return 'SuperStar'


class HorseName:
    def getName(self):
        return 'Caesario'


class GreatRealCondition:
    def __init__(self, c: Country, p: Position, h: HorseName):
        self.c = c
        self.p = p
        self.h = h

    def getGreatRealCondition(self):
        return self.c.getCountry() + "\n" + self.p.getPosition() + "\n" + self.h.getName() + "!"


if __name__ == '__main__':
    c = Country()
    p = Position()
    h = HorseName()
    g = GreatRealCondition(c, p, h)
    print(g.getGreatRealCondition())

実行結果.

Japanese
SuperStar
Caesario!

先ほどと同じ結果になった。

ここで大きく変わったことは、

GreatRealConditionクラスが他クラスを持たなくなったこと

に尽きる。

さっきまで、３密クラスに依存していて、他に使い道がなかったGreatRealConditionクラスが、

コンストラクタで３密クラスを持たせるようにすることで、いろんな用途が出来た。
（本当はいろんなパターンで試そうと思ったのだが、長くなりそうなのでまた今度）

とまあ、コンストラクタを使って、「依存性を注入」したわけです。

最初はこんな感じ。

今後

今回はコンストラクタを使用して注入したんだけど、

setterで注入だったり、インタフェース定義して注入したりといろいろ方法があるみたいなので是非試してみようと思います。

あと、pythonだと結構DIめんどいかも。
（慣れてないだけか）

Thanks!!

参考になった記事はこちらです。
ありがとうございます。
https://qiita.com/mkgask/items/d984f7f4d94cc39d8e3c

諸般の理由で『Pythonのlambda式を用いたラムダ計算の基礎表現』を書いた後にHaskellに触れたところ，無名版再帰関数を実行する不動点コンビネータがとんでもなく簡単に書けたため，同じ方法でSchemeやPythonでもできないか試したところ，これまたあっさりできたので，まとめメモ的に新しく記事にした．

このような内容がQiitaや書籍，ネット上に星の数の更に星の数乗ほどあることは承知しているが，この手の話はYコンビネータ（Zコンビネータ）が大きな割合を占めており（実際，元記事でも取り上げている），関心のある人々の数多ある参考資料のひとつ程度に捉えてもらえると幸いである．ツッコミ，編集リクエスト歓迎．

不動点コンビネータの定義

Haskell，Scheme，Pythonでの考察および実行例を述べる．なお，不動点コンビネータとは，$f(g(f))=g(f)$が成り立つ関数$g$を指す．

Haskell（GHC）

式に従い，不動点コンビネータを定義する．

Prelude> g f = f (g f)

階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．

Prelude> g (\fact -> \n r -> if n == 0 then r else fact (n-1) (n*r)) 5 1
120

Scheme（Gauche）

式に従い，不動点コンビネータを定義する．

gosh> (define (g f) (f (g f)))
g

階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．※注意：実行環境によっては危険！

gosh> (((g (lambda (fact) (lambda (n) (lambda (r) (if (= n 0) r ((fact (- n 1)) (* n r))))))) 5) 1)
; いつまでも表示されず → 強制終了

引数評価を先に行うという仕様上，実際の階乗計算の前に自己適用(g f)を繰り返して無限ループに陥り，メモリを食い潰していった模様．

同様の現象はYコンビネータでも起こるため，実際に稼働するZコンビネータへの変換と同じく，(g f)を，自由変数yを引数にもつlambda式でくくることで（ラムダ計算で言うη簡約の逆適用，実装上はクロージャの活用），呼び出されるまで実行を据え置くようにする．なお，Haskellの引数は実際に必要となるまで評価されない（遅延評価機能のひとつ）ため，このような問題が起こらない．

gosh> (define (g f) (f (lambda (y) ((g f) y))))
g

書き直した不動点コンビネータについて，階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．

gosh> (((g (lambda (fact) (lambda (n) (lambda (r) (if (= n 0) r ((fact (- n 1)) (* n r))))))) 5) 1)
120

Python（Python3）

式に従って不動点コンビネータを定義…したいところだが，Schemeと同じく引数評価を先に行うことがわかっているので，書き直したSchemeの定義と同じ内容の定義を行う．なお，lambda式を直接変数に代入するのはPEP8非推奨であり，内部で（クロージャで）定義した関数を返す関数を返す，という記述方法が一般的であるため，それにしたがった定義を行う．

>>> def g(f):
...     def ret(y):
...         return g(f)(y)
...     return f(ret)
...
>>>

階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．

>>> g(lambda fact: lambda n: lambda r: r if n == 0 else fact(n-1)(n*r))(5)(1)
120

補足説明

無名関数，高階関数

プログラミングにおける『無名関数』とは，関数名を持たずに引数のみを持つ関数定義のことを指す．関数定義構文を用いる必要がないため，関数定義を引数として受け取れる『高階関数』への小さな任意処理の埋め込み追加などによく用いられる．なお，高階関数は，関数定義を戻り値として返すことができるものも含まれる．

再帰関数，無名再帰

無名関数の最大の欠点は，関数名がないために，『再帰関数』を定義するのも実行するのも，特別な方法が必要となることである．その方法としては，自身の引数の名前で自身を呼び出せるようにしてくれる高階関数を別途用意したり，実行環境が無名関数の場所を自動的に覚えて特別な名前で自身を呼び出せるようにしたりといったものがある（Wikipedia『無名再帰』を参照）．

不動点コンビネータ

この記事では，無名再帰のための高階関数として『不動点コンビネータ』を定義する方法に焦点を当てている．不動点コンビネータには様々な関数があり，その中でも有名なのが，自身も無名関数として示されることが多いYコンビネータである．この記事では，Yコンビネータを特に意識しなくとも定義できる不動点コンビネータについて述べている．

備考

記事に関する補足

• 概説に留めたいため，この記事では正確な定義や位置付けは述べていない．
• PEP8非推奨は高階関数大好き人間にはやっぱりつらたん．

変更履歴

• 2020-07-29：初版公開

諸般の理由で『Pythonのlambda式を用いたラムダ計算の基礎表現』を書いた後にHaskellに触れたところ，無名再帰関数を実行する不動点コンビネータがとんでもなく簡単に書けたため，同じ方法でSchemeやPythonでもできないか試したところ，これまたあっさりできたので，まとめメモ的に新しく記事にした．

このような内容がQiitaや書籍，ネット上に星の数の更に星の数乗ほどあることは承知しているが，この手の話はYコンビネータ（Zコンビネータ）が大きな割合を占めており（実際，元記事でも取り上げている），関心のある人々の数多ある参考資料のひとつ程度に捉えてもらえると幸いである．ツッコミ，編集リクエスト歓迎．

不動点コンビネータの定義

Haskell，Scheme，Pythonでの考察および実行例を述べる．なお，不動点コンビネータとは，$f(g(f))=g(f)$が成り立つ関数$g$を指す．

Haskell（GHC）

式に従い，不動点コンビネータを定義する．

Prelude> g f = f (g f)

階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．

Prelude> g (\fact -> \n r -> if n == 0 then r else fact (n-1) (n*r)) 5 1
120

Scheme（Gauche）

式に従い，不動点コンビネータを定義する．

gosh> (define (g f) (f (g f)))
g

階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．※注意：実行環境によっては危険！

gosh> (((g (lambda (fact) (lambda (n) (lambda (r) (if (= n 0) r ((fact (- n 1)) (* n r))))))) 5) 1)
; いつまでも表示されず → 強制終了

引数評価を先に行うという仕様上，実際の階乗計算の前に自己適用(g f)を繰り返して無限ループに陥り，メモリを食い潰していった模様．

同様の現象はYコンビネータでも起こるため，実際に稼働するZコンビネータへの変換と同じく，(g f)を，自由変数yを引数にもつlambda式でくくることで（ラムダ計算で言うη簡約の逆適用であるη展開，実装上はクロージャの活用），呼び出されるまで実行を据え置くようにする．なお，Haskellの引数は実際に必要となるまで評価されない（遅延評価機能のひとつ）ため，このような問題が起こらない．

gosh> (define (g f) (f (lambda (y) ((g f) y))))
g

書き直した不動点コンビネータについて，階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．

gosh> (((g (lambda (fact) (lambda (n) (lambda (r) (if (= n 0) r ((fact (- n 1)) (* n r))))))) 5) 1)
120

Python（Python3）

式に従って不動点コンビネータを定義…したいところだが，Schemeと同じく引数評価を先に行うことがわかっているので，書き直したSchemeの定義と同じ内容の定義を行う．なお，lambda式を直接変数に代入するのはPEP8非推奨であり，内部で（クロージャで）定義した関数を返す関数を返す，という記述方法が一般的であるため，それに従った定義を行う．

>>> def g(f):
...     def ret(y):
...         return g(f)(y)
...     return f(ret)
...
>>>

階乗計算を行う無名関数を用いた動作確認を行った結果は次の通り．

>>> g(lambda fact: lambda n: lambda r: r if n == 0 else fact(n-1)(n*r))(5)(1)
120

補足説明

無名関数，高階関数

プログラミングにおける『無名関数』とは，関数名を持たずに引数のみを持つ関数定義のことを指す．関数定義構文を用いる必要がないため，関数定義を引数として受け取れる『高階関数』への小さな任意処理の埋め込み追加などによく用いられる．なお，高階関数は，関数定義を戻り値として返すことができるものも含まれる．

再帰関数，無名再帰

無名関数の最大の欠点は，関数名がないために，『再帰関数』を定義するのも実行するのも，特別な方法が必要となることである．その方法としては，自身の引数の名前で自身を呼び出せるようにしてくれる高階関数を別途用意したり，実行環境が無名関数の場所を自動的に覚えて特別な名前で自身を呼び出せるようにしたりといったものがある（Wikipedia『無名再帰』を参照）．

不動点コンビネータ

この記事では，無名再帰のための高階関数として『不動点コンビネータ』を定義する方法に焦点を当てている．不動点コンビネータには様々な関数があり，その中でも有名なのが，自身も無名関数として示されることが多いYコンビネータである．この記事では，Yコンビネータを特に意識しなくとも定義できる不動点コンビネータについて述べている．

備考

記事に関する補足

• 概説に留めたいため，この記事では正確な定義や位置付けは述べていない．
• PEP8非推奨は高階関数大好き人間にはやっぱりつらたん．

変更履歴

• 2020-07-29：初版公開

はじめに

scikit-learnに限らず関数の実行時間を計測したいことはたまにあると思いますが、計測後に計算を挟んだりとごちゃごちゃしてしまいます。

コード

関数の処理時間を計測したいのであれば、Pythonのおもしろい機能の一つであるデコレータを使ったほうが個人的には良いと思います。デコレータに汚い計算を任せてしまえということです。

import time
def clock(func):
    def clocked(*args):
        t0 = time.perf_counter()
        result = func(*args)
        elapsed = time.perf_counter() - t0
        arg_str = ", ".join(repr(arg) for arg in args)
        print("[%0.8fs %s(%s) -> %r" % (elapsed,func.__name__,arg_str,result))
        return result
    return clocked

デモ

scikit-learnの学習時間を簡単に測定して見ます。先程のコードはclockdeco.pyに保存しています。

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from clockdeco import clock

# load iris datasets
iris = datasets.load_iris()
X = iris.data[:,[2,3]]
y = iris.target
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=0)

# preprocessing
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)


def modelDemo(model,x_train,y_train,test):
    model.fit(x_train,y_train)
    y_pred = model.predict(test)
    return round(accuracy_score(y_test,y_pred),2)


# Perceptron
from sklearn.linear_model import Perceptron
@clock
def PerceptronDemo():
    ppn = Perceptron(max_iter=40,eta0=0.1,random_state=0,shuffle=True)
    result = modelDemo(model=ppn,x_train=X_train_std,y_train=y_train,test=X_test_std)
    return result

# LogisticRegression
from sklearn.linear_model import LogisticRegression
from sklearn.linear_model import SGDClassifier
@clock
def LogisticRegressionDemo():
    #lr = LogisticRegression(C=1000.0,random_state=0)
    lr = SGDClassifier(loss="log")
    result = modelDemo(model=lr,x_train=X_train_std,y_train=y_train,test=X_test_std)
    return result

# SuportVectorMachine
from sklearn.svm import SVC
@clock
def SVMDemo():
    svm = SVC(kernel="linear", C=1.0, random_state=0)
    result = modelDemo(model=svm,x_train=X_train_std,y_train=y_train,test=X_test_std)
    return result


# DecisionTree
from sklearn.tree import DecisionTreeClassifier
@clock
def DecisionTreeDemo():
    tree = DecisionTreeClassifier(criterion="entropy",max_depth=3,random_state=0)
    result = modelDemo(model=tree,x_train=X_train,y_train=y_train,test=X_test)
    return result

# RandomForest
from sklearn.ensemble import RandomForestClassifier
@clock
def RandomForestDemo():
    forest = RandomForestClassifier(criterion="entropy",n_estimators=10,random_state=1,n_jobs=2)
    result = modelDemo(model=forest,x_train=X_train,y_train=y_train,test=X_test)
    return result

# KNN
from sklearn.neighbors import KNeighborsClassifier
@clock
def KNNDemo():
    knn = KNeighborsClassifier(n_neighbors=5,p=2,metric="minkowski")
    result = modelDemo(model=knn,x_train=X_train,y_train=y_train,test=X_test)
    return result

# wbdc dataset
# pipeline test
from skutils import load_wdbc_dataset
df = load_wdbc_dataset()
X = df.loc[:,2:].values
y = df.loc[:,1].values

# クラスを0,1にする
from skutils import label_encode
le,y = label_encode(y)
X_train_w,X_test_w,y_train_w,y_test_w = train_test_split(X,y,test_size=0.20,random_state=1)

from sklearn.decomposition import PCA
from sklearn.pipeline import Pipeline
@clock
def wdbc_piplineDemo():
    procs = [("scl",StandardScaler()),
            ("pca",PCA(n_components=2)),("clf",LogisticRegression(random_state=1,solver='lbfgs'))]
    pipe_lr = Pipeline(procs)
    pipe_lr.fit(X_train_w,y_train_w)
    return round(pipe_lr.score(X_test_w,y_test_w),2)



demos = [globals()[name] for name in globals()
            if name.endswith("Demo")
            and name != "modelDemo"]


if __name__ == "__main__":
    for demo in demos :
        demo()

デコレータのおかげでかなりすっきり書けるようになったのではないでしょうか。ちなみに実行結果は以下のようになります。

前回の記事の続きで、Relational Networkのできる限りの説明になります。

Relational Networkについて

まずは元論文のリンクを(https://arxiv.org/pdf/1706.01427)
実験結果から見てしまいましょう。

これはCLEVRというオブジェクトの関係から回答を導くデータセットの正解率になります。よくあるニューラルネットワーク（CNN+LSTM、まあ今はあんまり使われてないみたいですが）の正解率は低く、人間（Human)を下回っています。一方、Relational Networkを用いた(CNN+LSTM+RN)は人間を上回る結果が出ています。
この結果から分かりますが、シンプルなニューラルネットワーク(NN)というものは関係というものを認識する能力が低いのです。そこで提案されたのがこのRelational Networkです。後述しますが、関係性を出力に反映するためにシンプルなニューラルネットワークとは違った特殊な構造を持っています。で、この技術をARCで使おうと考えているわけです。

Relational Network詳細

Relational Networkは式で表すと次のような構造になっています。

RN(O)=f_\phi (\sum_{i,j}g_\theta(o_i,o_j))

ここで$O=\{ o_1,o_2,\dots o_n \},o_i\in \mathbb{R}^m$で$o_i$はオブジェクトを表します。そして、$f_\phi$と$g_\theta$はパラメータつきの関数（Relational NetworkではMLPで実装）を表します。
図で表すと以下のようになります。

CNNとLSTMでオブジェクトを認識し、それをRNに入力することで回答を出すという構造です。
このRNの式、正直、私もいまいちよく分かっていないのですが、$g_\theta$で各オブジェクト毎の関係性を出力し、それらを加算して、$f_\phi$で統合し出力を得るみたいです。ただ、よくあるNN(すべてのオブジェクトを一列に並べてしまって、MLPに入力する)と違うのは二つのオブジェクトを表すベクトルと質問ベクトルだけを並べてMLPに入力しているという点です。これはよくあるNNより制限された構造と考えられ、この制限によりネットワークがオブジェクト間の関係性を学習しやすくなるのだと思っています。

Sort Of CLEVRデータセット

論文で実際に使用されたデータセットはほかにもあるようですが、Sort OF CLEVRの実験の追試をしてみました。Sort Of CLEVRの例は以下の図になります。

このデータセットは画像と質問文（図では文章が書いてありますが、実際には質問文はエンコードされています。）で構成されています。画像にはいくつかのオブジェクトがあり、質問文はそのオブジェクトに関する質問で成り立っています。質問には２つ種類があり、オブジェクト間の関係を考慮する必要のない質問（Non-relational question）とオブジェクト間の関係を考慮する必要のある質問（Relational question）があります。そして、図右上にもありますが、ここでもCNN＋RNはCNN+MLPを上回った正解率を特にRelational questionで出しています。

私も追試はしたのですが、正直ほとんどこのリポジトリ(https://github.com/kimhc6028/relational-networks)を参考にしただけなので、コードは特に載せません。追試の結果だけ示します。まず、訓練データの正解率です。

次にテストデータの正解率です。

訓練とテストの差を見る限り、20epochを超えたあたりで、過学習気味ですが、test_acc_relが90%近いのは良いのではないでしょうか。そして一番悪いtest_acc_ternary。これは3つのオブジェクトに関する質問なのですが、完璧に過学習状態であり、test_acc_relと比べても正解率が低いです。一応、60%は出ていますが、三つの関係というのはRNでも難しいようです。３つ以上の関係性は三体問題のような例もあるように、そもそもが難しいものだとは思います。ただ、Sort of Clevrの３つの関係性の問題はそこまで難しいものではない（私が解けば100%に近い数字が出ると思います。）ので、改善の余地があるでしょう。

まとめと今後

論文の結果からもわかるように、RNはシンプルなNNと比べて、関係性を処理する能力が高いということが分かります。ただし、３つの関係性には苦戦しているようで、３つ以上の関係性が必要な問題はARCにもあるでしょう。そこで、次はReccurent Relatinal Network（RRN）に挑戦してみようと思います。正直、この記事かなり適当なのですが、ただのRNではARCが解けないと思っていたので、このRRNに早く取り組みたかったからです。RRNを使うと数独も解ける用で、フォーマット的にも数独とARCは近いものがあると思います。まあ、どうなるかやってみましょう。

結論

ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

のエラーの原因として、

複数条件なのにそれぞれを() で括っていない、& | ^などのbit演算ではなくand or notなどと書いているなどが検索で出てきますが^1　2

isin をin にしてしまっていた時も同様のエラーメッセージがおきるので気をつけましょう。

原因となったコード

error.py

tmp__ = transactions[(transactions["year"] == "2014" ) & (transactions ["month"] in ["06","07","08"]))]

訂正したコード

correct.py

tmp__ = transactions[(transactions["year"] == "2014" ) & (transactions["month"].isin( ["06","07","08"]))]

---

1. nkmkさんのブログ記事にこのエラーが起きるケースとその理由（PandasやNumby ndarrayでは曖昧性解消のため、bitwise(&,|,~)を使うとelement-wiseなoperator(and,or,norなど）　にoverride されるようになっている）が書かれています　https://note.nkmk.me/python-numpy-pandas-value-error-ambiguous/ ↩

2. 　stackoverflowの記事ではどのように曖昧であるかをもう少し詳しく説明してあります。https://stackoverflow.com/questions/36921951/truth-value-of-a-series-is-ambiguous-use-a-empty-a-bool-a-item-a-any-o ↩

前回の記事
「FORTRAN77数値計算プログラミング」のプログラムをCとPythonに移植してみる（その2）

はじめに

　その1、その2とFortran77数値計算プログラミングの1章のコードを確認してきました。
　本では、1章にこのあと3つプログラムが載っているのですが、これ、全部誤差がどうなるかを確認しているものです。前回@cure_honey さんに教えていただいたとおり、16進数を基数とした浮動小数点数を使った計算結果が今のIEEE754方式の浮動小数点数での結果とは合わず、本での検証とはずれていくばかりなので、このあたりのコードはもう飛ばすことにします。
　誤差について飛ばすと次は乱数のお話で、乱数生成ってCにもPythonにも関数があるのでそれも飛ばすと、お次は5章、「連立1次方程式とLU分解」です。

LU分解

　本の5章、P.52〜の式を引きつつ、LU分解についてまとめます。

連立一次方程式の解き方

　$n\times n$行列の行列$A$

A=\begin{pmatrix}
a_{11} & a_{12} & \cdots & a_{1n} \\
a_{21} & a_{22} & \cdots &  a_{2n} \\
\vdots & \vdots & & \vdots \\
a_{n1} & a_{n2} & \cdots &  a_{nn} 
\end{pmatrix}\tag{1}

があって、$b$および$x$はそれぞれ次のようなベクトルのとき、

b = \begin{pmatrix}
b_1\\
b_2\\
\vdots\\
b_n
\end{pmatrix}\tag{2}
\\

x = \begin{pmatrix}
x_1\\
x_2\\
\vdots\\
x_n
\end{pmatrix}\tag{3}
\\

この$A$と$b$に対して

Ax = b\tag{4}

となる$x$を求める連立一次方程式を考えます。

LU分解とは

　LU分解というのは、与えられた行列$A$を左下三角行列$L$と右上三角行列$U$との積で表すことです。つまり、

A=\begin{pmatrix}
■&0&0&0&0\\
■&■&0&0&0\\
■&■&■&0&0\\
■&■&■&■&0\\
■&■&■&■&■
\end{pmatrix}
\begin{pmatrix}
■&■&■&■&■\\
0&■&■&■&■\\
0&0&■&■&■\\
0&0&0&■&■\\
0&0&0&0&■
\end{pmatrix}
\equiv
LU

になるように■を定めることです。ただし実際は、

A=\begin{pmatrix}
1&0&0&0&0\\
■&1&0&0&0\\
■&■&1&0&0\\
■&■&■&1&0\\
■&■&■&■&1
\end{pmatrix}
\begin{pmatrix}
■&■&■&■&■\\
0&■&■&■&■\\
0&0&■&■&■\\
0&0&0&■&■\\
0&0&0&0&■
\end{pmatrix}
\equiv
LU\tag{5}

という形に限定します。
　こうすることで、方程式$(4)$が

LUx=b\tag{6}

となって、これを解くためには、まず

Ly=b\tag{7}

の解$y$を求め、つぎにこの解$y$を右辺に持つ方程式

Ux=y\tag{8}

を解いて$x$を求めればよくなります。式が2つに増えてしまって、めんどくさそうですが、行列が三角行列になると、ずっと簡単に解くことが出来ます。

Fortranのコード

sdecom.f

      PROGRAM SDECOM
*                                                *
*       Sample program of DECOMP and SOLVE       *
*                                                *
      PARAMETER (NDIM = 20)
*
      REAL A(NDIM,NDIM),B(NDIM),X(NDIM)
      REAL W(NDIM),V(NDIM)
      INTEGER IP(NDIM)
*
      DO 10 NN = 1, 2
*
        N = 10 * NN
*
        CALL LUDATA (NDIM, N, A, B)
*
        CALL ANCOMP (NDIM, N, A, ANORM)
*
        WRITE (*,2000) ANORM
 2000   FORMAT (/' ---- DECOMP and SOLVE ----'/
     $           ' 1-norm of A = ',1PE13.6)

        CALL DECOMP (NDIM, N, A, W, IP)

        CALL SOLVE (NDIM, N, A, B, X, IP)

        CALL ESTCND (NDIM, N, A, V, IP, W,
     $               ANORM, COND)
*
        WRITE (*,2001) (X(I), I=1,N)
 2001   FORMAT (' solution X(I)'/(1X,5F9.5))
*
        WRITE (*,2002) COND
 2002   FORMAT (' condition number = ',1PE13.6)
*
   10 CONTINUE
*   
      END

ludata.f

      SUBROUTINE LUDATA (NDIM, N, A, B)
*                                                 *
*         Sample data of DECOMP and SOLVE         *
*                                                 *
        REAL A(NDIM,N),B(N)

        DO 510 I =1, N
          DO 520 J = 1, N
            A(I,J) = 0.0
  520     CONTINUE
  510  CONTINUE
*
        A(1,1) = 4.0
        A(1,2) = 1.0

        DO 530 I = 2, N - 1
           A(I,I-1) = 1.0
           A(I,I)   = 4.0
           A(I,I+1) = 1.0
  530   CONTINUE

        A(N,N-1) = 1.0
        A(N,N)   = 4.0

        DO 540 I = 1, N
          B(I) = 0.0
          DO 550 J = 1, N
            B(I) = B(I) + A(I,J) * J
  550     CONTINUE
  540   CONTINUE
*
        RETURN
      END

ancomp.f

      SUBROUTINE ANCOMP (NDIM, N, A, ANORM)
*                                            *
*     Compute 1-norm of A toestimate         *
*          condition number of A             *
*                                            *
        REAL A(NDIM,N)
*
        ANORM = 0.0
        DO 10 K = 1, N
          S = 0.0
          DO 520 I = 1, N
            S = S + ABS(A(I,K))
  520     CONTINUE
          IF (S .GT. ANORM) ANORM = S
  10    CONTINUE
*  
        RETURN
      END

decomp.f

      SUBROUTINE DECOMP (NDIM, N, A, W, IP)
*                                            *
*     LU decomposition of N * N matrix A     *
*                                            *
        REAL A(NDIM,N),W(N)
        INTEGER IP(N)
*
        DATA EPS / 1.0E-75 /
*
        DO 510 K = 1, N
          IP(K) = K
  510   CONTINUE
*
        DO 10 K = 1, N
          L = K
          AL = ABS(A(IP(L),K))
          DO 520 I = K+1, N 
            IF (ABS(A(IP(I),K)) .GT. AL) THEN
                L = I
                AL = ABS(A(IP(L),K))
            END IF
  520     CONTINUE
*
          IF (L .NE. K) THEN
*
*             ---- row exchange ----
*
            LV = IP(K)
            IP(K) = IP(L)
            IP(L) = LV
          END IF
*
          IF (ABS(A(IP(K),K)) .LE. EPS) GO TO 900
*
*             ---- Gauss elimination ----
*
            A(IP(K),K) = 1.0 /  A(IP(K),K)

            DO 30 I = K+1, N
              A(IP(I),K) = A(IP(I),K) * A(IP(K),K)
              DO 540 J = K+1, N 
                W(J) = A(IP(I),J) - A(IP(I),K) * A(IP(K),J)
  540         CONTINUE
              DO 550 J = K+1, N
                A(IP(I),J) = W(J)
  550         CONTINUE
   30       CONTINUE
*          
   10   CONTINUE
*
        RETURN
*
*       ---- matrix singular ----
*
  900   CONTINUE
        WRITE (*,2001) K
 2001   FORMAT (' (DECOMP) matrix singular ( at ',I4,
     $          '-th pivot)')
        N = - K
        RETURN
*
      END

solve.f

      SUBROUTINE SOLVE (NDIM, N, A, B, X, IP)
*                                            *
*     Solve system of linear equations       *
*                 A * X = B                  *
*                                            *
        REAL A(NDIM,N),B(N),X(N)
        INTEGER IP(N)
*
        REAL*8 T
*
*       ---- forward substitution ----
*
        DO 10 I = 1,N
          T = B(IP(I))
          DO 520 J = 1, I-1
            T = T - A(IP(I),J) * DBLE(X(J))
  520     CONTINUE
          X(I) = T
   10   CONTINUE
*
*       ---- backward substitution ----
*
        DO 30 I = N, 1, -1
          T = X(I)
          DO 540 J = I+1, N
            T = T - A(IP(I),J) * DBLE(X(J))
  540     CONTINUE
          X(I) = T * A(IP(I),I)
   30   CONTINUE
*
        RETURN
      END

estcnd.f

      SUBROUTINE ESTCND(NDIM, N, A, V, IP, Y,
     $                  ANORM, COND)
*                                            *
*     Estimate condition number of A         *
*                                            *        
       REAL A(NDIM,N),V(N),Y(N)
       INTEGER IP(N)
*
       REAL*8 T
*
       DO 10 K = 1,N 
         T = 0.0
         DO 520 I = 1, k-1
           T = T - A(IP(I),K) * DBLE(V(I))
 520     CONTINUE
         S = 1.0
         IF (T .LT. 0.0) S = -1.0
         V(K) = (S + T) * A(IP(K),K)
  10   CONTINUE
*
       DO 30 K = N, 1, -1
         T = V(K)
         DO 530 I = K+1, N
           T = T - A(IP(I),K) * DBLE(Y(IP(I)))
 530     CONTINUE
         Y(IP(K)) = T
  30   CONTINUE
*        
       YMAX = 0.0
       DO 540 I = 1, N
         IF (ABS(Y(I)) .GT. YMAX) YMAX = ABS(Y(I))
 540   CONTINUE
*
       COND = ANORM * YMAX
*
       RETURN
      END 

コードの理解

sdecom

メインプログラム。例題のための配列の大きさを与えるNDIMをPARAMETER文で定義しています。

ludata

ludataというサブルーチンはまず、

N=10

のときに

A=\begin{pmatrix}
4.0 & 1.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\
1.0 & 4.0 & 1.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\
0.0 & 1.0 & 4.0 & 1.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\
0.0 & 0.0 & 1.0 & 4.0 & 1.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\
0.0 & 0.0 & 0.0 & 1.0 & 4.0 & 1.0 & 0.0 & 0.0 & 0.0 & 0.0 \\
0.0 & 0.0 & 0.0 & 0.0 & 1.0 & 4.0 & 1.0 & 0.0 & 0.0 & 0.0 \\
0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 1.0 & 4.0 & 1.0 & 0.0 & 0.0 \\
0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 1.0 & 4.0 & 1.0 & 0.0 \\
0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 4.0 & 1.0 \\
0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 1.0 & 4.0 \\
\end{pmatrix}

b=\begin{pmatrix}
6.00000 & 12.00000 & 18.00000 &  24.00000 & 30.00000 & 36.00000 & 42.00000 & 48.00000 & 54.00000 & 49.00000
\end{pmatrix}

という行列を作っています。
このとき、行列$b$は、

b_i = \sum_{j=1}^na_{ij}j

で求められています。
やりたいことは、この$A$と$b$に対して

Ax = b

となる$x$を求めることでした。

ancomp

次に、ancompというサブルーチンは、

||A||_1 = \max_{1\leq k\leq n} \sum_{i=1}^n|a_{ik}|\tag{9}

という行列のノルムに基づいて条件数を設定しています。これが$ANORM$という変数に設定されています。
ここで作業用変数$S$に倍精度実数型の宣言を行っていないのは、このノルム自身はそれほど制度を必要としないからだそう。

decomp

decompが、本題のLU分解を行うサブルーチン。
引数は、行列$A$に対応する2次元配列$A$とインデックスベクトル$p$に対応する1次元の整数型配列$IP$、行列の次元$N$です。
まず配列$IP$を、

IP(k) = k, \quad k=1,2,\cdots, n

で初期化してから、ピボットの部分選択を行いながらガウス消去法によってLU分解を実行します。

solve

LU分解した結果を使って方程式$(4)$を解くサブルーチンがsolveです。

estcnd

行列$A$の条件数の推定値を計算するサブルーチンがestcnd。ただし、行列$A$があらかじめdecompによってLU分解されていることが前提。

Cのコード

sdecom.h

#ifndef NDIM
#define NDIM 20
#endif
void ludata(int n, float a[NDIM][NDIM], float b[NDIM]);
float ancomp(int n, float a[NDIM][NDIM]);
int decomp(int n, float a[NDIM][NDIM], float w[NDIM], int ip[NDIM]);
void solve(int n, float a[NDIM][NDIM], float b[NDIM], float x[NDIM], int ip[NDIM]);
float estcnd(int n, float a[NDIM][NDIM], float v[NDIM], int ip[NDIM], float y[NDIM], float anorm);

sdecom.c

#include <stdio.h>
#include<stdlib.h>
#include "sdecom.h"

int main(void)
{

    float a[NDIM][NDIM], b[NDIM], x[NDIM];
    float w[NDIM], v[NDIM];
    int ip[NDIM];

    int nn;
    int n;

    float anorm, cond;
    int i,j;

    for(nn = 1; nn < 3; nn++){
        n = 10 * nn;

        ludata(n, a, b);
        anorm = ancomp(n, a);
        printf(" ---- DECOMP and SOLVE ----\n 1-norm of A = %13.6E\n"
        , anorm);

        n = decomp(n, a, w, ip);
        solve(n, a, b, x, ip);

        cond = estcnd(n, a, v, ip, w, anorm);

        printf(" solution X(I)\n");
        for(i=0; i<n; i++){
            if(i != 0 && i % 5 == 0) {
                printf("\n");
            }
            printf(" %.5f", x[i]);
        }

        printf("\n condition number = %13.6E\n", cond);

    }

    return 0;
}

ludata.c

#include <stdio.h>
#include "sdecom.h"

void ludata(int n, float a[NDIM][NDIM], float b[NDIM])
{
    int i, j;

    for(i=0; i<n; i++){
        for(j=0; j<n; j++){
            a[i][j] = 0.0f;
        }
    }
    a[0][0] = 4.0f;
    a[0][1] = 1.0f;

    for(i=1; i<n-1; i++){
        a[i][i-1] = 1.0f;
        a[i][i] = 4.0f;
        a[i][i+1] = 1.0f;
    }
    a[n-1][n-2] = 1.0f;
    a[n-1][n-1] = 4.0f;

    for(i=0; i<n; i++){
        b[i] = 0.0f;
        for(j=0; j<n; j++) {
            b[i] +=  (a[i][j] * (j+1));
        } 
    }
}

ancomp.c

#include <stdio.h>
#include <math.h>
#include "sdecom.h"

float ancomp(int n, float a[NDIM][NDIM])
{
    int i,k;
    float s;

    float anorm = 0.0f;

    for(k=0; k<n; k++){
        s = 0.0f;
        for(i=0; i<n; i++) {
            s = s + fabsf(a[i][k]);
        }
        if (s > anorm){
            anorm = s;
        } 
    }

    return anorm;
}

decomp.c

#include <stdio.h>
#include <math.h>
#include <float.h>
#include "sdecom.h"

int decomp(int n, float a[NDIM][NDIM], float w[NDIM], int ip[NDIM])
{
    //double eps = 1.0e-75;
    int i,j,k,l;
    float al;
    int lv;

    for(k=0; k<n; k++){
        ip[k] = k;
    }


    for(k=0; k<n; k++){
        l = k;
        al = fabsf(a[ip[l]][k]);
        for(i=k+1; i<n; i++){
            if(fabsf(a[ip[i]][k]) > al) {
                l = i;
                al = fabsf(a[ip[l]][k]);
            }
        }

        if(l != k) {
            lv = ip[k];
            ip[k] = ip[l];
            ip[l] = lv;
        }

        if((fabsf(a[ip[k]][k]) <= DBL_EPSILON)) {
            printf(" (DECOMP) matrix singular ( at %4d-th pivot)\n", k);
            n = -k;
            break;
        } else {
            a[ip[k]][k] = 1.0f / a[ip[k]][k];
            for(i=k+1; i<n; i++) {
                a[ip[i]][k] = a[ip[i]][k] * a[ip[k]][k];
                for(j=k+1; j<n; j++) {
                    w[j] = a[ip[i]][j] - a[ip[i]][k] * a[ip[k]][j];
                }
                for(j=k+1; j<n; j++) {
                    a[ip[i]][j] = w[j];
                }
            }
        } 
    }
    return n;
}

solve.c

#include <stdio.h>
#include "sdecom.h"

void solve(int n, float a[NDIM][NDIM], float b[NDIM], float x[NDIM], int ip[NDIM])
{
    double t;
    int i,j;

    for(i=0; i<n; i++){
        x[i] = 0.0f;
    }

    for(i=0; i<n; i++){
        t = b[ip[i]];
        for(j=0; j<i; j++){
            t = t - a[ip[i]][j] * (double)x[j];
        }
        x[i] = t;
    }

    for(i=n-1; i>-1; i--){
        t = x[i];
        for(j=i+1; j <n; j++){
            t = t - a[ip[i]][j] * (double)x[j];
        }
        x[i] = t * a[ip[i]][i];
    }
}

estcnd.c

#include <stdio.h>
#include <math.h>
#include "sdecom.h"

float estcnd(int n, float a[NDIM][NDIM], float v[NDIM], int ip[NDIM], float y[NDIM], float anorm)
{
    float cond;

    double t;
    int i,k;
    float s;
    float ymax;

    for(k=0; k<n; k++){
        t = 0.0;
        for(i=0; i<k; i++){
            t = t - a[ip[i]][k] * (double)v[i];
        }
        s = 1.0f;
        if( t < 0.0f) {
            s = -1.0f;
        }
        v[k] = (s + t) * a[ip[k]][k];
    }

    for(k=n-1; k>-1; k--){
        t = v[k];
        for(i=k+1; i<n; i++){
            t = t - a[ip[i]][k] * (double)y[ip[i]];
        }
        y[ip[k]] = t;
    }

    ymax = 0.0f;
    for(i=0; i<n; i++){
        if(fabsf(y[i]) > ymax){
            ymax = fabsf(y[i]);
        }
    }

    cond = anorm * ymax;
    return cond;
}

ただ愚直にFortranのコードを置き換え。
変数をいっそのことグローバルで定義しちゃおうかな、とか思ったものの、個人的に無理でやめました。

Pythonのコード

import scipy.linalg as linalg
import numpy as np

def ludata(n):
    a = [[0.0] * n for i in range(n) ]

    a[0][0] = 4.0
    a[0][1] = 1.0

    for i in range(1,n-1):
        a[i][i-1] = 1.0
        a[i][i] = 4.0
        a[i][i+1] = 1.0

    a[n-1][n-2] = 1.0
    a[n-1][n-1] = 4.0

    b = [0.0] * n
    for i in range(n):
        for j in range(n):
            b[i] +=  (a[i][j] * (j+1))

    return a,b 

for nn in range(1,3):
    n = 10 * nn 
    a,b = ludata(n)

    LU = linalg.lu_factor(a)
    x = linalg.lu_solve(LU, b)

    print(x)

Pythonには、SciPyという強力な数値計算ライブラリがあり、当然のようにLU分解の関数もあるわけですね…。
そんなわけでゴリゴリ書くのはデータ作ってるところだけでした。

まとめ

探せばC言語にもなんか良さげなライブラリ公開されているんじゃないかなーとか思ったり。
とりあえず、だいぶ寝かせてしまった3回目、数式書くのが結構めんどくさかったです。

画面内にない要素をクリックすることはできない

driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")

スクロールして画面内に出すか、

---

driver.set_window_size(xxxx,yyyy)

で最初に画面サイズを変更する。
自分は毎回スクロールするのが面倒なので画面サイズを1980、1280にした。
他にもIDなどの要素までスクロールできるっぽい。

---

ユーザーエージェントがないとロボット扱いしてくるサイトもあるので

options.add_argument(f'user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36')

ユーザーエージェントを偽装する。

---

Javascriptのボタンなどをクリックできない場合

elements = driver.find_element_by_xpath("XPATH")
loc = elements.location
x, y = loc['x'], loc['y']
actions = ActionChains(driver)
actions.move_by_offset(x, y)
actions.click()
actions.perform()

XPATHの座標でクリックする。

---

テキストが画面内にないと.textなどでは取得できない

text = driver.find_element_by_id("ID").get_attribute("textContent")

get_attributeで取得する。

おわり

まだ始めて一ヶ月なのでこれ違うよなどツッコミがあるかもしれませんが、優しく言ってくださると幸いです。

M-SOKUTIONS プロコンオープン 2020にバーチャル参加しました。
ABCDの4問ACでした。
Python3を使用しています。

A問題

ifで条件分岐させます。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    X = int(input())
    if X >= 1800:
        print(1)
    elif X >= 1600:
        print(2)
    elif X >= 1400:
        print(3)
    elif X >= 1200:
        print(4)
    elif X >= 1000:
        print(5)
    elif X >= 800:
        print(6)
    elif X >= 600:
        print(7)
    else:
        print(8)           

if __name__ == "__main__":
    main()

B問題

条件を満たすまで操作を行い、操作回数がK以下であれば魔術を成功させられたと考えます。
これは入力されるA、B、C、Kが小さいために可能です。


M君は数字を2倍にする操作を行うため、最も小さい数となるべきAに操作を行わないことが分かります。
つまり、Aの値が固定された状態で考えます。
while文で、BがAより大きくなるように操作を行います。
これにより、Bの値が固定されます。
同様にwhile文でBより大きいCを求めることができます。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    A, B, C = map(int,input().split())
    K = int(input())
    count = 0
    while A >= B:
        B = B * 2
        count += 1
    while B >= C:
        C = C * 2
        count += 1
    if count <= K:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

C問題

この問題は、前学期より評点が高いが低いか判定する必要があるだけで、実際の評点を求める必要はありません。


N学期の評点はA[0]*A[1] ~ *A[N-1]で求められます。
N+1学期の評点はA[1] ~ *A[N-1]*A[N]で求められます。
評点の高低を比較するだけなので、A[0]とA[N]を比較するだけで十分です。
これをfor文で繰り返し、N-K個の結果を表示します。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    N, K = map(int,input().split())
    A = list(map(int,input().split()))
    for i in range(N - K):
        if A[i] < A[i + K]:
            print("Yes")
        else:
            print("No")  

if __name__ == "__main__":
    main()

D問題

株価が低いときに買って、株価が高いときに売りたいというのが基本的な目標です。


まずi番目とi+1番目を比較し、大きくなっていれば1、小さくなっていれば-1というリストを作ります。 (リスト内包表記の利用)
1のときは買えるだけ買います。
1が続くということは株価が上がっていくということなので、一番初めに1になった地点で買えばOKです。
同様に-1になったときは全ての株を売ります。
-1が続くということは株価が下がっていくということなので、一番初めに-1になった地点で売ればOKです。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    N = int(input())
    A = list(map(int,input().split()))
    zougen = [-1 if A[i] > A[i + 1] else 1 for i in range(N - 1)]
    money = 1000
    kabu = 0
    for i in range(N-1):
        if zougen[i] == 1:
            kabu += money // A[i]
            money = money % A[i]
        else:
            money += kabu * A[i]
            kabu = 0
    print(A[-1] * kabu + money)



if __name__ == "__main__":
    main()

M-SOLUTIONS プロコンオープン 2020にバーチャル参加しました。
ABCDの4問ACでした。
Python3を使用しています。

A問題

ifで条件分岐させます。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    X = int(input())
    if X >= 1800:
        print(1)
    elif X >= 1600:
        print(2)
    elif X >= 1400:
        print(3)
    elif X >= 1200:
        print(4)
    elif X >= 1000:
        print(5)
    elif X >= 800:
        print(6)
    elif X >= 600:
        print(7)
    else:
        print(8)           

if __name__ == "__main__":
    main()

B問題

条件を満たすまで操作を行い、操作回数がK以下であれば魔術を成功させられたと考えます。
これは入力されるA、B、C、Kが小さいために可能です。


M君は数字を2倍にする操作を行うため、最も小さい数となるべきAに操作を行わないことが分かります。
つまり、Aの値が固定された状態で考えます。
while文で、BがAより大きくなるように操作を行います。
これにより、Bの値が固定されます。
同様にwhile文でBより大きいCを求めることができます。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    A, B, C = map(int,input().split())
    K = int(input())
    count = 0
    while A >= B:
        B = B * 2
        count += 1
    while B >= C:
        C = C * 2
        count += 1
    if count <= K:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

C問題

この問題は、前学期より評点が高いが低いか判定する必要があるだけで、実際の評点を求める必要はありません。


N学期の評点はA[0]*A[1] ~ *A[N-1]で求められます。
N+1学期の評点はA[1] ~ *A[N-1]*A[N]で求められます。
評点の高低を比較するだけなので、A[0]とA[N]を比較するだけで十分です。
これをfor文で繰り返し、N-K個の結果を表示します。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    N, K = map(int,input().split())
    A = list(map(int,input().split()))
    for i in range(N - K):
        if A[i] < A[i + K]:
            print("Yes")
        else:
            print("No")  

if __name__ == "__main__":
    main()

D問題

株価が低いときに買って、株価が高いときに売りたいというのが基本的な目標です。


まずi番目とi+1番目を比較し、大きくなっていれば1、小さくなっていれば-1というリストを作ります。 (リスト内包表記の利用)
1のときは買えるだけ買います。
1が続くということは株価が上がっていくということなので、一番初めに1になった地点で買えばOKです。
同様に-1になったときは全ての株を売ります。
-1が続くということは株価が下がっていくということなので、一番初めに-1になった地点で売ればOKです。

import sys
def input():
    return sys.stdin.readline()[:-1]


def main():
    N = int(input())
    A = list(map(int,input().split()))
    zougen = [-1 if A[i] > A[i + 1] else 1 for i in range(N - 1)]
    money = 1000
    kabu = 0
    for i in range(N-1):
        if zougen[i] == 1:
            kabu += money // A[i]
            money = money % A[i]
        else:
            money += kabu * A[i]
            kabu = 0
    print(A[-1] * kabu + money)



if __name__ == "__main__":
    main()

概要

今回はフロントエンドにVue.js、バックエンドにFlaskを用いた画像認識アプリを作ります。
ひとまず今回は画像アップロード機能までの実装です。

環境

• Docker
• Vue-cli
• flask (pipenv)

上記の環境で環境構築しました。
手順や詳細は以下のリンクを参照してください。

Vue + Flask on Docker

要所の説明

Vue

詳細を説明するのは、以下のコード。

Home.vue

// 画像をサーバーへアップロード
    onUploadImage () {
      var params = new FormData()
      params.append('image', this.uploadedImage)
      // Axiosを用いてFormData化したデータをFlaskへPostしています。
      axios.post(`${API_URL}/classification`, params).then(function (response) {
        console.log(response)
    })

1. 取得した画像はBase64化がなされている。「data:image/jpeg:base64,〜」
2. FormDataにより、データをHTTPリクエストで「キー：値」の形式へ。
3. Axiosを適用し、'127.0.0.1:5000/classification'+ POSTメソッドでデータを送信。

Flask

詳細を説明するのは、以下のコード。

app.py

@app.route('/classification', methods=['POST'])
def uploadImage():
    if request.method == 'POST':
        base64_png =  request.form['image']
        code = base64.b64decode(base64_png.split(',')[1]) 
        image_decoded = Image.open(BytesIO(code))
        image_decoded.save(Path(app.config['UPLOAD_FOLDER']) / 'image.png')
        return make_response(jsonify({'result': 'success'}))
    else: 
        return make_response(jsonify({'result': 'invalid method'}), 400)

1. FormDataの内部に「data:image/jpeg:base64,〜」が存在。ファイル名を取得。
2. Pillow(PIL)で画像を取得。
3. 画像の保存。

全体像

Vue

Home.vue

<template>
  <div>
    <div class="imgContent">
      <div class="imagePreview">
        <img :src="uploadedImage" style="width:100%;" />
      </div>
      <input type="file" class="file_input" name="photo" @change="onFileChange"  accept="image/*" />
      <button @click='onUploadImage'>画像判定してくだちい・・・</button>
    </div>
  </div>
</template>

<script>
import axios from 'axios'

const API_URL = 'http://127.0.0.1:5000'
export default {
  data () {
    return {
      uploadedImage: ''
    }
  },
  methods: {
    // 選択した画像を反映
    onFileChange (e) {
      let files = e.target.files || e.dataTransfer.files
      this.createImage(files[0])
    },
    // アップロードした画像を表示
    createImage (file) {
      let reader = new FileReader()
      reader.onload = (e) => {
        this.uploadedImage = e.target.result
      }
      reader.readAsDataURL(file)
    },
    // 画像をサーバーへアップロード
    onUploadImage () {
      var params = new FormData()
      params.append('image', this.uploadedImage)
      // Axiosを用いてFormData化したデータをFlaskへPostしています。
      axios.post(`${API_URL}/classification`, params).then(function (response) {
        console.log(response)
      })
    }
  }
}
</script>

Flask

留意点

• CORSにより、異なるオリジン(プロトコルやドメイン、ポート)でもリソースを共有できる。
• CORSは異なるWebアプリケーションを持つ場合、必須。
• app.config['JSON_AS_ASCII'] = False により日本語対応可能。

app.py

# render_template：参照するテンプレートを指定
# jsonify：json出力
from flask import Flask, render_template, jsonify, request, make_response

# CORS：Ajax通信するためのライブラリ
from flask_restful import Api, Resource
from flask_cors import CORS 
from random import *
from PIL import Image
from pathlib import Path
from io import BytesIO
import base64

# static_folder：vueでビルドした静的ファイルのパスを指定
# template_folder：vueでビルドしたindex.htmlのパスを指定
app = Flask(__name__, static_folder = "./../frontend/dist/static", template_folder="./../frontend/dist")

#日本語
app.config['JSON_AS_ASCII'] = False
#CORS=Ajaxで安全に通信するための規約
api = Api(app)
CORS(app)

UPLOAD_FOLDER = './uploads'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

# 任意のリクエストを受け取った時、index.htmlを参照
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def index(path):
    return render_template("index.html")

@app.route('/classification', methods=['POST'])
def uploadImage():
    if request.method == 'POST':
        base64_png =  request.form['image']
        code = base64.b64decode(base64_png.split(',')[1]) 
        image_decoded = Image.open(BytesIO(code))
        image_decoded.save(Path(app.config['UPLOAD_FOLDER']) / 'image.png')
        return make_response(jsonify({'result': 'success'}))
    else: 
        return make_response(jsonify({'result': 'invalid method'}), 400)

# app.run(host, port)：hostとportを指定してflaskサーバを起動
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

様子

こんな感じ

非常に参考になりました

https://developer.mozilla.org/ja/docs/Web/HTTP/CORS
画像をPOST、顔検出、canvasで顔にお絵かき