Kaggle散歩（1st March to 10th May 2021）

Kaggle散歩（March 2021）

3月1日（月）

HuBMAP：1,130 teams, two months to go

今日はBatch_sizeの16と32に違いがあるかどうかを調べる。

EfficientNetB5-UnetのLB=0.836のコードがBatch_size=16だったので、これを32に変更したがGPUのメモリーオーバーとなったため、B4で実行した：結果はLB=0.836となった。

これで改善が認められれば他のDecoderでもやってみるつもりだったが、・・・。

次は、Encoderのpre-training weights（'imagenet'を常用している）によって違いがあるかどうかを調べる。

'noisy-student'：LB=0.831：0.005下がった。

'advprop'：LB=0.823：0.013下がった。

こういうのは、実際に使ってみないとわからないものだ。ただし、エポック数など、最適化できていないパラメータに起因して、スコアが低い、という可能性もある。

次は、pre-trained weightsではなく、random initializationでやってみよう。

A. Geron氏のテキストには、Glorot and He initialization, LeCun initialization, Xavier initializationなどが紹介されている。今使っているSegmentation Modelsでは、これらの initializationには対応していないようである。

random initialization(epochs=30)：LB=0.819 ：意外に健闘しているようにみえる。

今日のデータはすべて30エポックだが、random initializationについては、明日、エポック数を増やしてみよう。

3月2日（火）

HuBMAP：1,142 teams, two months to go

random initialization(epochs=50)：LB=0.778：期待外れ。これ以上追求しない。

（lr_schedulerは、OneCycleLRを使い続けているので、エポック数は、OneCycleLRの設定エポック数である。このスケジューラーは、early_stopで監視する必要が無く、極端なoverfittingにもならないようで、便利だが、Max_lrとエポック数の最適化は必須。合間に最適化を試みているが、まだ使いこなせていないように感じている。）

ここまで、"An activation function to apply after the final convolution layer. "をNoneにして、 score > 0、で評価してきたが、activation functionを"sigmoid"にして、score > thresholdとして、thresholdの最適化をやってみる。

ちょっとやってみたが、うまくいかない。何かおかしい。間違ったことをしているかもしれない・・・。

best single modelというタイトルのdiscussionにおいて、LB=0.84+から0.86+くらいのスコアのモデル（encoder+decoder）、optimizer、loss function、epochsなど概要が紹介されている。自分の結果、0.83+とは最大で0.03くらい違う。前処理、後処理などの情報が少ないので何を参考にすればよいのかわからないが、気になるのは、スコアが高い0.85+の4件が、EncoderにEfficientNetを使っていないことと、開発年代の古いEncoderを用いて、エポック数を多くしていることである。さらに、resnet34-UnetでLB=0.857というスコアを得ているのは驚きだ。FPNは1件で、そのほかはUnetを使っている。

Googleが昨年発表した論文"EfficientDet: Scalable and Efficient Object Detection"で提案している新しいモデルEfficientDetは、FPNから派生したもののようである"we propose a weighted bi-directional feature pyramid network (BiFPN)"。

3月3日（水）

HuBMAPに集中している間に、いろいろなコンペが通り過ぎていった。今日、新しいテーマのコンペ案内メールが来ていた。化学系には興味があるので調べてみる。

Bristol-Myers Squibb – Molecular Translation
Can you translate chemical images to text?

chemical imagesというのは構造式、textというのは、InChIのこと。構造式は画像として与えられる。InCHIについて、wikipediaの説明は以下の通り。

InChI(International Chemical Identifier)は、標準的かつ人間が読める方法で分子情報を提供し、またウェブ上でのデータベースからの情報の検索機能を提供する。元々、2000年から2005年にIUPACとNISTによって開発され、フォーマットとアルゴリズムは非営利であり、開発の継続は、IUPACも参画する非営利団体のInChI Trustにより、2010年までサポートされていた。現在の1.04版は、2011年9月にリリースされた。

1.04版の前までは、ソフトウェアはオープンソースのGNU Lesser General Public Licenseで無償で入手できたが[3]、現在は、IUPAC-InChI Trust Licenseと呼ばれる固有のライセンスとなっている[4]。ウイキペディアより引用。

構造式を含む文献を電子化する場合に必要となる技術の1つかもしれないが、InChIでは3次元構造は原理的に表現しきれないようであり、InChI表記は無味乾燥であり、機械学習で推測したInChIに学術的価値がどれだけあるのかも理解できないので、やってみようという気にならない。構造式の画像から近似的に3次元分子構造モデルを再現するということであれば楽しく取り組めそうだが、・・・。

HuBMAP：1,155 teams, two months to go（データ修正のため順延中）

昨日の取り組み「activation functionを"sigmoid"にして、score > thresholdとして、thresholdの最適化をやってみる。」のつづき。

threshold=0.5で、BCELossとFocalLossで10エポックの場合について調べた。

B5-Unet, BCELoss, AdamW, 10 epochs：LB=0.822 (output_file_ size=5.1 MB)

B5-Unet, FocalLoss, AdamW, 10 epochs：LB=0.799 (output_file_ size=4.94 MB) 

いずれも、出力データのサイズは4.9-5.1 MBとなり、sigmoidを使う前よりも小さい。sigmoidを使わずにLB=0.836となったときの出力データのサイズは、5.5-5.7 MBであった。データサイズとLBスコアとの間には必ずしも比例関係は無いが、今回の場合は、thresholdを下げればLBスコアが上がる可能性がありそうである。

GPUの割当は使い果たしたので、この確認は土曜日以降になる。

activation functionとしては、 “sigmoid”の他に, “softmax”, “logsoftmax”, “tanh”,などが使える。"tanh"は -1 < tanh < 1で、中央値付近の微分係数がsigmoidの4倍になるため、sigmoidよりも収束が速くなりそうだし、感度も高くなるかもしれないので、試してみよう。

3月4日（木）

HuBMAP： 1,167 teams, two months to go（データ更新待ち）

GPUが使えないのでCPUで計算する。：B5はメモリーオーバーになるので、計算時間も考えて、B0を使うことにする。B0-UnetでのLBスコアは0.827前後である。

最初にtanhを試す。

B0-Unet(tanh: threshold=0.0)-E10-B16 : LB=0.827

tanhも使えることがわかった。出力データは5.64 MBで、sigmoidの場合よりも大きい。

LBスコアは、sigmoidを使った場合よりも高くなっている。

次に、sigmoidで、thresholdの効果を試す。1サイクルに6時間くらいかかる（GPUなら60分くらい）ので、以下の3つの計算の結果が出そろうのは明日になる。

B0-Unet(sigmoid: threshold=0.50)-E10-B16: LB=0.819（このスコアで閾値を調整しても、とは思うのだが、何事も経験しておくことは大切だ、ということで、・・・。）

B0-Unet(sigmoid: threshold=0.45)-E10-B16: LB=0.820

B0-Unet(sigmoid: threshold=0.40)-E10-B16: LB=0.821

threshold依存性はありそうだ。しかし、このスコアでは、使う気にならない。

semantic segmentationについてもっと勉強しよう。 

Deep Semantic Segmentation of Natural and Medical Images: A Review
Saeid Asgari Taghanaki, Kumar Abhishek, Joseph Paul Cohen, Julien Cohen-Adad and Ghassan Hamarneh, arXiv:1910.07655v3 [cs.CV] 3 Jun 2020, 

Cross Entropy -->  Weighted Cross Entropy --> Focal Loss (Lin et al. (2017b) added the term (1 − pˆ)γ to the cross entropy loss)

Overlap Measure based Loss Functions：Dice Loss / F1 Score -->  Tversky Loss(Tversky loss (TL) (Salehi et al., 2017) is a generalization of the DL(Dice Loss) --> Exponential Logarithmic Loss --> Lovasz-Softmax loss(a smooth extension of the discrete Jaccard loss(IoU loss))

上記のような種々の損失関数の解説の最後に次のように書かれている。

The loss functions which use cross-entropy as the base and the overlap measure functions as a weighted regularizer show more stability during training. 

cross-entropy系をベースに、overlap系を加えることが推奨されている。Fig.12左側のcross-entropyとfocalの曲線は、相補的な特性を示しているように見える。これも組み合わせると良い、ということになるのだろうか。

3月5日（金）

HuBMAP：1,176 teams, two months to go（データ更新待ち）

シングルモデルでLB=0.85+となることを目標に、DeepLabV3+に集中してみよう。

DeepLabV3+の性能を発揮させるためには、パラメータを適正に設定しなければならない筈なので、論文を丁寧に読んで、モデルの中身を理解しなければならない。

ここまで、Unet以外の8種類のモデルのどれもが、Unetのスコアを超えられないのは、各モデルのパラメータを適切に設定することができていないからなのだろうと思う。

Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation
Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, and Hartwig Adam
Google Inc. ECCV 2018

Abstract.

Spatial pyramid pooling module or encode-decoder structure are used in deep neural networks for semantic segmentation task. The former networks are able to encode multi-scale contextual information by probing the incoming features with filters or pooling operations at multiple rates and multiple effective fields-of-view, while the latter networks can capture sharper object boundaries by gradually recovering the spatial
information.

In this work, we propose to combine the advantages from both methods. Specifically, our proposed model, DeepLabv3+, extends DeepLabv3 by adding a simple yet effective decoder module to refine the segmentation results especially along object boundaries. We further explore the Xception model and apply the depthwise separable convolution
to both Atrous Spatial Pyramid Pooling and decoder modules, resulting in a faster and stronger encoder-decoder network.

空間ピラミッドプーリングモジュールまたはエンコードデコーダー構造は、セマンティックセグメンテーションタスクのディープニューラルネットワークで使用されます。 前者のネットワークは、フィルターまたは複数のレートと複数の有効視野でのプール操作を使用して着信機能をプローブすることにより、マルチスケールのコンテキスト情報をエンコードできます。後者のネットワークは、空間情報を徐々に回復することにより、より鋭いオブジェクト境界をキャプチャできます。

この作業では、両方の方法の利点を組み合わせることを提案します。 具体的には、提案されたモデルであるDeepLabv3 +は、シンプルでありながら効果的なデコーダーモジュールを追加することで、DeepLabv3を拡張し、特にオブジェクトの境界に沿ってセグメンテーション結果を改善します。 Xceptionモデルをさらに調査し、深さ方向に分離可能な畳み込みをAtrous Spatial Pyramid Poolingとデコーダーモジュールの両方に適用して、より高速で強力なエンコーダー-デコーダーネットワークを実現します。

以上、google翻訳

3月6日（土）

GPU: 43h

HuBMAP：1,182 teams, two months to go（データ更新待ち）

HuBMAPコンペは、糸球体を細胞群から抽出するという単純な作業なんだが、糸球体の周辺/背景は、似たような細胞で満たされている。内部と外部は類似しているので、境界層の識別能力を高めることが重要なのだろうと思うのだが、どうやったら実現できるのか。上記のabstractに、DeepLabV3+は境界層の識別能力を改善したと書かれているので期待して使ってみよう。

問題は、計算時間で、EncoderにEfficientNetB3を使っても、1エポックに8分以上かかる。他のDecoderでは2分以内である。CPUでの計算時間は1エポックが20分くらいで、他のモデルと変わらないので、他のモデルよりもCPUへの負荷が大きいということのようだが、よくわからない。

DeepLabV3+の論文では、EncoderにXceptionが使われているので、EfficientNetからXceptionに変えてみた。しかし、意外なことに、Xceptionに対応していないというメッセージが現れ、停止した。あらためて論文を見ると、Xceptionはモディファイして用いていると書いてある。

論文には、Xceptionよりスコアは低いが、ResNet-101を用いて計算した例も示されているので、EncoderをResNet-101に変更して計算してみた。CPUでは1エポックに30分くらいかかり、さすがにこれでは使えないのでGPUに切り替えてみた。そうすると、これも意外なことに、1エポックあたりの計算時間が、約60秒であった。これなら問題なく条件検討ができる。

計算結果：LB=0.811：BCE+0.5*Focal

256x256を同じ視野で解像度を384x384にすると、LB=0.816になった。

Atrous convolution：設定パラメータは"decoder_atrous_rates"となっていて、デフォルトは (12, 24, 36)である。開発者の論文では (6, 12, 18) となっている。

encoder_output_stride：デフォルトの16以外の設定32や8を試しているが、詳細不明

decoder_channels：256をデフォルトにして、128ではスコアが下がるという記述はあるが、系統的に調べたというふうでもない。

計算の合間に論文を見ていたのだが、納得できる説明が見当たらない。上記のReviewで目立っていたので、このモデルを中心に据えて、じっくりと、取り組もうと思って始めてみたが、原著者らによるモデルの説明があいまいで、あまり可能性を感じないし、デフォルトで計算したLBスコアは良くないし、何よりも、DecoderにEfficientNetが使えない（GPUを使ったときの計算時間が長すぎる）など、メリットが感じられないので、DeepLabV3+は、このへんでやめておこうかと思う。

"COCO"が気になって調べてみた。

Microsoft COCO: Common Objects in Context
Tsung-Yi Lin Michael Maire Serge Belongie Lubomir Bourdev Ross Girshick
James Hays Pietro Perona Deva Ramanan C. Lawrence Zitnick Piotr Dollar´

arXiv:1405.0312v3 [cs.CV] 21 Feb 2015
Abstract—We present a new dataset with the goal of advancing the state-of-the-art in object recognition by placing the question of object recognition in the context of the broader question of scene understanding. This is achieved by gathering images of complexeveryday scenes containing common objects in their natural context. Objects are labeled using per-instance segmentations to aid in precise object localization. Our dataset contains photos of 91 objects types that would be easily recognizable by a 4 year old. With a total of 2.5 million labeled instances in 328k images, the creation of our dataset drew upon extensive crowd worker involvement via novel user interfaces for category detection, instance spotting and instance segmentation. We present a detailed statistical analysis of the dataset in comparison to PASCAL, ImageNet, and SUN. Finally, we provide baseline performance analysis for bounding box and segmentation detection results using a Deformable Parts Model. 

COCOデータセットを使ったコンペが継続的に開催されている。

Tasks: Detection | DensePose | Keypoints | Stuff | Panoptic | Captions

Leaderboard: Detection | Keypoints | Stuff | Panoptic | Captions

Panoptic segmentation aims to unify the typically distinct tasks of semantic segmentation (assign a class label to each pixel) and instance segmentation (detect and segment each object instance). Existing metrics are specialized for either semantic or instance segmentation and cannot be used to evaluate the joint task involving both stuff and thing classes. Rather than using a heuristic combination of disjoint metrics for the two tasks, the panoptic task introduces a new Panoptic Quality (PQ) metric. PQ evaluates performance for all categories, including both stuff and thing categories, in a unified manner.

Panoptic Leaderboardのトップのチームのpaper

Joint COCO and Mapillary Workshop at ICCV 2019: Panoptic Segmentation Challenge Track Technical Report: Explore Context Relation for Panoptic Segmentation
Shen Wang1,2∗ Tao Liu1,3∗ Huanyu Liu1∗ Yuchen Ma1 Zeming Li1 Zhicheng Wang1
Xinyu Zhou1 Gang Yu1 Erjin Zhou1 Xiangyu Zhang1 Jian Sun

これくらいの論文を書いてみたいものだ。

さて、LB=0.836のモデル、EfficientNetB5-Unet、に戻って、シングルモデルのチューニングしてみよう。損失関数と画像分解能などで、LB=84+を目指そう。

3月7日（日）

HuBMAP：1,189 teams, two months to go（データ更新待ち）

LB=0.836を超えるために：

モデル：Unetは、"decoder_attention_type"に"scse"を設定することによって、Attention moduleを組み込んだUnetになる。scseの効果を系統的に比較できていないので、scseの効果を見極めたい。

損失関数：Diceをベースに、BCEやJaccardとの組み合わの効果を調べる。

スライス（1024x1024）とダウンサイズ（256x256）：ダウンサイズの際の解像度を最大で512x512まで上げることを検討する。モデルサイズやバッチサイズの変更の効果と相殺されるので、可能な範囲で調べる。

モデル：種類もサイズも、まったく、最適化できていない。いろいろ調べたつもりだが、encode-decoderの組み合わせごとにある程度パラメータフィッティングしないと、判断を誤る可能性が高い。

バッチサイズ：モデルサイズと相反するので選択範囲は狭くなる。

Run1：scseの効果：LB=0.832：0.004下がった。：train中のloss（train_loss及びval_loss）は、scseを使う前よりも下がっているのでスコアは上がると期待していたのだが、どういうことだろうか。

Run2：scseは使わないで、解像度を256x256から320x320に変更：LB=0.834：0.002下がった。こちらも、train中のloss（train_loss及びval_loss）は、解像度を上げる前よりも下がっているのだが、どうなっているのだろうか。

Run1もRun2もoverfittingしている可能性が高い。Encoderを小さくするか、エポック数を少なくする必要があると思う。

次は、損失関数だが、上記のReviewには、「The loss functions which use cross-entropy as the base and the overlap measure functions as a weighted regularizer show more stability during training.」と書かれていた。今使っているものでいえば、overlap系はDice, Jaccard, Lovaszとなる。試してみるしかないのだろう。MAnetの論文では、BCEとDiceの比率は1対4であったように思う。Diceをベースに、BCEを加えている。LB=0.836を得ているのは全て、DiceLossのみなので、手始めに、MAnetの論文をまねてみるのもよいかもしれない。

と言いつつ、さきほど、Run2のDiceLossを、5つの損失関数を全て足したものに置き換えて、trainingした。その結果、val_lossがtrain_lossの1.75倍にもなってしまった。overfitting間違いなしだ。Diceが最も収束が遅いことはわかっていたのだから、エポック数は、少なくとも、30から20くらいまでは下げておくべきだったかもしれない。train_lossは、個々の損失関数のtrain_lossの和に近い値となっているので、正しく動作していることは確認できた。

Run3：Run2のDiceを、Dice + BCE + Lovasz + Jaccard + Focalとした：LB=0.828：train_lossとval_lossとの乖離が大きかった（1対1.75）ので、overfittingになり、もっと低いスコアになると予想していたので、このスコアには多少驚いた。

明日は、Run1, Run2, Run3のエポック数をいずれも30から25に減らしてみよう。さらに、20に減らしてみよう。Run1もRun2もスコアは上がるはずだと思っている。Run3は、エポック数を減らすとともに、学習速度が他よりも速いBCEとFocalの割合（寄与率）を下げてみよう（たとえば：Dice  + Lovasz + Jaccard + BCE/2 + Focal/2）。

3月8日（月）

HuBMAP：1,200 teams, 18 days to go (two months to go)

Run4：Unet ---> Unet_scseの効果を調べる：エポック数を30から25に減らしてみる。：LB=0.828：さらに0.004下がった。（0.836 -> 0.832 -> 0.828）

25エポックでの最終エポックのlossは、30エポックでの最終エポックのlossよりも大きいだけでなく、scseを使う前よりも大きな値になった。30エポックで、scseを使った場合、lossが下がったので、LBスコアは上がると予測したが、スコアは下がった。30エポックでは、overfittingになったと思ったのだが、そうではなかったのか。

振り返ると、モデルだけ変更した場合（例えばB5からB6に変更）、train_lossもval_lossも下がって、LBスコアが上がると期待するのだが、スコアが下がることもときどきあった。そういうときは、この課題にはB5が適切なのだろうと判断して先に進んできた。ここに問題/課題がありそうだが、・・・。

Run5：25エポックに下げてだめだったのだから、35エポックについても調べる必要がある。増やすという選択肢の他に、30エポックに戻して、収束の速いBCEやFocalと組み合わせる、という方法も考えられる。配合比をどうするか。まずは、30エポックに戻して、（Dice + BCE）を試してみよう。：LB=0.822：また下がった。

Run6：すなおにDiceのみ, 35エポックを試す。：LB=0.836：scse無しのスコアと同じだが、ほんの少し、前進できたような気がする。

Run7：では、40エポックにしてみよう。：LB=0.833：だめか。scseのメリットを見出せず。

次は、画像解像度の効果について調べる。320x320で検討するつもりだったが、現状のモデルとバッチ数ではこれ以上解像度を上げることができないので、512x512まで使える条件（モデルを小さく、バッチ数を少なく）で検討してみようと思う。

Bristol-Myers Squibb – Molecular Translation：138 teams, 3 months to go
Can you translate chemical images to text?

方針転換：参加しないと何も学べない --> 参加すれば、新たなデータと課題に触れる機会が得られ、新たな前処理手法、予測手法を学ぶことができる可能性がある。 --> 参加させていただくことにしよう。

以下、ウイキペディアより、

エタノール：CH3CH2OH：InChI=1S/C2H6O/c1-2-3/h3H,2H2,1H3 (standard InChI)

 全てのInChIは、”InChI=”という文字列から始まり、現在は1であるバージョンの数が続く。standard InChIでは、これにSの文字が続く。残りの情報は、レイヤーとサブレイヤーの配列として構造化され、各々のレイヤーは、1つの種類の情報を収める。レイヤーとサブレイヤーは、区切り文字 ”/” で隔てられ、（メインレイヤーの化学式サブレイヤーを除き）固有の接頭文字で始まる。6つのレイヤーと各々の重要なサブレイヤーは、以下の通りである。

1. メインレイヤー

化学式（接頭文字なし） - 全てのInChIに現れる唯一のサブレイヤー
原子の繋がり（接頭文字:”c”） - 化学式中の水素原子以外の原子には番号が付与される。このサブレイヤーでは、原子が他のどの原子と結合されているかを記述する。
水素原子（接頭文字:”h”） - 各々の原子にいくつの水素原子が結合しているかを記述する。

L-アスコルビン酸

InChI=1S/C6H8O6/c7-1-2(8)5-3(9)4(10)6(11)12-5/h2,5,7-8,10-11H,1H2/t2-,5+/m0/s1 (standard InChI)

3. 立体化学レイヤー

二重結合とクムレン（接頭文字:”b”）
原子の四面体配置とアレーン（接頭文字:”t”, ”m”）
立体化学の種類の情報（接頭文字:”s”）

構造式からInChI式を推測させようとするこの課題は、非常にレベルが高いと感じる。

さらに、コンペで提供される構造式の画像は、上記アスコルビン酸の構造式のように明瞭なものではない。

課題は、構造式の画像とInChI式（ラベル）を用いてモデルを訓練することにより、構造式からInChI式を予測すること。

数字の並びは、IUPACの規則に従う。 

3月9日（火）

HuBMAP：1,205 teams, two months to go（データ更新作業開始）

Run8：EfficientNetB5-Unet, batch=8, 512x512

現在午前11時4分、submitできない。Discussionをみると、新しいデータが届き、更新作業に入ったとのこと。

We've got a new private test set incoming. Some of the old test samples will be moved to train. The process is currently underway and may take some time. Submissions are disabled while this is taking place. We will notify you when the update is complete. Thank you for your patience!

BMS：149 teams, 3 months to go

画像からテキストへの変換だから、image-captioningのモデルを使うことができるようである。イメージを文字で表現する。分子構造式から、元素の種類と、数と、分子の形状と、官能基の結合位置と水素の結合位置を、InChIの表現形式に則って配置する。

captioningといっても、言葉ではなく、元素記号、結合位置を表す数字やハイフン、丸カッコ、意味内容の区切るスラッシュ、などが1列に並んだものである。アスコルビン酸だと、C, O, Hの3種類だが、N, P, S, Cl, F, Brなどの元素もあり、結合も1重、2重、3重があり、4員環、5員環、6員環、7員環、鎖状、なども区別して表示される。

3月10日（水）

HuBMAP：1,205 teams, 2 months to go（データのアップデート完了）

さて、再始動だ！と思ってプログラムを動かしたら、早速、エラーが発生した。そう、train/に、マスク無しのデータが存在する（旧test data）ために生じたエラーだ。

借り物のコードを、部分的にしか理解できていない状態で使っているので、エラー解消は容易ではないが、コードを理解する良い機会だ。

＊＊＊別件作業中＊＊＊

3月11日（木）

＊＊＊別件作業中＊＊＊

HuBMAP：1,210 teams, 2 months to go : May 10, 2021 - Final submission deadline.

データセットが更新されることによって、マスクの不具合が修正され、train_dataが増えたことから、LBスコアが跳ね上がったようだ。今の1位はLB=0.921。休眠状態だったつわものたちが本格的に動き始めるとさらに上がっていくのだろう。

さて、データ修正前の値だが、自分の0.836では勝負にならない。望みがあるとすれば、現在LB=0.90+の方が使用しているモデルがEfficientNetB4-Unetで解像度が512x512だということで、特殊なモデルを使っているわけではなく、自分も同様の条件で試したことがあるというところだ。しかし、それは、参加者みんながわかっていることなので、そこまでは到達して当たり前みたいな感じだとすると、やはり、現状では勝ち目はない。

別件を済ませて、これに集中したいのだが、・・・。

3月12日（金）

HuBMAP：1,211 teams, 2 months to go (gold: 0.916+)

train_dataに更新前のtest_dataが追加されたという情報から、勝手に、マスク無しのtrain_dataとして追加されたと思い込んでいたが、マスクデータは全てのtrain_dataにセットされている。したがって、エラーの原因はマスクではない。

image = dataset.read([1,2,3], <---ここでエラーが生じているようだが、・・・。

IndexError: band index 2 out of range (not in (1,))

よくわからんが、次の3種類のフォーマットが混在しているために、エラーになっているのだろうと思う。

[height, width, channel]

[channel, height, width]

[1, 1, channel, height, width]

ここからは、さらに踏み込んで、コードを、書き換えなければだめだろう。

とりあえず、エラーが生じる直前までの8個のtrain_dataだけを用いることができるようにして、計算させてみた。

プログラムが最後まで走るのか、さらに、commit, submitを経て、LBスコアが得られるのかは全く分からないが、train_lossは、データ更新前には見られなかったくらい小さくなっている。そのぶん、極端なoverfittingになっているようにみえる。

trainからinferenceに移ったら、trainのときと同様のエラーが発生した。データの読み込みを、データフォーマットに合わせるように、プログラムしなおす必要がありそうだ。

trainの場合は、フォーマットの違うtrain_dataを読み込まないようにしたのだが、inferenceの場合は、フォーマットの違うtest_dataを避けたらスコアが正しく計算されなくなってしまう。

データ更新前に投稿したものは、更新されたデータを使って再計算されることになっているようだが、自分のプログラムは、更新されたデータには対応していないので、再計算されないように思う。

train_modelを読み込んで、inferenceだけKaggle kernelを使っているチームの場合、Kaggleスタッフでは、trainのやりなおしができないので、あまり、意味がないような気がする。

更新前のデータに対して動いていたのだから、更新されたデータに対しても動いてくれなければ困る、と言いたいところだが、だれも言わないだろうな。それくらいはできないとだめですよ、と言われそうだ。優しいスタッフが、更新されたデータに対応できないチームのために、変換コードを用意してくれるかもしれない。

いやいや、スタッフが乗り出す前に、Kaggler仲間が、解決策を提案してくれている。

参加者どうしで助けあっている！

これが、Kaggleだ！

3月13日（土）

HuBMAP：1,213 teams, 2 months to go（現在のLBスコア1位：0.926）

train_dataとしては、15個のうちの8個を使っているだけだが、データ更新前と比べて、train_lossが70%くらいになっているようである。val_lossも相応に下がればうれしいのだが、逆に大きくなっているので、明らかに、overfittingの状態になっている。

マスクの精度が向上していると思うので、train_lossが下がるのは想定どおりであるが、教師データに学んだ結果が、validation_dataに正しく反映されないというのはどういうことなのか。ふつうに、overfittingということで片付けておく。

transformの程度を強くしてみたら、val_lossが明らかに小さくなった。これは良い兆候である。

前処理で、データの切り出しで、MIN_OVERLAPという値があり、これによってスコアが大きく変わったというコメントがあったので、試してみることにする。

切り出しの際の重なりを大きくするということは、データ数を増やしていることになるのだろうと思う。

初期値の32から、64, 128, 192と変えてみた。MIN_OVERLAP=192では、RAMの使用量が約2.5GB増えた。

結果は、若干、overfitting側に変化しているようにみえる。

いずれにしても、現状では、train_dataの全体を読み込むことができず、さらに、もっと困ったことには、肝心のtest_dataが読み込めない。これでは、先に進めない。

明日は、Discussionと公開コードを参考にして、フォーマットが変わってしまったtrain_dataとtest_dataの読み込みができるようにする予定。

overfitting、underfitting、スコアアップ: A. Geron氏のテキスト参照（chapter 7: Ensemble Learning and Random Forests）：実験第一！

・エポック数（early stopping, OneCycleLRのエポック数）

・モデルの大きさ：B0, B1, B2, B3, B4, B5, B6, B7, B8, 18, 34, 50, 101, 152, 121, 169, 201：パラメータの数を増やせば、より詳細なところまで見えるが、overfittingしやすくなり、汎用性は低下することがある。

・データ量（augmentationによる増量）

・augmentationの種類、変形強度（ElasticTransform, GlidDistortion, OpticalDistortion）

・dropout（ユニット、層、画像内部）

・ensemble（K-fold、stacking, voting, randomsampling, 

・ モデルの初期値（random, Glorot and He, LeCun, Xavier）

・pretrained_model（データの種類、量、質）

・out of bag evaluation

・random patches, random subspaces

from today's Twitter:

Deep Learning Weekly@dl_weekly
From this week's issue: Algorithms are meaningless without good data. The public can exploit that to demand change.

3月14日（日）

HuBMAP：1,219 teams, 2 months to go（Goldは0.92+）

今日は、Discussionと公開コードを参考にして、フォーマットの違うものが含まれているtrain_dataとtest_dataを読み込むことができるようにする。それができれば、データ更新後の初LBスコアを取得する。

公開コードを参考にして、作業を始めた。自分がベースにしているコードの作者をフォローしようと思って、そのコードを見に行ったら、2日前に更新されており、新たに加わったフォーマットに対応できるように変更されていた。有難い。しかも、そのコードは非常にスマートで、たった1行追加されているだけである。

ということで、更新データに、対応できるようになった。ただし、新たな課題が生じた。train_dataが増えたのはありがたいが、RAMに読み込んで動かしているため、13GBの制限に引っかかって、半分強くらいしか使えない。

さらに、train_lossとval_lossの差が大きい。更新データに対応したコードの製作者も、同様な結果になっていて、更新前のデータに対して使っていたパラメータのままでは、LBスコアは、かえって、悪くなる。

EfficientNetB5-Unetを試してみたが、今日は、LB=0.512が最大であった。いくらなんでもこれは無いだろう、と思った。リーダーボードのスコアがどんどん上がっているので、更新前のデータに対して用いていたのと同じ条件で計算しても、自分のスコアも、当然、上がるものだと思い込んでいた。

今日は、submitできるようになって、良かった。

しかし、明日から、overfittingとの戦いだ！

3月15日（月）

HuBMAP：1,223 teams

今頃は、LB=0.85+だと思ったのだが、更新データでの最良値は、なんと、LB=0.531である。原因は、train_dataの半分弱のデータを使っていないことにあるのかもしれない。

更新前と同じ8件のtrain_dataを使っているのだが、更新前と同じデータは5件あるが、3件は異なっている。

15件全部のtrain_dataを使いたいところだが、今の使い方ではメモリーオーバーになるので、まずは、更新前と同じデータ名のtrain_data：8件を使ってみよう。

更新前のrain_dataのみを読み込むようにコードを書き替えた。次のようなコードを追加して、新しいtrain_dataのファイルを読み飛ばすようにした。

if filename == '26dc41664':
    continue

その結果、データ更新前のモデルをそのまま使っても、train中の極端なoverfittingの傾向はなくなった。こんなにも違う結果になるとは、思わなかった。

さらに、train_lossもval_lossもデータ更新前よりも、かなり小さくなったので、データ更新前よりも、良いスコアが得られるのではないかと期待したが、LB=0.831となり、残念ながら、データ更新前のLB=0.836には届かなかった。

これで、ようやく、スタートラインに立てたように思う。

test_dataに類似したtrain_dataを使えば、スコアが良くなるのと同様に、test_dataと似ていないtrain_dataを使った場合にはスコアは上がらない、ということがおきていたということだろうと思う。試験範囲と外れたところを勉強しても良い点は取れない。

こういうことを経験すると、漫然と訓練していても良いモデルは作れない、という気がしてきた。test_dataを適切に処理できるためにどのように訓練しておけば良いのか。テストデータがわかっていれば、訓練データとの類似性や特徴などを調べておくことが重要になりそうだ。Kaggleのコンペがスタートすると、データ解析をしてみせて、訓練データとテストデータの特徴に違いがある場合には、Discussionで注意喚起し、その理由や対処方法まで丁寧に説明してくださるKagglerもおられる。

多値分類だと、分類するクラス毎の訓練データ数を同じになるようにするのだが、バックグラウンドとの識別の場合には、バックグラウンドの面積が何倍にもなる場合がある。そういうとき、segmentationの精度にはどんな影響があるのだろうか。精度に影響する因子にどのようなものがあって、どのように対処すればよい結果が得られるのだろうか。

明日は、

１．コードの学習：画像の前処理

２．LB=0.831を超えよう！ 

3月16日（火）

HuBMAP：1,232 teams (May 10, 2021 - Final submission deadline.)

１．コードの学習：3時間程度の予定：Resnet-Unetのようなモデルだが、DecoderにはFPNが使われているようだった。FPNのチャンネル数やUnetのチャンネル数の設定値を見ていて、自分もUnetとFPNを使っているが、デフォルトのままで、自分で設定したことがない。Unetのデフォルトはdecoder_channels=(256, 128, 64, 32, 16)となっているが、公開コードでは、もっと多くのチャンネル数が用いられているように見える。FPNにしても、デフォルトは、decoder_pyramid_channels=256, decoder_segmentation_channels=128となっているが、公開コードでは512チャンネルも使われているように見える。このあたりのパラメータを変えてみて、性能がどう変化するかを調べてみようと思う。

２．更新前のtrain_dataの8件に、新たに追加されたtrain_dataの7件から、メモリー一杯まで読み込んでtrainingすることによって、LBスコアが上がるかどうか調べる。

2件までしか追加できなかったが、とりあえず、train and inferenceを試してみることにする。

train_data=10件：LB=0.839になった。(EfficientNetB4-Unet-DiceLoss)

15件のtrain_dataを全て使うにはどうすれば良いのだろうか。

今使っているプログラムの良いところは、パラメータを変えてタイルを自由に作り変えることができるところだ。全てのtrain_dataを使えるようにすることを最優先に、タイルサイズを小さくし、オーバーラップをゼロにすることによって、15件のtrain_dataの全てを使うことができるようになった。

タイルサイズを小さくすると、1枚のタイルに含まれる糸球体が少なくなり、糸球体の多くが分割されてしまうのではないかと思う。このことが、糸球体のセグメンテーションにおいてどう作用するのだろう。

タイルサイズを小さくして計算した結果、出力ファイルのサイズが標準の５MBを大きく超えて、7.5MBとか21MBになってしまい、前者はエラー、後者はLB=0.675となった。commit中にもタイルサイズに関する警告が出ていたので、これは1024に戻すことを優先しようと思う。 

画像の分割は、非常に重要な作業のように思う。全ての糸球体の外周を分断することなく、完全な形のままで、画像を切り出す方法を調べてみよう。

明日は、これ（train_data=10件：LB=0.839になった。(EfficientNetB4-Unet-DiceLoss)）を超える方法を検討しよう。その１つの手段として、Unetのdecoder_channelsの変更を行ってみる。

（それにしても、上位との差は歴然！：最終日、トップは0.95+になっていて、自分は0.85+に到達して喜んでいるかもしれない！：あと50日間でこの差を埋めて逆転するためにはどうすればよいのかを考えよう）

3月17日（水）

HuBMAP： 1,236 teams (May 10 final submission deadline)

１．コードの学習

@iafoss氏の公開コード：class UneXt50(nn.Module)というものを構築している。パーツとしてFPN, UnetBlock, ASPPが使われている。encoderはResNet50で、decoderはUnetだが、ASPPとFPNが仕込まれている。

高度な機能を組み合わせることで、高度なモデルができるということを示している。

２．Unetのdecoder_channelsの効果

デフォルトのdecoder_channels=(256, 128, 64, 32, 16)を、2倍、decoder_channels=(512, 256, 128, 64, 32)にしてみた。出力データサイズは4.9 MBから5.34 MBに増えた。ノイズが増えたように見える。結果はLB=0.815であった。チャンネル数を増やせば保持できる情報量が増えてデメリットは無いように思うが、overfittingという落とし穴がある。

次は、チャンネル数を半分、decoder_channels=(128, 64, 32, 16, 8)にしてみた。出力データサイズは10.66 MBに増えた。ノイズはさらに増えているように見える。結果は、LB=0.231であった。チャンネル数は各深さにおける特徴量を保持するためのメモリーのようなものだと思うので、メモリーが少なくて情報を保持できないということだろうと思う。train_lossとval_lossの値からは、ここまでスコアが悪くなるとは思わなかった。非常に驚いている。

もう少し遊んでみよう。チャンネル数を減少ではなく増大させるとどうなるのだろう。decoder_channels=(16, 32, 64, 128, 256)としてみると、出力データサイズは6 MBで、ノイズが多そうなデータにみえたが、LB=0.798と、思ったほどはひどくはなかった。

ならば、平均値あたりに揃えたらどうなるのか。decoder_channels=(128, 128, 128, 128, 128)としてみた。LB=0.821

オリジナルの論文を見ると、チャンネル数はこんなもんじゃない。最低が64だから、５段であれば、decoder_channels=(1024, 512, 256, 128, 64)となる。

バカなことして遊んでいる場合じゃなかった。

このセットdecoder_channels=(1024, 512, 256, 128, 64)で計算してみたら、悪くはなかった。明日、submitしてみよう。：LB=0.813：

実は、このセット(512, 256, 128, 64, 32)の次に1024のセットを準備していたが、512のセットのスコアが期待外れだったので、遊びに転じてしまった。

以下に結果をまとめて示す： 

decoder_channels=(128, 64, 32, 16, 8)：LB=0.231

decoder_channels=(256, 128, 64, 32, 16)：LB=0.831

decoder_channels=(512, 256, 128, 64, 32)：LB=0.815

decoder_channels=(1024, 512, 256, 128, 64)：LB=0.813

decoder_channels=(16, 32, 64, 128, 256)：LB=0.798

decoder_channels=(128, 128, 128, 128, 128)：LB=0.821

decoder_channels=(256, 256, 256, 256, 256)：LB=0.790

この結果から何か言うとすれば、「いろいろ試してみれば、良い組み合わせが見つかるかもしれない」。

U-Net: Convolutional Networks for Biomedical Image Segmentation
Olaf Ronneberger, Philipp Fischer, and Thomas Brox

このUnetのオリジナル論文を検索しているときに、Unetの新しいバージョンに出くわした。

UNET 3+: A FULL-SCALE CONNECTED UNET FOR MEDICAL IMAGE SEGMENTATION
Huimin Huang 1, *Lanfen Lin1, Ruofeng Tong1, *Hongjie Hu2, Qiaowei Zhang2, Yutaro Iwamoto3, Xianhua Han3, *Yen-Wei Chen3,4,1, Jian Wu1

このUnet 3+のコードは、GitHubにある：https://github.com/ZJUGiveLab/UNet-Version

新たにコードを開発した研究者や技術者は、開発したコードをGitHubで公開することが多く、論文のabstractの下端に公開サイトのURLを示すことが多い。

3月18日（木）

HuBMAT：1,245 teams

今日は、Unet 3+を使ってみよう。https://github.com/ZJUGiveLab/UNet-Versionの、UNet-Version/models/には、次のコードが入っている。

UNet.py
UNet_2Plus.py
UNet_3Plus.py
init_weights.py
layers.py

さらに、UNet-Version/loss/には、次のコードが入っている。

bceLoss.py
iouLoss.py
msssimLoss.py

論文では、hybrid segmentation lossとして、focal lossとMS-SSIM lossとIOU lossを組み合わせたhybrid segmentation lossが提案されている。

UNet_3Plus.pyには、UNet_3Plusの他に、Unet_3Plus_DeepSupとUnet_3Plus_DeepSup_CGMが含まれている。それぞれ、ベースコード、with deep supervision、with deep supervision and class-guided moduleであり、論文中で追加機能として説明されているものである。

道具は揃った。

さて、このUnet_3Plus_DeepSup_CGMを使うにはどうすればよいのか。

まず、簡単なところから始めよう。

１．ライセンスの確認：

https://github.com/ZJUGiveLab/UNet-Versionのreadmeには、次の記述があるだけなので、このURLと論文を引用すれば十分ではないかと思う。

README.md
UNet 3+
Code for ICASSP 2020 paper ‘UNet 3+: A full-scale connected unet for medical image segmentation’

Requirements
python 3.6.2
pytorch 1.3.1

２．UNet.pyを使うための準備（最終的にはUnet_3Plus_DeepSup_CGMを使ってみたいが、使用方法を検討しやすい小さいプログラムを使う）

Unet.pyの最初に、次のコードが書かれている。

import torch
import torch.nn as nn
import torch.nn.functional as F
from layers import unetConv2, unetUp, unetUp_origin
from init_weights import init_weights
from torchvision import models
import numpy as np

UNet.pyをnotebookにコピペして走らせてみると、次のメッセージが出て停止した。

ModuleNotFoundError: No module named 'layers'

from layers import unetConv2, unetUp, unetUp_origin：ここでひっかかっている。

'layers.py'と'init_weight.py'の2つのモジュールを、カレントディレクトリに置かなければならないようだ。

Pythonのドキュメントの、 6. モジュール 、に次の説明がある。

モジュールは Python の定義や文が入ったファイルです。ファイル名はモジュール名に接尾語 .py がついたものになります。モジュールの中では、(文字列の) モジュール名をグローバル変数 __name__ で取得できます。例えば、お気に入りのテキストエディタを使って、現在のディレクトリに以下の内容のファイル fibo.py を作成してみましょう:

次に Python インタプリタに入り、モジュールを以下のコマンドで import しましょう:

つまり、UNet.pyが参照している関数が含まれている"layers.py"と"init_weights.py"をKaggle kernelのカレントディレクトリ―"/kaggle/working/"に入れておけば、importによって呼び出すことができるということのようだ。

そのためには、"layers.py"と"init_weights.py"をKaggleのデータセットに入れて、コードのinput_dataにアップロードすればよい。そうして、次のコードでカレントディレクトリ―にコピーする。

!cp ../input/unet-3plus-pytorch/models/init_weights.py /kaggle/working/
!cp ../input/unet-3plus-pytorch/models/layers.py /kaggle/working/

形式的には、こんな感じだが、これで、

from layers import unetConv2, unetUp, unetUp_origin
from init_weights import init_weights

この2つはエラーなく実行されたようである。

３．UNetを使う

これで、https://github.com/ZJUGiveLab/UNet-Versionの中のUNetを使う準備は整ったと思う。

model = UNet( )

model.to(DEVICE)

loss_fnには、 nn.BCEWithLogitsLoss( )を使ったのだが、どうも、うまく動作していないようである。lossが下がらない、すなわち学習が進まない。

とりあえず、先に進もう。

UNet_3Plus.pyは、ベースとなるUNet_3Plusの他に、オプションを付加した、Unet_3Plus_DeepSupとUnet_3Plus_DeepSup_CGMがある。

UNet_3Plusを動かしてみた。batch_size=16ではメモリーオーバーになった、batch_size=8ではGPUのRAMは14.7 GBで動いた。1エポックに7分以上かかっており、lossがわずかづつしか下がらず。

Unet_3Plus_DeepSupとUnet_3Plus_DeepSup_CGMは、GPUのRAMはそれぞれ11.4 GBと12.5 GBでUNet_3Plusより少ないが、いずれも次のようなエラーメッセージが現れて停止した。

AttributeError: 'tuple' object has no attribute 'size'

loss = loss_fn(output, target)：この計算の過程でエラーが生じているようである。

とりあえず、オプションなしのUNet_3Plusは動くようになったので、引き続き検討していこう。lossの変化が小さいのは、出口の活性化関数'sigmoid'によるものだろうと思う。他のモデルでも’sigmoid'を使うとlossが減少しにくくなり、LBスコアも0.01くらい下がるので、ここに何か問題がありそうだと思っている。

明日は、LB=0.916の公開コードに学ぼう。

何か本質的なところで、自分のtraining方法（もしくはtrainingコード）に本質的な間違いがあるような気がしている。

3月19日（金）

HuBMAP：1,251 teams, to May 10

LB=0.916の公開コードに学ぶ：

EfficientNetB2-Unet or FPN：パラメータは activation=sigmoid 以外デフォルト

optimizer=Adam,

loss=bce_dice or bce_jaccard, 

以上の条件は、自分が調べた範囲に、ほぼ、含まれている。これらの条件では、自分は、LB=0.83+止まりであった。

ReduceLROnPlateau, EarlyStopping, 

これらを適切に使えば、自分が使っているOneCycleLRよりも0.01~0.02くらいは高くなる可能性はあるかもしれない。（3月25日修正：OneCycleLRはすぐれもので、適切に使えば上回る可能性もある）

KFold, GroupKFold

これも適切に使えば、0.01~0.02くらい上がるかもしれない。

TTA

これも、0.01~0.02くらい高くなる可能性があるだろうか。TTAを+4でやってみたときには、+0.005程度、上がったことがある。

augmentation(albumentations)

メジャーなものは同じなので、差がつくとしても0.01以下であろうと思うが（3月25日追記/修正：HuBMAPコンペでは強すぎる幾何学的変形は性能を下げる。カラー調整やボケ具合やコントラストは適切に用いると0.02+の向上は可能である）、あまり使われていないものの中には、よいものがあるかもしれない。複数のブロックで画像を隠す方法（3月25日追記：aibumentationに"cutout"というのがある）を使ってみたいと思っているのだがまだ手が出せないでいる。

以上の４つの効果を足すと、0.04~0.07ほど高くなる可能性があり、0.83を足すと、0.87~0.90くらいになる可能性があるということになるが・・・。

もっと、具体的なコードの中身まで検討するつもりだったが、明日以降の宿題とする。

明日からの1週間は、EfficientNetB2-Unetから離れないで、チューニングしてみようと思う。

3月20日（土）～3月26日（金）：GPU 41ｈ

HuBMAP：EfficientNetB2-Unetに固定してチューニングを行ってみよう。

Unetは、activation="sigmoid"にして、他はデフォルトを用いる。

上記のLB=0.916の公開コードでは、loss=bce_dice or bce_jaccard, となっているが、コードをよく見ると、bce_weight=1となっているので、BCE一択のようである。これは、自分の最近の経験と一致する。すなわち、DiceLossとJaccardLossは、activationを"sigmoid"にすると、自分が使っているコードでは、全く機能しない。

BCEと組み合わせるなら、FocalLossやLovaszLossであろう。まずは、BCE単独で進めてみよう。SoftBCEWithLogitsLoss( )

optimizerは、AdamWをOneCycleLRとの組み合わせで使っていて、上記LB=0.916のコードで使われているAdamとは、weight_decayがデフォルトかどうかの違いだけで、大差ないように思う。

OneCycleLRは、比較のために、他のlr_schedulerも使ってみようかと思う。PyTorchは、種類が豊富で迷ってしまう。

簡単に使えて、有用だと思うもの。

torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma=0.1, last_epoch=-1, verbose=False)

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05 if epoch < 30
>>> # lr = 0.005 if 30 <= epoch < 60
>>> # lr = 0.0005 if 60 <= epoch < 90
>>> # ...
>>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
>>> for epoch in range(100):
>>> train(...)
>>> validate(...)
>>> scheduler.step()

これは、step_size 毎に、lrが、lr x gammaになる。

ReduceLROnPlateau

val_lossをモニターして、変動幅が設定値より小さくなると、lr x gammaを行う方法で、StepLRを自動化したようなもの。

val_acc、val_dice等をモニタしながらlrを変更することもできる。

EarlyStopping, 

元のプログラムを書き替えるときに、その場しのぎの書き換えをやったことで、エラーは出ないが、動作は、正しくないということがおきているかもしれない。桁落ちの問題はなかったかな。（TPUの桁落ち対策のことを思い出した）

3月20日（土）

LB=0.911の公開コードのtrain_codeに学ぶ。（max: LB=0.918)

EfficientNetB4-Unet（activationはデフォルトのNoneか？）

loss_fn=FocalLoss(alpha=0.25, gamma=2.0, reduction='mean')、この設定（alpha=0.25）はMAnetの論文で見たような気がする。

optimizer=ranger

Ranger - a synergistic optimizer combining RAdam (Rectified Adam) and LookAhead, and now GC (gradient centralization) in one optimizer.

EfficientNetB2-Unet：

Unetにactivation="sigmoid"とし、OneCycleLR(AdamW, max_lr=1e-3. epochs=20...), SoftBCEWithLogitsLoss, batch_size=16, train_dataは、データ更新前の8件を用いて計算した結果、LB=0.808となった。最終エポックにおいて、train_loss=0.668, val_loss=0.669となり、14エポック以降は殆ど変化していない。

さすがにこれ（LB=0.808）では、続ける気にならないので、activationを外すことにして、他は何も変えずに計算してsubmitしてみたら、LB=0.850となった。驚いた！！！

最終エポックでtrain_loss=0.0219, val_loss=0.0356となっており、これらは約1.6倍異なっているので、overfittingにしかみえず、これまでであれば、commit, submitしなかったと思う。しかし、今回は、これをスタートラインにしようと思っていたので、commit, submitした。これが、自己ベスト（LB=0.839）を0.011も上回ったことは非常に大きな驚きである。train中に Dice coefficientを計算して表示していれば、もっと早く、このレベルの結果が得られていたかもしれない。

ここで、train_dataを2件追加（CPUの許容範囲ギリギリ）し、他の条件は変えずに計算してcommit, submitしたところ、LB=0.865までスコアが上がった。なにも変わったことはしていないので、なぜ上がっているのかわからない。データが更新された後、更新データが使えるようになったときにtrain_dataを8件から10件に増やしたときには、LBスコアが0.83+から0.839に上がっていたので、今回も上がることは期待していたが、ここまで（0.015も）上がるとは思わなかった。

しかし、トップの、LB=0.928まで、あと、0.063もある。

明日は、OneCycleLRのmax_lrを1e-3の付近で変えてみよう。今日、max_lr=2.5e-4を試してみたら、LB=0.853となった。ちょっと下げすぎたかもしれない。max_lr=5e-4, 2.5e-3, 5e-3あたりを調べてみる。さらに、FocalLossとLovaszLossを試してみようと思う。

3月21日（日）

OneCycleLRのmax_lrを変えた時のLBスコアを調べてみた。

lrは、デフォルト設定でepochs=20の場合、max_lr/25からスタートし、6エポックの計算直後にmax_lrに達し、そこからlrは減衰し、最終的にmax_lr/25/1e4となるようである。

結果は次のようになった。数値だけではわかりにくいので、プロットしてみる。

max_lr=2.5e-4：LB=0.853

max_lr=5.0e-4：LB=0.866

max_lr=1.0e-3：LB=0.865

max_lr=2.5e-3：LB=0.855

max_lr=5.0e-3：LB=0.863

プロットすると下図のようになる。LBスコアはmax\lrが5e-4と1e-3の間で最大になりそうだが、5e-3より大きい値にするとどうなるのかも気になる。

この挙動は、エポック数によっても変わる可能性がある。

max_lrを小さくすると、全過程においてlrは小さいので、収束速度が遅くなると推測される。もしそうであれば、max_lr=2.5e-4の条件でエポック数を増やせばLBスコアはもっと高くなるはずである。

max_lrが大きい場合、6エポック前後でのlrが標準的な値を超えているときには、不安定な動きをしているようにみえる。減衰しはじめてから標準的なlr値になるまでに時間がかかるため、標準的なlr値に戻ってから最終エポックまでの計算量が少なくなるために、学習が不十分という状況が生じているかもしれない。

OneCycleLRのエポック数を増やしても、lrの変化は相似形になるので、max_lrが大きい場合にエポック数を増やすと、適正なlrになるエポック数は増えるが、適正値を超えるlrになっているエポック数も増える。といっても、適正値を超えるlrになっているエポック数が増えることが、最終的な学習結果にどう影響するかはわからない。

すべては、やってみないとわからない、としておこう。

細かすぎるような気もするが（目標は遥か彼方）、次の２つの条件を追加してみる。

max_lr=7.5e-4：LB=0.857

max_lr=1.0e-2：LB=0.858

期待しかなかったのだが、笑うしかない。

次は、1サイクルではなく、複数サイクルのスケジューラーを使ってみよう。

torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr, max_lr, step_size_up=2000, step_size_down=None, mode='triangular', gamma=1.0, scale_fn=None, scale_mode='cycle', cycle_momentum=True, base_momentum=0.8, max_momentum=0.9, last_epoch=-1, verbose=False) 

ちょっと動かしてみただけだが、optimizerとしてAdamを使おうとしたら、momentumが使えないoptimizerは使えない、というようなメッセージが現れて停止した。そのため、SGDを nesterov=Trueとして使ってみた。base_lr=0.1, max_lr=3, epochs=20に設定し、他はデフォルトで使ってみたら、20エポックでは1サイクルの途中までだった。そこで、20エポックで3サイクルになるようにstep_size_up=500（デフォルトは2000）として計算してみたら、lr=3付近で異常値を示した。想像の域を出ないが、急激なlrの増大が良くなかったのではないかと思う。max_lrを3から2に下げたら、正常に動き、最終の20エポック目のlossもそれなりの値を示した。

サイクルの繰り返しによって、val_lossが下がっているので、max_lrとstep_size_upとエポック数の最適な組み合わせを探してみよう。

3月22日（月）

lr_scheduler.CyclicLR、20エポックで、max_lr=2とし、1サイクル、2サイクル、3サイクルになるようにstep_size_upを調整し、計算した結果をsubmitした。結果は以下のようになった。カッコの中は、最終エポックのtrain_lossとval_lossである。

３サイクル：LB=0.869 : (0.267, 0.314)

２サイクル：LB=0.839 : (0.258, 0.301)

１サイクル：LB=0.856 : (0.243, 0.296)

自己ベストが出たのはよかったが、lossの値からは、サイクル数が少ないほどLBスコアは高くなると予想していたので、あてが外れてしまった。 

これならいけるだろうと思って意気込んで計算してsubmitしたのが次の結果である。

30エポック：3サイクル：max_lr=3：LB=0.835 : (0.253, 0.353)：val_lossが高すぎ！

最初から、base_lr=0.1, max_lr=3 : 20エポック＆3サイクルと決めていたが、20エポック＆3サイクルでは、max_le=3に設定すると、lr=3付近でval_lossが発散した。そこで、max_lr=3でも発散しない条件を調べて、30エポックであれば良い結果が得られそうだと思ってトライした。val_lossが0.353となり、かなり大きい値だが、29エポック目では、(0.251, 0.303)だったので、いけるかもしれないと思い、commit, submitした。残念。

ステップ数を正しく計算していなかったために、30エポックの最後は最少のlrが適用されるべきところが、base_lrからの立ち上がりの30ステップぶんのlrが適用されたために学習した重みが若干かく乱された可能性がある。少なくともステップ数は正しく設定しておくべきであった。（745とすべきところを740と設定していた）

他の条件についても正確に計算すると、偶然だが、LB=0.869となったものだけが、最終エポックがlrの減少中に終わっていた。494と入力するつもりのところに、500と入力されていたのが幸いしたのかもしれない。LB=0.835となったものは、max_lr=3であったことも、悪い方に作用したようである。

OneCycleLRを使っているときに、max_lr=3が頭にこびりついていて、今回のCyclicLRでも、base_lr=0.1, max_lr=3がベストと思い込んでしまっていたようだ。Leslie N. Smith氏の論文では、0.1-0.5, 0.1-1, 0.1-1.5, 0.1-2, 0.1-2.5, 0.1-3, 0.1-3.5, 0.1-4, 0.09-0.9など、いろいろ試した例が表に載っている。

Leslie N. Smith氏の2編の論文より、

Furthermore, there is a certain elegance to the rhythm of these cycles and it simplifies the decision of when to drop learning rates and when to stop the current training
run. Experiments show that replacing each step of a constant learning rate with at least 3 cycles trains the network weights most of the way and running for 4 or more cycles
will achieve even better performance. Also, it is best to stop training at the end of a cycle, which is when the learning rate is at the minimum value and the accuracy peaks.

3サイクル以上とすること（追記：要検討）、および、lrが最小値になるエポックで止めること、と書かれている。自分が気付いた注意点としては、ステップ数を正しく計算し、最終エポックの計算中に、lrが立ち上がっていく領域が含まれないようにすることが重要である。

3/24追記：cyclicの後に1 sycleの発想が出てきている。ここまでの自分の実験からは、サイクル数、学習率の範囲と変化形状、などの最適値は、用いるデータの量や質に依存し、モデルや画像処理にも依存するので、実験を適切に繰り返しながら見つけよう。

CyclicLRのエポック数は12から100くらいまで、OneCycleLRのエポック数は100から800くらいまで表に記載されている。max_lrが大きいほど、エポック数は多い傾向にある。自分が計算した例では、max_lrを3にすると異常値が現れてモデルが壊れることがあった。そういうときは、エポック数を増やすか、max_lrを下げるかする必要がある。

ずっと気になっていたのだが、train_lossとval_lossしか計算していないので、明日は、train_dice, val_diceを計算して表示できるようにしよう。

3月23日（火）

GPU : 17h 38m available of 41h 

HuBMAP：

20エポック、3サイクル、0.1-2、（傾斜：(max_lr-base_lr)/step_size_up：(2-0.1)/500)：LB=0.869：（昨日の結果）

20エポック、3サイクル、0.1-1、（傾斜：(max_lr-base_lr)/step_size_up：(2-0.1)/500)：LB=0.845：（昨日の結果）

20エポック、4サイクル、0.1-2、（傾斜：(max_lr-base_lr)/step_size_up：(2-0.1)/373)：LB=0.851：傾斜が1.34倍（max_lr=2.65と同等）

傾斜もmax_lrも同じにして、4サイクルにする：

27エポック、4サイクル、0.1-2、step_size_up=503：LB=0.846：

train_loss=0.0249, val_loss=0.0296：lossから予想されるLBスコアとの乖離は非常に大きいと感じる。

LB=0.869の再現実験：

１．条件設定を完全に一致させる：

２．train_lossもval_lossも表示範囲で一致、出力も見える範囲で完全一致

３．LB=0.869は、再現された。

max_lrを2から1にしただけで、LBスコアは、0.869から0.845に下がり、傾斜もmax_lrも同じにして、サイクルを1つ増やしただけで、0.869から0.846に下がった。

max_lr=2.25とmax_lr=1.75を試してみよう。

20エポック、3サイクル、max_lr=2.25 : LB=0.863 : (train_loss=0.0269, val_loss=0.0324)

20エポック、3サイクル、max_lr=1.75 : LB=0.869 : (train_loss=0.0266, val_loss=0.0352)

3月27日追記：20エポック、3サイクルでは、max_lrは2より小さい方が良いのか、もう少し調べてみたい。

OneCycleLRはAdamWを使っていた。CyclicLRでは、AdamWが使えないので仕方なくSGD(nesterov=True)を使っているのだが、良い結果が得られているので、OneCycleLRでも、再度、SGDを使ってみようかなと思う。

エポック数：

Leslie N. Smith氏の論文の表を見ると、エポック数を25、50、75、100、150と増やせば、確実に、スコアは上がっている。データ量が多い場合はこういう傾向になるのだろう。他方で、データ量が少ないときには、20エポックくらいで、CyclicLRやOneCycleLRが良い結果を与えることを、実験して確かめているようだ。

diceの計算：次のサイトから借用させていただく

https://github.com/UCAS-Vincent/UNet-3Plus/blob/master/metrics.py

def dice_coef(output, target):
      smooth = 1e-5

      if torch.is_tensor(output):
      output = torch.sigmoid(output).data.cpu().numpy()
      if torch.is_tensor(target):
      target = target.data.cpu().numpy()
      #output = torch.sigmoid(output).view(-1).data.cpu().numpy()
      #target = target.view(-1).data.cpu().numpy()

      intersection = (output * target).sum()

      return (2. * intersection + smooth) / (output.sum() + target.sum() + smooth)

......

dices = []

for image, target in loader:

      ......

      dice =dice_coef(output, target)

      dices.append(dice.item())

np.array(dices).mean()

動作確認中！！！

明日は、30エポック、3サイクル、0.1-3、1サイクルの前後の割合を30:70と70:30にした結果を比較してみる（OneCycleLRのデフォルトは30:70である：pct_start=0.3）。さらに、base_lrを0.1より小さくした場合についても調べる予定。OneCycleLRでも、SGDを試してみよう。

3月24日（水）

HuBMAP：1,291 teams：48 days to go : 0.869 ---> ???

remaining time of GPU：7 h

30エポック3サイクル、0.1-3、30：70：LB=0.857 : (train_loss=0.0253, val_loss=0.0368)

30エポック3サイクル、0.1-3、50：50：LB=0.835 : (train_loss=0.0253, val_loss=0.0353)

30エポック3サイクル、0.1-3、70：30：LB=0.834 : (train_loss=0.0270, val_loss=0.0310)

50:50は既出。昨日までのCyclicLRの結果は、すべて、50:50である。

lossは、最終エポックの平均値であり、モデルの最終パラメータは最終ステップ（バッチ）の学習結果だと思うので、これだけでも、対応関係は慎重に判断しないといけないように思う（この見立てが正しければ）。dice_coefficintの計算も、エポック毎の計算だと、予測性能の評価指標として不十分になる可能性はlossとかわらないだろう。今使っているCyclicLRは、最終エポックと最終ステップ（バッチ）における評価値（lossやacc）の差が、大きくなりやすい。（ということなのだろう）

30:70が良さそうだということで、ここまででLBスコアが最も高かった条件で、50:50を30:70に変えただけで計算し、commit, submitした。

20エポック3サイクル、0.1-2、30：70 : LB=0.849 : (train_loss=0.0252, val_loss=0.0301)

lossがエポック毎の平均値だからあてにならないとはいえ、つい、この値で判断してしまう。

submitするときにこのlossを見て、自己記録更新を確信した。

LB=0.849を見て、落胆した。

まさか、0.02も下がるとは思わなかった。

public_test_dataとの相性が悪いのだ、と思いたいが、汎用性が低い、すなわちoverfitting状態だということだろうと思う。

lossの全体としての変化の傾向から判断することにしよう。

この場合はoverfittingになったと仮定して、それを解消する方法として、少し条件のきついtransformを適用してみよう。transformの条件を強くし、他の条件はそのままで計算してみよう。

計算の結果、最終エポックでのlossは、train_loss=0.0266, val_loss=0.0372となった。train_lossが少し大きくなっているのは期待通りだが、val_lossは、平均値としてみても、あるいは１つ手前のエポックでの値と比較しても、少し大きすぎるように思う。

結果は、LB=0.875となった。自己新記録だ！

これは、30:70：LB=0.849からの0.026ものジャンプアップだ。

それならば、50:50 : LB=0.869に対して、この条件を強めたtransformを適用するとどうなるだろうか。明日計算してみよう。

もし、50:50でoverfittingになっていないのであれば、それに対して強めのtransformを適用すると、underfittingになる可能性もある。実験してみよう！

GPUの残りは5時間、20エポックで35-40分、commitがあるから70-80分、残り4条件程度となる。

OneCycleLRからCyclicLRへと移ってみたが、CyclicLRの完成系の１つが、OneCycleLRのようである。自分の計算結果を見直すと、train_lossもval_lossもOneCycleLR(optimizer=AdamW)を用いた場合の方が小さくなっている。

OneCycleLRを用いたときのLBスコアが0.86+で頭打ちになっていたのは、overfittingへの対策が不十分だったということだろうと思う。

ということで、明日は、OneCycleLR(optimizer=AdamW)と強めのtransformを用いて計算してみる。

3月25日（木）

HuBMAP： 1,295 teams：47 days to go : 0.875 ---> ???

remaining time of GPU：3.5 h

CyclicLRとSGDを組み合わせてある程度うまくいったので、OneCycleLRもSGDと組み合わせて使ってみよう。

OneCycleLRとAdamWとの組み合わせでLB=0.865となったコードをそのまま使う。

OneCycleLR(AdamW, maxlr=0.001) : LB=0.865 (train_loss=0.0238, val_loss=0.0311)

OneCycleLR(SGD, nesterov=True, max_lr=3) : LB=0.861 (train_loss=0.0252, val_loss=0.0286)

train_lossが小さいAdamWの方に、強めのtransformを適用してみよう。

OneCycleLR(AdamW, max_lr=0.001) : LB=0.869 (train_loss=0.0251, val_loss=0.0322)

0.004のアップ。期待したほどではなかった。

SGDのOneCycleLRを使ったものに対しても強めのtransformを試してみよう。

OneCycleLR(SGD, nesterov=True, max_lr=3) : LB=0.862 (train_loss=0.0262, val_loss=0.0328)

0.001のアップ。LB=0.875を超えることを期待したが、そうはならなかった。

次の1週間（3月27日（土）～4月2日（金））は、次のような、細かいチューニングをやってみよう。

⇒ OneCycleLR(SGD)：max_lr=3を2.5, 2.0, 1.5,1.0等に変える。

⇒ OneCycleLR(AdamW) ：epochs=20を18, 22, 24等に変える。

⇒ OneCycleLR(SGD), (AdamW) : pct_start=0.3を0.4, 0.5等に変える。

⇒ CyclicLR(SGD)：3cycle epochs=3n (18, 21, 24, ... )  

⇒ CyclicLR(SGD)：epochs=20, 3 cycle (step_size_up=297, step_size_down=696), max_lr=2で、mode="triangular2"を試す。

⇒ CyclicLR(SGD)：base_momentum=0.85, max_momentum=0.95,を試す。

⇒ augmentationのCutout, blurなどのパラメータを変えてみる。

⇒ batch_size=16 --> 12 --> 8 --> 4 --> 2 -->1 ???

⇒ 画像解像度：EfficientNetB2でバッチ数を下げて解像度を上げる。256x256 --> 320x320 --> 384x384 --> 448x448 --> 512x512：overlapも増やす、32 --> 48 --> 64 --> 96 --> 128

⇒ B2 --> B3 --> B4：これは、B2で、十分に検討した後で！

⇒ train_dataの使用量を増やす。

overfittingの程度によって、augmentationの効果は変わる。OneCycleLRはエポック数によってoverfitting側にもnderfitting側にもある程度制御しながら振ることができるので、今日実験した系に対して、追加で試してみようと思っている。

20エポック、3サイクル、0.1-2、50:50 : LB=0.869に対して強めのtransformを試す予定だったが、OneCyleLR（SGD）を試したことで、GPUを使い切ったため、土曜日以降になる。

CyclicLRは、OneCycleLRよりも自由度が高く、良い値も得られているので、続けてみようと思う。CyclicLRには3種類のモードがあって、"triangler"は三角形の頂点の学習率が変わらないが、"triangler2"は、三角形の頂点の学習率が、1, 1/2, 1/4と減衰する。さらに、“exp_range”では、三角形の頂点の学習率が指数関数的に減衰する。gammaとステップ数によって減衰率を変えることができるのだが、ピーク値がどういう値になるかは与式に従って計算しておく必要がある。

1サイクルが300+700チャンネルで3サイクルまでの場合：

gamma=0.999：各サイクルのピーク値は、0.74, 0.27, 0.10となる。

gamma=0.9993：0.81, 0.40, 0.20となり、"triangle2"と似たような変化率になる。

gamma=0.99965：0.90, 0.63, 0.45 (1.0 : 0.7 : 0.5)：ちょっと試してみたくなる。

Cyclicと1 Cycleの比較：

Cyclicのデフォルト：base_momentum=0.8, max_momentum=0.9

1 Cycleのデフォルト：base_momentum=0.85, max_momentum=0.95

Cyclicのbase_lr：固定かつデフォルト無し：論文では0.1が多いように思う。

1 Cycleのbase_lr：可変：初期値はmax_lr/div_factor（デフォルトはmax_lr/25）、最終値はmax_lr/div_factor/final_div_factor（デフォルトはmax_lr/div_factor/1e4）：1 Cycleでは、学習率の初期値も最終値も、Cyclicより小さく設定しているようである。この方が良いということであれば、Cyclicのbase_lrは0.1よりも小さい値にした方が良さそうである。実験結果では、一例に過ぎないが、20エポック、2サイクル、max_lr=2で、base_lr=0.1, 0.001, 0.00001にしたとき、LB=0.839, 0.853, 0.847となった。 

3月26日（金）

HuBMAP：1,296 teams, 46 days to go : top 0.934

augmentationを正しく理解したい。

基本的な考え方：augmentationを行う確率は100％より低い。ある割合は元画像をそのまま通過させるためだ。ただし、切り出しやサイズ変更では100％処理もありうる。データ量が多い場合は、augmentationの必要性は少なく、確率は10-30％で変化の強度も低くする。データ量が少ない場合は、それぞれ40-50%の確率で処理し、変化の強度も高くする。

画像を水増しするというが、1つの処理を50％の確率で行うと、倍になるのか。100枚の画像に対してノイズ添加を50％の確率で行うと、50％はノイズが加わり、50％がそのまま通過する。トータルは100枚のままである。水増しの文字通りの意味であれば、元画像はそのまま使い、そのうちの半分にノイズ添加をして元の画像に足せば、150枚の画像が出来上がることになる。あるいは、100枚にノイズを添加して元の画像に加えれば200枚になる。このあたりのことを具体的に何も知らないのがはがゆい。

自分が使っているコードの動きを見ている限りでは、指定した割合でデータ加工されているようで、加工の種類を増やすとそれだけ元画像の割合が少なくなるようであり、これでいいのかなと思ってしまう。

それだったら、オートフォーカスじゃないけど、全ての画像をCNN処理しやすいように前処理できればそれがベストということになるのか。前処理せずとも全ての画像を正しく処理できるモデルを構築するということになるのか。求められているのは後者だ。実画像にありそうな画像処理をしてモデルを訓練するということだ。

import albumentations as A

transform = A.Compose([
      A.RandomCrop(512, 512),
      A.RandomBrightnessContrast(p=0.3),
      A.HorizontalFlip(p=0.5),
])

3つの処理が上から順に並んでいる。処理は、この順番に行われる。

１．元画像から512x512の部分をランダムに切り取る。これは、100％行われる。

２．１．で処理された画像のうち、3割は、明るさやコントラストの変更がランダムに行われ、7割は、未処理で通過する。

３．２．を通過した画像のうち、5割は水平方向にフリップされ、5割はそのまま通過する。

これだと、入力画像数と出力画像数は同じで、cropされただけで通過する画像は35％、cropされてフリップされた画像が35％、cropされて明るさやコントラストを変更されただけの画像が15％、cropされ明るさやコントラストを変更されフリップされた画像が15％ということになる。

こうして、1式の画像を処理した画像がメモリーに保存されると、学習中、エポック単位の画像は変化しない。エポック毎にaugmentationを行うという方法が使えれば、エポックごとに違う画像で訓練することができて、良さそうに思うが、計算時間はそれなりに増えそうに思う。

このあたりの制御を的確に行うためには、ゼロからプログラムする技術、プログラムを正確に読む技術、プログラムを正確に組み込む技術、などが必要になるので、そこを意識してプログラムを読もう。

このコンペに必要な加工を考えて、augmentationのパラメータを決めよう。そのためには、モデルが予測した結果を画像化して、どのようなミスをしているのかを具体的に把握して対策していくことが必要かもしれない。LB_scoreトップの方が、セグメンテーションが難しい糸球体を特定し、それらの画像に特化した対策をすることによってLBスコアが上がったというようなことを言っておられたと思う。

3月27日（土）～ 4月2日（金）LB=0.875 ---> 0.88+

１．0.875となったモデルの周辺探索（epochs, augmentation, resolution, max_lr, ...） 

２．CyclicLRの、"triangular2 ", "exp_range"の検討（21エポック以下を重点的に）

3月27日（土）

HuBMAP：1,303 teams, 45 days to go :  top 0.934

GPU : 42 h

Run 1 : based on the model of LB=0.875 (0.0266, 0.0372) : E20 B16(149) 1024,32,256 trfm_4 b2-Unet CyclicLR SGD(nestelov) lr=0.1-2 triangular cycle=3 298,696 momentum=0.8-0.9 BCE train_data=8+26d...+4ef... : lr=0.1-2 --> lr=0.001-2 : LB=0.867 (-0.008) (0.0271, 0.0347)

Run 2 : triangular --> triangular2 : LB=0.861 : (0.0258, 0.0375)

Run 3 : batch_size=16 --> 8 : 4エポック目まで普通だったのだが、5エポック目からtrain_loss, val_lossともに異常値を示し、5エポックほど待ったが、全く改善されなかったので中止した。

バッチサイズが変わると1エポックあたりのステップ数（データ量÷バッチサイズ）が変わるので、パラメータを計算し直さないといけないのだが、それを怠ったことによるエラーであることが分かった。20エポック、6サイクルの設定になっていた。

Run 4 : batch_size=16 --> 24 : LB=0.867 (0.0255, 0.0333)

これも再計算を怠ったので、20エポック、2サイクルで動作したことになる。

Run 5 : momentum 0.80, 0.90 --> 0.85, 0.95 : LB=0.866 (0.0278, 0.0329)

Run 6 : image 256x256 --> 320x320 : LB=0.877 (0.0238, 0.0319)

0.002だけだが、自己新記録となった。

バッチサイズ効果については、パラメータを正しく設定してやり直す必要がある。

Run 1のbase_lrの値は、OneCycleLRの設定を真似て少し低くしてみたのだが、効果的ではなかったようだ。

Run 2のtriangular2は、サイクルごとに学習率lrのピーク値が半分になるので、ピーク値が同じ場合よりも収束しやすくなって良いかなと思ったが、こう思ってしまうのは、lrを段階的に下げるとか指数関数的に下げるという従来の方法が頭にこびりついているせいだろうなと思う。

バッチサイズは、ケースバイケースのようでよくわからず、試してみたいと思ったのだが、パラメータ設定をミスったので、明日にでも、やりなおしてみる。

momentumは、OneCycleLRとCyclicLRとでデフォルトが違っているので、試しに相手側のデフォルトにしてみたということ。今回は効果的ではなかったが、使える場面はあると思う。

画像解像度を上げることは、効果的だが、overfittingとの戦いになりそう。

3月28日（日）

HuBMAP：1,309 teams, 44 days to go : 0.057 to first place

今日は、昨日効果が認められた320x320より画素数を増やしてみよう。

B2-Unet, batch_size=16, 320x320, CyclicLR(SGD, epochs=20, up=298, down=696, 0.1-2.0, momentum=0.8, 0.9, triangular, ... : LB=877 (0.0238, 0.0319)

384x384 : LB=0.873 (0.0229, 0.0323)

448x448 : LB=0.860 (0.0212, 0.0303)

512x512 : LB=0.871 (0.0202, 0.0294)

train_lossもval_lossも小さくなっているので、スコアが上がってもよさそうなものだが、足ふみ状態だ。train_lossが高めであることから、いずれもoverfittingになっているのだろうと思う。

ここで、decoderを変えてみよう。

512x512に対する対応可否の確認も兼ねて512x512から始めよう。

Linknet：512x512 : LB=0.876 (0.0220, 0.0285)

PSPNet：収束せず。

FPN：収束が非常に悪いので中止。

MAnet：512x512 : LB=0.865 (0.0220. 0.0284)

PSPNetとFPNの応答が良くない。その原因を調べたいが、後日とする。

3月29日（月）

HuBMAP：1,313 teams, 43 days to go : 

512x512について、Unet, MAnetよりも良いLBスコアを示したLinknetについて、他の解像度についても実験してみる。

256x256 : (0.0301, 0.0356) : commitまで

320x320 : 見送り

384x384 : 見送り

448x448 : (0.0224, 0.0291) : LB=0.862

Linknetの256x256, 448x448のlossの値がUnetよりも高い。このことは、LinknetがUnetよりも性能が悪いことを示唆している。512x512でも、UnetよりLinknetのlossが大きく、それでもLBスコアが高いのは、Linknetの性能が少し悪いことによってoverfitが少し抑えられたためであると推測される。Linknetについては、ひとまず中断。

解像度の低い画像に対してはencoderを大きくし、解像度の高い画像に対してはencoderを小さくする、というのも1つの方法かもしれない。

encoderをb2からb3, b4に変更してみた。すると、大きな問題が生じた。

320x320にb3-Unetを用いると、次に示すように、3サイクル目の3エポック目からlossが1桁大きくなりそのまま収束しなくなった。

  1│ 0.1397│ 0.0703│ 1.70
  2│ 0.0531│ 0.1602│ 1.67
  3│ 0.0576│ 0.0428│ 1.67
  4│ 0.0378│ 0.0418│ 1.67
  5│ 0.0356│ 0.0394│ 1.66
  6│ 0.0316│ 0.0344│ 1.67
  7│ 0.0292│ 0.0327│ 1.66
  8│ 0.0288│ 0.0353│ 1.67
  9│ 0.0341│ 0.0370│ 1.67
10│ 0.0350│ 0.0405│ 1.67
11│ 0.0334│ 0.0339│ 1.67
12│ 0.0299│ 0.0304│ 1.67
13│ 0.0274│ 0.0355│ 1.67
14│ 0.0260│ 0.0322│ 1.67
15│ 0.0248│ 0.0337│ 1.66
16│ 0.0273│ 0.1100│ 1.68
17│ 0.3699│ 0.2800│ 1.68
18│ 0.2860│ 0.2863│ 1.67
19│ 0.2851│ 0.2800│ 1.67
20│ 0.2845│ 0.2840│ 1.67
21│ 0.2855│ 0.2821│ 1.69

数字は、左から、エポック数、train_loss, val_loss, 計算時間（分）を表している。

3サイクル目は15エポックから始まり、17エポック目の途中で学習率lrが最大になるように設定されている。2サイクル目まで問題ないように見えて、3サイクル目でこのような現象が生じるとは思わなかった。

20エポック、3サイクルで、max_lr=3以上に設定すると、学習率lrが最大になるエポックで異常値を示すということはわかっていたが、今回のように、2サイクルまで正常だったので、驚いた。

max_lrを2.0から1.5に下げて、他はそのままで計算してみた。

15│ 0.0243│ 0.0295│ 1.66
16│ 0.0266│ 0.0417│ 1.67
17│ 0.0300│ 0.0360│ 1.69
18│ 0.0269│ 0.0586│ 1.66
19│ 0.0262│ 0.0431│ 1.67
20│ 0.0241│ 0.0339│ 1.66
21│ 0.0228│ 0.0278│ 1.68

異常は生じずに、収束した。

encoderのサイズや画像の解像度によって、max_lrを最適化することが必要であることがわかった。

256x256の画像に対してencoderにEfficientNetB3を使ったときに、最終エポックのtrain_lossが少し大きくなっている（収束が良くない）ように感じたことがあった。このときも、症状は軽いながらも、異常が生じていたということだろうと思う。

ということであれば、4サイクルに増やした時に、4サイクル目で収束しなかったのも、同様の現象が生じていたのかもしれない。すなわち、サイクルを繰り返すと、訓練が進むが、訓練が進んでも同じmax_lrを適用していると、学習率lrを大きくした効果がなくなるだけでなく、かえって、モデルが悪化したり、収束しなくなるということだろう。学習が進んだモデルに大きすぎる学習率を適用すると、完成に近づいていたモデルが壊れてしまう、ということだろう。

そういうこともあって、サイクル毎にピーク値が半減する"triangular2"がオプションとして用意されているということなのだろう。

さらに、max_lrをサイクルごとに減衰させることができ、かつ、減衰の仕方を変えることができる"exp_range"というのも、オプションとして用意されている。

3サイクル、21エポック、学習率のベースと最大値：0.1-1.5

256x256 : b3 : (0.0266, 0.0315) : LB=0.858

320x320 : b3 : (0.0228, 0.0278) : LB=0.868

encoderを大きくすることで、val_lossが小さくなってoverfittingが抑制されることを期待したが、max_lrを下げざるを得なくなって、Super-Convergenceがうまく働くなってしまっているのだろうか。

overfitting対策のために、augmentationの調整をしてみよう。

早速augmentationのミスがあった。

Cutoutを使っているのだが、切り出しサイズのピクセル数が、256 x 0.1のように絶対値にしていた。そうすると、画像解像度が2倍になったとき、切り取りサイズが相対的に半分になる。面積で1/4。画像の画素数が多いほど、augmentationの効果は小さくなっていたということになる。

Cutoutのサイズを画素数に連動するよう変更するとともに、確率、サイズ、個数等の適切な値を探してみよう。

次の論文のFig. 1では、隠すのは1か所で、1/4面積の正方形で、はみだしOKで、100％適用している。はみだし無しで50％とか、サイズの異なるものも試みられているようである。Kaggleのコンペで見かけるのは、サイズを小さくして数を増やしたものが多い。

先入観にとらわれず、色々なパターンを実験してみるしかないように思う。借り物は,小さい正方形を10枚使っている。

面積1/4のサイズを1枚：1/2 x 1/2 ：確率25％に設定。

1│ 0.1415│ 0.0802│ 2.08
2│ 0.0614│ 0.1015│ 2.05
3│ 0.0744│ 0.2674│ 2.05
4│ 0.0598│ 0.0492│ 2.06
5│ 0.0479│ 0.0665│ 2.04
6│ 0.0438│ 0.0423│ 2.03
7│ 0.0404│ 0.0439│ 2.04
8│ 0.0396│ 0.0905│ 2.05
9│ 0.0472│ 0.0615│ 2.05
10│ 0.0490│ 0.0418│ 2.06
11│ 0.0437│ 0.0417│ 2.07
12│ 0.0396│ 0.0459│ 2.04
13│ 0.0367│ 0.0365│ 2.05
14│ 0.0352│ 0.0389│ 2.04
15│ 0.0365│ 0.0804│ 2.06
16│ 0.0377│ 0.0459│ 2.07
17│ 0.0406│ 0.1307│ 2.09
18│ 0.0411│ 0.0389│ 2.07
19│ 0.0370│ 0.0420│ 2.06
20│ 0.0329│ 0.0397│ 2.07
21│ 0.0340│ 0.0365│ 2.08

0.03以下でないと使えない。

面積1/10 のサイズを1枚≒0.316x0.316：確率25％に設定。

1│ 0.1341│ 0.0948│ 1.91
2│ 0.0531│ 0.0647│ 1.88
3│ 0.0431│ 0.0494│ 1.89
4│ 0.0389│ 0.0364│ 1.86
5│ 0.0358│ 0.0354│ 1.87
6│ 0.0316│ 0.0367│ 1.88
7│ 0.0296│ 0.0295│ 1.88
8│ 0.0289│ 0.0412│ 1.87
9│ 0.0307│ 0.0409│ 1.86
10│ 0.0335│ 0.0333│ 1.87
11│ 0.0315│ 0.0369│ 1.88
12│ 0.0298│ 0.0325│ 1.86
13│ 0.0271│ 0.0337│ 1.89
14│ 0.0268│ 0.0330│ 1.87
15│ 0.0258│ 0.0397│ 1.88
16│ 0.0282│ 0.0364│ 1.87
17│ 0.0296│ 0.0818│ 1.88
18│ 0.0323│ 0.0323│ 1.87
19│ 0.0274│ 0.0340│ 1.87
20│ 0.0250│ 0.0366│ 1.88
21│ 0.0256│ 0.0295│ 1.88

LB=0.874：A.cutoutが効いたかどうかはまだ不明。P=0.のときの結果が必要。

3サイクル目のlossの推移が若干、不自然のようだ。前に書いたが、3つの山が同じ高さだと、学習がある程度進んだあとの3つ目の山で収束が悪くなることや、モデルが壊れてしまうことがある。うまくいってるように見えても、収束が悪くなっている可能性がある。

ただし、ピークの高さゆえの、Super-Convergenceを利用しているので、全体を低くしてしまうわけにはいかない。

21エポック、3サイクル、batch\size=16の場合に、"exp_range"でgamma=0.9999とすれば、3つの山のピークは、0.969, 0.873, 0.787となる。こういうのを試してみよう。

gamma=1.0 (=triangular)  1.0, 1.0, 1.0 : LB=0.874 (0.0256, 0.0295)

gamma=0.9999   : 0.969, 0.873, 0.787 : LB=0.863 (0.0256, 0.0294)

gamma=0.9998   : 0.939, 0.762, 0.619 : LB=0.852 (0.0248, 0.0312)

学習率のピーク高さを減衰させると、LBスコアが低下する、という傾向が認められた。

4月1日（木）

GPU : no time left

ようやく、val_dice_coefficientを表示することができるようになった。

4月2日（金）

GPU : no time left

CPUを使って途中まで計算した結果を眺めてみよう（16エポックで止めた）。

21エポックで3サイクルになるように設定した（1サイクルが7エポック）。

CyclicLR(SGD, lr : 0.1-2.0),loss_fn=BCE, EfficientNetB2-Unet

左から、エポック数、train_loss, val_loss, train_dice, val_dice, 計算時間(min)

  1│ 0.1181│ 0.0710│ 0.6080│ 0.7867│ 26.24
  2│ 0.0676│ 0.4731│ 0.7739│ 0.3525│ 26.23
  3│ 0.0789│ 0.0875│ 0.7445│ 0.8000│ 26.10
  4│ 0.0563│ 0.2749│ 0.8181│ 0.4594│ 25.97
  5│ 0.0479│ 0.0423│ 0.8418│ 0.8608│ 25.97
  6│ 0.0398│ 0.0418│ 0.8616│ 0.8545│ 25.82
  7│ 0.0356│ 0.0334│ 0.8742│ 0.8781│ 25.85
  8│ 0.0358│ 0.0420│ 0.8740│ 0.8638│ 26.04
  9│ 0.0434│ 0.0935│ 0.8593│ 0.7237│ 26.04
10│ 0.0495│ 0.0421│ 0.8410│ 0.8683│ 26.10
11│ 0.0426│ 0.0381│ 0.8549│ 0.8719│ 26.16
12│ 0.0361│ 0.0386│ 0.8747│ 0.8560│ 26.08
13│ 0.0339│ 0.0341│ 0.8789│ 0.8730│ 25.93
14│ 0.0317│ 0.0334│ 0.8867│ 0.8852│ 26.07
15│ 0.0313│ 0.0363│ 0.8873│ 0.8756│ 26.31
16│ 0.0362│ 0.0432│ 0.8784│ 0.8691│ 26.11

val_diceは、サイクルの最後のエポック数において、最大値を示している。

2サイクル目の最後のエポックでのスコアの方が高い。今は、3回繰り返した後で、commit, submitしている。

さて、3月28日のLB=0.877を超えるためにどうすれば良いか考えよう。

これまでにわかったこと（確実なことは1つもない、すべては相対的）：

・train_dataは、当初の8件だけよりは、それに2件追加して10件にすることで良くなった。15件全部使ってみたいが、今のやり方では、メモリーの制限に引っかかり、1件も増やせない。解決策はある筈なので見つけたい。

・augmentationは、機械的変形を強くしすぎると逆効果になる。形状変化を伴わない適切な光学的処理がよさそうである。Cutoutも効いているようだが、要検討。

・LB=0.87+は、CyclicLR(SGD)のみであり、20または21エポックの3サイクルで、lrの範囲は0.1-2.0である。これがベストだとは思っていない。

・画像解像度は、1週間くらい前から検討しているが、overfitting状態である。

・EfficientNetB2-Unetを超えられないのがもどかしい。B3やB4、FPNやMAnet, Linknetなどを少し試したが、それぞれに、固有のチューニングが必要で、収拾がつかなくなりそうだと感じている。

・やっと計算できるようになったDaice coefficientとLBスコアとの関係が非常に気になる。discussionでは、CVとLBは近いとのこと。0.932:0.916, 0.94:0.932, 0.923:0.924などが報告されている。

・CyclicLRを使うことによって、LBスコアが0.87+になった。

・CyclicLRのサイクル数は、論文では3サイクル以上が良いと書かれていたが、3サイクル（v28 : LB=869 : 0.0267, 0.0314）から4サイクルに増やすとスコアが下がった（v36：LB=0.851 : 0.0255, 0.0306）ので、その時点（3月23日）でサイクル数を増やすのをやめた。最終エポックでのtrain_lossとval_lossは、4サイクルの方が小さいにも関わらずLBスコアが悪く、その原因が、4サイクル目の途中のlossの異常値(0.0282, 0.1107)にあると考えたためである。しかし、この判断は早計だったかもしれない。

4サイクルを止めた原因となった2つのデータを比較する。

LB=0.869のデータ：20エポックで3サイクルに設定しているので、1サイクルの最後、2サイクルの最後はサイクルの最終位置ではない。（バッチ単位（ステップ）でサイクルを決めているため）

  1│ 0.1264│ 0.0543│ 1.05
  2│ 0.0544│ 0.0593│ 1.03
  3│ 0.0446│ 0.0572│ 1.03
  4│ 0.0446│ 0.0766│ 1.03
  5│ 0.0481│ 0.0416│ 1.03
  6│ 0.0390│ 0.0375│ 1.03
  7│ 0.0329│ 0.0326│ 1.03
  8│ 0.0327│ 0.0378│ 1.03
  9│ 0.0337│ 0.0335│ 1.03
10│ 0.0343│ 0.0392│ 1.03
11│ 0.0339│ 0.0386│ 1.03
12│ 0.0306│ 0.0379│ 1.03
13│ 0.0289│ 0.0330│ 1.03
14│ 0.0270│ 0.0373│ 1.03
15│ 0.0274│ 0.0353│ 1.04
16│ 0.0278│ 0.0337│ 1.02
17│ 0.0324│ 0.0978│ 1.03
18│ 0.0348│ 0.0370│ 1.03
19│ 0.0282│ 0.0316│ 1.03
20│ 0.0267│ 0.0314│ 1.03

LB=0.851のデータ：これは、20エポックで4サイクルに設定しているので、最終サイクル位置は、5, 10, 15, 20エポックと一致する。

  1│ 0.1229│ 0.0606│ 1.10
  2│ 0.0552│ 0.0577│ 1.09
  3│ 0.0441│ 0.0484│ 1.07
  4│ 0.0399│ 0.0361│ 1.10
  5│ 0.0346│ 0.0315│ 1.12
  6│ 0.0319│ 0.0384│ 1.09
  7│ 0.0334│ 0.0421│ 1.07
  8│ 0.0351│ 0.0416│ 1.08
  9│ 0.0335│ 0.0314│ 1.11
10│ 0.0307│ 0.0314│ 1.09　　　　　　　　　　　　　　　　　　　　　　　　　　　11│ 0.0281│ 0.0378│ 1.09
12│ 0.0294│ 0.0362│ 1.08
13│ 0.0315│ 0.0348│ 1.12
14│ 0.0297│ 0.0372│ 1.16
15│ 0.0268│ 0.0349│ 1.12
16│ 0.0258│ 0.0286│ 1.11
17│ 0.0282│ 0.1107│ 1.00
18│ 0.0323│ 0.0368│ 1.13
19│ 0.0277│ 0.0321│ 1.09
20│ 0.0255│ 0.0306│ 1.10

このときは、LBスコアが低かったことと、赤で示した0.1107から、4エポックはダメと判断したのだが、3サイクルの場合でも、赤で示したように 0.0978というのがある。
4サイクルにすることでlossは下がっているので、LBスコアが3サイクルより低くなった原因は他にあると考えて、サイクル数を増やしてみようと思う。
3サイクルと4サイクルを正しく比較するには、1サイクルあたりのエポック数を同じにしなければならない。1サイクルを何エポックにするかは最適化できていないのでこれも含めて実験する必要がある。1サイクルの中での学習率が最大になるピーク位置についても最適化が必要で、この2つの場合は1サイクルの中心だったが、ある時点(v43)から、OneCycleLRでのデフォルト0.3(3:7)になるようにステップ数(step_size_up, step_size_down)を設定している。

4月3日（土）

GPU : 36 h (5.14 h/day)

Run 1：LB=0.875の計算過程におけるDice coefficientの確認（20エポック3サイクル）と、3サイクル以降のtrainingの経過調査（40エポック6サイクルに設定し、40エポックでのDice_coeffが良ければcommit, submitする。

20エポックでのval_dice_coeff=0.888であった。これがLB=0.875だというのは納得できる値だと思う。40エポック目のval_dice_coeff=0.9011となったので、commit, submitしてみよう。その結果が良ければ、60エポック、あるいは80エポックを試してみよう。結果は、LB=0.799であった。こうなると、次の一手が分からなくなってしまう。 

勝手にCutoutを悪者扱いして、Cutoutの影響/効果を調べる。そのために、Cutoutの確率0.25と0.0を比較する。

Cutout=0.25：val_dice_coeff=0.895 : LB=0.862

Cutout=0.0   : val_dice_coeff=0.903 : LB=0.850

Cutoutは、overfittingを抑制する効果があったということかな。

それにしても、val_dice_coefficientがまったく役に立たないとは、困ったものだ。

明日は、手前のサイクル数で止めて、LBスコアを出してみよう。しかし、こんなことをしても、前の週からの進展は、殆ど期待できないような気がする。

 val_dice_coefficientを計算することで、条件検討が捗ると期待したが、これでは、なんにもならない。何の指標にもならないのか。それとも、プログラミングに問題があるのか。val_lossと同一の手順で、val_lossに併記しているので、validationの結果を計算できている筈なのだが。

今日は、最高に、期待外れの日だった。

最初に、20エポック3サイクルでLB=0.875となったモデルで、20エポックの先を見るために、40エポック6サイクルの計算を行い、40エポック後にcommit, submitしたら、LB=0.799となった。val_Diceは20エポックで0.888となり、40エポックでは0.9011まで上がったので、20エポックの0.888でLB=0.875だから、40エポックの0.901では、LB=0.885くらいになると予想していたのだが、LB=0.799という値となった。残念過ぎる結果だ。

20エポック3サイクルというのは、立ち上がりが2エポックで、立下りが6.666エポックである。これだと学習率の最小値や最大値がエポックの中間にあらわれるので、立ち上がりを2エポック、立下りを4エポックという組み合わせに変更した。これだと、6エポック単位でサイクルが繰り返されるので、たとえば、5,6サイクルくらいまで計算しておいて、良さそうなサイクル数を選んで再度計算するのに都合が良いと考えた。

ということで、30エポック5サイクルで計算し、augmentationを3段階に設定して計算した。LBスコアは、augmentationの弱い方から、0.850, 0.862, 0.847となった。これもまた平凡な値になった。これらのval_Diceは、0.903, 0.895, 0.896であった。

3サイクルで0.875のモデルを6サイクルまで訓練したら、性能がガタ落ちしたということである。overfittingだけでは片づけられない問題だと思う。

augmentationの条件を3段階変えた例では、0.852がoverfitting、0.862は、augmentationによる予測性能の向上もしくはoverfittingの抑制、0.847は過剰なaugmentationということか。何のことかわからないので、解決策がわからない。

不適切なaugmentationだが、結果としてoverfittingは抑制されてLBスコアが少し上がったが、augmentationを強めると不適切な操作であるため、予測性能は低下した、ということかもしれない。今回変更したのはCutoutで、１）使わない、２）10個の正方形で、各正方形の面積は画像の1％、確率は25％、３）同2％、確率25％。 1％や2％というのは、1次元だと小さく感じるが、2次元だと、ヒトの目には大きく感じるものである。

LB=0.875は、Cutout（25％）とAffine（12.5％）を含んでいる。3サイクルまでは、ある程度学習が進み、適度なaugmentationによって予測性能が向上した。そこからさらに3サイクルほど学習が進む間に、CutoutやAffineのような幾何学的な画像操作による変形を学習してしまい、スライスによる入力画像であるがゆえのアーティファクトに過剰に反応するようになった、ということは考えられないだろうか。

4月4日（日）

GPU : 28 h

今日は、5サイクル30エポック、（１）Cutout無し、（２）0.1、（３）0.1414、について検討する。30エポックまで訓練したモデルのLBスコアは、（１）0.850、（２）0.862、（３）0.847だった。これを過剰訓練により、汎用性が失われたと推測する。過剰訓練によるものかどうかを確認するには、5サイクルより前のサイクルで終了させたモデルの予測性能をLBスコアで評価すればよい。

最初に、（１）Cutout無しについて、1サイクル後（6エポック後）のモデルで予測した結果を調べることから始めてみよう。lossを見ると、計算してみようとか、調べてみようとか思わないのだが、val_Diceの値を見ると、本当にそうなのだろうかと気になる。

6エポックと12エポックの結果が出た。ひどいもんだ。train_lossとval_lossだけ見ているほうが、まだまし、と思ってしまう。

epochs | train_loss | val_loss | train_Dice | val_Dice |

  1│ 0.1260│ 0.0678│ 0.5811│ 0.8120│
  2│ 0.0554│ 0.0500│ 0.8127│ 0.8475│ 
  3│ 0.0444│ 0.0867│ 0.8497│ 0.7538│ 
  4│ 0.0438│ 0.0386│ 0.8480│ 0.8574│ 
  5│ 0.0387│ 0.0511│ 0.8690│ 0.7533│ 
  6│ 0.0376│ 0.0347│ 0.8624│ 0.8859│ LB=0.850

..........

12│ 0.0286│ 0.0332│ 0.8988│ 0.8953│ LB=0.855

..........

18│ 0.0272│ 0.0322│ 0.9032│ 0.8987│ LB=0.852

..........

24│ 0.0243│ 0.0322│ 0.9125│ 0.9031│ 

..........

30│ 0.0235│ 0.0398│ 0.9144│ 0.9026│ LB=0.850

（１）Cutout無し、はここまで。（２）Cutout : 0.1、の12エポックと18エポックを計算しておこう。その後で、Dice_coefficientの計算を見直す。

（２）Cutout : 0.1（LB=0.875のモデルとの違いは、1サイクルのエポック数で、LB=0.875のモデルは、3サイクルで20エポック、ここでは、3サイクルで18エポック。

12│ 0.0300│ 0.0363│ 0.8931│ 0.8842│ LB=0.859

..........

18│ 0.0286│ 0.0305│ 0.8987│ 0.8930│ LB=0.859

Cutout : 0.1を追加することによって、train_lossが少し大きくなっている。train_lossは、パラメータの変化に対して最も再現性の良い指標の１つである。これに対して、val_lossは、試料数が少ないことや偏りがあることなどのために、ばらつきが大きい。

LBスコアを上げることはできなかったが、サイクル数の最適化には必要な作業だろうと思う。

＊＊＊Dice coefficientのコードを変更している間に、inferenceのコードもおかしくなってしまったので、LB=0.877(version52/87)のコードまでもどって再スタートする。Dice coefficientのことは、しばらく忘れよう。

この2日間で得たLBスコアは、0.799, 0.862, 0.850, 0.847, 0.832, 0.850, 0.855, 0.852, 0.859, 0.859の10件である。

4月3日から4月9日の計画は、lossとDice coefficientとLBスコアの相関を調べて整理することによって、次の進め方を考えることであった。

この2日間でわかったことは、Dice coefficientの計算に失敗しているらしいこと、Dice coefficientを指標にして決めたサイクル数の設定条件（特に、1サイクルあたりのエポック数：良い結果を得ていたのは3サイクル20エポックであり、これは、1サイクルあたりのエポック数が整数にならないので、今回は、3サイクル18エポック（5サイクル30エポック）の検討と、Dice coefficientの計算と、Dice coefficientを指標にして、サイクル数とLBスコアの関係を調べようとした。得られた結果は、

・Dice coefficientの計算ができるようにしたが、それらしい値は示しているものの、LBスコアとの対応は良くない。

・3サイクル20エポックと同等かそれ以上の性能を求めて、3サイクル18エポックすなわち1サイクル6エポックを検討したが、3サイクル20エポックに近い、3サイクル18エポックでのLBスコアは、0.859となり、3サイクル20エポックでのLBスコア0.875より0.016小さい値となった。5サイクル30エポックでのLBスコアが0.862であったことも加味すると、今の諸々の条件下では、1サイクル6エポックは、1サイクル6.67エポック（3サイクル20エポック）よりも小さいLBスコアになることが分かった。1サイクル6エポックはdownのサイクル数が少ないぶんだけ、学習量が少なく、lossの下がりが少なくなったのだろう。

明日以降の予定：

１．1サイクル7エポック（up: 2 epochs, down: 5 epochs）と8エポック（up: 2 epochs, down: 6 epochs）を試す。

２．Cutout条件と1サイクルのエポック数の見直し：320pixelの画像を使ったときに、LBスコアが、0.877と0.862になった。両者の違いは2か所ある。0.877は、3サイクル20エポック、かつ、cutoutが0.1x256を10か所。0.862は、3サイクル21エポック（1サイクル7エポック）、かつ、cutoutが0.1x320を10か所。0.1x256と0.1x320とでは、ホール面積は1.56倍異なる。

３．Cutout条件の見直し：多数ホールか単一ホールか、および、ホールのサイズ

これらをふまえつつ、512 pixelにフォーカスして検討してみようと思う。

4月5日（月）

HuBMAP： 1,374 teams, 36 days to go

今日は、CyclicLRの1サイクルから始めてみよう。

1サイクル7エポック (up: 2epochs, down: 5 epochs): LB=0.859 (0.0255, 0.0292)

このあたりのLBスコアはもう見たくない。1サイクルのエポック数を増やしてみよう。立ち上がりも2エポックから3エポックに増やしてみよう。立ち上がりを1サイクルの30％にするのがOneCycleLRのデフォルトであることからここでもその値を用いてみよう。そうすると、立ち上がりが3エポック、下りが7エポックとなる。

1サイクル10エポック (up: 3 epochs, down: 7 epochs): LB=0.880 (0.0235, 0.0287)

ようやく、0.877(320 pixel)を超えたが、256 pixelで0.875が得られているので、512 pixelで0.880というのは、まだ何も達成していないのと同じようなものだ。

2サイクル20エポックを試してみよう。

2サイクル20エポック (up: 3 epochs, down: 7 epochs) x 2 : LB=0.870 (0.0203, 0.277)

train_loss=0.0203となっているので、overfitting状態になっている。 

この状態から、Cutout条件を適正に設定することによって、LBスコアを0.89+にもっていくことができる筈だ。と思って取り組もう。カラーやノイズについても検討しよう。

4月6日（火）

＊＊＊また、文字変換の途中でフリーズして、フォーマットがぐちゃぐちゃになった。復元ボタンを使っても、フォーマットがぐちゃぐちゃのままで、全く使えない。無意味な復元ボタン！これで、何回目かな。なにもなくても（何かあったのだろうが気付かなかったのだろう）次に文書を開くとフォーマットが崩れていることもあった。＊＊＊ 

1時間半くらい、GPUの使用計画を立てていたのだが、消えてしまった。脳の中に少し残っているので書きとめておこう。

改善の対象とするデータ：2サイクル20エポック (up: 3 epochs, down: 7 epochs) x 2 : LB=0.870 (0.0203, 0.277)

検討課題１：Cutout：hole_numとホール面積の調整：ベース：hole_num=10, hole_size=1/10(hole_area=0.01)：2サイクル20エポックに適用して、train_lossが0.022～0.023くらいで、LB=0.88+になること。

検討課題２：Cutoutのベース条件で、train_lossが0.018レベルになること。何サイクル何エポックが最適かわからない。512 pixelで条件探索するのは時間がかかる。256 pixelで基本を押さえておこう。

実験：512 pixel

１．3サイクル30エポックで、train_lossが0.02以下になるかどうかを確認する。

２．hole_num=1, hole_area=0.1(hole_size=0.316)で、2サイクル20エポック条件の計算を行う。

予備実験：256 pixel

512 pixel 3サイクル30エポックで所望の結果（train_lossが0.018以下になること）が得られるかどうかを、256 pixelで確認する。

256 pixelでは、1サイクル10エポックはなく、2サイクル20エポックはあるが、3:7ではなく5:5である。3サイクル30エポックは3:7であるが、0.1-2.0ではなく0.1-3.0である。lr=0.1-3.0では、train_lossが、10E:0.0281, 20E:0.0255, 29E:0.0243, 30E:0.0253となっていて、LB=0.857（trfm_1：弱）であった。256 pixeで参考になるデータが少ないので、1から始めることになる。計算時間は512 pixelの1/3くらいですむが、基本データをとって、条件検討をするにはそれなりの時間がかかる。

ということで、256 pixelによる予備実験はとりやめにする。

まずは、512 pixelで、3サイクル30エポックの結果を確認しようか。

2サイクルで30エポックはどうだろうか。upは3エポックのままで、downを7エポックから12エポックに増やし、15エポックで0.21くらいまで下がれば、2サイクル目で0.185くらいまで下がることを期待するか。

ということは、1サイクルで15エポックがどうなるか調べておく必要がある。

1サイクル15エポック（up:3, down:12) : (0.0208, 0.0291) : LB=0.867

train_lossが0.021より少し低い値になったので、2サイクルで0.0185くらいになることを期待してもよさそうだ。

384 pixelの画像に対して、hole_num=1, hole_area=0.1(hole_size=0.316)と、hole_num=10, hole_size=0.1 (hole_area=0.01)を用いた結果を既に出していて、どちらを適用してもLBスコアが変わらなかったので、hole_num=1の条件を強くして適用することにしよう。

論文ではhole_area=0.25で良好な結果が得られると書かれていたように思うので、これを真似てみることにして、1サイクル15エポックに適用してみた。

1サイクル15エポック＆ hole_num=1, hole_area=0.25(hole_size=0.5) : (0.0293, 0.0347) : LB=0.878

train_lossは、0.0208から0.0293まで大きくなった。これはダメかな、ホールの面積が大きすぎたので、もう少し小さくしようかなと考えていたのだが、LBスコアが出てみると、それほど悪くない。使えそうだ！これで学習量を増やしていけば、LB=0.89+になるかもしれない。

サイクルを繰り返してみた。（CyclicLRというのは同じ学習を繰り返すことだということを、今初めて実感している。）

2サイクル30エポック＆ hole_num=1, hole_area=0.25(hole_size=0.5) : (0.0271, 0.0406) : 

思っていたほど、15エポックより30エポックのtrain_lossのほうが小さくなっているので、学習を繰り返した効果があったということだが、30エポックのval_lossが大きいので、LBスコアは上がるのだろうかと、かなり心配しながら、commitしているところ。

結果は、LB=0.859でした。ホールサイズが大きすぎたようだ。次はホールサイズを少し小さくしようと思うが、GPUの残り時間が6時間半となったし、1サイクル10エポックシリーズも先に検討しておきたいことがあるので、この続きは今週の土曜日以降になる。

学習経過は、こんなふうになった。

  1│ 0.1490│ 0.1265│ 2.98
  2│ 0.0597│ 0.0598│ 2.93
  3│ 0.0500│ 0.0583│ 2.94
  4│ 0.0465│ 0.0400│ 2.95
  5│ 0.0451│ 0.0450│ 2.94
  6│ 0.0392│ 0.0489│ 2.95
  7│ 0.0383│ 0.0482│ 2.95
  8│ 0.0366│ 0.0410│ 2.94
  9│ 0.0358│ 0.0388│ 2.94
10│ 0.0329│ 0.0441│ 2.96
11│ 0.0336│ 0.0362│ 2.96
12│ 0.0314│ 0.0415│ 2.98
13│ 0.0311│ 0.0444│ 2.97
14│ 0.0308│ 0.0376│ 2.95
15│ 0.0293│ 0.0347│ 3.00 : LB=0.878
16│ 0.0289│ 0.0384│ 2.95
17│ 0.0320│ 0.0620│ 2.97
18│ 0.0354│ 0.0527│ 2.97
19│ 0.0360│ 0.0528│ 2.98
20│ 0.0339│ 0.0427│ 3.00
21│ 0.0319│ 0.0343│ 2.97　　　　　　　　　　　　　　　　　　　　　　　　　　　22│ 0.0315│ 0.0400│ 2.96
23│ 0.0332│ 0.0341│ 2.97
24│ 0.0304│ 0.0471│ 2.98
25│ 0.0301│ 0.0453│ 2.97
26│ 0.0299│ 0.0352│ 2.98
27│ 0.0302│ 0.0404│ 2.96
28│ 0.0320│ 0.0360│ 2.98
29│ 0.0283│ 0.0365│ 2.96
30│ 0.0271│ 0.0406│ 2.95 : LB=0.859

この結果から、hole_area=0.25ではなく、0.20や0.15を使えば、15エポックでは、0.880を超えることができそうである。

1サイクル15エポックは、2サイクルに用いる繰り返しの単位としては、長すぎたようだ。最適な単位エポック数はいくらだろうか。6は短すぎたようだ。7は効果的だった。それ以上は検討できていない。間をとばして10と15を試みているというところだが、upとdownの比率は3:7が良好だが、upが2エポックの場合は1サイクルが7エポックくらい、upが3エポックの場合は1サイクルが10エポックとなる。upが4エポックの場合は、1サイクルが13エポックくらいとなる。上記の1サイクル15エポックはupが3サイクルなので、upとdownの比率は2:8となる。3:7は、OneCycleLRのデフォルトということであって、CyclicLRに対してのデフォルトではない。CyclicLRのデフォルトは5:5である。CuclicLRのupとdownの比率を5:5から3:7に変更したのは、CyclicLRのチューニング中にOneCycleLRのデフォルト設定値を思い出してちょっとやってみようと思っただけである。どのような比率がベストなのかはわからない。実験して探すしかない。元に戻ると、upが3エポックでdownが12エポックの1サイクル15エポックは、単独では悪いモデルではないのかもしれない。これをそのまま繰り返して2サイクル30エポックとして動作させた場合、今回は、良いモデルではなかったということ。

schedulerに限らず、気に入らなければ自分で書き換えれば良い。最初は既製品をデフォルトで使う。慣れてくると内部パラメータの適切な組み合わせを探すようになる。さらに進むと、既製品ではできないパラメータの組み合わせを試してみたくなる。このときに、元のコードに戻って、自分で書き換えて、既製品では不可能だった動作をさせることができるようになりたいものだ。

CyclicLRで使っていないパラメータがある。これら {triangular, triangular2, exp_range}の他に、自分で関数を入力することができる。

scale_fn (function) – Custom scaling policy defined by a single argument lambda function, where 0 <= scale_fn(x) <= 1 for all x >= 0. If specified, then ‘mode’ is ignored. Default: None

次のサイトに簡単な関数例が示されている。現状でも、まだできることがある。

https://github.com/keras-team/keras-contrib/blob/master/keras_contrib/callbacks/cyclical_learning_rate.py

clr_fn = lambda x: 0.5*(1+np.sin(x*np.pi/2.))

4月7日（水）

HuBMAP： 1,397 teams, 34 days to go : me:0.880 ---> top:0.939

GPU : 6.5 h

2サイクル20エポック（train_loss=0.0203 : LB=0.870）については、3サイクル30エポックに、hole_num=1, hole_area=0.25(hole_size=0.5)、を適用する。

この予定だったが、2サイクル30エポックのLBスコア向上に失敗したので、この1サイクル10エポック系は、2サイクル20エポックで0.880を超えることを目指す。

面積率とホールサイズ：0.1≒0.316x0.316 : 0.15≒0.387x0.387 : 0.2≒0.447x0.447

Base  : 1 cycle 10 epochs : num_hole=10, hole_size=0.1 x 0.1 : LB=0.880 (0.0235, 0.0287)

Run1 : 1 cycle 10 epochs : num_hole=1, hole_size=0.387 x 0.387 : LB=0.864 (0.0271, 0.0312)

この2つは直接比較できないが、Cutoutの全ホール面積が1.5倍になったことによってunderfittingの傾向になったと考える。次に、後者の条件でサイクルを繰り返すことによって、学習が進み、underfittingが解消されることによって、スコアが上がると予想した。train_loss, val_lossともに、小さくなっているので、予想通り、学習は進んだので、LBスコアは上がる筈だと思うのだが、上がるどころか、少し下がった。

Run2 : 2 cycle 20 epochs : num_hole=1, hole_size=0.387 x 0.387 : LB=0.860 (0.0243, 0.0305)

CutoutがLBスコアの向上に寄与しなかった理由として何が考えられるだろうか。使っているCutoutのパターンは、ホールが1個と10個の場合の2種類である。Cutoutのオリジナル論文は、ホールが1個、HuBMAPのコンペで自分が見た使用例は、ホールが10個、であり、そのことについてのコメントや注釈は見当たらなかった。ということから、これは、比較評価することが必要である。気になっていたのだが、1個のホールの方が良いと思い込んでいたかもしれない。ということで、予想通りのスコアが得られなかった原因として、Cutoutのパターンの選択が課題に対して適切でなかったということが考えられる。

1サイクル15エポック＆ hole_num=1, hole_area=0.25(hole_size=0.5) : (0.0293, 0.0347) : LB=0.878

この結果に対して、hole_area=0.20や0.15にすれば、LBスコアは0.880を超える筈だと書いた。これを確かめよう。

1サイクル15エポック＆ hole_num=1, hole_area=0.20(hole_size=0.447) : (0.0270, 0.0335) : LB=0.880

わずかに改善したが、超えられなかった。

上に書いたように（もっと前にも書いたような気がする）ホールが1個の場合と10個の場合の比較をする必要がある。もっといえば、適切なホールの個数と面積の組み合わせを探す必要がある。実験結果に基づかないことを根拠や指標にしていることがある（多い）ように思うので注意しよう。

予測性能を上げるために必要なことが何であるのか、正しく理解できていない。道具の使い方を間違っているのかもしれない。適用範囲を逸脱した領域で使っているのかもしれない。わからないことがたくさんある。何がわかっていないのかもわからない。

同一視野の画像の画素数による違い：EfficientNetB2-Unet, CyclicLR(SGD), lr=0.1-2.0, up 3 epochs, down 7 epochs, BCE, trfm_4

512 pixel

  1│ 0.1387│ 0.0823│ 3.16
  2│ 0.0468│ 0.0521│ 3.15
  3│ 0.0382│ 0.0438│ 3.14
  4│ 0.0372│ 0.0404│ 3.11
  5│ 0.0335│ 0.0374│ 3.11
  6│ 0.0297│ 0.0319│ 3.12
  7│ 0.0270│ 0.0352│ 3.12
  8│ 0.0259│ 0.0317│ 3.12
  9│ 0.0248│ 0.0291│ 3.14
10│ 0.0235│ 0.0287│ 3.12 : LB=0.880

256 pixel

  1│ 0.1422│ 0.0888│ 1.14
  2│ 0.0595│ 0.0557│ 1.13
  3│ 0.0519│ 0.1444│ 1.13
  4│ 0.0484│ 0.0510│ 1.12
  5│ 0.0414│ 0.0405│ 1.12
  6│ 0.0396│ 0.0499│ 1.12
  7│ 0.0372│ 0.0422│ 1.12
  8│ 0.0350│ 0.0343│ 1.12
  9│ 0.0315│ 0.0334│ 1.12
10│ 0.0308│ 0.0299│ 1.11 : LB=0.869

OneCycleLRを使っていた頃とはaugmentationの条件がかなり異なっている可能性が高いので、OneCycleLRについても再度計算（性能確認）する必要があるように思う。

4月8日（木）

HuBMAP：1,405 teams, 33 days to go

 256 pixel, batch_size=24, CyclicLR(SGD, 0.1-2.0, 3:7, 298:696), trfm_4, v50

  1│ 0.1572│ 0.0902│ 1.10
  2│ 0.0589│ 0.0579│ 1.08
  3│ 0.0475│ 0.0444│ 1.08
  4│ 0.0437│ 0.0397│ 1.08
  5│ 0.0393│ 0.0433│ 1.08
  6│ 0.0368│ 0.0418│ 1.08
  7│ 0.0344│ 0.0319│ 1.08
  8│ 0.0331│ 0.0322│ 1.08
  9│ 0.0302│ 0.0309│ 1.08
10│ 0.0295│ 0.0311│ 1.08　　　　　　　　　　　　　　　　　　　　　　　　　　　11│ 0.0290│ 0.0339│ 1.08
12│ 0.0295│ 0.0361│ 1.08
13│ 0.0309│ 0.0383│ 1.07
14│ 0.0327│ 0.0366│ 1.07
15│ 0.0318│ 0.0392│ 1.07
16│ 0.0303│ 0.0320│ 1.08
17│ 0.0298│ 0.0370│ 1.08
18│ 0.0285│ 0.0318│ 1.08
19│ 0.0269│ 0.0344│ 1.08
20│ 0.0255│ 0.0333│ 1.08 : LB=0.867

3サイクル20エポックで、batch_size=16-->24を検討するつもりだったが、ステップサイズを変更するのを忘れたために、当初の実験目的を外れたもの。

上に示した256 pixelの条件とbatch_size以外は全く同じで、1サイクル10エポック、を繰り返したものになっている。

1サイクル10エポックでは、バッチサイズを16から24に増やすことで、学習は少し効率よく進んだようにみえる。LBスコアへの影響を後日調べてみる。

EarlyStopping：

迷路に迷い込んでいるような気がしている。学習率は低減させていくのが常識だったし、train_lossとval_lossの動きを見ていて、両者が大きく乖離しないことと、val_lossが反転しない事の両方を満たすところで学習を停止するのが常識だったと思うのだが、OneCycleLRやCyclicLRはこれまで見たことが無いような変化をするので、惑わされてしまったように思う。OneCycleLRもCyclicLRも、設定しておいた最終エポックで良好な結果が得られるものだと思い込んでしまっていたように思う。

その流れで、512 pixel、20エポック3サイクル、学習率0.1-2.0で20エポックでのtrain_lossが0.0202になったのを見て、ここから、augmentationの条件を適切に調整することができさえすれば、スコアは上がっていくものと思い込んでしまった。

このことに気がついたからと言って、スコアが上がるわけではない。地道に、トライアンドエラー、系統的な実験、先人に学ぶ、ということを繰り返していく・・・。

EarlyStoppingの考え方に近い/関連性があるのは、サイクル数の繰り返しを減らす、最終エポック数を設定エポック数の少し手前に設定する、トータルエポック数を減らす、小さなモデル(今使っているモデルだと小さなEncoder）を用いる、画像の解像度を下げる、などであるから、結局はそれらの間のバランスをとりながら、LBスコアが最大になる組み合わせを探索し、アンサンブルやTTAを適切に組み合わせるということになるのだろう。言うは易し、行うは難し・・・。

LB=0.925のモデル（inferenceはコンペサイトのnotebook(code)、trainはGitHub）が公開されているので、そのあたりのスコアを望むだけなら真似すれば良いだけだが（とはいえ、口で言うほど簡単ではないが）、自分としては、今のやり方でスコアアップを目指すことが自分には必要だと思っている。すでに、その公開コードからエッセンスの一部を拝借しながら進めているので大きなことは言えないが、それでも、直接真似るのと、実験しながら進めるのとでは大きな違いがあると思っている。

4月10日（土）から4月15日（木）までの6日間の実験計画を立てよう！

目を閉じると、シナプスが活動しているのが見えるような気がする。そろそろ、良いアイデアが浮かんでもよさそうなものだが、浮かんでこないということは、努力が足りていないということなのだろう。集中力が足りないのか。深く考えるために必要な演算能力と記憶能力が不足しているのだろうか。記憶したものが片っ端から消去されているような気がする。

明日は、4月15日までに、LB=0.880 ---> 0.900、となることを目指して、実験計画を立てよう。0.900 - 0.880 = 0.001 x 20 : 0.001の改善を20回繰り返せば0.900に到達！

＊overfitting条件にしてから、augmentationを強めてjust-fittingにもっていこうとしていて条件探しの途中だが、min_lrとmax_lrの組み合わせ、1サイクルのエポック数、サイクル数、up_epochとdown_epochの組み合わせ、encoder、バッチサイズ、画素数なども並行して検討する必要がある。

限られた時間と資源の中で、効果的に実験する方法を考えよう。

教師データの量と質：バッチサイズ：モデル：損失関数：最適化関数：学習率スケジューラー

OneCycleLRから始めて、CyclicLRに移り、サイクル数や最大学習率、upとdownの比率などパラメータが多くて最適化はうまくいかず、最近の512 pixelの画像を使った実験では、CyclicLRを使いながら、11回の計算のうち、3回が2サイクルで8回は1サイクルであった。こうなった理由は、256 pixelの画像を使った場合よりも収束が速く、サイクルを繰り返すことによってlossを小さくする必要がなかったことにある。2回目に試みた1サイクル10エポックでLB=0.880になったが、それ以降はこれを超えることができていない。GPUを使った最後のテストは、512 pixelで0.88を得た1サイクル10エポックを256 pixelに適用することで、LB=0.869となった。1サイクルで十分ならば、OnsCycleLRがある。明日からのGPUマシンタイムは、OneCycleLRに集中するか1サイクルとの併用で進めようと思う。

バッチサイズの影響は、条件設定ミスで調べることができなかったので、優先度を上げて実施する。

Cutoutは、10ホールと1ホールの比較が不十分で、その中間状態（3ホールとか5ホール）については、全く調べることができていない。

256 pixelと512 pixelの間（320, 384, 448 pixelなど）はCutoutの条件設定ミスを含んだ結果があるだけで、0.877となった320 pixelすら、フォローできていない。これら中間的な解像度で良い結果が得られる可能性は高いと思うので、順に結果を出していく。

Encoderは、EfficientNetB2に固定して進めているが、underfittingになればB3やB4を試し、overfittingになればB1やB0を試すなど、最適な組み合わせを探っていく。

Decoderは、2月頃はFPNが良さそうであったが、3月末に調べたときには、FPNは収束が悪く、LinknetとMAnetは使えそうであったが、Unetに優るような感じはしなかった。

損失関数は、BCEから始めてDiceに落ち着きそうだったが、ある条件でDiceLossでは収束が遅くなったときにBCEで良好な結果が得られてからBCE単独で進めている。他の損失関数との組み合わせもどこかのタイミングで試してみたいと思っている。今回のマシンタイムに組み込もう。

4月10日（土）の予定

最初に、OneCycleLRの10エポックと20エポックの性能を評価し、CyclicLRで得られている結果と比較する。

Run1&2 : 256 pixelのスコアLB=0.875を、OneCycleLR（Adam）とOneCycleLR（SGD）で再現できるかどうかを調べる。CyclicLR（SGD）は3サイクル20エポックなので、20エポックで試す。

Run3&4 : 256 pixelのスコアLB=0.869を、OneCycleLR（Adam）とOneCycleLR（SGD）で再現できるかどうかを調べる。CyclicLR（SGD）は1サイクル10エポックなので、10エポックで試す。

4月11日（日）の予定：

256 pixelの画像を用いて、3サイクル20エポックで、LB=0.875を得ていたモデルとパラメータを用いて、1サイクルｎエポックで同等のLBスコアが得られる条件を見出す。

CyclicLRによる1サイクル10エポックでは、LB=0.869が得られているので、エポック数を増やすだけで0.875に近い値が得られるのではないかと思っている。このときに、4月10日に検討したOneCycleLRの方が優れていれば、OneCycleLRを用いて、エポック数の最適な値を探すことになる。

4月12日（月）の予定：

Cutoutの1ホールと3ホールと10ホールのトータル面積を等しくしてその効果の比較を行う。面積率は0.10とする。

4月13日（火）の予定：

バッチ数の効果を調べる。これまでの16をベースとして、24と32について調べる。

4月14日（水）の予定：

画素数の効果を調べる。256, 320, 384, 448, 512とし、256 pixelでの最大スコアが得られている条件をベースとして、画素数が増えるごとに、1エポックづつエポック数を減らして計算する。

たとえば、512 pixelでは、10エポックで0.880が得られているので、これをスタートラインとするならば、448 pixelでは11エポック、384 pixelでは12エポック、320 pixelでは13エポック、256 pixelでは14エポック、のように画像解像度が低いほどエポック数を増やす。

ただし、512 pixelありきで考えるよりは、256 pixelの方から積み上げていく方が、最終スコアは上がるのではないかと思っている。 

4月15日（木）の予定：

損失関数の検討。upとdownの割合、max_lr、

＜CPUを用いた予備検討＞

CPUを用い、同一条件で、ResNet34と EfficientNetB0の学習結果を比較してみる。

model = smp.Unet('resnet34', encoder_weights='imagenet', classes=1), batch_size=16, CyclicLR(SGD), lr=0.1-2.0, up=3 epochs, down=7 epochs

  1│ 0.1392│ 0.1253│ 25.53
  2│ 0.0850│ 0.5311│ 25.57
  3│ 0.1121│ 0.0932│ 25.49
  4│ 0.0781│ 0.0548│ 25.21
  5│ 0.0607│ 0.0632│ 25.28
  6│ 0.0568│ 0.0721│ 25.40
  7│ 0.0501│ 0.0496│ 25.34
  8│ 0.0479│ 0.0408│ 25.31
  9│ 0.0426│ 0.0397│ 25.25
10│ 0.0405│ 0.0372│ 25.37

model = smp.Unet('efficientnet-b0', encoder_weights='imagenet', classes=1), CyclicLR(SGD), lr=0.1-2.0, batch_size=16, up=3 epochs, down=7 epochs
  1│ 0.1533│ 0.1128│ 20.32                                                                                                      2│ 0.0657│ 0.3048│ 20.44
  3│ 0.0649│ 0.0624│ 20.31
  4│ 0.0587│ 0.0810│ 20.21
  5│ 0.0490│ 0.0474│ 20.67
  6│ 0.0444│ 0.0669│ 20.60
  7│ 0.0430│ 0.0385│ 20.67
  8│ 0.0381│ 0.0359│ 20.63
  9│ 0.0358│ 0.0337│ 20.44
10│ 0.0333│ 0.0360│ 20.44

以上の2つの結果は、resnet34とEfficientNetB0との違いを示すものである。これらのモデルで予測した結果がどうなるかまでは調べていないので安易な評価をしてはいけないかもしれないが、train_loss, val\lossともにEfficientNetB0の方が小さくなっているので、後者の方が速く収束しているとみてもよいのだろうと思う。

次に、model = smp.Unet('efficientnet-b0', encoder_weights='imagenet', classes=1)に対して、OneCycleLR(SGD, max_lr=2, epochs=10)を適用してみる。

  1│ 0.1547│ 0.0819│ 21.97
  2│ 0.0648│ 0.6287│ 21.18
  3│ 0.0905│ 0.1146│ 21.12
  4│ 0.0600│ 0.0506│ 21.11
  5│ 0.0493│ 0.0416│ 21.15
  6│ 0.0458│ 0.0681│ 21.23
  7│ 0.0418│ 0.0395│ 21.25
  8│ 0.0388│ 0.0364│ 21.19
  9│ 0.0355│ 0.0330│ 21.24
10│ 0.0334│ 0.0337│ 21.48

CyclicLRの1サイクルとOneCycleLRとで見た目には大差ない結果となっているように見える。同じ最適化関数とmax_lrを用いているが、異なるところは、学習率lrの変化が、CyclicLRが三角波であるのに対して、OneCycleLRはコサイン関数（三角波を選ぶこともできる）となっていることである。さらに、OneCycleLRでは、学習率lrの初期値と最終値を別々に指定することができる。デフォルトではlrの最終値はlrの初期値（デフォルトではmax_lrの1/25）より4桁小さい。

GPUが使えるようになれば、予測結果をsubmitしてLBスコアを比較する予定である。

最後に、model = smp.Unet('efficientnet-b0', encoder_weights='imagenet', classes=1)に対して、AdamWを最適化関数に用いた、OneCycleLR(AdamW, max_lr=1e-3, epochs=10)を試してみよう。これは、CyclicLRを使う前に、1か月以上使っていたものである。

  1│ 0.4280│ 0.1768│ 24.61
  2│ 0.1092│ 0.0692│ 24.71
  3│ 0.0607│ 0.0490│ 25.10
  4│ 0.0479│ 0.0434│ 25.04
  5│ 0.0439│ 0.0369│ 24.94
  6│ 0.0403│ 0.0374│ 24.98
  7│ 0.0371│ 0.0331│ 25.30
  8│ 0.0348│ 0.0341│ 25.21
  9│ 0.0327│ 0.0351│ 25.25
10│ 0.0320│ 0.0341│ 25.23

id predicted
0 aa05346ff 15325 185 46045 185 76764 187 107482 189 13820...
1 2ec3f1bb9 60690327 20 60714307 41 60738287 56 60762271 6...
2 3589adb90 68511797 12 68541223 56 68570651 65 68600081 7...
3 d488c759a 62493304 1 62539963 4 62586623 5 62633282 6 62...
4 57512b7f1 217865569 2 217898801 14 217898952 3 217932039...

4月10日（土）～4月16日（金）

GPU : 40 h

目標：LB=0.880 ---> LB=0.900

手段：256 pixelのLB=0.875から、augmentation, batch_size, loss_fn, optimizer, learning_scheduler, pixel_size, encoder-decoder,などの最適化

4月10日（土）

GPU : 40 h

HuBMAP：1,421 teams, 31 days to go : top LB score 0.943

今日は、OneCycleLRを用いて、256 pixelの自己記録LB=0.875を超えることを目指す。

CyclicLR(SGD, 0.1-2.0)の、1サイクル10エポックでLB=0.869、3サイクル20エポックでLB=0.875が得られている。

さて、このような状況で、本日最初の一手をどう指せばよいだろうか。これまでの248回のsubmissionデータを完璧な機械学習モデルに入力し学習させたら、どのような出力が出てくるだろうか。「入力データの質が悪すぎて予測不可能」と出力されそう。

5月10日のLBスコアの予測なら、簡単に答えが出てきそうだ。そんなのは、方眼紙にプロットすればすぐ出てくる。

2月22日（月）：0.836（EfficientNetB5-Unet,scse, DiceLoss, OneCycleLR(Adam, max_lr=1e-3, 30 epochs）

3月20日（土）：0.850（EfficientNetB2-Unet, BCELoss, OneCycleLR(Adam, max_lr=1e-3, 20 epochs, : train_loss= 0.0219, val_loss=0.0356)：更新データ8件使用

同日：0.865 更新データ10件使用（データ更新によりtrain_dataは8件から15件に増えたがメモリーの制約により今と同じ10件のみ使用）: (train_loss=0.0238, val_loss=0.0311)

3月24日（水）：0.875, Cutout

3月28日（日）：0.877, 320 pixel

4月5日（月）：0.880, 512 pixel

5月10日（月）：0.95？？？：妄想による予測結果

OneCycleLR：

Adam or SGD

max_lr：Adamなら1e-3, SGDなら2.0

up/(up+down)：デフォルトは0.3

エポック数 10：CyclicLRの1サイクル10エポック(v12)との比較、及び、baselineとして

その他：encoder-decoder, pixel_size, batch_size, loss_fn, augmentation,

b2-Unet, 256 pixel, batch_size=16, BCELoss, Cutout 10, 10%

1サイクル10エポックLB=0.869のlossは、(0.0308, 0.0299)であったのに対し、OneCycleLR(SGD, max_lr=2.0, epochs=10)では、(0.0310, 0.0315)であった。

結果：LB=0.866（-0.003となった）：0.869より少し低いが、CyclicLR(SGD)との比較ということでは、これで十分である。

次のターゲットは、3サイクル20エポックで得られたLB=0.875である。これには、エポック数を増やすことが必要だが、どこから始めようか。

それとも、エポック数10で、バッチ数の効果を先に調べておくか。

batch_size=16 : train_loss=0.0310, val_loss=0.0315 : LB=0.866

batch_size=24 : train_loss=0.0283, val_loss=0.0302 : LB=0.868

batch_size=32 : train_loss=0.0311, val_loss=0.0328 : commit, submitせず

batch_sizeを24に増やすと収束が良くなり、LBスコアも少し上がったが、32に増やすと収束が悪くなった。batch_sizeを大きくすると、GPUメモリー占有量が増えて、大きな画素数の画像が扱えなくなることも加味して、batch_sizeは、16を継続する。

さて、エポック数をどうしようか。

15エポックと20エポックは、計算しておく必要がありそうだ。

OneCycleLR(SGD)のエポック数を増やすだけではなく、max_lrやupとdownの比率などの調整が必要になるかもしれない。

次の2つの場合について実験する：まずは、LB=0.869を越えないと。

OneCycleLR(SGD, max_lr=2.0, epochs=15) : loss (0.0273, 0.0308) : LB=0.858

予測結果が、これまでと違っていて心配だ。LB=0.858となり、悪い予想が的中した。

10エポックの結果はこうなっていた。

OneCycleLR(SGD, max_lr=2.0, epochs=10, pct_start=0.3) : loss (0.0310, 0.0315) : LB=0.866

train_lossとval_lossの値は、常識的には、15エポックの方が、かなり優れている。にもかかわらず、10エポックよりもLBスコアが悪い。

こうなると、次に20エポックを試してもだめだろう。

15エポックの方が悪くなる原因として考えられるのは、15エポックの中身で、upが3割だから、内部では、upが4.5エポック、downが10.5エポックとなっている。10エポックのときは、upが3エポックで、downが7エポックである。10エポックと15エポックの本質的な違いは、学習率の変化率である、10エポックの場合は、3エポックで最大学習率2.0に達するが、15エポックでは、4.5エポックで最大学習率に達する。この違いが、Super-Convergenceの効果に大きな違いを生じている可能性がある。

とりあえず、15エポックの場合に、3エポックで学習率が最大になるように、pct_startを0.3から0.2に変更してみる。そうするとupが3エポックで、downが12エポックとなる。

OneCycleLRも、CyclicLRも性能を発揮するための条件は、Super-Convergenceなので、それを満たす条件から外れると、通常の学習率の制御方法を用いた場合よりも、非常に悪い結果しか得られないということになるのではないかと思う。

ということは、train_lossとval_lossの組み合わせに対して、従来の常識に従って判断すると、良い結果を見逃し、悪い結果に固執してしまうことにもなりかねない。

自分が落ち込んでいた罠の正体の何割かは、これによるものではないだろうか。

非常に気になったので、"super convergence deep learning" で検索したら、Super-Convergenceを理論的に解明した（らしい）論文があった。

Super-Convergence with an Unstable Learning Rate
Samet Oymak∗, arXiv:2102.10734v1 [cs.LG] 22 Feb 2021
Abstract
Conventional wisdom dictates that learning rate should be in the stable regime so that gradient-based algorithms don’t blow up. This note introduces a simple scenario where an unstable learning rate scheme leads to a super fast convergence, with the convergence rate depending only logarithmically on the condition number of the problem. Our scheme uses a Cyclical Learning Rate where we periodically take one large unstable step and several small stable steps to compensate for the instability. These findings also help explain the empirical observations of [Smith and Topin, 2019] where they claim CLR with a large maximum learning rate leads to “super-convergence”. We prove that our scheme excels in the problems where Hessian exhibits a bimodal spectrum and the eigenvalues can be grouped into two clusters (small and large). The unstable step is the key to enabling fast convergence over the small eigen-spectrum.

　従来の通念では、勾配ベースのアルゴリズムが爆発しないように、学習率は安定した状態にある必要があります。 このノートでは、不安定な学習率スキームが超高速収束につながる単純なシナリオを紹介します。収束率は、問題の条件数に対数的にのみ依存します。 私たちのスキームは、不安定性を補うために、定期的に1つの大きな不安定なステップといくつかの小さな安定したステップを実行する循環学習率を使用します。 これらの調査結果は、[Smith and Topin、2019]の経験的観察を説明するのにも役立ちます。ここでは、最大学習率が高いCLRが「超収束」につながると主張しています。 私たちのスキームは、ヘッセ行列が二峰性スペクトルを示し、固有値を2つのクラスター（小さいものと大きいもの）にグループ化できる問題に優れていることを証明します。 不安定なステップは、小さな固有スペクトルでの高速収束を可能にするための鍵です。（Google翻訳）

原理がわかっても、答えはわからない。個々の条件/状況によって実際に適用するときの数値は異なる。 

15エポックの場合に、3エポックで学習率が最大になるように、pct_startを0.3から0.2に変更してみた。（upが3エポックで、downが12エポック）

OneCycleLR(SGD, max_lr=2.0, epochs=15, pct_start=0.2) : loss (0.0272, 0.0320) : LB=0.865

最後に、12エポックを試しておく。pct_start=0.25としておけば、3エポックで学習率が最大になる。

OneCycleLR(SGD, max_lr=2.0, epochs=12, pct_start=0.25) : loss (0.0289, 0.0325) : LB=0.866

得られた結果を並べてみよう。3エポックまでは、全く同じであることがわかる。

OneCycleLR(SGD, max_lr=2., epochs=10, pct_start=0.3) : loss (0.0310, 0.0315) : LB=0.866

  1│ 0.1526│ 0.2327│ 1.12
  2│ 0.0623│ 0.0656│ 1.10
  3│ 0.0517│ 0.0459│ 1.11
  4│ 0.0494│ 0.0451│ 1.10
  5│ 0.0426│ 0.0481│ 1.10
  6│ 0.0418│ 0.0406│ 1.11
  7│ 0.0369│ 0.0373│ 1.11
  8│ 0.0359│ 0.0387│ 1.10
  9│ 0.0320│ 0.0339│ 1.11
10│ 0.0310│ 0.0315│ 1.10

OneCycleLR(SGD, max_lr=2., epochs=12, pct_start=0.25) : loss (0.0289, 0.0325) : LB=0.866

  1│ 0.1526│ 0.2327│ 1.14
  2│ 0.0623│ 0.0656│ 1.11
  3│ 0.0517│ 0.0459│ 1.12
  4│ 0.0494│ 0.0452│ 1.12
  5│ 0.0430│ 0.0498│ 1.13
  6│ 0.0417│ 0.0451│ 1.12
  7│ 0.0374│ 0.0395│ 1.12
  8│ 0.0373│ 0.0427│ 1.12
  9│ 0.0334│ 0.0355│ 1.12
10│ 0.0320│ 0.0330│ 1.12
11│ 0.0299│ 0.0332│ 1.11
12│ 0.0289│ 0.0325│ 1.11

OneCycleLR(SGD, max_lr=2., epochs=15, pct_start=0.2) : loss (0.0272, 0.0320) : LB=0.865

  1│ 0.1526│ 0.2327│ 1.13
  2│ 0.0623│ 0.0656│ 1.11
  3│ 0.0517│ 0.0459│ 1.11
  4│ 0.0495│ 0.0452│ 1.11
  5│ 0.0430│ 0.0549│ 1.10
  6│ 0.0426│ 0.0649│ 1.11
  7│ 0.0397│ 0.0424│ 1.12
  8│ 0.0386│ 0.0389│ 1.12
  9│ 0.0345│ 0.0354│ 1.11
10│ 0.0330│ 0.0335│ 1.11
11│ 0.0315│ 0.0330│ 1.12
12│ 0.0301│ 0.0373│ 1.11
13│ 0.0284│ 0.0322│ 1.11
14│ 0.0275│ 0.0352│ 1.11
15│ 0.0272│ 0.0320│ 1.10

明日は、3エポックで学習率が最大になる条件で、最大学習率を極限まで上げてみよう。CyclicLRを使っているときに、最大学習率が大きすぎると、lossが一旦大きくなって下がった後、収束しなくなるので、そうならない最大の値に近い値に設定して、LBスコアがどうなるかを調べてみよう。

256 pixelでLB=0.875となった、3サイクル20エポックの場合は、2エポックで最大学習率が2.0となる条件であった。

512 pixelでLB=0.880となった1サイクル10エポックの場合は、3エポックで最大学習率が2.0となる条件であった。

画素数によってもSuper-Convergenceの条件は異なるかもしれない。EfficientNetのB番号によってもSC条件は異なるかもしれない。FPNが収束しなかったのもSC条件が合わなかったことによるのかもしれない。

4月11日（日）

HuBMAP：1,429 teams, 30 days to go

エポック数10、12、15、は、それぞれ、up=3, down=7、up=3, down=9、up=3, down=12であった。これらの立ち上がりエポック数を2にして、立下りをup=3の場合と同じにすると、それぞれ、up=2, down=7、up=2, down=9、up=2, down=12となる。そうするためには、若干誤差を含むが、pct_startを、それぞれ、0.222、0.182、0.143とすればよい。以下の3通りの条件で計算してみよう。

OneCycleLR(SGD, max_lr=2., epochs=9, pct_start=0.222) : LB=0.861

OneCycleLR(SGD, max_lr=2., epochs=11, pct_start=0.182)

OneCycleLR(SGD, max_lr=2., epochs=14, pct_start=0.143) 

OneCycleLRは、デフォルトのコサインモード（anneal_strategy='cos'）にしているが、CyclicLRは、"triangle"すなわち線形モード（anneal_strategy='linear'）であった。

OneCycleLRでは、両方のモードが使えるので、その比較をやってみよう。

OneCycleLR(SGD, max_lr=2., epochs=9, pct_start=0.222, anneal_strategy='linear') : LB=0.863

OneCycleLR(SGD, max_lr=3., epochs=9, pct_start=0.222, anneal_strategy='linear') : 

max_lr=3と大きくしたことで、lossは(0.0608, 0.0494)までしか下がらなかったので、エポック数を増やしてみる。CyclicLRなら、downのエポックを増やすか、もう1サイクル追加すればlossはさらに下がるのだが、OneCycleLRでは、downのエポック数を増やすという選択肢だけである。

OneCycleLR(SGD, max_lr=3., epochs=14, pct_start=0.143, anneal_strategy='linear') :

2エポック目まで同じ条件のはずだが、2エポック目でlossが数桁大きくなり、収束しなくなった。

OneCycleLR(SGD, max_lr=3., epochs=14, pct_start=0.214, anneal_strategy='linear')

upを3エポックにしてみた。こういうことをしていると、もう、OneCycleLRを使う意味がないという気がしてきた。LB=0.856だった。コサインアニールに戻そう。

OneCycleLR(SGD, max_lr=3., epochs=14, pct_start=0.214, anneal_strategy='cos')

LB=0.857だった。低空飛行が続いています。

比較のために、1か月前のOneCycleLRのデフォルトを試して、OneCycleLRを終わろう。

OneCycleLR(AdamW, max_lr=1e-3., epochs=14) : LB=0.867

0.85+～0.86+をウロウロしていただけ！

OneCycleLRよりもCyclicLRの方が良さそうだ。上にも示した、次の論文に従って、CyclicLRに戻ろうか。 

Super-Convergence with an Unstable Learning Rate
Samet Oymak∗, arXiv:2102.10734v1 [cs.LG] 22 Feb 2021

Our scheme uses a Cyclical Learning Rate where we periodically take one large unstable step and several small stable steps to compensate for the instability.

one large unstable step and several small stable steps

256 pixel, 1サイクル10エポック、0.1-2.0, up=3, down=7, trfm_4, B2-Unet

  1│ 0.1422│ 0.0888│ 1.15
  2│ 0.0595│ 0.0557│ 1.13
  3│ 0.0519│ 0.1444│ 1.14
  4│ 0.0484│ 0.0510│ 1.12
  5│ 0.0414│ 0.0405│ 1.13
  6│ 0.0396│ 0.0499│ 1.13
  7│ 0.0372│ 0.0422│ 1.13
  8│ 0.0350│ 0.0343│ 1.13
  9│ 0.0315│ 0.0334│ 1.13
10│ 0.0308│ 0.0299│ 1.12 : LB=0.869

このデータもって、CyclicLRの再出発としよう。256 pixelで、LB=0.875を超えよう。

4月12日（月）

HuBMAP：1,435 teams, 29 days to go

SGDはCyclicLRではnesterov=Trueとして用いてきたが、これをFalseにしてみた。結果は、LB=0.867(v1)であった。Trueの場合のLB=0.869と大差なかった。以後もnesterov=Trueにしておこう。

max_lrを0.25に上げてみよう。結果は、LB=0.856(v2)となった。upが3エポック、downが7エポックで、変えていないのだが、lossがいったん下がってから上昇したときの最大値が4エポック目で、5エポック目もlossの下がりが少なく、最後の10エポックでもlossは十分下がらなかった（0.322, 0.314）。

次は、max_lrを1.5に下げてみよう。結果は、LB=0.865(v3)となった（0.0302, 0.0309）。

極大は、max_lr=2.0と1.5の間のようだ。

max_lrをどこまで上げられるかを調べることの方が重要なので、max_lr=3.0にしてみよう。3エポック目にval_lossが0.4を超えたが、10エポック目には（0.0315, 0.0302）となり、LB=0.867(v4)となった。max_lr=2.5でLB=0.856となったので駄目だろうなと思ったのだが、予想外の結果となった。

それではと、max_lyを5.0にしてみとところ、val_lossが1.0を超え、train_lossもval_lossも0.28くらいから下がらなくなった。これはダメのようだ。

max_lr=4.0を試すことにした。val\lossが3エポック目に0.5以上、5エポック目に0.3以上となってどうなることかと思ったが、10エポック目には（0.0316, 0.0311）となり、LB=0.861(v5)となった。

今日はここまで。

次はこれらを2サイクルにしてみよう。2サイクルにしてoverfittingするようであれば、downのエポック数を減らしてみよう。(up:3, down:7) x 2 --> (up:3, down:6) x 2 --> (up:3, down:5) x 2  

その前に、1エポックのままで、かつ、upは3エポックのままで、downを増やしてみようと思う、その理由は、max_lrが、2, 2.5, 3, 4のいずれの場合も、最終エポックの10エポック目で、trsin_lossよりもval_lossが大きいからである。

style=164 iterations=500

style=164 iterations=50

style=164 iterations=5

Kaggle散歩（February 2021）

Kaggle散歩（February 2021）

HuBMAPコンペは3月26日が最終日。（日本時間：3月27日午前9時00分）

2月3日追記：最終日は新規データが追加されてから2か月後とのこと、現時点で新規データは追加されていないため、4月2日以降になることは確実。

2月24日追記：データの更新はまだのようだ。最終日はデータ更新から2か月後との方針に変わりなければ、最終日は4月末。

2月1日（月）

HuBMAP：

昨日、efficientnet-UnetのB5, B6, B7, B8について、同一条件で計算した結果、LBスコアは、B5: 0.831, B6: 0.831, B7: 0.829, B8: 0.809となった。efficientnet-Unetを用いている公開コードでは、B4またはB5がベスト、となっているようである。スコアの大小関係は、画像サイズやaugmentationの複雑さなどによって変わる可能性があるので、いまは、どれがよいとはいえない。最終的には、public_LBではなく、private_LBだということも頭に入れておかないといけない。

DiceLoss, LovaszLoss, JaccardLoss, FocalLossなどを使って計算し、BCEWithLogitsLossとの比較を行ったところ、LBスコアは次のようになった。

BCE: 0.829, DiceLoss: 0.794, LovaszLoss: 0.830, JaccardLoss: 0.832, FocalLoss: 0.833

DiceLossのみ、他と少し違っている。なぜだろう。

明日は、segmentation modelの比較をやってみよう。

GPUの残り時間が7時間程度になったので、encoderを中くらいのefficientnetB4にして、Unet、Unet++, MAnet, Linknet, FPNなどのモデルの計算をしてみよう。

2月2日（火）

HuBMAP：

efficientnetB4をEncoderにして、Unet, Unet++, MAnet, FPNのモデルについて計算したところ、LBスコアは、次のようになった。

Unet: 0.832, Unet++: 0.823, FPN: 0.830, MAnet: 0.825

もっと違った結果を予想（期待）していたのだが、どんぐりの背比べといったところか。

各モデルのパラメータは、ほぼ、デフォルトのままで、最適化していないので、今は動作確認しているだけ、ということにしておこう。

そんなことを言っている場合ではないかもしれない。

今日はBCELossを使ったのだが、この課題のmetricsはmean Dice coefficientなのだから、DiceLossを使ったほうが良かったのかもしれない。

しかし、それで違いが現れるかどうか、期待しているような結果が得られるかどうかはわからない。

さて、GPUの割当時間の残りが3時間くらいになったので、明日から3日間は、機能アップのためのコードを探して組み込もう。

Loss関数の組み合わせ（BCEとDice）は今日組み込んだ。

DiceLossとLovaszLoss, JaccardLoss, FocalLossなどとの組み合わせもテストできるように組み込んでおこう。

あとは、TTA、pseudo labelの作成と訓練、モデルのアンサンブルなどが課題となる。

最新のDiscussionから２つのことがわかった。１つは、データの更新が遅れていること（1月中旬の予定だった）で、２つめは、データ更新の2か月後が締め切りとなる予定とのことだから、締め切りは4月になりそうだということ。

Kaggleスタッフからの1か月前の情報だが、20個のデータが全て公開され、新たに10個のprivate_dataが追加されるとのことなので、訓練に使えるデータが増えることになる。これは、正確さ向上に役立つのだが、増えたデータを有効に使いこなす能力が問われることになり、使える計算資源が限られる者にはハンディーとなる可能性がある。しかしながら、計算資源は同じはずなのに、次元の違う結果を出す人もいる。どのコンペだったか忘れたがデータ量が多くて扱えないと悲鳴があがっていたとき、高速処理ができるパッケージやモジュールやツールが紹介されていた。コンペではあらゆる能力が試されている。不可能を可能にする能力が求められている。

2月3日（水）

HuBMAP：

今日はLossの組み合わせと、TTAを実現しよう。

Effb4-Unetについて、BCEとDiceとLovaszとJaccardとFocalを等分に混合したLossを適用してみた。その結果、BCE単独のLBが0.832であったのに対し、0.827となった。結果はともかく、動作しているようだ。

中身がわからないままではだめなので、Lossについて学ぼう。

FocalLoss：Focal Loss for Dense Object Detection
Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Doll´ar

これが、FocalLossのパラメータ、alphaとgammaだろうと思う。

違うかもしれないな。

昨日「この課題のmetricsはmean Dice coefficientなのだから、DiceLossを使ったほうが良かったのかもしれない。」と書いたが、そうだろうか。

Google Scholarで検索した結果では、多くの場合、Dice lossのシンプルな定義を示した後、様々なオプションを付加したり、BCEなど他のLossと組み合わせている。segmentation modelsに含まれているDicelossは最もシンプルなタイプなので、Eff-Unetに対してLoss functionを比較したときにDice lossだけが少し低いLB値（0.794他の4種類は0.830~0.833）になったのは、種々の論文が示唆していることと整合している。

＊文献で良い結果を出しているLoss functionのパラメータとモデルの組み合わせを試してみたが、ダメだった。LB=0.833を超えると予想していたら、0.810だった。UnetとUnet++の比較にしてもそうだ、Unet++の方が良いという結果は、まだ得られていない。

Lossとモデルの組み合わせにしても、試してみないとわからない事ばかりなので、効率よく試す、実験する、ということを念頭において、最小の計算時間で適切な組み合わせを見つける方法を考えなければいけない。

encoderはefficientnetだけしか使っていないが、それでも、b0からb8まであるし、weightも3種類（imagenet, advprop, noisy-student）ある。検討する内容、最適化する内容に応じて、どれを使うかを適切に決める必要がある。

チューニングが主たる作業だった頃は、0.0001でも上がりそうだと、すぐに飛びついて計算し、順位を1つでも上にあげようとしていた。その癖が残っていて、0.001くらい上がりそうだと、すぐにやってみたくなる。それが、GPU消費（浪費）時間の増大につながっている。0.001の積み上げは重要だが、そこで止まってしまうようなチューニングではなく、さらに上を目指せる課題を探すことにもっと注力すべきなのだろうと思う。

今ある5種類のLossについては単純な線形結合で、自由に組み合わせることができるようにした。（注：単純な線形結合ではうまく計算されていない可能性がある）Lossのパラメータ設定については十分調べることはできなかったが、パラメータの意味を理解しながら実験していくしかなさそうである。

明日は、TTAを組み込む。

GitHubで、test time augmentation pytorchで検索し、上位に出てきた次のサイトがよさそうだったので、使わせていただこう。

https://github.com/qubvel/ttach

すぐにコードを組み込むことができなくても、TTAに関する情報収集の基地として便利なサイトだと思う。

Datasetに入れて、notebookのinput dataに追加し、次の命令で、インターネットなしで、インストールすることができるようにした。

!pip install ../input/ttach-pytorch -f ./ --no-index

2月4日（木）

HuBMAP：

TTAによって追加する画像の種類と枚数を決める基準は何だろう。 Chris Deotteさんが、枚数に対して効果をプロットとしていたような記憶がある。12~15枚がピークだったような気がする。モデルやハイパーパラメータ、augmentationの内容によって、効果は違うと思うので、自分で実験することが重要。

github.com/qubvel/ttachから引用：

Similar to what Data Augmentation is doing to the training set, the purpose of Test Time Augmentation is to perform random modifications to the test images. Thus, instead of showing the regular, “clean” images, only once to the trained model, we will show it the augmented images several times. We will then average the predictions of each corresponding image and take that as our final guess [1].

データ拡張がトレーニングセットに対して行っていることと同様に、テスト時間拡張（Test Time Augmentation）の目的は、テストイメージにランダムな変更を実行することです。 したがって、通常の「クリーンな」画像をトレーニング済みモデルに1回だけ表示する代わりに、拡張画像を数回表示します。 次に、対応する各画像の予測を平均し、それを最終的な推測として使用します[1]。by Google翻訳

HuBMAPコンペサイトに、TTAを非常にわかりやすく、具体的に説明したcodeが公開されている。Let's Understand TTA in Segmentation by @ joshi98kishan

この図面はすばらしい！

github.com/qubvel/ttachに説明されている手順：reverse transformations for each batch of masks/labels、の意味が一目でわかって納得した。図中では、文字が小さくて読み取りにくいが、TTA in Segmentationのすぐ下に、Deaugmentationと書かれている。

要するに、変換して変形した形状を、再度変換することによって、元の形状に戻すということだ。

ところで、torchvision.transformとalbumentationの区別がつかなくて困っている。

それぞれTとAを前に付けていればわかるのだが、

trfm = A.Compose([
      A.Resize(NEW_SIZE,NEW_SIZE),
      A.HorizontalFlip(p=0.5),
      A.VerticalFlip(p=0.5),

これなら問題ないが、

transforms = Compose([
　　　　　　　　HorizontalFlip( ),
　　　　　　　　VerticalFlip( ),
　　　　　　　　RandomRotate90( ),

これはどっちなんだろう。torchvisionには、RandomRotate90( )は無い。

このコードは、次のように両方のパッケージ/モジュールを呼び出していて、as Tとかas Aを使っていないので見づらくなっているように思う。

import torchvision
from torchvision import transforms

from albumentations import *

albumentationsのドキュメントでは、次のように例示している。

import albumentations as A

まずは、TTAの枠組みを作ろう。参考にするコードは2つあって、1つは、垂直と水平のフリップのみ、もう1つは、垂直と水平のフリップに加えて、回転と、ランダムに選んだ3種類の光学的条件（コントラスト、色相、明度など）のうちの１つ

どれが効果的なのかを調べるためにどうすればよいのか。

train time augmentation（TRAとしよう）の効果とtest time augmentation（TTA）の効果を個別に調べる、連動させて調べる、無関係に連動させて調べる。

TRAのみ。TTAのみ。TRAとTTAを一致させる。TRAとTTAを直交させる（同一種類の変更を用いない）

いずれにしても、まずは効果的なTRAの加工条件を探索する必要がある。

TTA加工条件は、TRA加工条件と連動できるようにする。（現状はtrainとinferenceがつながっているので容易にできる）

TTAのお手本のコードは、PyTorchでTPUを使っており、trainとinferenceを分けているので、TTAと一緒に、trainとinferenceの分離、および、TPUの使い方を学ぶことにする。

計算資源のことで不足があるなら、文句を言う前に、Kaggleが提供してくれている計算環境をすべて利用しなければならない。

https://www.kaggle.com/docs/tpu：ここに、How to Use Kaggle, Help and Documentationというのがあって、KerasとPytorchに分けて説明されている。

コードコンペでは、inferenceにTPUは使えないので、TPUを用いたtrainからGPUを用いたinferenceに引き継ぐ方法が説明されている。

TPUs in Code Competitions
Due to technical limitations for certain kinds of code-only competitions we aren’t able to support notebook submissions that run on TPUs, made clear in the competition's rules. But that doesn’t mean you can’t use TPUs to train your models!

A workaround to this restriction is to run your model training in a separate notebook that uses TPUs, and then to save the resulting model. You can then load that model into the notebook you use for your submission and use a GPU to run inference and generate your predictions.

コードコンペティションのTPU
特定の種類のコードのみのコンテストの技術的な制限により、コンテストのルールで明確にされているように、TPUで実行されるノートブックの提出をサポートすることはできません。 ただし、TPUを使用してモデルをトレーニングできないわけではありません。

この制限の回避策は、TPUを使用する別のノートブックでモデルトレーニングを実行し、結果のモデルを保存することです。 次に、そのモデルを送信に使用するノートブックにロードし、GPUを使用して推論を実行して予測を生成できます。by Google 翻訳

なんとかなりそうだな。これからは、TPUも使おう。 

早速、お手本予定のコードをTPUでRunさせたのだが、1回目は2エポックで停止、2回目は14エポックで停止した。

エラー箇所とエラーメッセージ：

---> 36 start_method = 'fork')

ProcessExitedException: process 3 terminated with signal SIGABRT

View Session Metricsを見ると、CPUが399％になっていたので、この負荷の大きさがエラーを引き起こしているかもしれないと思い、負荷を下げるためにbatch_sizeを32から16にしてみた。すると、止まらずに動くようになった。しかし、trainの進行が遅くなり、結果としてスコアも悪くなった。使っているversionのコードでは、trainの停止条件をエポック数だけで決めているので、スコアへの影響が大きいのだろう。

2月5日（金）

HuBMAP：

今日もGPUは使えないので、TPUのコードで、augmentationの効果を調べる。trainだけのコードなので、val_diceで判断する。

当然、trainの場合にのみaugmentationを使うのだが、ここでふと思った。

validationのときに、TTAで使うaugmentationをためしてみてはどうかと。

trainのaugmentationとvalidationのaugmentationをそれぞれ、train_aug, val_augとしておけば、できるかもしれない。

簡単にはいかない。deaugmentationして平均をとる処理が必要であり、それをしないで、単に画像を増やしてもTTAのテストにはならない。

まずは、手元にある3組のaugmentationの効果を比べよう。

augmentation無しの場合のval_diceは0.85、2組はほぼ同等の0.86、幾何学的変形を強くした1組は0.79であった。現状はこの程度の効果であり、適切にやらないと、逆効果になってしまうということがわかった。augmentationによって、0.85が0.79になることがあるというのは、衝撃だ。augmentationすれば、予測性能は必ず上がるものと思っていた。EfficientnetB7-Unetで、AlbumentationのHPに紹介されている組み合わせの例をそのまま適用して、LBスコアが0.80に達しなかったとき、まさか、何もしない場合よりも悪いスコアになっているとは思わなかった。

data augmentationの本質を理解しよう。

data augmentationの本質を理解するためには、教師データの本質を理解している必要がある。機械学習モデルは、labelの正確さを超えることはない。画像とlabelは、pixelレベルで1対1に正しく対応していなければならない。機械学習モデルは、画像とlabelの対応関係を根拠として、新たな画像に対して、labelを推測する。labelが正確でない場合、機械学習モデルは、正確でないlabelを推測する。

無償で使わせていただいている立場では言いにくいことだが、このコンペのlabelは、ほぼ滑らかな曲線であるべき糸球体の境界を、不十分な辺の数の多角形で近似しているので、正しくない。スムージング処理によって改善されるかどうか調べてみようと思う。そのために、マスクの形状を加工する方法を探そう。

2月6日（土）

HuBMAP：964 teams, 2 months to go

良いaugmentationの方法はないものかと捜し歩いているがみつからない。

efficientnetb0-Unetは今日だけだが、LB=0.826がベストスコアだった。

このaugmentationの探索からは、TTAには、あまり期待できないが、3回の推測結果の平均値をとるという意味では、スコアアップの可能性はありそうだ。

2月7日（日）

HuBMAP：

A.OneOf([
      A.RandomContrast( ),
      A.RandomGamma( ),
      A.RandomBrightness( ),
      A.ColorJitter(brightness=0.07, contrast=0.07, saturation=0.1, hue=0.1,      always_apply=False, p=0.3),
], p=0.3), 

最後のP=0.3としてあるところを、0.0から0.6まで変えた時の、efficientnetB0-Unetによる予測結果のLBスコアは、次のようになった。

0.0: 0.822, 0.1: 0.820, 0.2: 0.826, 0.3: 0.826, 0.4: 0.827, 0.5: 0.825, 0.6: 0.824

この結果から、この部分のaugmentationは効果があって、0.2から0.5くらいであれば大差ないように見える。

次は、p=0.4で固定して、efficientnetを複雑にしていくとどうなるかを調べてみよう。

b1からb5まで順に計算してみるつもりだ。気が変わらなければ。

2月8日（月）

HuBMAP：971 teams, 2 months to go

OneCycleLRを使っているのだが、性能が発揮できていないような気がしてきた。

論文を読んで理解しよう。

Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates
Leslie N. Smith, Nicholay Topin, arXiv:1708.07120v3 [cs.LG] 17 May 2018

Abstract
In this paper, we describe a phenomenon, which we named “super-convergence”,
where neural networks can be trained an order of magnitude faster than with
standard training methods. The existence of super-convergence is relevant to
understanding why deep networks generalize well. One of the key elements of
super-convergence is training with one learning rate cycle and a large maximum
learning rate. A primary insight that allows super-convergence training is that large
learning rates regularize the training, hence requiring a reduction of all other forms
of regularization in order to preserve an optimal regularization balance. We also
derive a simplification of the Hessian Free optimization method to compute an
estimate of the optimal learning rate. Experiments demonstrate super-convergence
for Cifar-10/100, MNIST and Imagenet datasets, and resnet, wide-resnet, densenet,
and inception architectures. In addition, we show that super-convergence provides
a greater boost in performance relative to standard training when the amount of
labeled training data is limited. The architectures to replicate this work will be
made available upon publication.

概要
この論文では、ニューラルネットワークを標準的なトレーニング方法よりも1桁速くトレーニングできる、「超収束」と名付けた現象について説明します。超収束の存在は、なぜ深いネットワークがうまく一般化するのかを理解することに関連しています。超収束の重要な要素の1つは、1つの学習率サイクルと大きな最大学習率でのトレーニングです。スーパーコンバージェンストレーニングを可能にする主な洞察は、学習率が高いとトレーニングが正規化されるため、最適な正規化バランスを維持するために、他のすべての形式の正規化を減らす必要があるということです。また、最適な学習率の推定値を計算するために、ヘッセ行列のない最適化手法の簡略化を導き出します。実験は、Cifar-10 / 100、MNIST、Imagenetデータセット、およびresnet、wide-resnet、densenet、およびinceptionアーキテクチャの超収束を示しています。さらに、ラベル付けされたトレーニングデータの量が限られている場合、スーパーコンバージェンスが標準トレーニングと比較してパフォーマンスを大幅に向上させることを示します。この作業を複製するためのアーキテクチャは、公開時に利用可能になります。

by Google翻訳

OneCycleLRのexampleは、optimizerにSGDを使っているが、そのexampleをコピペして使っても、良い結果が得られない（まともな結果が得られない）ので、optimizerにAdamWを使っている。

論文では、optimizerはSGDだけであり、SGDの良さを強調している。

While deep neural networks have achieved amazing successes in a range of applications, understanding why stochastic gradient descent (SGD) works so well remains an open and active area of research. Specifically, we show that, for certain hyper-parameter values, using very large learning rates with the cyclical learning rate (CLR) method [Smith, 2015, 2017] can speed up training by as much as an order of magnitude. We named this phenomenon “super-convergence.” In addition to the practical value of super-convergence training, this paper provides empirical support and theoretical insights
to the active discussions in the literature on stochastic gradient descent (SGD) and understanding generalization.

ディープニューラルネットワークはさまざまなアプリケーションで驚くべき成功を収めていますが、確率的勾配降下法（SGD）がうまく機能する理由を理解することは、オープンで活発な研究分野です。具体的には、特定のハイパーパラメータ値について、循環学習率（CLR）法[Smith、2015、2017]で非常に大きな学習率を使用すると、トレーニングを1桁も高速化できることを示します。 この現象を「超収束」と名付けました。 超収束トレーニングの実用的な価値に加えて、この論文は、確率的勾配降下法（SGD）と一般化の理解に関する文献での活発な議論に対する経験的サポートと理論的洞察を提供します。 by Google翻訳

optimizerをSGDにして、lrとMax_lrを変更してみた。AdamWでのLBスコアが0.827となったモデルである。LBスコアは0.815と0.821で、他にもトライした2条件では、良い結果を期待できそうなval_lossの変化だったが、Submission Scoring Errorになってしまった。適切な値というのは、モデル、データ、課題などの組み合わせによって違ってくるので、計画的に実験しないと、なかなか、良い結果にたどり着けない。

max_lrの設定値が重要で、目安はoptimizerのデフォルトのlr値の10倍から30倍程度ということだろうと思う。SGDなら1から3、AdamWなら1e-2から3e-2程度という感触を得たので、明日、気が向いたら確かめてみようと思う。

2月9日（火）

HuBMAP：

SGD:

Max_lr=0.3: LB=0.815

Max_lr=2: LB=0.824

Max_lr=3: LB=0.821

AdamW:

Max_lr=1e-3: LB=0.827（過去のデータ）

Max_lr=1e-2: LB=0.818

Max_lr=2e-2: LB=0.805

Max_lr=3e-2: LB=0.812

この3件、プログラムミスの影響を受けている可能性あり。

OneCycleLRの条件検討を行ってきたここまでの結果では、Max_Lrをデフォルトのlr(SGD: 0.1, AdamW: 1e-3)の10~30倍にすることによるLBスコアは、SGDにおいては少し上がったが、AdamWでは、逆に下がった。この手法は、SGD限定なのかもしれない。

気分転換に、Encoderを変えてみようと思う。

ResNet18, 34, 50, 101, 151, Senet154, Se_Resnet50, 101, 152, Se_Resnext50_32x4d, 101, Densnet121, 169, 201, 161, Inceptionresnetv2, Inceptionv4, Xception, Dpn68, 98, 131, VGG11, 13, 16, 19, などを使う準備をした。

2月10日（水）

HuBMAP：

Efficientnet-UnetでLB~0.83を示すコードのEncoderを次のモデルで置き換え、他の条件は一切変えずに走らせた。

Resnet18: LB=0.813

Resnet34: LB=0.805

Resnet50: LB=0.810

Resnet101: LB=0.815

Rennet152: LB=0.812

この5件、プログラムミスの影響を受けている可能性あり。

次の論文は、最新のテクニックを駆使すれば、昔のモデル(ResNet)でも新しいモデル(EfficientNet)に匹敵するような性能を示す、ということを示している論文のようだが、そういうテクニックを持ち合わせていない場合は、新しい高性能なモデルを使う方が良い結果を得られますよ、というふうに読める。

Compounding the Performance Improvements of Assembled Techniques in a Convolutional Neural Network
Jungkyu Lee, Taeryun Won, Tae Kwan Lee, Hyemin Lee, Geonmo Gu, Kiho Hong

arXiv:2001.06268v2 [cs.CV] 13 Mar 2020

Autoaugという単語が気になる。

AutoAugment: Learning Augmentation Strategies from Data
Ekin D. Cubuk , Barret Zoph, Dandelion Man´e, Vijay Vasudevan, Quoc V. Le

arXiv:1805.09501v3 [cs.CV] 11 Apr 2019

明日の予定：気が変わらなければ、se_resnet50, 101, 152, se_resnext50_32x4d, 101をencoderに用いたUnetを使ってみる。

2月11日（木）

HuBMAP：

①se_resnext50_32x4d: LB=0.822

②se_resnext101_32x4d: LB=0.809

➂senet154: LB=0.823

この3件、プログラムミスの影響を受けている可能性あり。

Resnetよりは、少し、良い結果になった。

ちなみに、trainの所要時間の比率は、①1.0 : ②1.5 : ➂2.6であった。

もっと良いモデルはないものか。 

ResNeSt: Split-Attention Networks
Hang Zhang et al., arXiv:2004.08955v2 [cs.CV] 30 Dec 2020

7. Conclusion
This work proposes the ResNeSt architecture that leverages the channel-wise attention with multi-path representation into a single unified Split-Attention block. The model
universally improves the learned feature representations to boost performance across image classification, object detection, instance segmentation and semantic segmentation. Our Split-Attention block is easy to work with (i.e., dropin replacement of a standard residual block), computationally efficient (i.e., 32% less latency than EfficientNet-B7 but with better accuracy), and transfers well. We believe ResNeSt can have an impact across multiple vision tasks, as it has already been adopted by multiple winning entries in 2020 COCO-LVIS challenge and 2020 DAVIS-VOS chanllenge.

こういうのを見ると、あらためて、EfficientNetは凄いんだな、と思う。

予定を変更して、EfficientNet-B7とResNeSt-269を比較してみよう。

EfficientNet-B7: 0.682

明らかにおかしな結果になったので、プログラムを見直したら、inferenceのところで実験的に変えていたパラメータを元に戻し忘れていた。2月9日から2月11日15時までの間に行った計算結果は、間違っている可能性がある。

以下は、元に戻したコードで計算した結果である。

ResNeSt-269: LB=0.829

EfficientNet-B7:0.652

？？？、何か変だ。

2月12日（金）

HuBMAP：

EfficientNetB0-UnetのLBスコアのバッチサイズ(32, 16, 8, 4)による違いを調べてみた。（commitまで昨日行い、今朝9時すぎにsubmitした。）

Batch_size=4:   LB=0.819

Batch_size=8:   LB=0.647

Batch_size=16: LB=0.830

Batch_size=32: LB=0.826

ここでも、異常値が生じた。

これらの異常は、overfittingによって生じている可能性がある。

lrスケジューラーとして使っているOneCycleLRは、overfittingしにくく、再現性が高いので、信用しきって使っているが、パラメータは殆どデフォルト値で、エポック数は時間節約のために10に設定しているが、公開コードを見ていると、エポック数として25±5くらいが良く使われていることなどを勘案すると、問題発生の原因になっている可能性がある。OneCycleLRの適切なパラメータの探索が必要だ。

さらに、予測したマスクを画像に戻して、trained_modelが予測しているsegmentationがどうなっているのかを、画像として確認できるようにしよう。

メモ：予測結果を画像に変換して確認、K-fold, Auto-augmentation, TTA, DropBlock, Model-ensemble, pseud_label, ...

これはどうなんだろう。著者は、Google Research, Brain Teamとなっている。

EfficientNetの論文のときと似たような図がトップページに掲載されている。

EfficientDet: Scalable and Efficient Object Detection
Mingxing Tan, Ruoming Pang, and Quoc V. Le,  arXiv:1911.09070v7 [cs.CV] 27 Jul 2020

While our EfficientDet models are mainly designed for object detection, we are also interested in their performance on other tasks such as semantic segmentation. Following
[19], we modify our EfficientDet model to keep feature level fP2; P3; :::; P7g in BiFPN, but only use P2 for the final per-pixel classification. For simplicity, here we only evaluate a EfficientDet-D4 based model, which uses a ImageNet pretrained EfficientNet-B4 backbone (similar size to ResNet-50). We set the channel size to 128 for BiFPN and
256 for classification head. Both BiFPN and classification head are repeated by 3 times. 

この論文見てたら、「いつまでUnet使っているのか」「なぜ、FPNとかDeepLav3を使わないのか」さらに、「それらを飛ばして、EfficientDetを使ってみたらどうか」と言われているような気がする。

2月1日のデータだが、EfficientnetB7-Unetで、損失関数を評価した結果は、次のようになった。これで、DiceLossを使わなくなったのだが、

BCELoss:       LB=0.829（1月31日）

DiceLoss:      LB=0.794

LovaszLoss:  LB=0.830

JaccardLoss: LB=0.832

FocalLoss:    LB=0.833
いずれもOneCycleLRの10エポックで、Lossの収束具合から判断すると、FocalLossは収束が速く、10エポックでも十分という感じだが、他は、もっとエポック数を増やせば、よくなりそうな気配を感じる。

ということで、明日は、エポック数依存性を、DiceLossについて調べてみよう。

EncoderとDecoderの組み合わせをどうするか。

2月13日（土）

HuBMAP：990 teams, a month to go（データの更新から2か月：データ更新待ち）

今日から1週間のGPUの割当は、先週と同じで、43時間である。

まずは、DiceLossで、OneCycleLRのエポック数を10回から20回、30回に増やしてみよう。

B0とB7では、単位エポックあたりの計算時間が3倍くらい違うので、B0でテストしてみよう。現状、256ｘ256で、8000枚程度の画像処理なので、B0で十分だろうと思う。

EfficientNetB0-Unet, DiceLoss：

epochs=10: LB=0.826

epochs=20: LB=0.830

epochs=30: LB=0.832

まあまあ、期待していたような結果になった。

それならば、BCELossは10エポックのデータがあるので、20エポックと30エポックの場合について計算してみよう。

BCEWithLogitsLoss：

epochs=10: LB=0.830（2月11日のデータ）

epochs=20: LB=0.822

epochs=30: LB=中止：計算が途中で停止し、かつ、Lossの変化も適正ではなかった！

BCELossは期待外れ、ということになった。

今日の最後は、JaccardLossの20エポックにしてみよう。

JaccardLoss：

epochs=10: LB=0.832（EfficientNetB7-Unet：2月1日計算）

epochs=20: LB=0.829（EfficientNetB0-Unet）

これらは比較できない！

B7の10エポックがB0の20エポックを少し上回っただけ。

複数の条件が異なる場合の比較は不可。

2月2日に、Decoderを比較したところ、以下のようになった。

LossFunction＝BCE, lr_Scheduler=OneCycleLR(epochs=10)

Encoder：EfficientNetB4

Decoder：Unet: LB=0.832, Unet++: LB=0.823, FPN: LB=0.830, MAnet: LB=0.825

これらの結果に対しては、「動作確認しただけ」と書いたが、この後今日まで、Decoderは、Unetを使ってきた。

このときのメモをよく見ると、Unetのパラメータはデフォルトではなく、decoder_attention_type="scse"としていた。

明日は、DecoderとしてFPN、Loss functionとしてDiceLossを使ってみよう。

そろそろ、パーソナルベストのLB=0.833を超えたいな。

2月14日（日）

HuBMAP：994 teams

EfficientNetBn-FPN-DiceLoss-AdamW-OneCycleLR-soft_augmentation：

EfficientNetB3-FPN_10 epochs: LB=0.826

EfficientNetB4-FPN_10 epochs: LB=0.829

EfficientNetB5-FPN_10 epochs: LB=0.832：EfficientNetB5-FPN_20 epochs: LB=0.834

EfficientNetB6-FPN_10 epochs: LB=0.828

似たり寄ったりというところかな。

B3からB6の比較では、B5が良さそうという結果だが、Unetでは、B0でも十分という結果なのだが。Decoderによって、最適なEncoderのサイズが違うのかもしれない。

EncoderにEfficientNetB5、Loss functionにDiceLossを使って、9種類のDecorderとの組み合わせで、LBスコアの比較をしてみよう。DiceLossはBCEより収束が遅いので、ベースのエポック数を15にしよう。

2月15日（月）

HuBMAP： 998 teams

EfficientNetB5-Decoder-DiceLoss-AdamW-OneCycleLR_15epochs-soft_augmentation：

Unet_scse:      LB=0.827

Unet++_scse: LB=0.831

MAnet:           LB=0.831

Linknet:          LB=0.832

Linknetの論文を示しておこう。

LinkNet: Exploiting Encoder Representations for Efficient Semantic Segmentation

Abhishek Chaurasia and Eugenio Culurciello, postarXiv:1707.03718v1 [cs.CV] 14 Jun 2017

LinkNetは計算速度の速さが売りのようだが、1エポックあたりの計算時間はUnetより10％くらい短いだけだった。LBスコアは（今回の条件では）Unetより少しよさそうだ。

OneCycleLR：

OneCycleLRは、モデルが小さい場合には、エポック数を多くする方が良いようだ。その理由は、モデルが小さいほど収束が遅いから、ということのようだ。

モデルが大きい場合には、エポック数を増やしていくと、overfittingして、スコアが低下することがあるようだ。

EfficientNetB0-Unetで、10, 20, 30のエポック数に対して、 LBスコアが、0.826, 0.830, 0.832となったのは、DiceLossが相対的に収束が遅く、かつ、小さなモデルであるB0と組み合わせたことによるのかもしれない。

BCELossを用いた場合には、DiceLossよりも収束が速いので、OneCycleLRのエポック数を増やすと、overfittingになりやすいようである。

ただし、これらの現象は、OneCycleLRと組み合わせるOptimizerの種類やMax_Lrの設定値によっても変わるようなので、適宜、チューニングすることが必要だろう。

組合せの数が多くて、収拾がつかなくなりそうだ。

これだけ多くのモデルを扱っているのだから、アンサンブルする方法を考えて、スコアアップにつなげていきたいものだ。

明日submitする予定の計算実施：

EfficientNetB5-Decoder-DiceLoss-AdamW-OneCycleLR_15epochs-soft_augmentation：

PSPNet: 

PAN: 1エポックの計算時間が長いため中止

DeepLabV3: GPUメモリーオーバー

DeepLabV3+: 1エポックの計算時間が長いため中止

FPNは10エポックと20エポックの結果があるので、別の検討を行う。

EfficientNetB5-FPN-DiceLossを用いたMax_Lrの検討：

optimizer: SGD：max_lr=3(x30): エポック数を20、30、50とする。

optimizer: AdamW：max_lr=1e-2(x10): エポック数は30とする。

torch.optimのマニュアルでは、SGDのlrはlr=<required parameter>となっていて、デフォルト値は与えられていない。すぐ後のexampleに、lr=0.1とあるだけ。

AdamWのlrのデフォルト値はlr=0.001となっている。

明日から、今使っているコードのinferenceの部分を理解し、TTAを組み込む。 

2月16日（火）

HuBMAP：

EfficientNetB5-Decoder-DiceLoss-AdamW-OneCycleLR_15epochs-soft_augmentation：

PSPNet: LB=0.821

この条件で計算した中では、PSPNetのLBスコアが最も低かった。

PSPNetの論文を見ておこう。

Pyramid scene parsing network
H Zhao, J Shi, X Qi, X Wang… - Proceedings of the IEEE …, 2017 - openaccess.thecvf.com

Abstract
Scene parsing is challenging for unrestricted open vocabulary and diverse scenes. In this paper, we exploit the capability of global context information by different-regionbased context aggregation through our pyramid pooling module together with the proposed pyramid scene parsing network (PSPNet). Our global prior representation is effective to produce good quality results on the scene parsing task, while PSPNet provides a superior framework for pixellevel prediction. The proposed approach achieves state-ofthe-art performance on various datasets. It came first in ImageNet scene parsing challenge 2016, PASCAL VOC 2012 benchmark and Cityscapes benchmark. A single PSPNet yields the new record of mIoU accuracy 85.4% on PASCAL VOC 2012 and accuracy 80.2% on Cityscapes.

OneCycleLR(DiceLoss)のmax_lrの検討：

optimizer: SGD：max_lr=3(x30):

epochs=20: LB=0.826: (2/18 submit)

epochs=30: LB=0.829: (2/18 submit)

epochs=50: LB=0.828

optimizer: AdamW：max_lr=1e-2(x10):

epochs=30: LB=(submission scoring error): （2/18再度submit）: LB=0.827

SGDでもAdamWに近い結果が得られるようになってきた。さらに、50エポックまで増やしても効果はなく、30エポックで十分だということを示すものとなった。

TTA：

TTAを組み込んだコードのベースは、自分が使っているコードのベースと同一なので、単に移植するだけであれば、難しくないと思われる。

と、思って取り掛かってみたが、そう簡単ではない。

最初に、Lambda、が定義されていないとのエラー、次は、preprocess_inputでひっかかり、これらを使わない方法を考えていたのだが、get_preprocessing_fn、が気になって調べてみた結果、これらが重要な関数であることがわかった。

調べてみると、TTAを追加した人は、Segmentation Modelsのパッケージを使っており、そのパッケージのマニュアルには、次の例に従って入力データを前処理するように書かれているのだが、自分は同じSegmentation Modelsのパッケージを使っていながら、これらの関数を知らなかったために、エラーの意味するところが分からなかった、ということである。これは重要な情報である。今使っているコードを見直す必要があるかもしれない。（まずは、このコードの機能と使い方を理解しよう）

from segmentation_models_pytorch.encoders import get_preprocessing_fn

preprocess_input = get_preprocessing_fn('resnet18', pretrained='imagenet')

'resnet18' はexampleで、使用するEncoder名を入れる。

とりあえず、大きなエラーは解消できたので、TTAが機能するかどうか調べてみる。

といっても、inferenceの部分だから、commit, submitしないとわからないので、明日にしよう。

2月17日（水）

HuBMAP： 1,012 teams

TTAを搭載したコード、昨日はCPUで途中まで動くことを確認した。

GPUでinferenceまで完了。

EfficientNetB0-FPNで、inference所要時間は41分であった。

commitしてoutputを見て唖然！

何も出力されていなかった。

最終行に、submission.head( )、と書いておきましょう！

＊＊＊バグ出し・コード修正作業中＊＊＊

・バグ出しに必要なコードの知識が不足。

・必要と考えられる機能を全て追加してしまってからバグを見つける、ということができるような、コーディング技術は、まだ持っていない。

・動いているコードに、正確に作動する状態を保持しながら、TTAに必要な機能を、1行づつ（少しづつ）追加していく、というようなやりかたをとってみよう。

2月18日（木）

HuBMAP： 1,019 teams

TTAのセットで使われている次のコードの意味がわからない。

preprocess_input = Lambda(image = get_preprocessing_fn(encoder_name = ENCODER_NAME, pretrained = 'imagenet'))

TTAのコード（inference）の作者の（train）コードを見ると、そこでも使われている。

TTAの作者がtrainで用いているEncoderは'se_resnext50_32x4d'であり、自分が今使っているEncoder（EfficientNet）とは異なることに起因する何らかの不整合がエラーの原因となっている可能性がある。

ということで、TTAの作者と同じ、se_resnext50_32x4d-Unetを使って確かめてみよう。

これはピントはずれだった。

出力されなかった原因は、単純ミスだった。

TTA用の画像も、それに対する予測も正しく行われていることを確認した。

それでも、最終出力は空（empty）であった。このことから、次のコード「preds[x1:x2,y1:y2] = (pred > 0).astype(np.uint8)」が動作していないということが推測された。このコードは、次のforループ「for (x1,x2,y1,y2) in slices:」の中にあるべきものだが、それが、インデントの間違いによって、このforループの外に出てしまっていたのである。そのために、予測値が格納されず、空のままだったということである。

原因：TTAを含むコードの作者は、複数のFoldに対応するモデルによる予測値の平均を計算するためのforループを用いていたが、自分が使っているコードは、Foldを使っていないので、そのforループを除去したのだが、その作業中にそのforループの外側の行まで動かして（インデントの変更をして）しまったために、予測値の読み込みのコードが必要な時に呼び出されなくなってしまった、ということである。

ということで、ようやく解決した。

明日は、TTAの効果を調べたいところだが、GPUの残り時間が無くなった。

明日は、trainとinferenceの分離、モデルのアンサンブル、などについて検討する。

2月19日（金）

HuBMAP：1,028 teams, two months to go (To be determined)

trainとinferenceに分離：trainedパラメータの授受

train_code: パラメータの保存コードの例

torch.save(model.state_dict(), 'model.pth')

torch.save(model.state_dict(),"best.pth")

torch.save(model.state_dict(),f'FOLD-{fold}-model.pth')

inference_code: 保存したパラメータの読み込みコードの例

model.load_state_dict(state_dict)

model.load_state_dict(checkpoint['state_dict'])

model.load_state_dict(torch.load("../input/private_dataset/FOLD-{fold}-model.pth"))

モデルのアンサンブルについて：

現状のinferenceの所要時間は15分程度。TTAで3枚に増えると45分程度、モデルを4種類使うと180分程度となる。

TTAの参考にさせていただいたコードは４Foldの計算で、各Foldのパラメータを読み込んだモデルを用意しておいて、forループで順に予測し、予測値をループ毎に加算し、最後に4で除算している。この4Foldの代わりに、4種類のtrain済みのモデルを用意しておけばアンサンブルができそうな気がするのだが、どうだろう。

4Foldの場合は、inferenceコードでモデルを準備し、trainコードで作成し出力した各Foldのtrainedパラメータを読み込んだモデルをmodel_0, model_1, model_2, model_3のように準備し、これらのモデルを順に適用して予測し、最後に平均をとる。

モデルのアンサンブルの場合は、inferenceコードで複数のモデルを準備し、trainコードで作成した各モデルのtrainedパラメータを読み込んだモデルをmodel_A, model_B, model_C, model_Dのように準備し、これらのモデルを順に適用して予測し、最後に平均をとる。

メモリーオーバーになりそうだし、そう簡単にはいかないかもしれないが、まずは、サイズの小さな、2種類のモデルを使って、やってみよう。（後日）

これなに？：

identity = rasterio.Affine(1, 0, 0, 0, 1, 0)：

この括弧の中の6つ並んでいる1と0の数字は、下のマトリックスの(a, b, c, d, e, f)に対応していて、対角成分が1の対角行列を示しているようだ。

以下は、https://github.com/sgillies/affine、から引用したもので、適当に書き加えた。

The 3x3 augmented affine transformation matrix for transformations in two dimensions is illustrated below.

| x' |   | a  b  c | | x |
| y' | = | d  e  f | | y |
| 1  |   | 0  0  1 | | 1 |

>>> Affine.identity()
Affine(1.0, 0.0, 0.0,
           0.0, 1.0, 0.0) 

a=1, b=0, c=0, d=0, e=1, f=0, を代入すると上のマトリクスの式はつぎのようになる。

| x' |   | 1  0  0 | | x |
| y' | = | 0  1  0 | | y |
| 1  |   | 0  0  1 | | 1 |

 x'=1, y'=1

identity（同一）だから、こんな感じでいいのかな。

明日は、TTAの効果を試してみよう。

2月20日（土）

GPU: 43 h

HuBMAP：1,042 teams, two months to go

TTA：

TTA-EfficientNetB0-FPN(decoder-dropout=0.5)-Batch_16-Epochs_10-Dice-AdW-trfm_1

TTA_0: no TTA: LB=0.825

TTA_1: identity + holrizontal_flip: LB=0.822

TTA_2: identity + horizontal_flip + vertival_flip: LB=0.827

TTA_3: identity + horizontal_flip + vertival_flip + rotate: LB=0.828

TTA_4: identity + horizontal_flip + vertival_flip + rotate + pixel_level_trfms: LB=0.830

プログラムは正しく動作しているようで、TTAの効果が認められた。

計算時間をできるだけ短くしようとしてB0を用いたが、それにはDiceLossは適切ではなく（10エポックでは不足）、LBスコアとしては、満足のいく結果にはならなかった。

大きなモデルを使うと予測時間が極端に長くかかり、この先、モデルのアンサンブルのことも考えると、計算速度は速く、モデルは小さく、する必要がある。

今回のモデルでは、TTA無しのときの予測時間が12.5分で、4枚追加すると予測には、45分くらいかかっている。仮に5つのモデルをアンサンブルすると、45ｘ5=225分かかる。よくわかっていないのだが、submit中に、予測はprivate_dataに対しても行われ、private_dataがtest_dataの1.4倍ある場合には、225 x 2.4=540分=9時間となる。B0でギリギリなので、大きなモデルを使うには、アンサンブルするモデルの数を減らす、TTAの枚数を減らす、ということをする必要がある。B5などでは、予測時間が長くなって、とても使えそうにないと思う。

明日は、TTAなし、予測時間15分以内、LBスコア0.832以上をリストアップ/探索し、実際に0.832以上になった場合には、TTA_4を適用してみよう。

EfficientNetB0,B1,B2,B3,B4

Unet, Unet-scse, FPN, MAnet, Linknet,

FocalLoss, JaccardLoss, LoaszLoss, BCELoss, DiceLoss,

組み合わせとしては、おおよそ、この範囲内で、検討しよう。

過去の実験結果リマインド：OneCycleLRのエポック数とLoss_function：一例

EfficientNetB0-Unet, OneCycleLR (AdamW: lr=1e-4, Max_lr=1e-3)

BCEWithLogitsLoss：

epochs, public_LB = (10, 0.830) -> (20, 0.822) -> (30, no submittion)

at last epoch: (train_loss, val_loss) = (0.041, 0.053) -> (0.034, 0.047) -> (0.031, 0.054)

DiceLoss：

epochs, public_LB = (10, 0.826) -> (20, 0.830) -> (30, 0.832)

at last apoch: train_loss, val_loss = (0.106, 0.123) -> (0.101 0.113) -> (0.096, 0.111)

2月21日（日）

HuBMAP：1,054 teams, two months to go

GPU: 36h40m

EfficientNetB0-Decoder, FocalLoss, OneCycleLR(AdamW, 1e-4, max_lr=1e-3), TTA-4

Unet:          LB=0.830

Unet-scse:  LB=0.829

FPN:           LB=0.818

MAnet:      LB=0.828

Linknet:     LB= 0.820

TTA無しでのスコアが0.832以上になる組み合わせを探索したうえで、TTA-4を適用するつもりだったが、trainの段階でのFocalLossの値が良さそうだったので、条件出しせずにTTA-4の計算を行った結果は以上のようになった。

FocalLossを使ったのは、EfficientNetB7-Unetに(FocalLoss, JaccardLoss, LoaszLoss, BCELoss, DiceLoss)を適用したとき、最も収束が良く、LBスコアも高かったのがFocalLossだったためである。EfficientNetB0-FPN(とLinknet)のスコアがこんなに低くなるとは思わなかったが、train結果を見直してみると、EffB0-FPN(とLinknet)のval_lossの値は、他のDecoderの結果よりも明らかに大きい。ResNext152-FPNを扱った文献に、FocalLoss（α=0.25, β=2.0)が良好な結果を与える、と記述されていたのをメモっていたので、FocalLossとFPNとの相性は良いんだろうと思っていた。相性が良いのはResNext152やEfficientNetB7と組み合わせた場合に限る、ということかもしれない。

モデルが小さい場合、エポック数を増やす必要がある。

予測時間は、モデルサイズを大きくすると長くなるが、エポック数を増やしても、予測時間は変わらないと思い込んでいたが、実験してみると・・・。

小さなモデルで、エポック数を増やして、良い結果が得られるならば、その方が良い。

EfficientNetBn-FPNを用いて、Bnと予測時間の関係をTTA無しで比較してみよう。

EffB0-FPN: 11m19s(draft), 11m51s(commit)

EffB1-FPN: 13m11s(draft), 11m12s(commit)

EffB2-FPN: 12m29s(draft), 10m47s(commit)

EffB3-FPN: 13m15s(draft), 12m43s(commit)

この程度の時間差であれば、パラメータの増加等による性能アップの効果の方が大きいのではないだろうか。 

明日は、EncoderをEfficientNetB3に変更し、他は全く同じ条件のままで、計算してみようと思っていたが、上記のように予測時間のモデル依存性を調べた結果、B4, B5, B6, B7等についても調べ、そのうえで、これまで得られている結果も勘案して、これから使っていくEfficientNetのモデルを絞り込んでいこうと思う。 

2月22日（月）

HuBMAP：1,062 teams, two months to go

EfficientNetBn-FPNの予測時間

EffB4-FPN: 12m11s(draft), 14m49s(commit)

EffB5-FPN: 13m27s(draft), 15m25s(commit)

EffB6-FPN: 16m10s(draft), 15m42s(commit)

これにスコアを加えたいのだが、Decoder、エポック数、損失関数、augmentationの種類等によって変わるので、難しい。

ここからは、OneCycleLRのエポック数は30、EncoderはEfficientNetB5、損失関数はDiceLoss、をbaseとしよう。

EfficientNetB5-Decoder, DiceLoss, OneCycleLR(AdamW, 1e-4, max_lr=1e-3, 30 epochs), batch_size=16, with soft augmentation, without TTA, 

Unet:      LB=0.836 (15 epochs: 0.827)

Unet++: LB=0.836 (15 epochs: 0.831)

FPN:       LB=0.830 (20 epochs: 0.834)

MAnet:  LB=0.834 (15 epochs: 0.831)

Linknet: LB=0.836 (15 epochs: 0.832)

Unet, MAnet, Linknetについて、さらに、エポック数を増やしてみようかなと思うのだが、overfittingによってスコアは反転するだろうから、そこを見極める必要がある。overfittingしてから、適度なdata_augmentationができれば、スコアはさらに上げることができるかもしれない。 

FPNは、Decoderのdropoutを0.5にしたのがまずかったかもしれないので（20エポックもdropout=0.5）、0.2に戻してみよう。

GPUの残りが8.5時間になった。明日、Linknet, Unet, MAnetのエポック数を増やすだけで使い切ってしまいそうだ。

その後の3日間は、trainと、inferenceのコードを作り、K-Foldとアンサンブルができるように準備しよう。

2月23日（火）

HuBMAP：1,070 teams, two months to go（まだデータは更新されていないようだ）

エポック数を50にしてみた。1エポックあたり1分を少し超えるので、trainで60分くらいかかる。データ前処理の5分とinferenceの15分を足すと約80分を要す。

commitも同じ時間を要するので、パラメータ設定時間等も加えると、１つのスコアを得るのに、3時間くらいかかる。

ということで、今日は、Linknet, Unet, Manetの50エポックの計算で終了予定。

OneCycleLRにおけるエポック数：プログラムのTTAの動作確認のために3エポックでtrainを終え、commit,submitしてみたら、LBスコアが0.80くらいになってたいへん驚いたことがある。10エポックで0.82+のモデルである。エポック数を増やす実験を、30くらいまで、何度かやってみたところ、このブログにも部分的に記録を残しているが、EncoderがB0でDiceLossの場合、エポック数が10、20、30と増えるにつれてスコアは上がったが、EncoderがB5以上でBCELossの場合には20以上ではスコアは低下する傾向がみられた。といっても、OneCycleLRの性能は、用いるoptimizerとそのパラメータだけでなく、Max_lrによっても大きく変わるので、エポック数の最適値がどこにあるかは、実験してみるしかない、ということになる。

Linknet：15エポックでLB=0.832、30エポックでLB=0.836だったのに対し、50エポックまで増やすと、LB=0.831となった。エポック数を40にするか50にするか迷ったのだが、これによって、50以下にピークがあることがわかった、ということにしておこう。

この結果をみると、UnetやMAnetは50エポックではなく、40エポックくらいにしてみよう、となるかもしれないが、既に、Unetは50エポックで計算し、commit, submitしており、MAnetは50エポックで計算中である。

Unet： 30エポックでLB=0.836だったのに対し、50エポックまで増やすと、LB=0.834となった。

MAnet： 30エポックでLB=0.834だったのに対し、50エポックまで増やすと、LB=0.830となった。

以上、いずれのDecoderも、50エポックまで増やすことによって、publicLBスコアは下がった。LinknetとMAnetのLBスコアのピークは30エポック前後、UnetのLBスコアのピークは40エポック近傍であると推測される。

最後に、B5-UnetのLB=0.836のときと同じ条件でtrainingした後で、TTA_4を適用してみよう。

inferenceに要した時間は約54分で、B0-Unetの41分の約1.3倍となった。

TTA_4を追加することによって、0.84+となることを期待したが、LB=0.836となり、スコアは上がらなかった。

GPUの残り時間が30分以下となったので、ここで終了！

これまでの実験結果を簡単にまとめると次のようになる。

１．TTAが可能になった。

２．EfficientNetB0-FPNのモデルを用いて、TTAの効果を調べ、TTA無しでLB=0.825だったのが、TTA_4ではLB=0.830となり、TTAによってLBスコアが向上することを確認した。

３．OneCycleLRで常用してきた10エポックを30エポックまで増やすことによって、LBスコアが0.836まで向上したので、そのモデルにTTA_4を適用することでさらにスコアが上がることを期待したが、TTA無しと同じスコア0.836となった。

検討：

TTAの効果を最初に調べたモデルでのLBスコアは、TTA無し: 0.825、TTA_1: 0.822, TTA_2:0.827, TTA_3: 0.828, TTA_4: 0.830であった。数字は追加画像の枚数である。

これに対して今日のモデルは、TTA無しでもLBスコアが0.836と高いことが関係しているのか、それとも、TTA無しで0.836というのは別の計算なので、TTA_4を適用したときのモデルの性能が、TTA無しのときのモデルの性能よりも低かったということか。

TTA適用無し：30エポック目: train_loss=0.094, val_loss=0.107

TTA_4適用：　30エポック目: train_loss=0.096, val_loss=0.113となっていた。

両者は、trainまでは、全く同じコードの筈なのだが、この最終エポックでのlossの値からは、TTA適用無しのtrainedモデルの方が良いと判定される。すなわち、TTAを適用する前のモデルの予測性能が劣っていたために、あたかも、TTAの効果が皆無であったかのような結果になったということではないだろうか。

最初にTTAの効果を調べたときも、TTA無しと各TTA有は、全てその都度trainを行なっている。それゆえ、毎回、trainedモデルの性能は異なっていた可能性が高い。実際、TTA_1のスコア0.822は、TTA無しのスコア0.825よりも低かった。この時の実験をこれでやめていたら、TTAの効果は無い、TTAをすることで、かえってスコアは悪くなる、2枚の予測結果の処理の仕方を見直そう、などと考えたかもしれない。しかし、TTAの枚数を増やしていった結果、枚数が多くなればスコアが上がるという結果となり、それによって、TTAによりLBスコアは良くなる、と判断することになった。

今のコードは、trainとinferenceが連結されているので、このような現象が起きる。

trainとinferenceが分離されていれば、同一のtrainedモデルを使うことができるので、inferenceの条件の違いが明確に現れ、同一のモデルを使っているにもかかわらず、TTAの効果が現れたり、消えたり、マイナスになったりする、ということは生じないはずである。

ということで、明日から、train専用モデルと、inference専用モデルを作るとともに、アンサンブルの方法も検討していくことにする。

2月24日（水）

HuBMAP：1,082 teams, two months to go

trainコード：

・inferenceを切り離す（不要なセルを消去するのではなく、markdownに変更する）。

・trained_modelをsaveする。公開コードには次のようなコードが使われている。

torch.save(model.state_dict(), 'model.pth')

torch.save(model.state_dict(),f'FOLD-{fold}-model.pth')

・Foldを使う。公開コードで使われているコード例。容易ではないのでもう少しコードに慣れてからチャレンジする。

from sklearn.model_selection import GroupKFold

group_kfold = GroupKFold(n_splits = 3)

inferenceコード：

・Trainコードで、次のように識別しやすいファイル名で出力したstate.dict( )ファイルを、データセットにして、Inferenceコードのinput_datasetに加える。

torch.save(model.state_dict(), 'EfficientNetB5-Unet_model.pth') 

・inferenceコードで同じモデルを次のようにして準備し、データセットから、state_dictを読み込む。

model = smp.Unet('efficientnet-b5', encoder_weights='imagenet', classes=1)

path = '../input/state_dict_dataset/EfficientNetB5-Unet_model.pth'

state_dict = torch.load(path)

model.load_state_dict(state_dict)

明日、trainのコードセルをmarkdownに変更し、これらのコードを追加して、inferenceできるかどうか試してみよう。

2/21に計算し、commitしておいたものをsubmitしてみた。

EfficientNetBn-FPN-FocalLoss-OneCycleLR(AdamW, epoch=10)

B0: LB=0.793,  B1: LB=0.570,  B2: LB=0.817,  B3: LB=0.812

B4: LB=0.813,  B5: LB=0.822,  B6: LB=0.823

B0(epoch=10, BCELoss): LB=0.82+, B4(epoch=10, BCELoss): LB=0.830

＊EfficientNetB7-Unetに対して、Focal Lossは他のLoss_functionより良いスコアを与えたこと、および、Focal Lossの論文を斜め読みして、Focal LossはFPNとの相性が良い、と思い込んだ結果がこれである。

Twitterで @Deep Learning Weeklyがtweetしていた論文：興味深い：

Unsupervised Semantic Segmentation by Contrasting Object Mask Proposals
Wouter Van Gansbeke1* Simon Vandenhende1* Stamatios Georgoulis2 Luc Van Gool1,2
1KU Leuven/ESAT-PSI 2ETH Zurich/CVL, TRACE,  arXiv:2102.06191v1 [cs.CV] 11 Feb 2021

糸球体の領域を過不足なく囲うことができるヒトは、糸球体をどう定義しているのだろうか。そのヒトは、1枚の光学顕微鏡像から、3次元構造を正しく想像することができているのだろう。それが正しくできるためには、細胞レベルでの腎臓の正しい3次元構造を知っていることが必要である。さらに、加工（包埋/凍結・切断）による変形・変質、染色等の化学処理による変形・変色などについての正しい知識を適切に適用することで、より正確に糸球体の境界を判定することが可能になるのだろう。同じことをコンピュータが自動的に行えるようにするためには、最初に与えられた課題と画像から必要な知識領域を判定し、課題解決に必要な知識を収集し、課題解決に必要な知識を集約し、知識を解析手段に変換し、画像を解析し、課題を解決するまでのプロセスを自動的に実行する。

2月25日（木）

HuBMAP： 1,090 teams, two months to go（締切日は、データ更新から2か月後）

今日は、trainedモデルのstate_dict( )をデータセットに格納し、inferenceコードにそのデータセットを追加し（+ add data）、そのデータセットからstate_dict( )を読み込み、inferenceモデルにstate_dict( )を読み込んで、inferenceを行う。

今日のテスト用に作ったtrained_modelは、EfficientNetB0-UnetとEfficientNetB0-MAnetであり、それらの学習済みモデルのパラメータ、EffB0-Unet-SBCE-model.pthとEffB0-MAnet-SBCE-model.pthは、データセットに入れた。

model_U = smp.Unet('efficientnet-b0', encoder_weights='imagenet', classes=1)

model_M = smp.MAnet('efficientnet-b0', encoder_weights='imagenet', classes=1)

path_U = '../input/state_dict_dataset/EffB0-Unet-SBCE-model.pth'

path_M = '../input/state_dict_dataset/EffB0-MAnet-SBCE-model.pth'

state_dict_U = torch.load(path_U)

state_dict_M = torch.load(path_M)

model_U.load_state_dict(state_dict_U)

model_M.load_state_dict(state_dict_M)

こんな感じで、2つの学習済みモデルをinferenceに使うことができるのだろうか。

試してみようとしたが、CPUだけだとメモリーオーバーになりやすく、かつ、予測も進まないので、土曜日の午前9時にGPUが使えるようになるまで本件は休止。

2月26日（金）

HubMAP：1,104 teams, two months to go

Albumentations Documentationsの入り口あたりをちょっと眺めていた。

import albumentations as A
import cv2

transform = A.Compose([
A.RandomCrop(width=256, height=256),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.2),
])

AutoAlbument is an AutoML tool that learns image augmentation policies from data using the Faster AutoAugment algorithm. It relieves the user from manually selecting augmentations and tuning their parameters. AutoAlbument provides a complete ready-to-use configuration for an augmentation pipeline.

AutoAlbument supports image classification and semantic segmentation tasks. The library requires Python 3.6 or higher.

The source code and issue tracker are available at https://github.com/albumentations-team/autoalbument

この論文を読んでみよう。

Faster AutoAugment: Learning Augmentation Strategies using Backpropagation
Ryuichiro Hataya, Jan Zdenek, Kazuki Yoshizoe, and Hideki Nakayama

arXiv:1911.06987v1 [cs.CV] 16 Nov 2019  

2月27日（土）

GPU: 38h：≒ 5.4h/day

HuBMAP：1,111 teams, two months to go

1st public LB=0.896: my public LB=0.836: Δ=-0.06: very large

この差を埋める方法を探す：

現状を知る：予測結果を画像化する：難しい：検討中

画像サイズ、縮小率など、基本的なところを、検討することが必要である。画素数を、256, 320, 384, 448, 512と変えてみて、スコアがどうなるかを調べてみよう。といっても、画素数の大きな画像を扱うには小さなモデルを使うとか、バッチサイズを小さくするとかしないとメモリーオーバーになるので、スコアアップにつながる組み合わせを見つけるのは容易ではない。

EfficientNetB5-Decoderを計算したときに結果が出なかったPAN, DeepLabV3,および　 DeepLabV3Plusの性能が気になっている。PSPNetも含め、DiceLoss, 30エポックの結果を調べてみたいと思って、再度、検討してみた。PSPNetはDiceLossの30エポックでLB=0.822となり、他のモデルより0.01以上小さい。PAN, DeepLabV3, およびDeepLabV3Plusは、前回調べたときには、GPUの残り時間が少なくなっていなかったので、少し待つだけでデータが出ないとあきらめていたが、今回は、1エポック目の結果が出るまで待ってみた、その結果、1エポックあたりのtrain時間が、他のDecoderの場合の10倍以上になることがわかった。以上のようにPSPNetは明らかに他よりスコアが低いこと、PAN, DeepLabV3,およびDeepLabV3Plusは、理由はわからないが、計算時間が長すぎるので、これ以上追求しないことにする。

inference専用コード：作成中

2月28日（日）

HuBMAP：1,115 teams, two months to go

画素数増大の効果：

元画像の切り出しと縮小は、ここまで、公開コードをフォークしたときの値を変更せずに使ってきた。切り出しが1024x1024、これを256x256に解像度を下げて使っている。

EfficientNetB5-FPNで、256x256で、LB=0.835であったものを、320x320, 384x384, 512x512と変えてみた。GPUのメモリー占有量は、画素数を反映しているので、コードは正しく動作していると思うのだが、LBスコアは、0.829から0.835の間であった。

メモリーオーバーを避けるために、B4またはB5、バッチ数は16または32とした。

コンペのディスカッションでも、低解像度でバッチ数を増やしてtrainingした方がLBスコアが高いと報告している人もいる。

HuBMAPコンペサイトのDiscussionから引用：

LB 0.837 : batch size =16 / size=320x320
LB 0.845 : batch size =32 / size=256x256

これは、ぜひ、検討してみよう。256x256のbatch=32だと、EfficientNetB5-Unetではメモリーオーバーになるので、B4EfficientNetB4-Unetにする必要がある。他のDecoderについては、調べる必要がある。

EfficientNetの番号を決めるときの根拠の1つになる。画素数が多くなるとメモリーを消費するのでバッチ数を上げられなくなる。それでもバッチ数を上げようとすると、EfficientNetの番号の小さいモデルを選ぶ必要が出てくる。最適な組み合わせは実験によってしか得られない。

FoldもTTAもアンサンブルも適切なタイルの作成も後処理もNoisyStudentもpseudo labelsもSelf-trainingも検討中。augmentationもoptimizerもlr-schedulerも検討中。

2月の目標：LB=0.84+には届かなかった。

style=163 iterations=500

style=163 iterations=50

style=163 iterations=5

Kaggle散歩（January 2021）

Kaggle散歩（January 2021）

1月7日に、Riiidコンペが終了する。：1月8日追記：Riiidコンペは393位だった。72時間くらいの間に100チームくらいに追い越された。これがKaggleだ！

その後は、

HuBMAP - Hacking the Kidney
Identify glomeruli in human kidney tissue images

を考えている。

このテーマから、Discussionとnotebookの全ての関連情報（引用文献、引用コードを含む）に目を通すことによって知識を増やし、研究者レベルのコード開発を目指していきたいと思っている。

１月は、前処理、モデル構築と訓練、予測とsubmissionデータの作成、の順にベースモデルを作成する予定である。

1月1日（金）

Riiid AIEd Challenge, 3,221 teams, 7 days to go

private LB scoreが見えてしまうというトラブルがあったようだ。

公平を期するために、各人の昨年のある時点までの投稿データのうち、private LBスコアが最も高いものについて、private LB scoreを見ることができるようになっている。

"To retrieve your team’s score as of 2020-12-29 16:00:48 UTC, please visit this link."

こういうことは、メールで参加者に伝えられるのではなく、Discussionをチェックして、自分で気づかないとわからない。

必要な情報は、コンペサイトの中（Discussion）で適切に表示されるので、参加者の責任で取得する、というのが、Kaggleのルールになっている。

1月2日（土）

Riiid AIEd Challenge, 3,238 teams, 6 days to go

featureの選択にしても、LGBMのチューニングにしても、もう限界のようだ。

それでもまだ終わっていないので、何か手段を講じてスコアを上げたいものだ。 

Discussion

Most Votesでsortして、順にみていこう。

最初はKaggleのstaffによるメッセージである。

SAINT+: A Transformer-based model for correctness prediction

SAINT+はRiiidの研究者によって開発されたtransformerベースのプログラムで、論文へのリンクが張られている。このコンペに参加した当初は自分で文献調査して同じ論文を見つけて、”しめしめ”と思ったのだが、その時すでにDiscussionでKaggleのスタッフから紹介されていたようである。

さらに、トピックには、コメント（Comments）がつく。Kagglerたちが、トピックオーサー（ここではKaggleスタッフの1人）に対して質問したり、関連情報を交換したり、Kagglerどうしで、当該トピックスに関連した議論をする。

GitHubにSAINTとSAKTのコード例が公開されているとか、コンペサイト内にそれらしいコードが公開されているとか、コードにデータを入力するためにfeatureをベクトル化する方法を聞くとか、transformerモデルのコーディングの基礎が紹介されているサイトを紹介する、などのやりとりがある。SAINTやSAKTなどのNNと、LGBMとの比較。データ量が多いので、データハンドリング方法の工夫が必要だとか。コーディングに長けた人が、テストデータに対するハンドリング方法のコード例を具体的に示すこともある。

次は、kaggle staffによる新規参加者に対するlectureや注意事項の説明である。内容は省略するが、Kaggle内における遵守事項は重要である。

次は、kaggle staffによる、private scoreの情報が漏れたことへの対応に関するものである。kaggle staffが熟慮して決められた方法を受け入れるべきだと思う。が、しかし、金メダルレベル、賞金レベルの人達にとっては、公開される情報の質と量は非常に重要であり、真に公平な解決方法はないのかもしれない。

あとは、kaggel staffによるwelcome message、 課題提供者の挨拶、kaggle staffによるチーム結成の案内などがある。

次から、参加者からのトピックスである。

最初は、投票数256（upvote）、コメントや返信が40件ほどある。2か月前の投稿で、課題解決の参考になる情報である。課題解決のヒントになる情報で、特に、上記のSAINTの情報を調べると、GBM系よりもNN系が良さそうに思うだろうが、LGBMモデルベースでpublic LB=0.789を得ている、と記されている。

こういう情報は、締切日が近くなると、公開することに問題があると考えられなくもないが（他にこの種の情報が公開されていない場合）、締め切りまでにまだ2か月あるので、多くの人に有用だと考えて公開することにした、と書かれている。これ以外にも非常に本質的で有用な情報が含まれていて、全体のレベルを上げるのに貢献している優れた内容の投稿だと思う。

いまごろ読んでも遅いのかもしれないが、理解が深まってきた今だからこそ理解できる内容もたくさんある。

これ以上は書いてもきりがないので、書かないが、チューニングの合間に読み進めていきたいと思う。

1月3日（日）

• Riiid AIEd Challenge
• , 3,258 teams
• , 5 days to go

なかなかスコアが上がらず、順位が下がっていく。このままだと、あと2日くらいでメダル圏外に放り出されそうだ。

min_data_in_leaf、SAKTとLGBMの比率、などの最適値を探索中。

アンサンブルの比率について：公開コードで、0.771と0.772くらいのアンサンブルで0.782になるというのがあって驚いたが、1.4％程度の増大である。小さくはないが驚くほどでもない変化幅である。

HuBMAP:

締切が当初の2月初旬から3月下旬に変更された。

実質、今日から参加。

Your challenge is to detect functional tissue units (FTUs) across different tissue preparation pipelines. An FTU is defined as a “three-dimensional block of cells centered around a capillary, such that each cell in this block is within diffusion distance from any other cell in the same block” (de Bono, 2013). The goal of this competition is the implementation of a successful and robust glomeruli FTU detector.：Descriptionより

あなたの課題は、さまざまな組織準備パイプライン全体で機能組織ユニット（FTU）を検出することです。 FTUは、「毛細血管を中心とするセルの3次元ブロックであり、このブロック内の各セルが同じブロック内の他のセルから拡散距離内にある」と定義されています（de Bono、2013）。 この競争の目標は、成功した堅牢な糸球体FTU検出器の実装です。：グーグル翻訳

The focus of HuBMAP is understanding the intrinsic intra-, inter-, and extra- cellular biomolecular distribution in human tissue. HuBMAP will focus on fresh, fixed, or frozen healthy human tissue using in situ and dissociative techniques that have high-spatial resolution.

The HubMAP Data Portal aims to be an open map of the human body at the cellular level. These tools and maps are openly available, to accelerate understanding of the relationships between cell and tissue organization and function and human health.

HuBMAPの焦点は、ヒト組織における固有の細胞内、細胞間、および細胞外の生体分子分布を理解することです。 HuBMAPは、高い空間分解能を持つin situおよび解離技術を使用して、新鮮な、固定された、または凍結された健康なヒト組織に焦点を当てます。

HubMAPデータポータルは、細胞レベルでの人体のオープンマップを目指しています。 これらのツールとマップは公開されており、細胞と組織の組織と機能および人間の健康との関係の理解を促進します。：グーグル翻訳

1月4日（月）

Riiid AIEd Challenge, 3,285 teams, 4 days to go ,286th

順位の後退速度の速さには勝てないが、ほんの少し前進した(283th)。

しかし、22：30現在、290thまで下がった。

InnovationDigi(HuBMAP - Hacking the Kidney
Identify glomeruli in human kidney tissue images), 766 teams, 3 months to go

課題提供者からのメッセージと情報：

We are very much looking forward to the innovative solutions teams will generate to identify glomeruli in images of human kidney tissue.

私たちは、人間の腎臓組織の画像から糸球体glomeruliを特定するためにチームが生成する革新的なソリューションを非常に楽しみにしています。

提供されるデータ：

The kidney images and their segmentation masks, both of anatomical structures and glomeruli, were generated by HuBMAP’s tissue mapping center at Vanderbilt University (TMC-VU) team at the BIOmolecular Multimodal Imaging Center (BIOMIC). The glomeruli masks were further improved to provide a "gold standard" by the Indiana University team through a combination of manual and machine learning efforts. Any annotations of glomeruli that were considered incorrect, ambiguous, or originating from damaged portions of the images were removed.

解剖学的構造と糸球体の両方の腎臓画像とそのセグメンテーションマスクは、BIOmolecule Multimodal Imaging Center（BIOMIC）のヴァンダービルト大学（TMC-VU）チームにあるHuBMAPの組織マッピングセンターによって生成されました。 糸球体マスクはさらに改良され、手動学習と機械学習の組み合わせを通じて、インディアナ大学チームによって「ゴールドスタンダード」を提供しました。 不正確、曖昧、または画像の損傷部分に由来すると見なされた糸球体の注釈はすべて削除されました。

先行研究：5件の論文が紹介されている。

感想：目的物以外の検出、分野の固有評価方法の援用などが使えそう。解析ソフトは既製品で、GitHubにある。

"This Github page explains how to use the output of ilastik classification in segmentation .tiff files and obtain disease scores per glomeruli."「このGithubページでは、セグメンテーション.tiffファイルでilastik分類の出力を使用して、糸球体ごとの疾患スコアを取得する方法について説明します。グーグル翻訳」

この"ilastik classification"について調べてみた。

"Leverage machine learning algorithms to easily segment, classify, track and count your cells or other experimental data. Most operations are interactive, even on large datasets: you just draw the labels and immediately see the result. No machine learning expertise required."

「機械学習アルゴリズムを活用して、細胞やその他の実験データを簡単にセグメント化、分類、追跡、カウントします。 大規模なデータセットであっても、ほとんどの操作はインタラクティブです。ラベルを描画するだけで、すぐに結果が表示されます。 機械学習の専門知識は必要ありません。グーグル翻訳」

既製品なので、コンペで使うものではない。

NotebooksとDiscussionにおいて"ilastik"で検索したが何も出てこない。

次は２つめの論文：

Glomerulus Classification and Detection Based on Convolutional Neural Networks †
Jaime Gallego, Anibal Pedraza, Samuel Lopez, Georg Steiner, Lucia Gonzalez, Arvydas Laurinavicius and Gloria Bueno

In this paper we propose two methods devoted to: Glomerulus classification and Glomerulus detection. In the Glomerulus classification proposal (Method I), we study the viability of the CNN to achieve a correct Glomerulus classification into Glomerulus/non-Glomerulus classes. In the Glomerulus detection method (Method II), we use the CNN configuration that gave the best results and performance for Glomerulus classification (Method I) to achieve the Glomeruli detection in a WSI. In this proposal, we present a method suitable for PAS samples belonging to different laboratories, thanks to color normalization process used in the data augmentation step. Our method uses a sliding
window with overlapping to perform the detection, and utilizes a majority vote decision for each pixel to reduce false positive detections. With this proposal, we achieve a detection score of 93.7%, which improves upon the results obtained in reference methods.

「 この論文では、糸球体分類と糸球体検出の2つの方法を提案します。 糸球体分類提案（方法I）では、CNNの実行可能性を調査して、糸球体/非糸球体クラスへの正しい糸球体分類を実現します。 糸球体検出法（方法II）では、糸球体分類（方法I）で最高の結果とパフォーマンスを提供するCNN構成を使用して、WSI（Whole Slide Images）で糸球体検出を実現します。 この提案では、データ拡張ステップで使用される色の正規化プロセスのおかげで、さまざまな研究所に属するPAS(Periodic Acid Schiff)サンプルに適した方法を提示します。 私たちの方法は、オーバーラップのあるスライディングウィンドウを使用して検出を実行し、各ピクセルの多数決を利用して誤検出を減らします。 この提案により、93.7％の検出スコアを達成し、参照方法で得られた結果を改善します。グーグル翻訳」

論文はこのくらいにしておこう。自分が良い結果を得て論文にしようとするときには、先行研究を引用しながら自分の研究のどこが先行研究と異なっているかを説明するために用いる。今の自分のレベルと3月末の締め切り日を考えると、新しい評価方法を考案し良い結果を得て論文にまとめることになるとは考えにくい。

課題提供者からの情報のもっと重要な部分に移ろう。

(How to Convert Polygon Masks to Pixel Masks)と(How to Perform Run-Length Encoding)である。多角形で与えられたマスクをピクセルマスクに変換するコードと、検出領域を報告する書式の説明である。

データを眺めてみよう。

とりあえず、論文の画像。

以上は主催者がDiscussionで紹介されている5件の論文から転載したものである。

1月5日（火）

Riiid AIEd Challenge, 3,312 teams, 3 days to go：301th（9：12）

進展なし。

1月6日（水）

Riiid AIEd Challenge, 3,344 teams, 2 days to go：327th

チューニング中！

夜中に、メダル圏外に放出されました。

あと1日ある。さらに離されるか、それとも・・・。

HuBMAP, 783 teams, 3 months to go

ベースモデルを作成しようとしている。

edaとbaselineをキーワードに、公開コードから、自分でハンドリングできそうなコードを探しているのだが、なかなか見つけられない。

チューニングの立場から見ると、チューニングしやすいコードは、スコアに関係しているコードがどれであるか、がわかりやすく、理解しやすく、かつ、パラメータだけでなく、コードの変更も容易であるということになる。目の前のコードがどこまであてはまるかは、見る側のコード理解力、コード構成能力による。

いわゆるベースラインコードと呼ばれるものは、初級レベルの人にも理解しやすいということに加えて、前処理も、訓練/予測モデルも教科書的であり、必要最小限の機能をもつだけであることが多い。

ゼロから作るのは難しく、ベースラインとなるコードから始めるということであれば、これまでと同じように、チューニングしやすいコードを探すことから始めるのがよさそうであるということになる。

これまでと変えたいと思っているのは、フォークしたコードは、理解できる範囲でチューニングするのではなく、隅々まで理解して、あらゆる箇所に手を加えることができるようになることである。

1つのモデルを選定した。そのモデルの作成者は、機械学習・ディープラーニングの中級であると自称している。Kaggleのcompetition, notebook, およびdiscussionのexpertである。

前処理が約110行、訓練が約30行、予測も約30行で、その他が約120行である。

順に理解していこう。

前処理は３種類あり、１つは、マスクの処理で、Run-Length Encodingに関する処理のための関数：rle_encode, rle_decodeなど、もう1つは、画像の分割、最後に、画像とマスクのデータセットの作成である。

1月7日（木）

 Riiid AIEd Challenge, 3,366 teams, a day to go：350th

メダル圏外に放出された。

完敗です。

チューニングメインの戦いはこれを最後にする。

最後にちょっと面白い現象を見ることができた。

フォークしたとき、feature_fractionの値は、0.52に設定されていた。意味が分からずそのまま使っていたが、12月29日に、先が見えなくなって、意味も分からず、0.75と0.25を試してみたら、0.25の場合にpublic LBが上がった。といっても数値は変わらず順位が少し上がっただけである。翌日、0.20を試してみたら、さらに、順位が少し上がった。それ以降0.2がベストだと思い込んでそのまま使っていた。今日、もうすることがなくなって、試しに、feature_fractionを外してみた（デフォルトは1.0）。そうすると、収束後のfeature_importanceの分布が0.2の場合とは全く違うものになった。0.2の場合は、40近くのfeatureを使っていても、ほぼ全てのfeatureがそれなりに寄与していたのだが、デフォルトの1.0では、20個を超えたくらいから寄与が非常に小さくなった。寄与率の減衰率が明らかに大きくなったのである。0.2に設定すると、ランダムに選ばれた2割のfeatureで最適化しようとするから、もともと重要でないfeatureでも無理に使われていたのかもしれない。さらに、0.2では、計算の都度、val_AUCがかなりばらついたし、feature_importanceもval_AUCと同様、計算するたびに、明らかに分布が異なっていたように思う。本質的ではないところで時間を無駄にしたような気がする。上位にいくためには、こんなチューニングよりは、アンサンブルの片割れのSAKTのチューニング、もしくは、SAKTのSAINTとの置き換えに時間を使ったほうが良かったのではないかと思う。

HuBMAP：796 teams, 3 months to go

Run-Length Encodingについては、コンペの課題提供グループから、説明図付きでコードが提供されている。

これはglomerulusとマスクの画像の例である。このマスクは、glomerulusの領域を正しく表現しているのだろうか。

もっと詳細な評価をしている論文はないのか。

この論文では、 glomerular lesions（糸球体の病変）まで検出している。

The convolutional neural networks implemented in this paper consist of U-Net, DenseNet, LSTM-GCNet, and 2D V-Net. All of these architectures receive images
with labels, and output the corresponding predictions. UNet [33], consists of several contracting paths to capture context and symmetric expanding paths which enable
precise segmentation and location.

このホワイトペーパーで実装されている畳み込みニューラルネットワークは、U-Net、DenseNet、LSTM-GCNet、および2DV-Netで構成されています。 これらのアーキテクチャはすべて、ラベル付きの画像を受け取り、対応する予測を出力します。 UNet [33]は、コンテキストをキャプチャするためのいくつかの縮小パスと、正確なセグメンテーションとロケーションを可能にする対称的な拡張パスで構成されています。（グーグル翻訳）

画像解析には、U-Net、DenseNet、LSTM-GCNet、および2DV-Netを用いていると書かれており、最初の段階である糸球体の検出とセグメンテーションには、U-Netが用いられている。

もう1つの論文を見よう。

この論文の解析対象は、糸球体の内部に存在するスパイク状の構造である。

U-Netでセグメンテーションを行い、その内部にあるスパイク構造をResNetで検出・分類している。コンペの課題は、この図では、前処理段階に相当する。

セグメンテーションの正確さが問われているが、正確さの評価は Dice coefficient、

すなわち、正しいマスクと予測したマスクとの重なり度合いで評価される。

train_dataのマスクと、test_dataのマスクのグレードは同じであると仮定すると、train_dataのマスクを用いて訓練するのが最良だと思うが、どうなんだろう。

Run-Length Encodingについて考えているうちに、検出しようとしている糸球体の形状の詳細と対応するマスクの形状との関係が気になって、以上の論文を調べてみた。

コンペの画像とマスクの位置関係を見ていると、マスクは糸球体そのものだけでなく、糸球体を覆っている境界層、および境界層と糸球体の隙間も含んでいるように見える。

ウイキペディアの模式図はつぎのように描かれている。

Bowman's capsuleは、自分が見た範囲（上記論文およびコンペの画像数枚）では、この模式図ほどは厚くないようであるが、コンペのマスクが、総じてこのカプセルを含んでいるように見える。マスクは提供されたまま使うべきかどうか。マスクのサイズや形状を変えたらどうなるのか気になるので、変えられるようにしよう。

＊1月8日追記：2か月前にマスクの正確さについてユーザーから問題提起され、スタッフが対応したことがdiscussionに残されている。その後、private_test_dataにおいても不具合が見つかり、その対応のために、コンペ期間が3月下旬まで延長されることになったということのようである。

主催者が用意している情報をもう一度最初からチェックする。

discussionのタイトル：Welcome to the HuBMAP: Hacking the Kidney Competition!

最初のnotebookのタイトル：Dataset Details

Normal glomeruli typically range from 100-350 μm in diameter with a roughly spherical shape (Kannan, 2019)30155-X/abstract). 

図3は、PASで染色されたヒト腎臓組織のサブセクションからの糸球体を含む光学顕微鏡画像です。 細胞の遺伝物質（核酸で構成される染色体）を含む、細胞ごとに1つの核（球形）は、PAS染色画像で濃い青紫色に染色されます。 PAS染色組織のマゼンタ染色領域は、染色された多糖類です。グーグル翻訳

Figure 3: Glomerulus within PAS Stain Kidney Image

次は、Polygon to Pixel Mask Conversionのnotebookから学ぼう。

学ぶだけでは前進できない。

さあ、新しく、自分のnotebookを立ち上げよう。
 

1月8日（金）

• Riiid AIEd Challenge, 
• 3,399 teams, 
• 2 hours to go：393th 

結果：目標としていた銀メダル以上に届かなかった。

成果：LightGBMに対する理解が増した。

反省：

１．feature engineeringの技術習得が進まなかった。

２．AI Educationへの興味が続かず、当該分野の本質を理解できなかった。（プログラミングやチューニングは手段であり、メダル取得、賞金取得などは目標ではあっても目的ではない。目的はAIの技術開発に寄与することであり、それを実現するためには、コンペの課題をもっと深く理解し、AIをどう使えばこれまでと違うレベルのことができるようになるのかを考え続ける状態を維持しなければならなかったと思う。目標に集中するあまり、目的を見失っていたということになる。当該コンペの開催期間中は当該コンペの課題に集中しなければ何も得られずにおわってしまうということ。期間が短いので、より集中力を高めて取り組まないと身に付かないのだろうと思う。）

３．Riiidコンペが終了する前に次のコンペに取り掛かったのはまずかった。1月3日、Riiidのドラフト計算とcommitの待ち時間に、次のコンペをどれにしようかと考え、on goingのコンペを調べているうちに、HuBMAPに入り込み、お手本になりそうなコードをフォークしてsubmitまでしてしまった。Riiidモデルの見直しやfeature選択の見直しなどやるべきことがあったはずなのに、メダル圏内残留を諦めたようになってしまった。コンペの最後の3日間に集中できなかったことは、反省、反省、反省。

感想：

ちょっと調べたら、すでに商品化されていること、商品化のベースとなっていると推測されるレベルの高い予測モデルが論文発表されていることなどがわかった。それにもかかわらず賞金までつけてKaggleに課題を出したということは、トップレベルのKagglerへの挑戦（状）であって、自分の出る幕ではないと感じた。だからこそ自分の取り組み方を変えなければと思いながら取り組み始めたが、公開コードのチューニングから抜け出せず、途中であきらめようとしたが、それでも何かを学ばねばという思いで取り組んでいた。しかしながら、結局は、チューニングのどつぼにはまってしまったということだ。また、終盤に集中を切らした理由の１つは、銀のレベルまで上がる可能性がなくなったことである。次のレベルに上がるには銀以上が必要だから。

HuBMAP：805 teams, 3 months to go：624th（仮）

notebookの立ち上げ：今日は枠組みを作ろう。

１．notebookのタイトル

・公開コードからキーワードを拾ってみると、（PyTorch or Fastai or Keras or TF）、（EffUNet or ResUNet or PraNet or RetinaNet or FPN or Double UNet or ...）、（GPU or TPU）、・・・

２．構成：概要説明、import、configuration、前処理（preprocess）、augmentation（PyTorch :albumentations） 、モデル（model）、訓練（train）、予測（inference）、TTA、後処理（postprocess）、submitファイルの作成など。

・公開コードから、どのようにパーツを配置しているのかを学ぼう。

・1つ1つのセルに、どれだけのコードを入れるのか。1セル、1機能とか。

・注釈は、どの位置に、どのように入れるのか。マークダウンセルを使う。コードセルの先頭に書く。クラスや関数の直前に書く。

・わかりやすいコードの書き方、改造しやすいコードの書き方。

1月11日（月）

HuBMAP：

さあ、自分のnotebookを作ろう。

HuBMAPのコンペサイトで、New Notebookをクリックし、Notebookを選択し、Createをクリックすると、notebookが立ち上がる。

notebookのタイトルは、"notebook84f8ff2dab"のように、自動的に割り当てられる。そのタイトルのまま使うのは不便なので、コードの内容を表すタイトルに変更する。

＊notebookのタイトル変更：仮に、"HuBMAP TF/Keras UNet"としておこう。

notebookには、コンペのDatasetがデフォルトで付属する。

Notebookを説明しているセルが１つデフォルトで付属する。

そのセルは、実行すると、pandasとnumpyとosをimportし、Datasetのディレクト名やファイル名を表示する。ファイル名の拡張子は、csvの他に、tiffとjsonがある。

1月12日（火）

HuBMAP：839 teams, 2 months to go

自分のnotebookを作ろうとしている。

そのnotebookのタイトルを仮に"HuBMAP TF/Keras UNet"としたのは、HuBMAPのコンペで、プログラムをTF/Kerasで記述し、UNetを使って、glomeruli FTU（functional tissue units ）を検出しようと考えている、ということである。

notebookを立ち上げた時にデフォルトで付いていたセルはそのまま使う。これを1番目のセルとする。1番目のセルは手を加えずにそのまま使うことにする。

2番目のセルをどうしようか迷っている。よくあるパターンは、モジュールとかパッケージをimportすることである。

プログラムを作る順番を、迷う必要はない。セルの追加・削除、順番の入れ替えなどは、いつでも、容易にできるので、1セル1機能の考え方で、とにかく必要なセルを作っていこう。

ようやく、train.csvを読み込んでtableを表示した。8つの画像のidとマスクの位置情報（RLE encoded segmentation masks）が含まれている。

まずは、画像とマスクを表示してみよう。

画像を読み込んで表示してみた。ファイルサイズが大きいので、適切なタイミングで消去しなければ、メモリーオーバーになって、プログラムは途中で停止してしまう。

1月13日（水）

HuBMAP：849 teams, 2 months to go (Mar 26)

今日は、マスクデータの操作方法を学ぶ。

Paulo Pinto氏により公開された、Severstal: Steel Defect Detectionのコンペにおける"mask2rle"と"rle2mask"のコードが、このコンペの公開コードで引用されている。

"mask2rle"のコードは、実質6行、"rle2mask"のコードは、実質9行である。

rle2maskには、shape=(1600, 256)というように画像サイズが指定されていて、違和感を感じたが、これは、Severstal: Steel Defect Detectionコンペのsteel試験片の画像サイズに対応しているので、目的とする画像サイズに合わせればよいということがわかる。

理解しておくべき主なキーワードは、"T", "flatten", "concatenate", "where", "join", "split"である。 

Notebooks Grandmasterのiafoss氏も同様なコードを使っており、扱いにくい大きな画像を短冊状に切り出して使いやすくした画像のデータセットを公開されているので、iafoss氏のコードも見ておく。iafoss氏の関数のネーミングは、"mask2enc" と "enc2mask" となっている。

この2つの関数 "mask2enc"  と "enc2mask" を使うことにして、先へ進む。

1月14日（木）

HuBMAP

いろいろなコードを見ていると、目移りして、現在位置がわからなくなった。

自分のnotebookは、1週間経っても、まだ、"train/0486052bb.tiff"を表示しただけである。

1月6日に、trainとinferenceを含む公開コードの1つを選んで、それに倣って、自前のコードを構築するつもりだったが、2，3日の中断の間にそのことから離れてしまっていた。その公開コードにもどろう。

そのコードは、train+inferenceであり、submitしてpubliv LBも得られているので、学ぶには適切だと思ったが、入力データが3つあって（input(3)）、PreTrain coco weightsと、PyTorch pretrained modelsが含まれている。こういうデータセットは有用だが、最初からこれを使ってしまうと、それに縛られて次の展開が難しくなるかもしれないので、入力データが、コンペのデータセットのみ（input(1)）のコードを探した。そうすると、version1がそれに該当し、かつ、そのコードは公開コードのコピーではないことがわかったので、version1をお手本にして次に進もう。

version1はtrainまでだが、そのtrainの結果を見ると、1エポックに約40分かかっており、かつ、train BCEは順調に下がっているが、valid BCEは1度下がっただけで反転、すなわち3エポック目でoverfittingになっている。

モデルは、torchvision.models.segmentation.fcn_resnet50(True)を使っている。

PyTorchのドキュメンテーションを見ると、Semantic Segmentationとして、FCN ResNetとDeepLabV3 ResNetの2種類がある。

notebookのタイトルからは、EffUNet, ResUNet, PraNet, RetinaNet, FPN, Double UNet, Unet++などのモデルが使われていることがわかった。

それぞれの特徴を調べてみようと思って文献を検索してみた。特徴を調べると書いたが、本音は、糸球体の領域を正しく検出できるモデルはどれかを知りたいということである。しかし、糸球体をDNNで調べる最終的な目的は、糸球体の病態を調べることにあるからだろうと思うのだが、今回のコンペのように糸球体の領域をいかに正確に切り出すことができるか、ということについて、種々のモデルを比較した論文は見つけられなかった。自分でやってみて論文にまとめると面白いかもしれない。しかしながら、本当に重要なのはこれまでのどのモデルよりも正確に評価するモデルを構築することだ。

input(1)にこだわっていたが、このコードの作者は、version4（input(3)）において、学習済みモデルを使用するなどの対策を講じることによって、train時間を短縮し、val_lossを低減することに成功し、かつsubmissionファイルも完成させているので、このversion4の理解を次の目標にする。

version4のセルの総数は20。セル１からセル５までは準備。

セル６は、rle_encode, rle_decode, make_grid（画像の分割）。

セル７は、全く理解できない。セル８は、・・・。セル９は画像とマスクのペアを描画して確認。

セル10とセル11は、train_dataとval_dataへの分割か？

セル12からセル17までは、get_modelからtrainまで。セル18で不要なデータを消去。

セル19は、test_dataの処理と予測とsubmissionデータの作成。

セル20は、submissionファイルの作成。

1月15日（金）

HuBMAP：

セル単位で理解しながら、1語づつ、１行づつ、丁寧に転記していこうと思ったが、理解が追い付かず、思うように進まないので、夕方になって、version 4の20のセルの全てをコピペした。

これをRunしたら、これまでのチューニングと、ほぼ同じことになる。

学びやすいコードを選んだ結果、PyTorchを使うことになった。notebookの名前は、TF/Keras UNetとしていたが、中身は、現時点では、PyTorch FCN ResNet50である。

FCN ResNet101、DeepLabV3 ResNet50、DeepLabV3 ResNet101などを使ってみることについては、比較的容易にできそうである。

この中では、DeepLabV3 ResNet101が最も性能が高そうだが、Kaggle kernelで動かせるかどうかわからないが、やってみればわかること。

それよりも、EfficientNetとUNetの組み合わせが良さそうなので、UNet with EfficientNet Encoderモデルを調査しよう。

 1月16日（土）

HuBMAP：

UNet with EfficientNet Encoderを論文を見ながら組み上げる力はないので、コードを探してみる。

最初に探すべき場所は、GitHubであろう。

efficientnet unetで検索すると14件のrepositoryが出てきた。

segmentation modelを包括的に扱っているrepositoryでは、Unet, Linknet, FPN(Feature Pyramid Network), PSPNet(Pyramid Scene Parsing Network)の4種類のモデルと、VGGからEfficientNetまで10種類（サイズまでカウントすれば32種類）のbackboneの組み合わせが紹介されている。

当該コンペ内で、Unetがどのように使われているかを調べてみると、ほぼ、上記のGitHubサイトからの引用であることがわかった。

ということで、明日は、すでに誰かが作成しているデータセットがあればそれを使うこととし、もし、便利に使えるデータセットがなければ、自分でデータセットを作ってみようと思う。

最初は、網羅的なことは考えず、EfficientNetをbackboneとするUnetを、intenet offで使えるようにする。 

1月17日（日）

HuBMAP：

インターネットに接続しておけば、次のコードで簡単にインストールできるのだが、

!pip install git+https://github.com/qubvel/segmentation_models.pytorch

これをデータセットにして、インプットデータに加えて、次のコードでインストールしようとしたが、うまくいかなかった。

!pip install ../input/qubvelsegmentationmodelspytorch -f ./ --no-index

"qubvelsegmentationmodelspytorch"は、作成したデータセットのファイル名である。

次のようなメッセージが現れて停止する。

Looking in links: ./
Processing /kaggle/input/qubvelsegmentationmodelspytorch
Requirement already satisfied: torchvision>=0.3.0 in /opt/conda/lib/python3.7/site-packages (from segmentation-models-pytorch==0.1.3) (0.8.1)
ERROR: Could not find a version that satisfies the requirement pretrainedmodels==0.7.4 (from segmentation-models-pytorch)
ERROR: No matching distribution found for pretrainedmodels==0.7.

requirements.txt は、以下の内容である。

torchvision>=0.3.0
pretrainedmodels==0.7.4
efficientnet-pytorch==0.6.3
timm==0.3.2

これらのモジュール/パッケージがインストール済みであることが前提になっているのだろう。ということだとすると、Kaggle kernelの中を把握し、それを適切にコントロールできることが必要なのだろう。 

1月18日（月）

HuBMAP：

GitHubにあるsegmentation modelをHuBMAP用のnotebookで使えるようにするために、今日は、Kaggle の notebook について学ぼう。

＊＊＊急用が入ったので中断 ＊＊＊

1月20日（水）

HuBMAP： 

1月18日に調べていたnotebookのDockerについて、作業を進めよう。

KaggleのNotebookのサイトのトップページに移動する。

Notebooks
Explore and run data science and machine learning notebooks. Learn More.

トップページにある、このLearn More.をクリックすると、次のサイトに移動する。

How to Use Kaggle
Help and Documentation

ここから、Notebooks/The notebook Environment/modifying a Notebook-specific Environmentと辿れば、notebookのDockerの使い方がわかる。

自分が今使っているnotebookのセルにおいて、!pip install my-new-package（!pip install pretrainedmodels==0.7.4）を実行すれば、notebookのDocker containerに、モジュールやパッケージを、インストールすることができる。

既に存在するパッケージのバージョンを変更したい場合は、!pip install my-existing-package==X.Y.Zとすればよい。

ということで、次の3つをインストールした。

!pip install pretrainedmodels==0.7.4
!pip install efficientnet-pytorch==0.6.3
!pip install timm==0.3.2

この3つを、今使っているnotebookにインストールしておけば、インターネットを閉じて、notebookにinput dataとしてアップロードしたdatasetに格納したPyTorchのsegmentation modelsをインストールすることができることを確認した。

これで、課題を１つクリヤすることができた。

インストールしたモジュールやパッケージがnotebookのDockerに格納されているかどうかは、notebookのセルで、!pip listを実行すれば、確認することができる。

このDockerの状態が、notebookに対して別の作業をしたときにも保持されているかどうかは、まだわからない。

明日から、segmentation modelsに入っていて、notebookのDockerに格納されたであろうパッケージ内にあるモデルを読み込んで、現状のモデル "Pytorch FCN-Resnet50"と置き換えることに挑戦する。

最初に、EfficientNet-Unetを使えるようにする。

1月21日（木）

notebookのDockerへのパッケージの追加はうまくいったと思ったが、Run allを実行すると、追加したパッケージは削除されていた。

特定のnotebookに特定のDockerを付属させることができるようだが、再スタートするとインストールされたはずのパッケージが消えている。

Kaggleの説明文：

Modifying a Notebook-specific Environment
It is also possible to modify the Docker container associated with the current Notebook image.

Using a standard package installer
In the Notebook Editor, make sure "Internet" is enabled in the Settings pane (it will be by default if it's a new notebook).

For Python, you can run arbitrary shell commands by prepending ! to a code cell. For instance, to install a new package using pip, run !pip install my-new-package. You can also upgrade or downgrade an existing package by running !pip install my-existing-package==X.Y.Z.

!pip installを実行すれば、確かに、新たにDocker containerに、インストールしたことを!pip listによって、確認することができる。

Restart sessionで、元の木阿弥になる、インストールしたパッケージが消えてしまうのだ。

変更したDocker imageを使うのだから、Environment Preferenceの、Pin to original environmentではなく、Always use latest environmentを選んでいる。

インターネットOnで、パッケージをインストールした後、インターネットOffにして、ドラフトを走らせれば良いのではないかと思うのだが、うまくいってない。timmとかefficientnet-pytorchなども、datasetに入れて、inputdataとして読み込んでインストールできれば良いのだが、できないだろうか。

HuBMAP：892 teams, 2 months to go : 698th(0.827)

FCN-Resnet50のかわりに、とりあえず、DeepLabV3 Resnet50を使おうとしたら、エラーが出てしまった。うまくいかないものだ。まだ、コードの理解が足らないのだろう。torchvisionに入っているのだから、簡単だろうと思ったのだが、うまくいかない。

1月22日（金）

HuBMAP：

Dockerにパッケージを追加してからinternet offにしてRun allにすれば計算は可能で、submitも可能（エラーは出ない）であることを確認した。

しかし、commitの結果を見ると、プログラムの最初に実行した!pip listによって、ドラフト計算中に存在していたはずのパッケージが消失していることが分かった。

internet offの条件付きのコードコンペでは、追加したいモジュール/パッケージは、全て、Datasetからインストールするしかなさそうだ。

よくわからなかったが、いろいろやってみて、なんとかできるようになった。

＊必要なもの（pretrainedmodels==0.7.4、efficientnet-pytorch==0.6.3、timm==0.3.2）は、Datasetにして、Datasetからインストールすることができるようになった）

Datasetの作り方：

・pretrainedmodels==0.7.4をインストールするためのDataset：

Googleで検索し、ダウンロードサイトhttps://pypi.org/project/pretrainedmodels/　に行って、ファイルをダウンロードし、Kaggle のDatasetサイトの、+ New Datasetをクリックし、ダウンロードしたファイルを、フォルダーごと、Drag and drop files to uploadのスペースに移動する。データセットに名前を付けて、Createボタンをクリックすれば出来上がり。Createボタンの横にあるボタンで、PrivateかPublicかを選んでおく。

・efficientnet-pytorch==0.6.3をインストールするためのDataset：

同様にして、https://pypi.org/project/efficientnet-pytorch/　このサイトからダウンロードした。ただし、バージョンがefficientnet-pytorch 0.7.0となっていたので、Project descriptionボタンの下の、Release historyをクリックして、0.6.3を選んでダウンロードした。以下同じ。

・timm==0.3.2をインストールするためのDataset：

同様にして、https://pypi.org/project/timm/0.3.2/　このサイトからダウンロードして、同様の操作をしたが、圧縮ファイルであったためか、作成したDatasetでは、installできなかった。エラーメッセージに、setup.pyが見つからないと表示されていた。確かに、フォルダーの中を見ても、そのようなファイルが見当たらない。結局、7-zipで解凍し、setup.pyを確認してから、Datasetを作成した。

＊これで、Segmentation-models-pytorch 0.1.3 を使う準備ができた。

明日は、FCN-Resnet50が使っているpretrain-coco-weights-pytorchとpytorch-pretrained-modelsの２つのDatasetがどのように使われているのかを確かめるとともに、新たなDataset：segmentation-models-pytorch013の使い方を検討する。

1月23日（土）

HuBMAP：896 teams, 2 months to go：

FCN-Resnet50をdeeplabv3-Resnet50に変更した。

オリジナルコードのinput Datasetに必要なデータが入っていたのでモデル名を書き換えただけで動くと思ったが、エラーが出た。データサイズが違うからダメとのこと。

model.classifier[4]とmodel.aux_classifier[4]の意味が分からずググると、GitHubでabeja-incが公開しているコードplatform-feature-image-segmentationのtrain.pyの中で使われていて、FCN-とdeeplabv3ではコードが少し異なっていて、if文で分けている。それに倣ってコードを変更することによりdeeplabv3-が使えるようになった。しかし、計算時間は3割増し、Lossの初期値は4割増しとなり、途中までは期待外れ。エポック数を増やしてみてどうなるか、調べてみる。

3エポックでは、deeplabv3の方がval_lossがかなり大きいにもかかわらずLBは同レベルだった。deeplabv3を7エポックまで増やしてcommit, submitした結果、overfittingのためLBは14/1000悪化した。FCNとの比較ではdeeplabv3が少しよさそうな感触だが、これ以上は追及しない。 

segmentation_models_pytorch 0.1.3：

各モデルのweightは、外部から読み込むようになっているので、internet offでは、

URLError: <urlopen error [Errno -3] Temporary failure in name resolution>

このようにエラーとなる。

ということで、Datasetを作った。といっても新たに作ったのはなく、Datasetのコピーである。元のdatasetのネーミングがわかりにくかったので、わかりやすいものにした。

internet経由でのweightの読み込みは、こんなふうになっている。

Downloading: "https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b5-b6417697.pth" to /root/.cache/torch/hub/checkpoints/efficientnet-b5-b6417697.pth

Dataset（名前は、pytorch_efficientnet_pretrained_models）から読み込んだweightのデータは、同じ場所に置くことになる。そのためのコードは、勉強中のコードを参考にすると、次のようになる。（最初にこのコードを見たときは全く理解できなかった）

!mkdir -p /root/.cache/torch/hub/checkpoints/

!cp ../input/pytorch_efficientnet_pretrained_models

/efficientnet-b5-b6417697.pth /root/.cache/torch/hub/checkpoints/ 

ようやく、internet offで、efficientnetB5-Unetのモデルができた。

モデルのコードのほんの1部分を表示する。（注） インデントは表示できない。

最初の6行：effitientnetB5ベースのエンコーダ：

Unet(
(encoder): EfficientNetEncoder(
(_conv_stem): Conv2dStaticSamePadding(
3, 48, kernel_size=(3, 3), stride=(2, 2), bias=False
(static_padding): ZeroPad2d(padding=(0, 1, 0, 1), value=0.0)
)

おそらく、デコーダーの開始：

(decoder): UnetDecoder(
(center): Identity()
(blocks): ModuleList(
(0): DecoderBlock(
(conv1): Conv2dReLU(
(0): Conv2d(688, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
デコーダのブロックが０から４まで続き、最後はセグメンテーションブロック：
(segmentation_head): SegmentationHead(
(0): Conv2d(16, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): Identity()
(2): Activation(
(activation): Identity() ) ) )

次は、このefficientnetB5-Unetで解析する方法を検討しよう。

コードを作るにも、バグ出しするにも、時間がかかるだろうから、まずは、B5よりも倍以上計算速度が速い、efficientnetB0-Unetで検討することにしよう。

関係ありそうなコード

model = smp.Unet('efficientnet-b0', classes=1, aux_params=aux_params)

試しに走らせてみたらエラーになった箇所

output = model(image)['out']：TypeError: new(): invalid data type 'str'

1月24日（日）

HuBMAP：

PyTorchでEfficientnet-Unetを用いたコードを調べた。

output = model(image)['out']ではなく、output = model(image)となっていたので、['out']を削除した。

その結果、trainまでエラーなく動き、lossも減少している。

efficientnetB0からB3にすると、B0では、train_lossとval_lossの反転が3エポック目で生じたが、B3では、5エポックでも反転しなかった。B5では、GPUのメモリーオーバーとなって計算できなかった。

順調かと思いきや、trainまでは動いたが、inferenceの次の行でエラーが発生した。

score = model(image.to(DEVICE)[None])['out'][0][0]

上記と同様に対処すればよいのだろうが、どこまで削除したらよいのだろう。

score = model(image.to(DEVICE))：これで動けばよいのだが。

動作確認中に、failed to fetchと表示されて計算停止。再度Run。

RuntimeError: Expected 4-dimensional input for 4-dimensional weight [40, 3, 3, 3], but got 3-dimensional input of size [3, 257, 257] instead

trainのときの対応と同じく、['out']のみ除去する、ということでエラーは回避できた。

1月25日（月）

HuBMAP：

efficientnetB3-Unetの5エポックで、LB=0.740：849th相当/905 teams

3エポックでは、LB=0.280となり、心配だったが、うまく計算できているようだ。

6エポックでは、LB=0.777となった。

他の条件は全く同じで、FCN-Resnet50の場合には、3エポックでLB=0.798であった。ちょっと計算してみた、というだけでは、各モデルを正しく評価できていないかもしれない。

U-Netの調査

Review: U-Net (Biomedical Image Segmentation)
Sik-Ho Tsang, Nov 5, 2018·5 min read

 Since unpadded convolution is used, output size is smaller than input size. Instead of downsizing before network and upsampling after network, overlap tile strategy is used. Thereby, the whole image is predicted part by part as in the figure above. The yellow area in the image is predicted using the blue area. At the image boundary, image is extrapolated by mirroring.

 Since the training set can only be annotated by experts, the training set is small. To increase the size of training set, data augmentation is done by randomly deformed the input image and output segmentation map.

GitHub：qubvel/segmentation_models.pytorch：に含まれているモデルは、9種類ある。HuBMAPの課題に対して、どれが最適かは、実際に適用しなければわからない。

Unet,  Unet++, MAnet, Linknet, FPN, PSPNet, PAN, DeepLabV3, DeepLabV3+

これらのモデルの文献を調べると、Unetが2015年、PSPNetが2016年、LinknetとDeepLabV3が2017年、Unet++とPANとDeepLabV3+が2018年、FPNは2017年の論文ではdetectionに、2018年以降にsegmentationにも用いられたようである。MAnetは2020年となっている。このように、MAnetが最も新しく、肝臓と腫瘍のsegmentationや、空撮画像のsegmentationに威力を発揮しているようである。その模式図は以下の通り。

それではと意気込んでMA-Netで計算してみたが、デフォルトでは、良い結果は得られなかった。HuBMAPの課題に合わないのか、それとも、正しく使えていないのか。

1月26日（火）

HuBMAP：

MA-Net：上に示した模式図の外観からはU-Netのバリエーションの1つと考えられる。

名称はMulti-scale Attention Netで、2つの構成要素からなる。Position-wise Attention Block (PAB) and Multi-scale Fusion Attention Block (MFAB)

それぞれ次のように説明されている。The PAB is used to model the feature interdependencies in spatial dimensions, which capture the spatial dependencies between pixels in a global view. In addition, the MFAB is to capture the channel dependencies between any feature map by multi-scale semantic feature fusion.

引用文献を示していなかった。

表2と表3の両方に、U-Netがある。表2のU-Netはオリジナルで、表3のU-Netは``Liver segmentation in CT images using three dimensional to two dimensional fully convolutional network"というタイトルの論文中で次のような模式図で表されている。

というように、MA-Netは優れもののようだが、試しに動かしただけでは、期待した結果は得られていない。

今日は、LinknetとPSPNet（Pyramid Scene Parsing Network）を3エポック計算してcommit, submitしたが、いずれもSubmission Scoring Errorとなった。

PAN（Pyramid Attention Network）も計算してみた。計算時間は他のモデルの2倍くらいかかった。LBスコアは2エポックからoverfittingになっていたので予想通り低く、0.243であった。

encoderをefficientnetB3にし、batch_size=32で、9つのモデルの全てで計算可能か否かを調べた。その結果DeepLabV3のみ、batch_size=16にしてメモリーオーバーを回避した以外は、計算できた。1エポックあたりの計算時間は6つが12分程度だったが、PANとDeepLabV3+は約20分、DeepLabV3はbatch_size=16で24分を要した。

まだ、性能を比較できる段階には到っていない。

公開コードの様子から、efficientnetB3-UnetでLB=0.85が視界に入るぐらいになってからにしようかなと思っている。

• Segmentation Modelsは、FCN-Resnet50が動作していた公開コードを借用して、モデルを置き換えただけである。
• Aux classification outputが次のように例示されているが、まだ使っていない。
• 今回の課題は糸球体だけを検出するから、不要！

• aux_params=dict(
      pooling='avg',             # one of 'avg', 'max'
      dropout=0.5,               # dropout ratio, default is None
      activation='sigmoid',      # activation function, default is None
      classes=4,                 # define number of output labels
  )
  model = smp.Unet('resnet34', classes=4, aux_params=aux_params)
  mask, label = model(x)
  mask.shape, label.shape
  # (N, 4, H, W), (N, 4)

次のようなlossが用意されているが、これもまだ使っていない。

JaccardLoss
DiceLoss
FocalLoss
LovaszLoss
SoftBCEWithLogitsLoss
SoftCrossEntropyLoss
SoftCrossEntropyLossは、Drop-in replacement for torch.nn.CrossEntropyLoss with label_smoothingとのことである。

あとは、k fold cross validationと、data augmentationをやらないといけない。

GPUは残り20分程度になってしまったので、本格的な計算はできない。

（出力層）、loss、K fold cv、augmentationなどを、GPUが使えるようになる土曜日の朝までに追加して、次のステージに進めるようにしよう。

1月27日（水）

HuBMAP：

出力層（Aux classification output）を、良く考えずに追加しようとしたが、maskは1種類で、分類はしないから、不要！

augmentationをやってみよう。

Albumentations Documentationを見ると、目的毎に良く使われる方法や、ベースセットのようなものが、加工後の画像例とともに示されているので、適当に選んで、コピペして使うことができる。

augmentasionのセットをコピペして、計算できることをCPUで確認した。GPUが使えない（使い切った）ので3エポックぐらい計算しただけで、commit, submitまではできなかった。効果の確認やチューニングは土曜日以降になる。

loss関数、optimizer、lrについては、明日、検討してみる。

1月28日（木）

HuBMAP：

lossは、順に試してみるつもりだが、２つか３つを組み合わせることで、より良い結果が得られるという報告もあり、最適解を見つけるのは容易ではなさそうだ。

Kaggleで過去のコンペのトップクラスの解法を見れば、参考になることは多いが、状況が異なっているので、そのまま適用してもうまくいかないかもしれない。

プログラム中に、全てのloss関数を書き込んでおいて、単独でも混合でも使えるようにしておこう。

optimizer, lr scheduler：

最近提案されたoptimizerに、NovoGradというのがあって、AdamやAdamWよりも高性能ということらしい。

Training Deep Networks with Stochastic Gradient Normalized by Layerwise Adaptive Second Moments, Boris Ginsburg  et al., arXiv:1905.11286v3 [cs.LG] 6 Feb 2020

In all experiments, NovoGrad performed equally or better than SGD and Adam/AdamW. NovoGrad is more robust to the initial learning rate and weight initialization than other methods. For example, NovoGrad works well without LR warm-up, while other methods require it. NovoGrad performs exceptionally well for large batch training, e.g. it outperforms other methods for ResNet-50 for all batches up to 32K. In addition, NovoGrad requires half the memory compared to Adam.

NovoGrad and all models in this paper are open sourced. 

https://github.com/jettify/pytorch-optimizer

Datasetを作って、このpytorch-optimizerを使う準備をした。

明日は、NovoGradとOneCycleLR Schedulerを使ってみよう。 

1月29日（金）

HuBMAP：

optimizerとlr_scheduler：素人につき、検討中！

順序：

optimizer = torch.optim.AdamW( ...

scheduler = optim.lr_scheduler.OneCycleLR(optimizer, ...

for image, mask in loader:

      ................................

      output = model(image) 

      loss = loss_fn(output, mask)

      loss.backward( )

      optimizer.step( )

      scheduler.step( )

こんな感じでよいのかな。

この順に並べてみたが、計算結果は異常であった。train_lossはlr_scheduler無しの場合よりも少し大きかったが問題ないレベルだと思う。しかしval_lossが桁違いに大きかった。

pytorchのマニュアルをみるとexampleがあり、引用文献をみるとoptimizerにSGDを使い、lrは考えられないくらい大きな値（最大値）を使っている。まずは、次のexampleをそのまま使ってみよう。

Example

>>> data_loader = torch.utils.data.DataLoader(...)
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=0.01, steps_per_epoch=len(data_loader), epochs=10)
>>> for epoch in range(10):
>>>     for batch in data_loader:
>>>         train_batch(...)
>>>         scheduler.step()

これでは、trainingは進まなかった。原因調査中。

Example

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = ReduceLROnPlateau(optimizer, 'min')
>>> for epoch in range(10):
>>>     train(...)
>>>     val_loss = validate(...)
>>>     # Note that step should be called after validate()
>>>     scheduler.step(val_loss)

Example

>>> scheduler = CosineAnnealingWarmRestarts(optimizer, T_0, T_mult)
>>> iters = len(dataloader)
>>> for epoch in range(20):
>>>     for i, sample in enumerate(dataloader):
>>>         inputs, labels = sample['inputs'], sample['labels']
>>>         optimizer.zero_grad()
>>>         outputs = net(inputs)
>>>         loss = criterion(outputs, labels)
>>>         loss.backward()
>>>         optimizer.step()
>>>         scheduler.step(epoch + i / iters)

WARNING

Prior to PyTorch 1.1.0, the learning rate scheduler was expected to be called before the optimizer’s update; 1.1.0 changed this behavior in a BC-breaking way. If you use the learning rate scheduler (calling scheduler.step()) before the optimizer’s update (calling optimizer.step()), this will skip the first value of the learning rate schedule. If you are unable to reproduce results after upgrading to PyTorch 1.1.0, please check if you are calling scheduler.step() at the wrong time.

1月30日（土）

HuBMAP：

OneCycleLR：これを使えるようにする。

optimizer：SGD：torch.optimのマニュアルのexampleそのままで実行してみた結果、train_lossは見事に収束したが、val_lossはtrain_lossより小さい。すなわち、underfitting、のような結果である。パラメータの設定が不十分なのだと思う。

今は、submitしてスコアが計算されることの確認が重要なのでcommitした。

ところが、commit中にWarningが現れ、心配た。約4時間後、スコアは計算されていた。それはよかったのだが、なんと、LB=0.486であった。なさけない。

optimizer：AdamW：AdamWはlr_schedulerを使わない場合のデータがあるので、lr_schedulerを入れたことによるlossの変化を比較することができる。

schedulerはそのままで、lrとweight_decayはデフォルト値から始めてみた。

train_lossは減少したが、val_lossが、ありえないくらい大きな値になった。

不慣れでよくわからなかったが、lrの初期値や最大値を変更することで、設定した10エポックで収束し、かつ、lr_schedulerを使わない場合よりも30％くらい小さいval_lossが得られた。

その結果、ようやくLB=0.796（859th相当）となった。

公開コードのチューニングをしていて最も驚いたことの１つが、この、lr_scheduler.OneCycleLRである。

指定したエポック数で収束する仕組みは凄いなと思う。

efficientnetのpretrained modelには、imagenetの他に、advpropやnoisy-studentいうのがある。これらを使えるようにしたいと思う。

これは、モデルのweightに"advprop"もしくは"noisy-student"を指定してRunすれば、学習済みモデルのweightの場所を指定するメッセージが現れてプログラムが停止するので、そのメッセージに示されているURLからweightをダウンロードして、Datasetを作ればよい。

明日は、計算速度向上の方法を、"Pytorch FCN-Resnet50 in 20 minute"に学ぼう。

1月31日（日）

HuBMAP：

昨日だけでGPUを16時間以上使い、LBスコアは0.777から0.796まで上がった。

元は同じコードで、前処理の計算時間を短縮したバージョンを別のKagglerが公開しているので、それに乗り換えてみる。train時間だけを見ると、8倍くらい速く、トータルでも3~4倍速い。

コードを解析して高速化した部分だけ移植する方法もあるが、コードの変更履歴がわからないことと、コードの理解力不足のため、乗り換える（主に、segmentation modelsパッケージの追加）という方法をとることにする。

とりあえず、trainまで動くようにした。メモリーの使用状況を見ると、前処理したデータを全部RAMに格納してから、trainを開始していることがわかった。元のコードではCPUとGPUが交互に動作していたが、高速コードでは、CPUとGPUが並列動作しているように見える。それで、全体として、処理速度が向上しているのだろう。commit, submitしてみると、LBスコアも計算された。

昨日は、LB=0.80を超えられなかったが、時間短縮できるコードに乗り換えると、時間短縮の効果に加えて、LBスコアも0.83+にアップした。

スコアアップの原因は、augmentationであることがわかった。

コード乗り換えの際に、使われているaugmentationのコードが同じものに見えたので、取り換えなかったのだが、よく見ると、新たなaugmentationコードでは、distortion（ElasticTransform, GridDistortion, OpticalDistortion）の確率がゼロになっていたのである。昨日までのコードは、変形量を大きくしすぎていたために、trainがうまく進まなかったものと思われる。

1月7日に終了したRiiid!コンペは残念な結果に終わった。チューニングだけでは、まぐれあるいは幸運にも恵まれないとメダルは難しい。

次のステップに進むために、GitHubを活用し、モデルの選択肢を増やし、最新の情報に接し、日々勉強を怠らず、技術と知識を積み重ねていこう。

1月は今日で終わり。来月もKaggleに集中しよう。

style=162 iteration=500

style=162 iteration=50

style=162 iteration=5

Kggle散歩（December 2020）

Kggle散歩（December 2020）

MoAが終了した。

現在参加しているものはいくつかあるが、今月は、Riiid!に注力しようと思う。

MoAで２つめのメダルがとれそうである（暫定181位で銀）：12月11日確定！！：Kaggle Competition Expertになった。

次のランクアップのためには、金メダルが必要になる（銀も必要）。これまでの参加経験からして、相転移しなければ、金メダル獲得は無理である。金の難しさは桁違いだ。

12月1日（火）

Riiid!：2,177 teams, a month to go

the starter notebookを学習中

MoA： 終了

終了後に上位陣のスコアを生み出したコードのアーキテクチャが明らかになるので、しっかり学びたい。コンペ終了時にはいつもそう思うのだが、上っ面を眺めただけで終わってしまうことが多い。コンペが途切れた時に時間ができて過去のコンペに戻って復習しようとしても、反省すべきことも、コンペの課題もぼやけてしまっていて、結局のところ、真剣に振り返って学んだことはほとんどない。

まだ記憶に残っているうちに、次のレベルに向かうために必要なことを検討しよう。

学習を効果的に行うために必要なことは何か。Riiid!コンペの本質もそこにあると思うのだが、いつ何をどのように学習すると成績が向上するのか。なぜ、同じだけ得点をアップするのに3か月で済む人と半年以上かかる人がいるのかを考えてみる必要がある。

Riiid!が、学習の効率を測るために、学校での学習や塾での学習ではなく、TOEICを取り上げたのは、本当の理由は知らないが、次のように推測される。

TOEICには、固定した学習プログラムがなく、同じテキストと教材を使っても、スケジュールが個人任せになっているので、参加者の取り組み方に、非常に大きなばらつきが存在する可能性が高い。効果的に学習出来て成績が短期間で向上する人から、そうでない人まで、非常に広範囲にわたるデータが集まる可能性がある。学校のプログラムで同じことをやると、記憶力とか理解力が大きく反映されて、学習効率を測ることが難しくなるのではないだろうか。

本題に戻ろう。

１．現状分析

これまでに20件近くのコンペに参加した。そのうちの13件は成績が残っており、そのうちの2件は、ほんの少しだけの参加で、残りの11件は、メダル獲得を目指したものであり、入賞はLandmarkとMoA （暫定）の2件である。

まず、見えていない部分（約20件と13件の差、約7件）について検討してみよう。

記憶に新しいものはARCコンペである。これに取り組んでいた頃は、ARCの論文を勉強していて、知能テストについてもいろいろと調べていた。コンペが始まってすぐに感じたことは、コンペの主催者（F. Chollet氏）が求めていることと、現に存在している機械学習（ディープラーニング等を含む）でできることとのギャップの大きさである。このコンペは、目指しているものが非常に高いところにあるということでは歴史に残るものかもしれない。勝者はいわゆる力づくで解いたヒトのようである。train dataからできるだけ多くのパターンを把握し、test dataの例題から解答パターン（モザイクの構造パターン）を推測し、用意しておいたパターン変換を行うというもので、従来型のプログラミング手法によるものである。機械学習を用いて、興味深い結果を得ているものもいくつかあった。自分は、コンピュータに解き方を教えるための方法を考えるために、課題を解きながら解き方を分類してプログラムコードに置き換えようとしていたが、途中で投げ出してしまった。5月27日にコンペが終了した後、ARCコンペから何かを学ぼうとしたが、人工知能に関する論文（教育心理学？哲学？）をいくつか読んで終わった。

他に、かなり力を入れて参加したのは、眼底写真から病状を分類するAPTOS2019と鋼板表面の異常部を検出するSeverstalがある。

APTOS2019は、submit後にエラーになって記録が残らなかった。前処理とsubmissionファイルを作成する部分がよくわからずその部分のコードを公開コードから借用した。

Severstalは、前処理からできるようにしたいと思って、ゼロからプログラムしていたが、結局、前処理を完成することなく終わった。

このころの目標は、自前のプログラムコードを作成して、予測して、結果をsubmitして,リーダーボードに載ることだった。

ここからは、あまり見られたくないことも、少し書いておく。

Kaggleでは、まず、参加することによって得るものがあると思ったコンペに参加する。

次に、コンペの概要、データの概要をある程度把握したら、notebookのEDAをざっと見てデータの概要を図や表から、もう少し詳しく把握する。

その次に、高いスコアを得ているコードの中から、読みやすく、再チューニングやモデルの変更がしやすそうなコードをフォークして、Kaggle kernel内で実行、commit、submitする。

その次に、予測モデルのハイパーパラメータや構造をチェックして、経験上、変更した方が良さそうなパラメータ（モデルの簡単な構造変更を含む）を変更し、Kaggle kernel内で実行し、commit、submitする。

選んだモデルで得られるスコアに限界を感じたら、ディスカッションを読み、高得点を得ている公開コードをチェックする。このとき、高得点を得ていなくても、良いモデルを使っていて、読みやすい、変更しやすい、改善すべきポイントがなんとなく見える、というような公開コードを探す。

勝負は、generalizationにあり、ということで、最終段階はどのようにしてアンサンブルを行うか、ということになる。ここでは、モデルを組み合わせる技術、コンペ毎に定められている計算時間内に計算を終わらせる技術などが求められるが、これについては、まだまだ、不十分である。

２．課題と対策

グランドマスターの方々の講演を聞いていると、あるいは聞くまでもないことだが（すでに常識となっている）、データサイエンス、機械学習で最も重要なことは、データの前処理である。前処理と言っても、予測モデルに読み込ませるだけの定型的なプログラミング技術ではない。データが持っている有用な情報をいかにして取り出すかということである。雑音を除去し、重要な特徴量を抽出するだけではなく、データの中に潜んでいる、原理や法則、関係性を把握して、それをモデルに反映させることができるようにすることが重要であろう。

自分の今の課題は、１）前処理の部分を読み飛ばしていること、２）モデルの性能を左右するツールに関する勉強不足、３）後処理（submission.txtの作成を含む）の部分を読み飛ばしていること、４）チューニングに膨大な時間を費やしていること、および、５）上に書いたような前処理技術、と思っている。

これらに対する対策は、一言でいえば、当該コンペサイトのKagglerに学ぶ、ということである。できることから書いていくと、１）技術的ディスカッションの理解に努める（Discussionもしくは公開コードの後ろのComments）、２）公開コードをスコアの高いものだけ見るのではなく、自分の現状に見合ったコードやEDA中心のコードの理解に努めること、３）予測モデルの制御部分のコードを意識して理解すること、４）前処理技術を理解すること、５）後処理技術を理解すること、６）チューニングよりもコードの理解を優先すること、などである。

以上、実行あるのみ。 

12月2日（水）

Riiid! Answer Correctness Prediction

NotebooksのMost Votesの最初から見ていくことにしよう。

最初は、大きなデータの扱い方で、大きなデータをpandasで普通に読み込むと、メモリーオーバーや読み込むのに10分くらいかかるところを、メモリーオーバーを生じさせることなく1分もかからず読み込む方法が紹介されている。フォーマット変換方法も紹介されていて非常に応用範囲の広いものである。

2番目は、EDA+Baselineである。図表を駆使しながら非常に丁寧に説明されている。

これまで、EDAは、ただ眺めるだけであったが、今回は、Kaggle kernel内で実行しながら学ぶことにした。そうすると、よくできたEDAは、詳細な説明とプログラムコードが交互に現れ、説明を読みながらコードセルを1つ1つ実行させていくことになるので、データの内容を調べながら、プログラムの書き方も学ぶことができる。

この調子で、チューニングのエキスパートではなく、データサイエンスと機械学習のエキスパートを目指して頑張ってみることにしよう。

12月3日（木）

Riiid! Answer Correctness Prediction

EDA + Baselineを最後まで見た。ようやく全体像が見えてきたように思う。

Baselineは、LightGBMである。

Riiid! AI Researchが、関連論文を公開している。

Towards an Appropriate Query, Key, and Value Computation for Knowledge Tracing

SAINT+: Integrating Temporal Features for EdNet Correctness Prediction

コンペと同じ条件かどうかはわからないが、AUCの最大値が0.7914となっている。

コンペでは、すでに、8チームが0.800を超えている。さすが、Kagglerってとこかな。

この、Riiid! AI Researchの論文とKagglerのスコアを見ると、このコンペでの金は無理だなと思うが、どのコンペであっても、似たようなものだろうな。APTOS2019でもコンペ開催時期に非常に優れた論文が発表されたが、Kagglerの上位者のスコアはそれを遥かに上回っていた。

金メダルは、狙ってもとれるものではないかもしれないが、狙わないととれないのも確かだろうな。

2021年1月7日に、単独で金メダル圏内に入っているための必要条件を考えてみよう。

１．課題と提供されるデータを完全に理解すること。

２．Time-series API（Competition API Detailed Introduction）を完全に理解すること。

３．コンペのdiscussionと公開コードを完全に理解すること。

４．上記2件の論文と完全に理解すること。

これをやり遂げれば、少しは、金メダルに近づけるだろうか？

公開コードに、SAKTと、SAINTを意識したものがあるので、それをフォークさせていただいて、あとは、自力で進めるというのが当面の仕事になりそうだな。

12月4日（金）

Riiid!： 2,307 teams, a month to go

フォークしたTransformer Encode Modelを3日以内を目標に解読してみよう。

F. Cholletさんのテキストでは索引に載っていない。A. Geronさんのテキストでは、Transformer architecture, 554となっている。

Chapter 16: Natural Language Processing with RNNs and Attention

Attention Is All You Need: The Transformer Architecture

画期的な技術で、次のように書かれている。

... the Transformer, which significantly improved the state of the art in NMT without using any recurrent or convolutional layers, just attention mechanisms (plus embedding layers, dense layers, normalization layers, and a few other bits and pieces).

554ページには、Transformer architecture の模式図がある。元の論文を示す。

GitHubで’”Tranformer””で検索すると10,835 repository resultsと表示される。トップに出てくるrepositoryをクリックすると、そこには膨大な量の情報がある。どこに何があるか知っていればいつか役に立つだろう。

A. Geronさんのテキストでは10ページあまりにわたって説明されているが、それを読み込んでもコードが書けるわけではない。

フォークしたコードは、TensorFlowのチュートリアルhttps://www.tensorflow.org/tutorials/text/transformerのコードを用いているので、そちらで学ぶことにしよう。

TensorFlowのチュートリアルのタイトルが"Transformer model for language understanding"となっていて、text generationとattentionの知識があることを前提にしていると書かれている。

チューニングの合間に、チュートリアルと、フォークしたコードを比較している。

よくできているチュートリアルだと思う。

チュートリアルの事例はスペイン語から英語への翻訳で、言語間の相関を解析しているのだが、Riiid!の課題は行動（学習）パターンを解析することで、全く異質だと思うので、途惑うことばかりだ。そういうことからすると、フォークしたコードは、よく考えているなと思う。といっても、翻訳用のコードを、学習行動解析用に、どういうふうに変換しているのかは、まだ、まったく把握できていない。

12月5日（土）

Riiid!：2,344 teams, a month to go

＜雑談＞

F. Chollet氏のテキストに、AttentionやTransformerは無い。と思う。やはり、古いのだ。これに比して、A. Geron氏のテキスト（第2版：TF2）は、TF2というだけあって、2019年の前半くらいまでの情報が含まれていて、GPTやBERTも紹介されている。AnacondaにTF2がインストールできず、かつ、英語力も不足していたので、A. Geron氏のテキストを十分学べず、知らないことが多すぎるだけでなく、自分の勝手な解釈も多いことがわかってきた。目の前の話だと、encoder-decoderの理解の問題。variational auto encoderの印象が強くて、encoder-decoderに対して本来の意味とは全く異なるイメージを抱いていたようだ。情けないことだが、これが現実なのだ。

A. Geron氏のテキストでは、Figure 15-4にEncoder-Decoder networks、Figure 16-6にEncoder-Decoder network with an attention model、Figure 16-8にTransformer architecture、Figure 16-10にMulti-Head Attention layer architectureがそれぞれ図示されている。これで、encode-decoderとattentionとtransformerがつながった。

こんなんじゃ、だめだな。

本丸に切り込んでみよう。

解答者の解答履歴と行動履歴の中から、正答率との相関（正でも負でも）が高いものを選ぶこと、作り出すこと、見つけること、などが重要になるのだろうから、データをよく見て理解していく必要があるな。

どの情報が重要かは、最終的には、モデルに組み入れて確認することになるだろう。

TOEICについて、知らないよりは知っている方が良さそうだな。

TOEICをウイキペディアで調べてみよう。

試験問題の構成[編集]

2016年5月以降に実施されている試験問題の構成は次の通りである。

聞き取り（リスニングセクション）[編集]

聞き取り（リスニングセクション^[28]）は合計100問、所要時間は45分間である（但し、音声の長さに応じて所要時間が多少変わる場合があり、その場合は予め告知される）。

• Part 1 - 写真描写問題 (Photographs) - 1枚の写真を見て、その写真について放送される適切な英文を選ぶ。4択式で合計6問。
• Part 2 - 応答問題 (Question-Response) - 質問文が放送された後、それに対する応答文が3つ放送され、適切なものを選ぶ。合計25問。
• Part 3 - 会話問題 (Short Conversations) - 2人の会話を聞いて、その会話についての質問に対し最も適当な選択肢を選ぶ。質問文と選択肢は問題用紙に記載されている。4択式で合計39問。
• Part 4 - 説明文問題 (Short Talks) - ナレーションを聞いて、それについての質問に対し適切な選択肢を選ぶ。1つのナレーションにつき複数問出題される。質問と選択肢は問題用紙に記載されており、4択式で合計30問。

旧構成の Part 3、Part 4の問題文は印刷のみであったが、新構成では印刷されている問題文が音声でも読み上げられる。またPart 3、Part 4の1つの会話・説明文に対する問題数が2〜3問と不定であったものが、新構成ではそれぞれ3問に固定されている。

読解（リーディングセクション）[編集]

読解（リーディングセクション^[28]）は合計100問、制限時間は75分間である。聞き取り（リスニング^[28]）の終了と同時に読解（リーディング^[28]）の試験が開始され、読解（リーディング）の開始の指示は特になされない。

• Part 5 - 短文穴埋め問題 (Incomplete Sentences) - 短文の一部が空欄になっていて、4つの選択肢の中から最も適切な語句を選ぶ。合計30問。
• Part 6 - 長文穴埋め問題 (Text Completion) - 手紙などの長文のうち複数の箇所が空欄になっていて、それぞれ4つの選択肢から最も適切な語句を選ぶ。合計16問。
• Part 7 - 読解問題 (Reading Comprehension) - 広告、手紙、新聞記事などの英文を読み、それについての質問に答える。読解すべき文書が一つのもの (Single passage) が29問。「手紙＋タイムテーブル」など読解すべき文書が2つもしくは3つのもの (Multiple passage) が25問。それぞれ4択式。

question.csvのpartは、Kaggleのデータの説明に、the relevant section of the TOEIC test.と書いてあるので、上記の1～7を指すのだろうが、lectures.csvのpartは、top level category code for the lectureと説明されていて、よくわからない。

今のモデルの現状は、LB=0.736である。

来週末までに、流すデータを見直して、0.74+にしたいと思う。

12月6日（日）

Riiid!：2,383 teams, a month to go : gold 0.797+, silver 0.776+

＜雑談＞

LightGBM系とDNN系についてちょっと考えてみよう。機械学習とディープラーニングの比較のつもりだが、ディープラーニングは定義上、機械学習に含まれるようなので、このような表現にした。ただし、LightGBMはDNN以外のモデルというつもりで示しており、このモデルに限るということではない。Riiid!コンペもそうだが、表データのコンペでは、LightGBMを使ったコードがたくさん公開される。同じツールを使っていても、データの前処理、後処理、アンサンブル、ハイパーパラメータなど、の最適化の程度によってスコアはばらつく。DNNを使った場合も同様なのだが、ばらつきは概してLight GBMのグループの方が小さい。ハイスコア側は公開コードには現れないので実際のところはわからないが、見える範囲ではそう感じる。そこで知りたいのはばらつきの大きさやその原因ではなく、ハイスコアの限界はどこにあるか、LightGBMとDNNのどちらのスコアが高いのか、ということが、誰もが知りたいことである。DNNと書いただけだと、LightGBMに勝ち目はなくDNNの勝利となるだろう。最終的にどちらが高いスコアに達するかというときに、もしかすると、最高位は、両方のグループを合わせたアンサンブル、LightGBM系＋DNN系かもしれない。多分そうなんだろうと思う。特性の異なるモデルを適切にアンサンブルすることによって最高のスコアが得られるということなのだろうと思う。Kaggleコンペに限らず、コンペの順位は主催者が選んだテストデータに対するスコアの順位で決められるので、話は複雑である。submitしたモデルの中から選んだ数件のモデルで最終スコアを争うのではなく、submitした全てのモデルに対して最高スコアを争うことにすると、勝者の範囲は狭くなるだろう。ある意味、面白さは減るかもしれない。自分が勝者になるかもしれない！、という期待感も小さくなるかもしれない。番狂わせがあるというのは、多くの場合は、public_test_dataに対してoverfittingになっているかどうかということであって、よくないモデルでも勝てるということではない。この雑談を書こうと思ったのは、１つには、単独のモデルで勝つのは難しいということ、ベストモデルにこだわるなということである。MoAでいえば、TabNetが話題になり、TabNetで競うようなところもあったようだが、つまるところ、同じモデルを使っても、前処理、featureの選び方・作り方により、もちろんハイパーパラメータによってもスコアは変わるので、結局は総合力ということになる。だから、今回も、特定のモデルにこだわることなく、種々のモデルを試すこと、データベースをより深く理解すること、time-series APIを正しく理解することなど、様々な要素に対する取り組みが必要だということであると思うが、どこまでできるだろうか。

MoAコンペの優勝チームの手の内紹介記事を見た。難しくて理解できない。やっていることは、文章と模式図から、なんとなくわかるが、どうやってそういう発想になったのか、発想できたとしてどうやってコード化したのか、トレーニングはどうやって行ったのか、皆目わからん。こういう人と勝負して勝つにはどうすれば良いのだろうか。

GitHubに用いた7つのモデルを公開しているというので見に行ったら、この優勝チームのリーダーは、既に、162のrepositoriesを作っている。大半はフォークしたものだが、オリジナルもいくつかある。Kaggleコンペの優勝者のモデルもいくつかフォークしている。そうなんだ、オープンソースライセンスが、今のプログラムの流通のベースになっているし、Kaggleのサイトの中も同様なんだ。といっても、コンペサイトだから、なんでもオープンにするわけにはいかない。

チューニングしないとパラメータの最適値が分からないし、プログラムの各部分が正しく機能しているのかどうかを確かめるためにもチューニングは適切に行っていく必要がある。

やっと、0.74+になったが、原作者は0.767まで向上している。

Riiid! Researchの論文をチェックして、エンコーダ、デコーダに入力しているデータを特定しようとしているのだが、まだ、まったく、つかめない。

12月7日（月）

Riiid!：2,415 teams, a month to go：gold 0.797 over, silver 0.777 over

今のモデルのパラメータのおおよその適正範囲がわかってきたので、今日は、流すデータ量を単純に増やしてみる。具体的には、10Mでパラメータ調整し、そのまま、データ量だけ増やすということ。20M, 50M, 100Mと増やしてみたいが、100Mをやってみてからその次を考える。

その後で、再度、パラメータの適正範囲を探索してみよう。

10Mを100Mにすると、val_AUCは、0.8-0.9%程度大きくなった。

この増分は、モデルとハイパーパラメータと流すデータの質にも依存すると思うし、そもそもどのレベルにあるのかにもよるだろう。この結果は、val_AUC=0.75+で得られたものである。現状でも、かなり良くできたモデルなのかもしれない。

ここから、ハイパーパラメータを変更するのは、ベースラインを上げてからにしようと思う。入力データの検討とモデルのアーキテクチャの検討をして結果を出さなければ、0.76+以上は望めないように思う。

最終目標の0.82+は、はるか彼方である。 

100Mのデータを通した結果のcommit中に、トラブル発生。3時間以上かかった計算のやり直し。計算とcommit合わせて、約7時間のロスだ。ただで使わせいただいているのだから文句は言えないというところか。残念だな。

もう1度100Mをやるには、さらに6時間以上GPUを使うことになる。

一足飛びに100Mをやるのではなく、着実に進めなさいということを暗示しているのだと思って、10Mから始めて20M, 30Mという順で、結果（public LB）を出してみることにしよう。今の条件では、10Mのデータでも、2エポック目でval_AUCは最大値になっていて、1エポック目との差も0.5-1.0％程度なので、時間節約のために1エポックで結果を出してみる。

12月8日（火）

Riiid!： 2,453 teams, a month to go

投入したデータ量（目安）とスコアの関係（1エポックでtraining終了）

          val_AUC    public LB

10M     0.748      0.744

20M     0.751      0.749

30M     0.755      0.748

40M     0.755      0.750

60M     0.757      0.755

100M   0.758         ?

このような相関が常に成り立つかどうかわからないが、通常の条件検討は効率優先で、20～30M程度でテストして、最終段階では、データ量を増やすことによって少しでもスコアを上げるのに役に立つかもしれない。といっても、メモリーオーバーで停止するとか、改善につながらない可能性も否定できない。データのばらつきにも注意が必要。

ちなみに、Kaggle kernel内ですべての計算を行っているのだが、transformerモデルのユニット数や層数は最小限に近いレベルに設定しないとメモリーエラーが生じ、それでも、100Mのデータを流すと、1エポックでも、計算を完了するには、3時間くらいかかっている。

＜メモ＞

MoAコンペの、submitしたモデルを眺めていて気付いたこと。NNモデルのdropoutの数値を下げてweight_decayを上げると、単独モデルのpublic LBスコアは良くなったが、他のモデルとアンサンブルしたときには、そのdropoutの数値を下げてweight_decayも下げたモデルの方が、public LBスコアも最終的なprivate LBスコアも良かった。といっても、それはもちろん、結果がそうだったというだけのこと。それを見越して最終モデルを選んだわけではない。単独のスコアは良いのに、アンサンブルしたら悪化するモデルのことは、discussionでも話題になっていた。dropoutは、アンサンブルの一種とみなされる。ユニット数を変えながら訓練しているので、様々なユニット数のモデルを組み合わせているのと似ているということだ。だから、CVが同じでも、dropoutの割合が高いモデルの方が、汎用性は高いと考えられる。これまでの経験では、dropoutの割合が高いモデルの方が、private teat dataに対しては良い結果となっている。今使っているTransformerモデルでは、dropoutを変えても有意差がわからない。モデルの安定性の問題かもしれない。今使っているモデルのval_AUCは、計算後とcommit後とで、±0.3％くらいは変動しているようである。

同じことの繰り返しはやめよう、じじくさい。

transformerの論文でも読もう

なんちゃわからん。

RNNがわかっとらんからな。

以下は、A. Geronさんのテキスト第2版からの転載です。

p.501 Input and Output Sequences

An RNN can simultaneously take a sequence of inputs and produce a sequence of outputs. this type of sequence-to-sequence network is useful for predicting time series such as stock prices: you feed the prices over tha last N days, and it must output the prices shifted by one day into the future.

Alternatively, you could feed the network a sequence of inputs and ignore all outputs except for the last one. In other words, this is a sequence-to-vector network. For example, you could feed the network a sequence of words corresponding to a movie review, and the network would output a sentiment score (e.g., from -1 [hate] to +1 [love]).

Conversely, you could feed the network the same input vector over and over again at each time step and let it output a sequence. This is a vector-to-sequence network. For example, the input could be an image (or the output of a CNN), and the output could be a caption for that image.

sequence-to-sequenceと、sequence-to-vectorと、vector-to-sequenceについて、なんとなくわかった。

ここからが本命のEncoder-Decoderだ。

Lastly, you could have a sequence-to-vector network, called an encoder, followed by a vector-to-sequence network called a decoder. For example, this could be used for translating a sentence from one language to another. You would feed the network a sentence in one language, the encoder would convert this sentence into a single vector representation, and then the decoder would decode this vector into a sentence in another language. This two-step model, called an Encoder-Decoder, works much better than trying to translate on the fly with a single sequence-sequence RNN: the last words of a sentence can affect the first words of the translation, so you need to wait untill you have seen the whole sentence before translating it. We will see how to implement an Encoder-Decoder in Chapter 16.

ふむふむ。なんとなく、Encoder-Decoderのことがわかってきたような気がする。

A. Geronさんのテキストの第16章　Natural Language Processing with RNNs and Atentionを理解しよう。

全40ページだ。

読書百遍義自ずから見る、といきますか。ちなみに「見る」は「あらわる」と読む。

で、読んでいるのだが、tokenizer, GRU, embedding, LSTM, ...勉強不足でわからん。Chapter 15: Processing Sequencies Using RNNs and CNNsにもどらないと、・・・。

40+25=60ページになる。必要なことだが、まず、40ページを、最後まで読もう。

12月9日（水）

Riiid!： 2,487 teams, a month to go

今日は朝からA. Geronさんのテキストの第16章を勉強している。

現状のモデルでもチューニングしたいことはたくさんあるのだが、KaggleのGPUの残り時間がわずかになっているので、今日はチューニングの計算をしていない。

するとどうだろう、時間が余る。テキストを読んでいても時間が長くなると頭が飽和して先に進めなくなる。などと、うだうだいってサボっていては金メダルに近づけないので、テキストを読む。

545ページにEncoder-Decoderのコードが20行あり、その説明の最初にこう書かれている。The code is mostly self-explanatory, but there are a few point to note.

それはそうだろうな。難しい数式も、難しい理論も、なさそうだ。あるのは、等式: =, tuple: ( ... ), list: [ ... ]の他に、英単語が並んでいるだけ。
encoder_inputs, keras.layers.Input, shape, dtype, np.int32, decoder_inputs, sequence_length, embeddings, keras.layers.Embedding, vocab_size, embed_size, encoder_embeddings, decoder_embeddings, encoder, keras.layers.LSTM, return_state, True, state_h, state_c, sampler, tfa.seq2seq.sampler.TrainingSampler, encode_cell, keras.layers.LSTMCell, output_layer, keras.layers.Dense, tfa.seq2seq.basic_decoder.BasicDecoder, sampler, final_outputs, final_state, final_sequence_length, initial_state, Y_proba, tf.nn.softmax, 

単語を書き並べてみた。

547ページのBeam Searchとは何か。

約2ページにわたる解説のまとめが以下のようになっている。

With all this, you can get good translations for fairly short sentences (esoecially if you use pretrained word embeddings). Unfortunately, this model will be really bad at translationg long sentences. Once again, the problem comes from the limited short term memory of RNNs. Attention mechanisms are the game-changing innovation that addressed this problem.

だとさ。技術的な中身が理解できないまま、表面的な理解で読み進んでいるだけのような気がする。

次は、549ページからのAttention Mechanism

自然言語処理としてのTransformerの説明のようだし、Riiid!コンペの課題に対してイメージが湧かない。もちろん、イメージが湧くまで読み込んでいないということかもしれないが、TOEICの問題に対して正答する確率を求めることと、翻訳とか、文章生成とか、要約とかが全く結びつかないので、このへんで、テキストの学習は中断する。百篇どころか一遍読んだかどうかというところで中断とは情けないが読んでいても明らかに脳のニューロンを素通りしている。

Riiid! AI Researchの論文を読んでみよう。

SAINTの0.78、SAINT+の0.79を、当面の目標にしよう。今は0.755だから目標高すぎ！

12月10日（水）

Riiid!：2,516 teams, a month to go

昨夜、Riiid!コンペに対応している（らしい）プログラムコードをGitHubで見つけ、ダウンロードした。Kaggle kernelにアップロードして実行し、trainingまで動作することを確認した。途中経過をsaveし、継続してtrainingできるように組まれており、制限時間を気にせず、十分なtrainingが可能ということで期待して実行してみた。途中でエラーが発生しないように変更した以外、パラメータは変更しなかった。GPUを使用し、10Mのデータ量で、1エポックの80％くらい走らせてみた。約50分くらいかかり、val_AUCは、0.65+で収束しそうな感じであった。スコアはともかく、プログラムコードは、課題に合うように考えて、しっかり書かれているようで、参考になりそうだ。

今日、GitHubからのモデルのハイパーパラメータを見直してtrainingした結果、val_AUCは0.74+レベルになった。計算時間が長かったのは、ユニット数が多かっただけである。ただし、1エポックでの比較なので、ユニット数を減らすのが良いかどうかはわからない。土曜日にGPUが使えるようになれば、ユニット数が多い場合のtrainingをやり直し、（ユニット数、エポック数、val_AUC）等について相関を調べる予定である。

GitHubからのコードとKaggleの公開コードの比較だが、使っているデータもモデルの構造も少し異なっているので比較できないが、いずれのコードも自分のレベルを超えており、しっかり学びたい。

今日は、SAINTの要点を把握し、実際のデータとの関係を把握しよう。

重要な要素は2つある。

1つは、Exercise embedding sequenceをEncoderに、Responce embedding sequenceをDecoderに分けて流す（入力する）こと。

Exercise embedding sequence    -->  enter the Encoder

Response embedding sequence  -->  enter the Decoder

２つめは、ExercisesとResponcesの複雑な関係を、deep self-attentive computationsを使って、効果的に捕える（capture）こと。

Ii : interactions Ii = ( Ei, Ri )

Ei : denotes the exercise information, the i-th exercise given to the student with related matadatasuch as the type of the exercise

Ri : denotes the responce information, the student responce ri to Ei with related metadata such as the duration of tome the student took to respond

ri : denotes the student responce, is equal to 1 if their i-th responce is correct and 0 if it is not

Thus, SAINT id designed to predict the probability

P( rk = 1 | Ii, ..., Ik-1, Ek ) 

12月11日（金）

Riiid!：2,543 teams, 28 days to go

SAINTに関連するDiscussionで、全データ（100M）を用い、d_modelもwindow_sizeもかなり大きく（ユニット数を多く）しないと、0.78-0.79には、届かないようなことが書かれている。SAINTの論文に書いてある条件では、メモリーアウトで計算できない。まあでも、解は1つではないはずだ。 

MoA：varification終了により順位確定

コンペの結果が確定し、Silver medalとKaggle Competition Expertの通知メールがきた。

1年前の12月12日、手帳に、「ビリでもいいからリーダーボードにのりたい」と書いてある。そのページには、YOLO、３D、６D、バウンディングボックス、KITTI、などの単語が書きつけられている。1月には鋼材表面の欠陥検出、2月には高額の賞金がかかったfake画像検出、3月にはARC、4月は大学受験数学に集中、5月はARC再開、6月中旬からTReNDS、7月にはPANDA、7月末からSIIIM、COVID-19、LandMark、Bird、OSIC、RSNA、LyFT、MoA、Riiid!、・・・。

12月12日（土）

Riiid!：2,601 teams, 27 days to go

これからも何度も起きると思うが、ハイスコア（自分のレベルと比較して）の公開コード（0.765）が投稿され、60番くらい下がった。

今のコードのポテンシャルを生かせず、0.755を超えられず、苦戦中。

ユニット数を文献やDiscussionでの値に近づけて設定して計算してみた。1エポックに4時間くらいかかる条件だったが、可能性を調べるために計算を初めて見た。そうすると、途中からlossの下がり方、AUCの上がり方が悪くなり、2時間くらい経過すると、lossとAUCが反転し始めた。一時的なものかと思い、しばらく様子を見たが、だめなようで、中止した。GPUがリセットされ34時間まで使用可能になったので、意気込んで計算し始めたのだが、残念な結果となった。

ギャー、0.772が投稿された。目標が0.78以上だから関係ない！と、強がってみる。

気になったのは、その公開コードの前書きに、12Mのデータで0.770-0.772を得たとなっていることだ。

10M使って0.744、60M使って0.755では、話にならんな。

今日は、60Mのデータにこだわって計算して、思うような結果が得られず（実のところ、非常に良い結果が得られそうな気がしていた。SAINTの論文とKaggle Discussionでの話とで一致する条件を選んでいるから、間違いないと思った）、結局10時間近くもGPUを消費してしまった。大きなデータ量で良い結果が出れば言うことなしなのだが、結果が出なかったときの損失は非常に大きく感じる。

12Mのような、少ないデータ量で、もっと基本的なところを押さえていこう。

60Mでの失敗は、特定のパラメータ群を一気に変更して、うまくいかなかったということだが、それは、関連する他の条件があって、それらも同時に変更する必要があった、ということなのだろうと思う。そのパラメータが何であるか、それを探索して調整する必要がある、ということなのだろうと思っている。

優先順位を決めておこう。

１．Transformerのスレの内容を確認する。まだ手を付けることができていなことがいくつかあるが、このスレには、具体的な解決につながるヒントがありそうだ。

２．１．を終えるまでは、次の段階に移らないことにする。そのスレの何か所かを拾い読みし、その情報で対応してきたのだが、全部きちんと読まないとダメな気がしてきた。SAINTの論文を読むと、わかったような気になるが、プログラムとの対応は、いまいちわからず、具体的な問題解決につながらないで困っている。

12月13日（日）

Riiid!

今日は、transformerに関する情報収集の前に、やりかけのチューニングを片付けようとしてドツボにはまった。GPUの使用時間を今日だけで14時間以上消費し、残りは8時間になった。

ユニット数を多くしすぎて失敗した件は、原因がはっきりわかったわけではないが、learning rateのスケジューリングプログラムを使うことで、とりあえず、解消した。

それならばと、意気込んで、60Mのデータを流してハイスコアの可能性を調べたものだから、時間ばかりかかって、成果は殆どなかった。現状のプログラムでは、0.76+が限界であることがわかった。0.77+が次々と公開されている状況では話にならないので、transformer関する情報収集と検討を明日からやる。

今週の目標は0.76だったが、実現したのは0.757までだった。

来週の目標は0.77に設定しているので、金曜日までにプログラムに手を入れて、土日に結果を出したいと考えている。 

12月14日（月）

Riiid!：2,678 teams, 25 days to go

SAINT benchmarkというというトピックに関する意見交換を読んでいるのだが、topic autherは0.795、transformerのbaseline code（0.715）を公開した人は0.784、に達していて、毎日のようにスコアは向上しているようだ。

give and takeが進んでいて、性能に直結するような情報の交換が行われている。公開コードを共有するのと同様に、ハイパーパラメータの具体的な値、モデルの構造、プログラムの一部などの情報を交換している。

読み込むべきは、discussionでも論文でもなく、コード自体である。英語力を鍛えてきたように、プログラミング力を最優先に鍛えていこう。

プログラミング力の無いところに金メダルは無い。

12月15日（火）

Riiid!：2,722 teams, 24 days to go

昨夜、0.78のコードが公開されていた。SAKTとLGBMのアンサンブルである。SAKTはtrain済みのパラメータを読み込むだけで、LGBMはtrainを含む。SAINTを完成させないとその先は無いと思って、フォークは少し控えていたのだが、手を出してしまった。すでに、150チームくらいが並んでいる。別の方法でそこに到達したチームもおられるが、ちょいと乗っかったチームと見分けはつかない。その大部分はメダル圏内だが、まだ先は長いので、コンペが終わるまでには、みんなメダル圏外だろうな。何度も見てきた風景だが、そこに自分も入っている。

積読してあった「ゼロからはじめるデータサイエンス：Joel Grus著、菊池彰訳」に目を通し始めている。原著は2015年、訳本は2017年の発刊のようである。機械学習のテキストとしては新しくはないが、Python、データの可視化、線形代数、統計、確率、仮説と推定、勾配降下法、データの取得、データの操作、機械学習、・・・と続いていて、基礎を学ぶには最新でなくても良いと思う。2年以上前に何冊か購入したうちの1冊だが、数ページ目を通しただけで放置したようだ。最低でも購入日や購入書店名、読み始めればその日付などを書くのだが、そのどれもが記入されていないほど、気に入らなかったのだろうと思う。今見ると、機械学習初心者には向かない（基礎の部分が延々と続き、機械学習の話が始まるのは160ページを過ぎてからである）が、実務者には必携の書物だなと思う。

F. CholletさんのテキストもA. Geronさんのテキストも英文のまま読んでいる。コードが英文で書かれているので、とにかく、英単語が日本語に変換することなくすっと頭に入るようになりたいと思ってそうしているのだが、それにはデメリットもある。とにかく、進むのが遅い。それと、今、訳本を読み始めて感じたのだが、英語のテキストだと本文を読むのに疲れて、コードへの集中力が高まらない。対して訳本は、コードに集中できる。原著だと、コードを理解するために本文を読むのは英英辞典を使うようなものだが、訳本だと、コードを理解するときに、コードの英単語にはかなり慣れてきて辞書は要らないので、コードの機能を理解することに集中できるというメリットがある。結局は、学習の積み重ねが重要ということになるのかな。

ちょっと戻るが、FORTRANやBASICを使ってプログラミングしてきたから、Pythonなんてチョロいと思っていたのが良くなかったな。なんでもかんでもFORTRANではどうだったかな、BASICではどうだったかなと考えて、無理に置き換えて理解しようとしてつまづいたような気がする。CとかC++でもやっておけばよかったのかもしれないが、そこはまったく手を付けることがなかった。

雑談はこのくらいにしてプログラミングに集中しよう。

つい、悪い癖が・・・。0.780のコードをフォークして、チューニングしている自分がいる。  チューニングで負けないことも重要なのだ、ということにしておこう。 

12月16日（水）

• Riiid AIEd Challenge
• , 2,760 teams
• , 23 days to go

今、0.780に約220チーム（166～384）が並んでいる。

ここから脱出しようともがいている。その結果、今、0.780の先頭にいる。

今日は、0.780で先頭のまま、終わってしまいそうだ。 

「ゼロからはじめるデータサイエンス」

1章のイントロダクションの中をウロウロしている。辞書形式のユーザーリストから始まる。idとnameが並んでいるだけ。交友関係を調べてグラフ化する。

users = [

      { "id": 0, "name": "Hero"},

      { "id": 1, "name": "Dunn"},

こんな感じで並んでいるのだが、いかにもめんどくさそう。

この辞書形式は、パラメータの設定で使われる。

Riiid!のコンペで使っているtrain_dataの情報をdictionary形式で表現すると、

data_types_dict = {
    'timestamp': 'int64',
    'user_id': 'int32', 
    'content_id': 'int16', 
    'content_type_id':'int8', 
    'task_container_id': 'int16',
    'user_answer': 'int8',
    'answered_correctly': 'int8', 
    'prior_question_elapsed_time': 'float32', 
    'prior_question_had_explanation': 'bool'
}

目の前の課題に直結した事例で説明されていれば、だれでも食らいつくだろうが、内容に興味が持てない場合には、勉強が捗らない。これが、自習の難しさの重要な要因の１つだろうな。

次は、交友関係をタプルで表したものが現れる。

friendships = [(0, 1), (0,2), (1, 2), (1, 3), (2, 3), ..., ...]

さらに各ユーザーが持っている興味を表にしたもの。

interests = [

      (0, "Hadoop"), (0, "Big Data), ..., (1, "NoSQL"), ..., (2, "Python"), ...,

]

書くのが面倒だからめちゃくちゃ省いた。

書いてることもめちゃくちゃになってきた。

次に移ろう。

第2章のPython速習コースだ。

19ページ：空白によるフォーマット

知らなかった：

丸カッコ、角カッコの内部では空白が無視されるので、長い行を折り返して書けます。

コードの右側が見えないとき、適当に切断して折り返したら、誤動作したことがあった。これは、簡単なことだが、重要だ。

20ページ：モジュール

importの便利な機能、import *には要注意。

不用意にモジュール全体をインポートすると、自分で定義した変数を意図せずに上書きしてしまう点に注意が必要。

21ページ：関数

def double(x):

      return x * 2

名前を持たない短い関数（ラムダ：lambda）がよくわからない。

y = apply_to_one(lambda x: x + 4)

デフォルト引数という使い方：こういうのは知らないと困る。

def subtract(a=0, b=0):

      return a - b

subtract(10, 5) # =5

subtract(b=5) # =-5：b=5だけが関数subtractに送られると、a=0とb=5が代入されて、0-5=-5 が返される。

22ページ：文字列

バックスラッシュに注意

複数文字列については理解できない。

29ページ：例外

try:

    print 0 / 0

except ZeroDivisionError:

    print "cannot divide by zero"

29ページ：リスト

Pythonの最も基本的なデータ構造は、おそらくリストでしょう。：と書かれている。

これは、イロハのイですかね。：自分は、これを理解できていないがゆえに、コードの理解/解読/書き換え等に手間取っている、苦しんでいる。

integer_list = [1, 2, 3]

heterogeneous_list = ["string", 0.1, True]

list_of_lists = [integer_list, heterogeneous_list, [ ] ]

list_length = len(integer_list) # 3

list_sum = sum(integer_list) # 6

24ページ：リストの続き

x = range(10) # list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

zero = x[0] # 0番目　インデックス0の要素、すなわち0

one = x[1]

nine = x[-1]

eight = x[-2]

x[0] = 1 # list [-1, 1, 2, 3, 4, 5, 6, 7, 8, 9]：ここで、xが変更されたことに注意！

first_three = x[ :3] # 0番目から3番目までの要素：[-1, 1, 2]

three_to_end = x[3: ] # 3番目から最後までの要素：[3, 4, 5, 6, 7, 8, 9]

one_to_four =  x[1:5]

last_three = [-3: ] # 最後から3つ前までの要素：[7, 8, 9]

without_first_and_last = x[1:-1]

copy_of_x = x[ : ]

...

x = [1, 2, 3]

x.extend([4, 5, 6]) # xは[1, 2, 3, 4, 5, 6]になる。

[ ]が( )に囲まれている、[ ] が( )の中にある、( [     ] )、こういうのを見ただけで気分が悪くなる。違和感を感じてしまう。それぞれの役割が理解できていないからだろう。

x.extend( )が定義で、extendしたいリスト[ ]を、( )の中に記述する、というだけのことか。y = [4, 5, 6]としておけば、x.extend(y) = x.extend([4, 5, 6])。

x = [1, 2, 3]

z = len(x)：z = len([1, 2, 3])

x, y = [1, 2]：x=1, y=2

_, y = [1, 2]：y=2：こういう表記 "_," は違和感を感じるのだが、こういうのを多用したコードから、つい、目をそらしてしまう。慣れてしまおう。

25ページ：タプル

読めばわかるかな。

26ページ：辞書

２，３写しておく。

grades = { "Joel" : 80, "Tim" : 95 }

joel_grade = grades["Joel"]

少しぼやけてきた。辞書は、キー”Joel"と値80を関連付けて格納したもの。

27ページ：defaultdictクラス

文章document中の単語wordの数を数えるcount。

word_counts = { }

for word in document:　　　　　 # documentの端から順にwordを取り出す

      if word in word_counts:            # 取り出したwordが辞書にあれば1を追加する。  

            word_counts[word] += 1

      else:　　　        　　   # 取り出したwordが辞書になければwordを登録し1とする。

       　 word_counts[word] = 1

コメントは自分が適当につけたもので、これでよいかどうかわからない。

キーが登録されていることが前提のようなコードなので、最初の行でword_countsを初期化しているのが腑に落ちない。

defaultdictというのを使えばよいらしい。

29ページ：Counterクラス

単語の出現数を数える問題は次の1行で完成するとのこと。

word_counts = Counter(document)

出現数の多い順に要素を返すmost_commonメソッドが用意されているとのこと。

for word, count in word_counts.most_common(10):

      print word, count

29ページ下：集合

大量のデータの中から要素が含まれるかチェックする必要があるなら、集合は最も適したデータ構造とのこと。

最後に、集合より辞書やリストの方が頻繁に使われます、と書かれている。

30ページ：実行順制御

ifによる条件判定

whileループ

forとinの組み合わせ

for x in range(10):

      print x, "は、10より小さい”

より複雑な制御が必要ならcontinueやbreakも利用できる、とのこと。

31ページ：真偽

True, False

次は上級Pythonと書いてある。

12月17日（木）

Riiid AIEd Challenge, 2,787 teams, 22 days to go

急に順位が下がったと思ったら、0.781のコードが公開されている。

0.780のコードとの違いは、主に、流すデータ量の違いで、0.780のコードは、（12M、fraction=0.15）、0.781のコードは、（20M、fraction=0.09）、となっている。

これを実現するために、featureを減らしている。featureを減らさないでこれだけのデータ量を流そうとするとエラーが出る（確認済み）。

今（13時）調べると約80チームが0.781に、約200チームが0.780に並んでいる。

Discussionによれば、現在1位の人は、SAINTベースで、7位の人はLGBMベースのようである。重要なのは、feature engineeringのようだ。

0.780が0.781になったのは、データ量が12Mから20Mに増えたのが原因ではなく、featureを減らしたことが原因であるかもしれない。その効果を打ち消すようなfeatureの組があって、片方を削除したことで、他方の効果が現れたのかもしれない。

といっても、効果は+0.001です。小さくはないが、大きくもない。今の段階では、データ量を増やすことよりも、featureを工夫することが重要だろうな。

LightGBM：

優れものらしいが、パラメータが多くて、性能を発揮するには、データ、前処理、プログラム構成などの要素に加えて、LGBMそのものの特性・特徴をよく理解しておかなければならない。ということだけど、具体的にどうすればよいのか。

ドキュメント量は非常に多く、パラメータの定義を見ても、パラメータの設定範囲がわかりにくいものもある。optunaの開発メンバー、小嵜氏のブログを見ると、次のようなコードが示されている。これで、チューニングにおいてこれらのパラメータが重要だろうと推測される。

param = {

        'objective': 'binary',

        'metric': 'binary_logloss',

        'lambda_l1': trial.suggest_loguniform('lambda_l1', 1e-8, 10.0),

        'lambda_l2': trial.suggest_loguniform('lambda_l2', 1e-8, 10.0),

        'num_leaves': trial.suggest_int('num_leaves', 2, 256),

        'feature_fraction': trial.suggest_uniform('feature_fraction', 0.4, 1.0),

        'bagging_fraction': trial.suggest_uniform('bagging_fraction', 0.4, 1.0),

        'bagging_freq': trial.suggest_int('bagging_freq', 1, 7),

        'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),

    }

このコードであれっと思った箇所が２つある。１つは、num_leavesの最大値が256となっていること、もう1つは、lambdaの設定値の最大値が10となっていることである。

前者については、300以上に設定している例をよくみかける。性能アップにはnum_leavesを大きくすべし、と書かれている記事が多いからだろうと思う。

後者については、設定範囲は0-1と、勝手に思いこんでいた。

これを見ると、optunaというものを使ってみたくなるな。

投入できるデータ量を増やすために、featureを見直した結果、良いか悪いかはわからないが、これまでの条件では極端なオーバーフィッティングになることがわかった。L1,L2も効かないので、num_leavesから見直しを始めた。フォークしたときの350を、そのまま使い続けていたがこの際だから、再出発のつもりで、デフォルトの32から検討している。

num_leaves=32：train_auc=0.782, val_auc=0.767でピーク：目標の0.772+は遠い。

num_leaves=64：train_auc=0.787, val_auc=0.769：まだまだだが、num_leaves=350の結果をわずかではあるが上回った。葉っぱの枚数が多ければ良いというものではないことを実感した。NN系のoverfittingには慣れているが、機械学習系はこれまでoverfittingを実感することはなかった。

num_leaves=96：train_auc=0.788, val_auc=0.768：これ以上良くならない。

「ゼロからはじめるデータサイエンス」J. Grus著、菊池彰訳

第5章　統計

代表値：

通常、データはどこが中心となっているのかに興味がある。多くの場合、値の総和をデータ数で割った平均値を用いる。

def mean(x):

      return sum(x) / len(x)

場合により、中央値medianが必要になる場合もある。

def median(v):

      n = len(v)

      soeted_v = sorted(v)

      midpoint = n // 2

      if n % 2 == 1:

            return sorted_v[midpoint]

      else

            lo = midpoint - 1

            hi = midpoint

            return (sorted_v[lo] + sorted_v[hi]) / 2

平均値meanはデータ内の外れ値に対して中央値medianよりも敏感である。

繰り返し語られる話題：1980年代中ごろ、ノースカロライナ大学の卒業生で最も高い初任給を得られた専攻は地理学であった。それは、NBAのスター選手（良い意味の外れ値を提供）、マイケル・ジョーダンが原因である。

モード（最頻値）も重要である。

12月18日（金）

Riiid AIEd Challenge, 2,823 teams, 21 days to go

当面は、公開コードによって増殖中の0.781を超えないとメダルは無い。

0.781を超えようと思って昨夜セットした計算は1000ラウンドで収束したが、commitは3500ラウンドを超えても収束しない。どうなることやら。

結局、4700ラウンドの手前で終了したが、8時間くらいかかった。やれやれ。

なんとか、0.781の列の前の方に着地した。

val_AUCからは、0.782になってもよさそうなのだが・・・。

commit中にラウンド数が増えるとともに、val_aucも上がったので喜んでいたのだが、期待通りにならなかった。

どうも、commit中にオーバーフィッティングが増幅されているようだ。

12月19日（土）

この1週間のGPUの割当は30時間となっている。少ないな！

Riiid AIEd Challenge, 2,854 teams, 20 days to go

オーバーフィッティングを避ける方法の１つとして、少なめのラウンド数で止めてsubmitしてみた。val_aucがほぼ同じで、train_aucは低く抑えられた。

しかし、LBの改善には結びつかなかった。

再現性が良くない。

commit中にoverfitting気味になるかと思えば、明らかに小さな値になることもある。

現在の条件で再現性を調べてみる。

誰かの記事にならって６Mくらいのrawデータ量でチューニングしてから、データ量を増すことにして、チューニングをしてみたが、ラウンド数が少ないと、ばらつきのために違いが見えにくく、６Mのデータでも時間がかかる。パラメータによっては、ラウンド数が増えてから効果が現れてくるものもあるので、早い段階での数値を比較していると判断を誤ることがある。これは結構深刻な問題である。

フォークしたコードのLBスコアを0.001上げられずに苦しんでいる自分がいる。

昨日はcommit中のスコアが高くなり、今日はcommit中のスコアが低くなった。

結果として、どちらの場合でもLBスコアの向上に結び付いていない。

feature engineeringをやれと言われているような気がしてくる。 

12月20日（日）Riiid AIEd Challenge, 2,890 teams, 19 days to go

チューニングによるスコアが頭打ちになってきたので、featureの選択や処理/追加作製方法を学ぼうと、notebookを検索してみた。

以前にも参考にさせていただいたコードが、バージョンアップされていた。EDAとBaseline modelという内容はそのままだと思うが、以前に見たときは、計算するところで終わっていたように思うが、submitできるようになっている。

コンペで競うことを目的に参加している人が大半だと思うが、コンペ参加者のために、EDA、解法例、submittするためのコード、などを公開することを目的とされている人がおられるのではないかと思う。非常にありがたいことである。

featureの選択をやっているが、難しい。

12月21日（月）

Riiid AIEd Challenge, 2,923 teams, 18 days to go 

今日もfeatureの選択をやっている。

いろいろやっていて、面白い現象がおきた。

投入するfeatureの組み合わせによって、Feature Importanceの分布が大きく変化したのである。分布の見た目の違いほどには、Val_AUCは変わらなかったが、少し大きくなる組み合わせも出てきた。LBも改善されることを期待しているが結果はまだ出ていない。

残念、少し良い結果をcommitしている最中にエラーが発生した。

計算からやり直しだ。

12月22日（火）

Riiid AIEd Challenge, 2,960 teams, 17 days to go 

feature選定検討中

12月23日（水）

Riiid AIEd Challenge, 2,994 teams, 16 days to go

12月18日に0.781に着地して以来、更新できていない。

それも、100％借り物のコードである。

LGBMについては、少しは理解が進んだと思うが、思考錯誤の時間さえあればだれでもできそうなことしかできていない。

feature engineeringをやっている、と感じられるコードをみていると、val_AUCの値も、feature importanceの分布も、用いるfeatureによって大きく変化しているのがわかる。

それらの変化の大きさと比べると、LGBMのチューニングによる効果は小さい。

といっても、'gbdt'の中でのことであって、'goss'や'dart'までは試していない。

LGBMのサイトの、Parameters Tuningには、次のような項目がある。

For Better Accuracy 

• Use large max_bin (may be slower)

• Use small learning_rate with large num_iterations

• Use large num_leaves (may cause over-fitting)

• Use bigger training data

• Try dart

これだけでは、さっぱりわからない。

LGBMのサイトのExperimentsに、xgboostとxgboost_histとLightGBMの性能を比較した結果があるが、その際に用いられているLGBMのパラメータは次のようになっている。

（・・・）は自分の付記である。

LightGBM:

learning_rate = 0.1（デフォルト）
num_leaves = 255（デフォルト：31）
num_trees = 500（num_iterationsと同じ？）
num_threads = 16（CPUのコア数）
min_data_in_leaf = 0（デフォルト：20）
min_sum_hessian_in_leaf = 100（デフォルト：1e-3）

12月24日（木）

• Riiid AIEd Challenge
• , 3,029 teams
• , 15 days to go

現在、0.782の最後尾：まだ2週間もあるので、このままでは、メダル圏外は確実だ：銀は0.785：金は0.805

LGBMのコードのfeatureの選択を行っている。

現状でほぼ最大値を示す状態から、各featureをOn, Offしたときのスコアの変化量を見ようとしている。各featureは独立しているとは限らないので、その扱いは単純ではないが、数値化することによって、先が見えてくるかもしれない。

各featureをOn, Offしたときのスコア変化を1つ1つ調べ、変化による差異を記録し、全てを調べた後で、プラス方向に変化するようにfeatureをon,offすれば、最適化が進むと考え、試してみた。

問題は、データ量と、収束条件をどうするかだ。

データ量はある程度の大きさで固定すれば良さそうである。

収束条件は、early_stoppingを使ったのだが、onとoffの差が小さく、有用なはずのfeatureがマイナスの評価になることがあった。こういう評価は、探索の前に、必ず、ばらつきを抑えておかないとだめだな。スコアがなかなか上がらないとあせってしまって、手抜きになって、十分な成果が得られない。不要なfeatureを選び、必要なfeatureを落としているかもしれない。

他にも問題がある。これもばらつきが原因なのだが、どうも、ドラフト計算結果よりcommit後の方が良くない結果になることが多い。これも、同一条件で3回繰り返せばはっきりするのだが、ドラフトとcommitで５～６時間以上かかっているので、同一条件の繰り返しは、できていない。何度かやろうとしたが、ついつい、パラメータをいじってしまう。同じ時間を費やすなら、異なるパラメータの結果を知りたいと思ってしまうのだが、結局、それも、ばらつきがわからないから、大小関係の判定が正しく行えないので意味不明の結果になってしまう。

今から、同一条件で、ドラフトーcommitを3回繰り返してみよう。ばらつきは、計算プロセスの中に存在し、ドラフトかcommitかは無関係なので、それぞれがばらついて、3回とも、commit後の値が小さくなる確率は非常に小さいはずだ。

1回目：ドラフト：0.7745、commit：0.7734

2回目：ドラフト：0.7742、commit：0.7743

3回目：ドラフト：0.7745、commit：0.7743

結果は、こうなった。いずれも、LGBM：500ラウンドの結果である。1回目のcommitが若干はずれている、というところか。

なぜ、commit後の値の方が小さくなると感じているのかを分析してみよう。

その答えは簡単である。

すなわち、計算は、何らかの指標によって改善が見込まれるときに行うので、途中経過が良くないと、中止してしまっているのである。反対に、途中経過が良いときには、気をよくしてcommit, submitに進むのである。つまり、途中経過が良くない場合に中止しないでcommitしていれば、ドラフトよりもcommit後の結果の方が良くなっていただろう、ということである。つまり、commit後の計算がいつも小さくなっているように感じるのは、途中経過が良い場合にのみ、commitしているからである。

予測モデルの汎用性を高めるには、計算を繰り返して、良い結果も悪い結果も全部含めて平均を取ることが効果的であって、良い結果だけの平均をとることは、汎用性を下げてしまうことになっている可能性が高い。いわゆるoverfittingである。

ヒトが介入することで、良くなることもあれば、悪くなることもある。

ということからすると、AとBのアンサンブルをする場合に、スコアの良い方の比重を上げようとすることが多いが、それは、overfittingにつながるかもしれない。public LBも常に向上するとは限らない。凝り固まらずに、いろいろ試してみることが重要。

どのコンペだったか、アンサンブルにアンサンブルを重ねて失敗したことがあった。private LBが最も良かったのは、全てのモデルの単純平均だったような気がする。このときは、ヒトが介入しすぎて、public_dataにoverfitしてしまったということだろうな。

そうだ、機械的にやればいい。・・学習ですから。

計算の合間に「ゼロからはじめるデータサイエンス」Joel Grus著、菊池彰訳

ソート

x = [ 4, 1, 2, 3 ]

y = sorted(x) # y = [ 1, 2, 3, 4 ]

x.sort( ) # x = [ 1, 2, 3, 4 ]

# 絶対値で降順にソート

x = sorted([ -4, 1, -2, 3], key=abs, reverse=True) # is [ -4, 3, -2, 1 ]

リストの連結

x = [1, 2, 3]

x.extend([4, 5, 6]) # リストxは、[1, 2, 3, 4, 5, 6]になる。

要素の追加

x = [1, 2, 3]

x.append(0) # リストxは、[1, 2, 3, 0]となった。

z = len(x) # z = 4

12月25日（金）

Riiid AIEd Challenge, 3,061 teams, 14 days to go 

昨日はmax_round=500で実施したが、earlystopの条件を満たさず、3回ともmax_roundの500で停止した。

次は、max_round=1000、にして、3回繰り返してみる。

ちょっと（5時間程度）やってみたが、昨日の3回の結果でLBスコアの改善が見られなかったことと、繰り返し再現性（ばらつき）についてある程度の知見は得られたので、スコアアップのための他の方法を検討する。

featureを順位の高い方から10件だけ使うとか、30件くらい使うとか、いろいろやっているが、val_AUCが上がらない。下がることの方が多い。

正直、途方に暮れている。

こういうときに、最も簡単で効果的な方法がある。

これまで最高のスコアを出したコードに戻って、そこから、確実な改善を積み重ねることである。ここから、まだ、ハイスコアのコードが公開される可能性は高いが、だからといって、まだ、そういうものと戦う力は無いので、一足飛びに上を目指すのは少し横においておこう。

まずは、0.782の中を這い上がろう。

計算の合間に「ゼロからはじめるデータサイエンス」Joel Grus著、菊池彰訳

リスト内包

even_numbers = [x for x in range(5) if x % 2 == 0] # [0, 2, 4]

squares = [x * x for x in range(5)] # [0, 1, 4, 9, 16]

even_squares = [x * x for x in even_numbers] # [0, 4, 16]

square_dict = { x : x * x for x in range(5)} # { 0:0, 1:1, 2:4, 3:9, 4:16 }

square_set = { x * x for x in [1, -1]} # { 1 }

簡単な表現で十分に慣れておけば、実際の場面でも理解できるようになるだろう。

アンダースコア "_" も慣れておけば、出くわしたときに、あわてなくてすむ。

zeros = [ 0 for _ in even_numbers ] # even_numbersと同じ長さの0が続くリスト

Training data-efficient image transformers & distillation through attention
Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Herve J ´ egou ´, Facebook AI, Sorbonne University

Abstract

Recently, neural networks purely based on attention were shown to address image understanding tasks such as image classification.

However, these visual transformers are pre-trained with hundreds of millions of images using an expensive infrastructure, thereby limiting their adoption by the larger community.

In this work, with an adequate training scheme, we produce a competitive convolution-free transformer by training on Imagenet only.

We train it on a single computer in less than 3 days. Our reference vision transformer
(86M parameters) achieves top-1 accuracy of 83.1% (single-crop evaluation) on ImageNet with no external data. We share our code and models to accelerate community advances on this line of research.

Additionally, we introduce a teacher-student strategy specific to transformers.

It relies on a distillation token ensuring that the student learns from the teacher through attention.

We show the interest of this tokenbased distillation, especially when using a convnet as a teacher.

This leads us to report results competitive with convnets for both Imagenet (where
we obtain up to 84.4% accuracy) and when transferring to other tasks. 

12月26日（土）

Riiid AIEd Challenge, 3,098 teams, 13 days to go 

残り2週間を切った。0.8+に至る道は、まだ見えない。

0.79+レベルのコメントでは、公開コードにあるfeatureの組み合わせでは不十分で、さらに工夫が必要になるとのこと。

＊＊＊雑談＊＊＊

Python系のプログラミング技術の習得が不十分であるために自分でプログラムを組むことができないからフォークするのか、それとも、課題を解決する方法がわからないためにプログラミングするところまでいかないからフォークするのか。

優れたプログラミング技術と優れた課題解決方法を学ぶためにフォークしているのです、と答えたいところだが、実際のところは、リーダーボードに掲載されてみたいし、あわよくばメダルを獲得したいからである、ということになろうか。

フォークすること自体は何の問題もない。問題があるとすれば、フォークしたコードをそのまま実行し、その結果をsubmitしてしまうことである。いや、これも問題はない。フォークしたコードをチューニングすることも加工することも、問題はない。

公開コードは、ある程度の時間が経てば、初級レベルからメダル圏内に入りそうなレベルのものまで公開されている。したがって、十分な時間があれば、手作りから始めて、わからないところは、公開コードを参考にしながら、プログラムを組み上げていけばよいのである。この作業を丁寧にやっていれば、プログラミング技術は向上し、課題解決能力も向上していく。

12月27日（日）

Riiid AIEd Challenge, 3,122 teams,12 days to go 

0.783の爆弾が落とされて、メダル圏外に放り出されてしまった。

このコードは、0.780、0.781と似ているが、LGBMモデルに学習させるfeatureの数と種類が異なっていて、データ量も違っている。

データ量とfeature数は逆相関になっていて、データ量を増やすには、featureを減らす必要があった。公開コードの0.780と0.781が示していた（暗示していた）ことは、feature数を減らしてデータ量を増やせば、0.001だけLBが上がるということであった。

200チーム以上がフォークしてチューニングを試みたと思うが、この方向が効果的であれば、0.782になだれ込むはずだが、そうはならなかった。自分も、featureを減らしてデータ量を増やすことでLBアップを狙ったが、労力の割には効果は小さかったと思う。

0.781の中を通って、0.782の仲間入りを果たしたまでは良かったが、0.782の最後尾に張り付いたまま動けなくなった。

現在、0.783のコードが 2つ公開されているが、まさにこのfeature数とデータ量の違いである。feature量を効果的に減らしてデータ量を増やすか、データ量は押さえてfeatureの種類を増やすかの2者択一になっている。

では、もっと上位の方々は、どういう方法を用いてるのだろうか。

アンサンブルかな。

SAKT、SAINT、TabNet、1次元CNNやLSTM、GRUなどの従来型のRNNなど様々な手法のモデルのアンサンブルが有効なのかもしれない。
公開コードの中に存在しているものを適切に組み合わせる技術があればいいのだが。

今後のためにも、その方法を少しでも多く学んでおこう。

12月28日（月）

Riiid AIEd Challenge, 3,161 teams, 11 days to go

銀以上を狙っているのだが、現状では、銅も難しい。

競争が本格化するのはここからだ。1週間前、3日前と、さらに厳しくなる。

0.783をフォークしてチューニングしているが、前進できない。featureの選び方に不自然さを感じたので、これまで自分なりに順位付けしていたfeatureを優先的に選んでみたが、val_aucは上がっても、LBスコアは上がらない。

不思議なのは、40個以上あるfeatureのうちで、feature importanceが小さい5つを除いてみると、val_aucは0.0013上がるが、LBは上がらない。それだけでなく、feature importanceの順番と分布が一目でわかるくらい大きく変わったことである。

ということから、val_aucの値とfeature importanceの分布が、それぞれ適切な値/分布になるときに、LBスコアは上がるということのようなので、探索範囲を拡げて1つ1つ調べていく必要がありそうだ。

計算の合間に文法を学ぼう。

.replace：文字列を置換する

pandas.get_dummies()：

note.nkmk.meから引用：

pandasでカテゴリ変数（カテゴリカルデータ、質的データ）をダミー変数に変換するには、pandas.get_dummies()関数を使う。

文字列でカテゴリー分けされた性別などのデータを、男を0, 女を1のように変換したり、多クラスの特徴量をone-hot表現に変換したりすることができる。機械学習の前処理として行うことが多い。

例として以下のデータを使用する。説明のために列を追加している。

import pandas as pd
import numpy as np

df = pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0)

df['sex'] = ['female', np.nan, 'male', 'male', 'female', 'male']
df['rank'] = [2, 1, 1, 0, 2, 0]

print(df)
#          age state  point     sex  rank
# name                                   
# Alice     24    NY     64  female     2
# Bob       42    CA     92     NaN     1
# Charlie   18    CA     70    male     1
# Dave      68    TX     70    male     0
# Ellen     24    CA     88  female     2
# Frank     30    NY     57    male     0

引数にpandas.DataFrameを指定する場合
pandas.DataFrameの場合は、デフォルトではデータ型dtypeがobject（おもに文字列）またはcategoryである列がすべてダミー変数化される。

数値（int, float）やブールboolの列は変換されず元のまま。数値やブールの列もダミー化したい場合の設定については後述。

pandas.DataFrameの場合の列名は元の列名_カテゴリー名となる。変更する設定は後述。

print(pd.get_dummies(df))
#          age  point  rank  state_CA  state_NY  state_TX  sex_female  sex_male
# name                                                                         
# Alice     24     64     2         0         1         0           1         0
# Bob       42     92     1         1         0         0           0         0
# Charlie   18     70     1         1         0         0           0         1
# Dave      68     70     0         0         0         1           0         1
# Ellen     24     88     2         1         0         0           1         0
# Frank     30     57     0         0         1         0           0         1

source: pandas_get_dummies.py

これ以上の転載はやめておく。

pd.get_dummies( )を使いこなせるようになろう。

.groupby：note.nkmk.meから引用

pandas.DataFrameをGroupByでグルーピングし統計量を算出

pandas.DataFrame, pandas.Seriesのgroupby()メソッドでデータをグルーピング（グループ分け）できる。グループごとにデータを集約して、それぞれの平均、最小値、最大値、合計などの統計量を算出したり、任意の関数で処理したりすることが可能。

なお、マルチインデックスを設定することでも同様の処理ができる。以下の記事を参照。

関連記事: pandasのMultiindexで階層ごとの統計量・サンプル数を算出
また、pandas.pivot_table(), pandas.crosstab()という関数を用いてカテゴリごとの統計量やサンプル数を算出することもできる。この方法が一番シンプルかも知れない。

関連記事: pandasのピボットテーブルでカテゴリ毎の統計量などを算出
関連記事: pandasのcrosstabでクロス集計（カテゴリ毎の出現回数・頻度を算出）

groupby()でグルーピング
pandas.DataFrameのgroupby()メソッドでグルーピング（グループ分け）する。なお、pandas.Seriesにも同様にgroupby()メソッドがある。

pandas.DataFrame.groupby — pandas 1.0.4 documentation
pandas.Series.groupby — pandas 1.0.4 documentation
引数に列名を指定するとその列の値ごとにグルーピングされる。

GroupByオブジェクトからメソッドを実行することでグループごとに処理ができる。メソッド一覧は以下の公式ドキュメント参照。

GroupBy — pandas 1.0.4 documentation
例えばsize()メソッドでそれぞれのグループごとのサンプル数が確認できる。

平均、最小値、最大値、合計などを算出
上記のメソッド一覧にあるように、GroupByオブジェクトに対しmean(), min(), max(), sum()などのメソッドを適用すると、グループごとの平均、最小値、最大値、合計などの統計量を算出できる。

そのほか標準偏差std()、分散var()などもある。

いずれのメソッドも新たなpandas.DataFrameを返す。

任意の処理を適用して集約: agg()
GroupByオブジェクトのagg()メソッドで任意の処理を適用することもできる。

pandas.core.groupby.GroupBy.agg — pandas 1.0.4 documentation
引数に適用したい処理を指定する。

GroupByオブジェクトのメソッド名を文字列で指定できるほか、組み込み関数やNumPyの関数などの呼び出し可能オブジェクト（callable）を指定可能。

関連記事: pandasのagg(), aggregate()の使い方

.reset_index：

pandas.DataFrame, Seriesのインデックスを振り直すreset_index

reset_index()メソッドを使うと、pandas.DataFrame, pandas.Seriesのインデックスindex（行名、行ラベル）を0始まりの連番（行番号）に振り直すことができる。

pandas.DataFrame.reset_index — pandas 0.22.0 documentation
行番号をインデックスとして使っている場合、ソートして行の順番が変わったときや行を削除して欠番が出たときなどはインデックスを振り直したほうが使いやすい。

また、行名（行ラベル）をインデックスとして使っている場合に、現在のインデックスを削除したりデータ列に戻すためにも使う。set_index()とreset_index()を使うことで、インデックスを別の列に変更（再設定）することができる。

feature enginering：

An Empirical Analysis of Feature Engineering for Predictive Modeling
Jeff Heaton, SoutheastCon 2016, 2016 - ieeexplore.ieee.org

I. INTRODUCTION
Feature engineering is an essential but labor-intensive component of machine learning applications [1]. Most machinelearning performance is heavily dependent on the representation of the feature vector. As a result, data scientists spend much of their effort designing preprocessing pipelines and data transformations [1]. To utilize feature engineering, the model must preprocess its input data by adding new features based on the other features [2]. These new features might be ratios, differences, or other mathematical transformations of existing features. This process is similar to the equations that human analysts design. They construct new features such as body mass index
(BMI), wind chill, or Triglyceride/HDL cholesterol ratio to help understand existing features’ interactions. Kaggle and ACM’s KDD Cup have seen feature engineering play an essential part in several winning submissions. Individuals applied feature engineering to the winning KDD Cup 2010 competition entry [3]. Additionally, researchers won
the Kaggle Algorithmic Trading Challenge with an ensemble of models and feature engineering. These individuals created these engineered features by hand.  

... the following sixteen selected engineered features:
• Counts
• Differences
• Distance Between Quadratic Roots
• Distance Formula
• Logarithms
• Max of Inputs
• Polynomials
• Power Ratio (such as BMI)
• Powers
• Ratio of a Product
• Rational Differences
• Rational Polynomials
• Ratios
• Root Distance
• Root of a Ratio (such as Standard Deviation)
• Square Roots

こういう演算によってfeatureを作り出すということのようだ。

LGBMを使った公開コードを見ていると、これらの演算を使ってfeatureを作っていることがわかる。演算の種類も、featureの組み合わせ方も重要で、いかにして良いfeatureを作り出すか、ということなんだろうな。

12月29日（火）

Riiid AIEd Challenge, 3,184 teams, 10 days to go

昨夜、LGBMのパラメータ：feature_fractionが気になって、値を少し大きく変えて計算してみた。そうすると、feature_importanceの分布がその値によって大きく変わることがわかった。val_aucの値も変化している。submitしてLBスコアを確かめよう。LBスコアは少し改善した。といっても、0.001以下でのこと。

計算の合間にLGBMとfeature_engineering：

Francois Chollet “Developing good models requires iterating many times on your initial ideas, up until the deadline; you can always improve your models further. Your final models will typically share little in common with the solutions you envisioned when first approaching the problem, because a-priori plans basically never survive confrontation with experimental reality.”

Francois Chollet「優れたモデルを開発するには、締め切りまで、最初のアイデアを何度も繰り返す必要があります。 モデルはいつでもさらに改善できます。 事前の計画は基本的に実験的な現実との対立に耐えることができないため、最終的なモデルは通常、最初に問題に取り組むときに想定したソリューションとほとんど共通点がありません。」

                                                                                                           by google translation

12月30日（水）

Riiid AIEd Challenge, 3,211 teams, 9 days to go 

意味を理解できていないパラメータを意味の分からない値に設定しながら、ようやく0.785に到達した。

今朝、自信をもってsubmitしたが、前進できなかった。改善は、ばらつきの範囲で、偶然生じただけかもしれない。

確認のためには、同一条件での計算を、3回繰り返すことになる。

ばらつきによって上がったのを、パラメータが適切であったと思ってしまったら、誤った方向に行くことになる。

さらに、忘れてはならないのは、private_dataへのover-fittingである。

「意味を理解できていないパラメータを意味の分からない値に設定しながら」：こういうことだと、public_LBだけを頼りにfeatureの選択やパラメータの設定をすることになるので、public_dataへのoverfittingになりやすい。

チューニングが行き詰ってきたこともあり、LightGBMのマニュアルの ”Parameters Tuning"を参考に、num_leavesとmin_data_in_leafとmax_depthを用いて、条件検討をやりなおすことにした。num_leavesしか使っていなかったので、他の２つは適当に値を設定してやってみたら、10時間くらいで、なんとなくそれらしい結果が出始めた。そこで、submitではなく、記録のためにcommitしたら、commitの途中で、"[Worning] No further splits with positive gain, best gain: -inf"というメッセージが現れた。これはダメだろうと思い、中断して、調べたら、min_data_in_leafの設定値、1024が大きすぎることによるものであるらしい、ということがわかった。

マニュアルには、大きなデータの場合には数百もしくは数千で十分"In practice, setting it to hundreds or thousands is enough for a large dataset".とあったので、間をとって1024にしたのだが、この1024が不適切だったようだ。

そこで、min_data_in_leafを512, 256, 128とかえてみたが、同じ症状だった。ドラフト計算可能、良好な結果が得られている。しかし、commitすると、警告が出る。

min_data_in_leafは、over-fittingしないための非常に重要なパラメータである（This is a very important parameter to prevent over-fitting in a leaf-wise tree.、と書かれている。 

なんとかして、使いこなしたいものだ。 

計算の合間にLGBMとfeature_engineering：

bagging_fractionの使い方：指定した割合のデータをランダムにサンプリングする。

pos_とneg_があって、used for imbalanced binary classification problem、となっている。今回のRiiidコンペの場合だと、正答率が約65％でアンバランスだから、正答をpositiveとすれば、pos_bagging_gractionを0.35、neg_bagging_fractionを0.65とすれば、サンプリングしたデータ中には、正答と誤答が同等の割合で含まれることになる。ただし、他の方法で補正しているかもしれないので、公開コードを使うときには、全部調べてからにしないと、これを使ったがために、かえって、アンバランスを生じる可能性がある。しかしながら、理屈通りに動作するとは限らないので、比率を系統的に変えてみて、結果がどうなるかを実験してみるのも、よいかもしれない。

feature_fractionもbagging_fractionも、”can be used to speed up training、can be used to deal with over-fitting””という記述がある。直観的には、dropoutに似た効果かなと思う。

LGBMのParameterの説明について"over-fitting"を検索すると、次のパラメータが、over-fittingに関連していることがわかる。

"extra_trees", "max_bin", "min_data_in_bin", "max_depth", "min_data_in_leaf", "min_sum_hessian_leaf",

"max_bin"は、"small number of bins may reduce training accuracy but may increase general power (deal with over-fitting)"、と記述されている。

max_binは、accuracyが上がることを期待して大きな値にセッティングしがちだが、generalizationとのバランスが必要のようだ。

LightGBMのマニュアルの”Parameters Tuning"をじっくり眺めてみよう。

Tune Parameters for the Leaf-wise (Best-first) Tree 

LightGBM uses the leaf-wise tree growth algorithm, while many other popular tools use depth-wise tree growth. Compared with depth-wise growth, the leaf-wise algorithm can converge much faster. However, the leaf-wise growth may be over-fitting if not used with the appropriate parameters.

To get good results using a leaf-wise tree, these are some important parameters:

1. num_leaves. This is the main parameter to control the complexity of the tree model. Theoretically, we can set num_leaves = 2^(max_depth) to obtain the same number of leaves as depth-wise tree. However, this simple conversion is not good in practice. The reason is that a leaf-wise tree is typically much deeper than a depth-wise tree for a fixed number of leaves. Unconstrained depth can induce over-fitting. Thus, when trying to tune the num_leaves, we should let it be smaller than 2^(max_depth). For example, when the max_depth=7 the depth-wise tree can get good accuracy, but setting num_leaves to 127 may cause over-fitting, and setting it to 70 or 80 may get better accuracy than depth-wise.

2. min_data_in_leaf. This is a very important parameter to prevent over-fitting in a leaf-wise tree. Its optimal value depends on the number of training samples and num_leaves. Setting it to a large value can avoid growing too deep a tree, but may cause under-fitting. In practice, setting it to hundreds or thousands is enough for a large dataset.

3. max_depth. You also can use max_depth to limit the tree depth explicitly. 

リーフワイズ（ベストファースト）ツリーのパラメーターを調整する
LightGBMは葉ごとのツリー成長アルゴリズムを使用しますが、他の多くの一般的なツールは深さ方向のツリー成長を使用します。深さ方向の成長と比較して、葉方向のアルゴリズムははるかに速く収束できます。ただし、適切なパラメーターを使用しないと、葉ごとの成長が過剰適合する可能性があります。

リーフワイズツリーを使用して良好な結果を得るには、次のいくつかの重要なパラメーターがあります。

num_leaves：これは、ツリーモデルの複雑さを制御するための主要なパラメーターです。理論的には、num_leaves = 2 ^（max_depth）を設定して、深さ方向のツリーと同じ数の葉を取得できます。ただし、この単純な変換は実際には適切ではありません。その理由は、葉の数が決まっている場合、通常、葉の数のツリーは深さのツリーよりもはるかに深いためです。制約のない深さは、過剰適合を引き起こす可能性があります。したがって、num_leavesを調整しようとするときは、2 ^（max_depth）より小さくする必要があります。たとえば、max_depth = 7の場合、深さ方向のツリーは良好な精度を得ることができますが、num_leavesを127に設定すると過剰適合が発生する可能性があり、70または80に設定すると深さ方向よりも精度が高くなる可能性があります。

min_data_in_leaf：これは、葉ごとのツリーでの過剰適合を防ぐための非常に重要なパラメーターです。その最適値は、トレーニングサンプルとnum_leavesの数によって異なります。大きな値に設定すると、ツリーが深くなりすぎるのを防ぐことができますが、フィットが不十分になる可能性があります。実際には、大規模なデータセットの場合は、数百または数千に設定するだけで十分です。

max_depth： max_depthを使用して、ツリーの深さを明示的に制限することもできます。　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　by google translation

この文章は、LGBMはパラメータを適切に設定しないで使うとover-fittingします、という忠告文としてとらえるのがよさそうである。

12月31日（木）

Riiid AIEd Challenge, 3,234 teams, 8 days to go 

min_data_in_leafとmax_depthは、over-fittingの抑制に効果的だということは実感できたが、commit中にエラーになるのでは使えない。

この2つが競合していると仮定して、片方だけ使うことにしてみる。min_data_in_leafの方が重要だとの記述から、最初に、max_depthを省いてみる。それでだめなら、逆にする、それでもだめなら、今回は両方とも使わないことにする。

max_depthを省くことで、commit中のエラーは表示されなくなった。

ただし、max_depthが、over-fittingの抑制にかなり寄与していたことがわかったので、min_data_in_leafをさらに調整する必要がある。 

style=160 iteration=500

style=160 iteration=50

style=160 iteration=5

GitHub散歩（November 2020）

GitHub散歩（November 2020）

これまでは、コードを見るだけのGitHubだった。

もう少し活用したいと思っている。

11月21日（土）

GitHub Guidesのページの下端に次のように書かれている。

GitHub is the best way to build and ship software.
Powerful collaboration, code review, and code management for open source and private projects.

GitHubを初めて使ったのは、機械学習のテキストを学習する際、実際にプログラムコードを動かすため、GitHubに置かれているプログラムコードをダウンロードしたときである。機械学習のテキストを購入するたびにGitHubからプログラムをダウンロードした。

テキストの著者がGitHubでBuildしたソフトウエアを利用していたということだ。

GitHubをプログラムをダウンロードする場所としてしかみていなかったが、プログラムを作って公開して共同で編集する場所のようですね。

GitHub Guidesに入ると、そこには、GitHubを理解し、活用するために必要なさまざまな仕掛け、教育ツール、ドキュメントが存在している。さまざまなプログラム言語も学べるようになっている。

11月22日（日）

What is GitHub?

I'm glad you asked! Many people come to GitHub because they want to contribute to open source 📖 projects, or they're invited by teammates or classmates who use it for their projects. Why do people use GitHub for these projects?

open source

Open source software is software that can be freely used, modified, and shared (in both modified and unmodified form) by anyone. Today the concept of "open source" is often extended beyond software, to represent a philosophy of collaboration in which working materials are made available online for anyone to fork, modify, discuss, and contribute to.

forkは次のように定義されている。

fork

A fork is a personal copy of another user's repository that lives on your account. Forks allow you to freely make changes to a project without affecting the original upstream repository. You can also open a pull request in the upstream repository and keep your fork synced with the latest changes since both repositories are still connected.

forkは、forkしたコードの改善、改良のために行うものであり、成果があれば、元の所有者に、改善結果等を反映するかどうか打診する。ということかな。

GitHubの中に、Learnibg labというのがあり、いろいろ学べるようになっているのだが、Introduction to GitHubを最初にやりましょうと促されたので、やってみることにした。

Introduction to GitHubは、1から8までのコースステップからなっていて、このコースを完了すれば次のステップに進めるようになっているようだ。逆にいえば、このコースを完了しないと、GitHubを利用することはできないのではないかと推測される。

1から8までのステップの項目は、1. Assign yourself, 2. Turn on GitHub Pages, 3. Close an issue, 4. Create a branch, 5. Commit a file, 6. Open a pull request, 7. Respond to a review, 8. Merge your pull request, となっていて、GitHubでの操作手順の説明がなされているようである。

わからないことがあれば、こまごまとしたことまで、丁寧にリンクが張られていて、用語もきちんと説明されている。

今日の書き始めの箇所に、一部、コピペしているが、いくらやってもきりがないので、教育内容まで踏み込むのはやめておく。

上記の8つの項目についても、前に進むには、少なくとも、紫で示した単語についての、GitHub内での定義とその内容を理解しておかなければならないので、初心者がこの8つのステップをクリヤするのは、容易ではないと思う。

ということで、自分も、ちょっと見ただけでも、理解しなければならないことがたくさんあり、かつ、英語で直接コミュニケーションできるようにするために、苦手の英語を、できるだけそのまま理解しながら前に進もうとしているので、いつ、8つのステップをクリヤできるかわからない。

この8つのステップをクリヤ出来たら、そのことを書きたいと思う。

11月23日（月）：

Introduction to GitHub

Step 1を学習中：Step 4まで通過したが、

Step 5: Commit a fileで止まっている。

style=159 iteration=500

style=159 iteration=50

style=159 iteration=5

DNNで量子化学計算（November 2020）

DNNで量子化学計算（November 2020）

最近の進展についてまとめる機会があったので、より深く理解することと、実際の解析コードを使えるようになることを目標に、その経過をブログに記す。

11月10日（火）

FermiNet：

FermiNet is a neural network for learning the ground state wavefunctions of atoms and molecules using a variational Monte Carlo approach.

基底状態の波動関数を学習するためのNNであるという記述が気になる。

troyerらの成果

Despite the simplicity of the restricted Boltzman machines, very accurate results for both ground-state and dynamical properties of prototypical spin models can be readily obtained.

図のタイトルを並べてみると、

Figure 1.  Artificial Neural Network encoding a many-body quantum state of N spins.

Figure 2.  Neural Network representation of the many-body ground states of prototypical spin models in one and two dimensions.

Figure 3.  Finding the many-body ground-state energy with neural-network quantum states.

Figure 4.  Describing the many-body unitary time evolution with neural-network quantum states.  Shown are results for the time evolution induced by a quantum quench in the microscopical parameters of the models we study (the transverse field h, for the TFI model and the coupling constant Jz in the AFH model). 

TFI : transverse-field Ising (model)

AFH : anti-ferromagnetic Heisenberg (model)

11月11日（水）

HermannらのPauliNetの成果

PauliNet outperforms comparable state-of-the-art VMC anzats for atoms, diatomic molecules and a strong-correlated hydrogen chain by a margin and is yet computational efficient.

成果は、正確さと効率化（行列の数）だけなのか。効率化によって、より大きな原子、分子について正確な計算結果を得ることができたということなのか。

Figure 1に、PauliNetによる効率化の程度がわかりやすく図示されている。

PfauらのFermiNetの成果

Using no data other than atomic positions and charges, we predict the dissociation curves of the nitrogen molecule and hydrogen chain, two challenging strongly correlated systems, to significantly higher accuracy than the coupled cluster method, widely considered the most accurate scalable method for quantum chemistry at equilibrium geometry.

coupled cluster method：結合クラスター法

 結合クラスター法（けつごうクラスターほう、クラスター展開法、CC法：Coupled Cluster）は多体系を記述するために使われる数値手法である。最もよく使われるのは、量子化学（計算化学）におけるポスト-ハートリー-フォック第一原理計算がある。CC法は、ハートリーフォック分子軌道法を基本にして、電子相関を考慮する指数関数クラスター演算子を使って多電子波動関数を構成する。CC法を用いて、小さい分子や中程度の大きさの分子について最も正確な計算を行うことができる^[1][2][3]。from ウイキペディア

Table 1.  Ground state energy, ionization potential, and electron affinity for first-row atoms.

Table 2.  Ground-state energy at equilibrium geometry for diatomic and small molecules.

いずれの表も、FermiNetがCCSD(T)に優っていることを示している。イオン化ポテンシャルと電子親和力は、FermiNetの結果しかないのは、CCSD(T)では基底状態のエネルギーしか計算できないということだろうか。

C.  The H4 rectangleの最初に次のように記述されている。

While CCSD(T) is exceptionally accurate for equilibrium geometries, it often fails for molecules with low-lying exited states or stretched, twisted or otherwise out-of-equiliblrium geometries.

昨日学会に送ったA4半ページの紹介記事で、FermiNetやPauliNetは励起状態のエネルギーも正確に計算できると書いたのだが、励起状態あるいは非平衡状態のエネルギーの計算に関しては、論文の斜め読みでそう書いただけだったので、気になっていたのだが、少なくとも、FermiNetに関しては問題ないようだ。図４から図6には、非平衡状態の計算においてもFermiNetはFCIなどの厳密な計算手法や正確な実験データに匹敵する正確さをもつことが示されている。

PauliNetについても、原子間距離に対するエネルギーの変化をHaetree-Fockなどの量子化学計算結果と比較していて、PauliNetのほうが、exactなデータに近いことが示されているので問題なさそうである。

11月12日（木）

PauliNetのGitHubを見てみよう。

deepqmc：Deep learning quantum Monte Carlo for electrons in real space

deepqmc.github.io：DeepQMC documentation

プログラムコードとは別にドキュメンテーション（ユーザーガイドを含む）も用意されていて、勉強しやすそうだ。

11月14日（土）

FermiNetのGitHubを見てみよう。

REDME.mdの最後に、This is not an official Google product.と書かれていて不安になるが、アルファ碁を開発し、その後はバイオやフィジックスなどの自然科学の領域でも影響力を増しているDeepMindが運営している89のrepositoriesのうちの１つである。

PauliNetの開発者Jan Hermann氏は、量子物理の専門家であり、計算物理の専門家でもある。Hermann氏のGitHubには45のrepositoriesがあり、量子物理計算関連の内容がメインで、pySCFやSchNet（K.T. Schütt. P.-J. Kindermans, H. E. Sauceda, S. Chmiela, A. Tkatchenko, K.-R. Müller. SchNet: A continuous-filter convolutional neural network for modeling quantum interactions. Advances in Neural Information Processing Systems 30, pp. 992-1002 (2017)）なども含まれている。

FermiNetとPauliNetのどちらから始めようか考えているのだが、Hermann氏のサイトは、SCF計算やSchuNetなど量子物理の匂いが強く、DeepMind社のサイトはディープラーニングの匂いが強い。個人と団体の違いもある。入り口で立ち往生しても始まらないし、チェックしたいGitHubサイトは無限にあるので、GitHub散歩、みたいな感じで進めていこうと思う。

11月15日（日）

Hermann氏のサイトをながめてみよう。

Software projects

Most of my programming is related to my research in computational materials science. I believe that strong computational science benefits from strong software engineering, and that all scientific academic software should be open source.

I am involved in the following software projects.

 Creator

• PyBerny—Python package for optimizing molecular geometries, supported by PySCF, ASE, and QCEngine
• Libmbd—Fortran/Python library implementing the many-body dispersion method, embedded in FHI-aims and DFTB+
• DeepQMC—Pytorch implementation of quantum Monte Carlo with deep neural network ansatzes

 Beta projects

These are experimental packages that, although fully functional, I don’t yet consider finished.

• KnitJ—alternative front-end to Jupyter kernels aiming at editor freedom and easy versioning
• Mona—framework for reproducible and distributed, potentially long-running calculations

 Contributor

• FHI-aims—massively parallel electronic structure code package with DFT at its core

＜雑談＞

ずっと会社に勤めていて、結局、独立することなく終わったのだが、50歳くらいで研究に没頭できる環境が欲しいと思って、理論計算の受託で稼ぎながら、研究できないかと検討したことがある。 理論屋でも物理屋でもないのだが、量子化学、化学結合論などに興味があって、様々な分子軌道計算の論文をながめていたことがあったので、Gaussianのようなソフトを購入して、自分で使いながら、使いたい人に使い方や理論を教えたり、計算代行したりということを考えていた。このとき、ネックになったのが、ソフトの購入代金（使用料）と計算環境であった。会社の中で提案できるヒトではなかったので、夢想に終わった。ネットにアクセスできるパソコンがあれば、幸いにも、無料で、Gaussian（詳細は知らない）のような計算ができるようになっているので、夢の大半は実現することができる。ということを、pySCFについて調べながら、ぼんやり振り返っている。

DNN＋量子化学計算＋紹介記事　⇒　FermiNet & PauliNet

ということになったのだが、現実問題として、FermiNetやPauliNetにアクセスしてすぐに計算を始められるヒトは理論も計算もすでにプロの領域にいる研究者に限られるだろう。φ、ψ、HF、CBS、FN-DMC、QMC、VMC、Jastrow、FCI、fixed-node correlation energy、・・・、専門用語や略語の意味も分からず、DNNが最先端の量子化学計算の分野に応用されているというだけで食いついても、この技術を適用する課題をもっていないことには始まらない、いや、終わらない。

PySCFについて調べてみた。

Recent developments in the PySCF program package
Qiming Sun et al., arXiv:2002.12531v2 [physics.chem-ph] 11 Jul 2020

abstract

PYSCF is a Python-based general-purpose electronic structure platform that both supports first-principles simulations of molecules and solids, as well as accelerates the development of new methodology and complex computational workflows.

The present paper explains the design and philosophy behind PYSCF that enables it to meet these twin objectives.

With several case studies, we show how users can easily implement their own methods using PYSCF as a development environment.

We then summarize the capabilities of PYSCF for molecular and solid-state simulations.

Finally, we describe the growing ecosystem of projects that use PYSCF across the domains of quantum chemistry, materials science, machine learning and quantum information science.

machine learningに関係する記述を次に示す。

A. PySCF in the materials genome initiative and machine learning

As discussed in section I, one of our objectives when developing PYSCF was to create a tool which could be used by non-specialist researchers in other fields.

With the integration of machine learning techniques into molecular and materials
simulations, we find that PYSCF is being used in many applications in conjunction with machine learning.

For example, the flexibility of the PYSCF DFT module has allowed it to be used to test exchange-correlation functionals generated by machine-learning protocols in several projects, and has been integrated into other machine learning workflows.

PYSCF can be used as a large-scale computational engine for quantum chemistry data generation.

Also, in the context of machine learning of wavefunctions, PYSCF has been used as
the starting point to develop neural network based approaches for SCF initial guesses, for the learning of HF orbitals by the DeepMind team, and for Hamiltonian integrals used by fermionic neural nets in NETKET.

最後のNETKETってなんだろう。

著者19名の論文が出ている。

トップオーサーのCarleo氏は最初に多体問題にNNを適用した2017年の論文の著者。

NetKetを共通基盤にして、さらなる発展を目指すということかな。

NetKet: A machine learning toolkit for many-body quantum systems
Giuseppe Carleo, Kenny Choo et al., SoftwareX 10 (2019) 100311

abstract

We introduce NetKet, a comprehensive open source framework for the study of many-body quantum systems using machine learning techniques.

The framework is built around a general and flexible implementation of neural-network quantum states, which are used as a variational ansatz for quantum wavefunctions.

NetKet provides algorithms for several key tasks in quantum many-body physics and
quantum technology, namely quantum state tomography, supervised learning from wavefunction data, and ground state searches for a wide range of customizable lattice models.

Our aim is to provide a common platform for open research and to stimulate the collaborative development of computational methods at the interface of machine learning and many-body physics.

NetKetのホームページがある。

What is NetKet?

NetKet is an open-source project delivering cutting-edge methods for the study of many-body quantum systems with artificial neural networks and machine learning techniques.

GitHubに公開されているが、NetKetで検索しても出てこないので、使いにくそうだ。ElsevierのSoftwareXというシステムの中に埋もれてしまっているようである。

NetKetのホームページはチュートリアルもあって、コードの説明も詳しく、自習に適しているように思う。

Carleo氏オリジナルのNQS（Neural-network Quantum States）がGitHubに掲載されているが、更新している形跡がない理由がこれでわかったような気がする。

＜雑談＞

頭が使える間に、何かできないかなと思うのだが、何もできていない。小柴先生が亡くなられたが、ニュートリノの検出に成功されてノーベル賞を受賞され、お弟子さんの梶田先生もニュートリノに質量があることを明らかにしてノーベル賞を受賞された。こんな実験は誰にでもできるものではないが、湯川先生の中間子理論なら誰にでも発見のチャンスはあった。最先端の分野の論文を読んでディスカッションを重ね仮説を積み上げ理論を組み立て・・・。

11月16日（月）

G. Carleo氏らの総説（著者8名）、Machine learning and the physical science、arXiv:1903.10563v2 [physics.comp-ph] 6 Dec 2019を読んでみた。 

機械学習がこれだけ浸透していたのかと驚かされる内容だ。

と、書いてみたが、斜め読み（英文の斜め読みだから内容までは頭に入っていない）しただけで、これからじっくり解読していこうと思う。

著者と所属（専門領域が想像できる機関名）をいくつか示す。

Giuseppe Carleo
Center for Computational Quantum Physics,

Ignacio Cirac
Max-Planck-Institut fur Quantenoptik,

Kyle Cranmer
Center for Cosmology and Particle Physics,
Center of Data Science,

Maria Schuld
National Institute for Theoretical Physics,

Leslie Vogt-Maranto
Department of Chemistry

Lenka Zdeborová
Institut de physique théorique

11月17日（火）

FermiNetとPauliNetのどちらに食らいつこうか考えていて、チュートリアルも含め、コードの解説がしっかり書かれているように感じたHermann先生のPauliNetでほぼ決まりのつもりだった。

ところが、Neural-network quantum states (NQS) の創始者のCarleo先生は、FermiNetとPauliNetの論文を引用したうえで、NQSをさらに発展させた論文を書いておられる。

さらに、共著で機械学習の物理学への展開と相互作用に関する総説を書かれている。

加えて、NetKetと称する多体量子系に適用する機械学習toolkitを開発されている。

以上のことを勘案して、NetKetで本格的な学習を始めることにしたいと思う。

ということで、早速、NetKetのホームページへ、行く。

まずは、Get Started、をクリック。

下の方に、青地に白抜きで、こんな表示がある。

Remarks

We are not yet supporting Conda installs

Windows Os is not supported

想定されているのは、MacとUbuntuである。

Windowsユーザーは、これにて終了！

ということにならないために、

Windowsパソコンで、Ubuntuを使えるようにする、ということになる。

今使っているパソコンに何かあると困るので、他のWindowsパソコンで確認してみようと思う。

昨年、使わなくなったWindows Vistaパソコンに、Ubuntuをインストールしており、すぐにでも使える状態にある。GPUはなく、RAMは4GB、HDは100GBで、とりあえず動くのであるが、勝手がわからないというか、まったく手も足も出ず、放置している。

Windowsの方々は、私のように、ここで止まってしまう可能性が高いので、Ubuntuを使えるようになることを、当面の目標としよう。

Ubuntuの立ち上げ：

WindowsとUbuntuをパソコンの起動時に切り替えられるようにしている。

Ubuntuを使いたいと思ったのは、Anacondaに後から追加できるpythonパッケージやモジュールに制限があることで、AnacondaはTF2.0に対しても対応が非常に遅かった。無理に入れようとして、Anaconda3を壊してしまったこともある。

Ubuntuのインストールは、簡単なマニュアルを見ればできる。問題は、UbuntuでAnaconda3を使おうとしたときにおきた。WindowsにAnaconda3をインストールするのは容易で、Windows10だと、すぐに使えるようになったので、その感覚でUbuntuにもAnaconda3を簡単にインストールできると思ったのが間違いだった。

Anacondaのドキュメントには、Installing on Linuxという項目があって、インストール手順を説明しているのだが、Ubuntuという単語が見当たらない。

ウイキペディアによると、

Ubuntu（ウブントゥ^[6]、[ʊˈbʊntuː] ( 音声ファイル); oo-BOON-too^[7]）はDebian GNU/Linuxを母体としたオペレーティングシステム（OS）である。Linuxディストリビューションの1つであり、フリーソフトウェアとして提供されている。概念はディストリビューションも参照。カノニカルから支援を受けて開発されている。開発目標は「誰にでも使いやすい最新かつ安定したOS」を提供することである。

Linux（リナックス、他の読みは後述）とは、狭義にはUnix系オペレーティングシステムカーネルであるLinuxカーネルを指し、広義にはそれをカーネルとして周辺を整備したシステム全体のことをいう（GNU/Linuxシステムも参照）。

Linuxは、狭義にはLinuxカーネル、広義にはそれをカーネルとして用いたオペレーティングシステムを指す。LinuxはUnix系（英: Unix like、Unixライク）オペレーティングシステム (OS) の1つとされる。カタカナでは「リナックス」と表記されることが多い（「Linux」の読み方を参照）。Linuxは、スーパーコンピュータ・メインフレーム・サーバ・パーソナルコンピュータ・組み込みシステム（携帯電話やテレビなど）など、幅広い種類のハードウェアで使用されている。

デスクトップやサーバ用のLinuxは、Linuxディストリビューションという形でパッケージ化されて配布されている。有名なLinuxディストリビューションとしては、Debian（とその派生であるUbuntu、Linux Mint）、Red Hat Linux（とその派生であるFedora、Red Hat Enterprise Linux、CentOS）、Mandriva Linux/Mageia、openSUSE、Arch Linuxなどがある。各Linuxディストリビューションは、Linuxカーネル、システムソフトウェア、ライブラリ等、巨大なコンパイル済のアプリケーション群を含んでいる。

＜雑談＞

Ubuntuはメジャーではなさそうだが、Kerasを開発したF. Cholleさんが、著書Deep Learning with PythonのAppendixAに、Installing Keras and its dependences on Ubuntuという記事を書かれていたことと、12年ほど前にイオン散乱シミュレーションのソフトを使おうとしたときに、教授から渡されたソフトがUbuntu上で動いていて、Ubuntuの入門書を渡されたということがあって、自分の中ではメジャーであった。しかし、今から思えば残念なのだが、ほどなくして、Windows上で動作する高性能のシミュレーションソフトを使うことになって、Ubuntuという奇妙な単語だけが頭に残った。さらに、F. Cholle氏のテキストをバイブルとしてディープラーニングを学ぶときにはAppendixAの記事を読む前にGPUを搭載したWindowsマシンを購入してAnaconda3上でKeras/TensouFlowを使うようになっていたので、後に、Ubuntuを使ってみたいと思ったときには、時すでに遅し、大きな壁が立ちはだかっていたのである。

今、そのAppendixAを眺めているのだが、sudo apt-get update, sudo pip3 install tensorflow-gpu, sudo python setup.py installなどの単語が並んでいる。

こういうものだということがわかったのだから、コマンドプロンプトに慣れて、Ubuntuを自分のものにしていこう。ほんとうに必要性を感じた時に使ってみよう。難しいのではなく、不慣れなだけである、ということにして、Ubuntuは、とりあえずこのへんでおいておく。

11月18日（水）

NetKetのホームページを丁寧に辿っていけば目的とする量子化学計算に辿りつけそうであることはわかってきた。

NetKetの論文のabstractをもう1度見てみよう。

abstract

We introduce NetKet, a comprehensive open source framework for the study of many-body quantum systems using machine learning techniques.

The framework is built around a general and flexible implementation of neural-network quantum states, which are used as a variational ansatz for quantum wavefunctions.

NetKet provides algorithms for several key tasks in quantum many-body physics and
quantum technology, namely quantum state tomography, supervised learning from wavefunction data, and ground state searches for a wide range of customizable lattice models.

Our aim is to provide a common platform for open research and to stimulate the collaborative development of computational methods at the interface of machine learning and many-body physics.

NetKitの論文を最後まで読んでみた感想：

neural-network quantum states (NQS)とrestricted Boltzman machine (RBM)が根底にあり、C++でプログラムを強化しているようである。使いやすさを強調しており、例題をみると、プログラムコードは非常に単純化されていて、確かに、すぐに使えそうな感じである。機械学習と量子化学計算の橋渡しをするプログラム開発の拠点を目指しているようである。

PauliNet：Hermann先生のこてこての量子物理、FermiNet：DeepMindチームのディープラーニング等と比べると、NetKitに対しては、量子物理の観点からも、機械学習の観点からも、前2者と比べると、もの足りなさを感じる。

ということで、NetKitは、このあたりで、ひとまずおいておく。

さて、つぎ、どうしようか。

多体電子系の量子化学計算ができるようになりたいと思って、このテーマでブログを書いているのだが、「DNNで量子化学計算」というタイトルから多くの方が思い浮かべるのは、おそらく、教師あり学習で、分子構造と基底状態のエネルギー（DFT、CCSD(T)等による計算結果）を教師データにして、DNNにその関係性を学ばせることによって、任意の分子構造に対して基底状態のエネルギー値を予測することができる、ということではないだろうか。

ここで紹介している3種類のNNは、波動関数をなんらかの方法でNNに記述し、その波動関数に物理的意味を与える（最適化する）ために、そのNNを、VMC（variational Monte Carlo)等を用いて学習させる。そうすると、学習したNNは、基底状態だけでなく、非平衡状態や励起状態の分子のエネルギーをも計算することができる、というものだと理解している。

この説明は正確ではないかもしれないので、正しい知識を得るために、D. PfauらのFermiNetの論文を熟読したいと思う。

Ⅰ.  Introduction

ここでは、DNNを量子化学計算に用いる、これまでの方法が紹介されている。そのうちの1つの論文（引用文献6）を眺めてみよう。

Physical machine learning outperforms “human learning” in Quantum Chemistry
A. V. Sinitskiy and V. S. Pande, Department of Bioengineering, Stanford University, Stanford CA 94305, arXiv:1908.00971 (2019).

abstract

Two types of approaches to modeling molecular systems have demonstrated high practical efficiency. Density functional theory (DFT), the most widely used quantum chemical method, is a physical approach predicting energies and electron densities of molecules.

Recently, numerous papers on machine learning (ML) of molecular properties have also been published. ML models greatly outperform DFT in terms of computational costs, and may even reach comparable accuracy, but they are missing physicality — a direct link to Quantum Physics — which limits their applicability.

Here, we propose an approach that combines the strong sides of DFT and ML, namely, physicality and low computational cost. By generalizing the famous Hohenberg-Kohn theorems, we derive general equations for exact electron densities and energies that can naturally guide applications of ML in Quantum Chemistry. Based on these equations, we build a deep neural network that can compute electron densities and energies of a wide range of organic molecules not only much faster, but also closer to exact physical values than current versions of DFT. In particular, we reached a mean absolute error in energies of molecules with up to eight non-hydrogen atoms as low as 0.9 kcal/mol relative to CCSD(T) values, noticeably lower than those of DFT (down to ~3 kcal/mol on the same set of molecules) and ML (down to ~1.5 kcal/mol) methods. A simultaneous improvement in the accuracy of predictions of electron densities and energies suggests that the proposed approach describes the physics of molecules better than DFT functionals developed by “human learning” earlier. Thus, physics-based ML offers exciting opportunities for modeling, with high-theory-level quantum chemical accuracy, of much larger molecular systems than currently possible.

赤色に変えた文章が、これまで最も多く用いられてきた手法である。同じことが本文中ではもう少し詳しく記述されている。

Recently, many authors used machine learning (ML) for much faster computations of E and some other molecular properties (polarizabilities, HOMO-LUMO gaps, etc.).

However, neither currently used descriptors of molecules, nor ML models have a transparent connection to the basic physical concepts derived from the Schrödinger equation.

For example, the vast majority of ML models cannot be extended to compounds with new elements without retraining, making them methodologically inferior even to least accurate DFT functionals, let alone the absolutely transferable Schrödinger equation.

As a result, such approaches might be devoid of physics, and the criticism of ML as “black boxes” and “curve-fitting” seems totally applicable to them.

物理の教授に機械学習やディープラーニングの話をすると、ああ、あれね、ブラックボックス化されていて、何やってるかわからないよね、物理じゃなくて、単なるカーブフィッティングでしょ、などどいわれる。

A. V. Sinitskiyらは、上記abstractの紫色で示したように、ネットワークの中に物理（DFT)を持ち込み、持ち込んだ関数をDNNで最適化することによってDFTよりも高性能なCCSD(T)を超える正確さでEやρを高速に計算することができるとのことである。FermiNetやPauliNetは基底状態だけでなく非平衡状態（例えば結合距離を変化させたとき）や励起状態のエネルギーを計算できる。これに対して、A. V. Sinitskiyらがこの論文で示しているのは基底状態のみであるが、本文の最後に次の記述がある。

We foresee wide-scale applications of the approach proposed here (after certain technical developments) to computer modeling of various large molecular systems, including biomolecular or artificial material systems of much practical interest, and highly accurate and fast modeling of excited states of molecules and chemical reactions involving bond breaking and formation.

Fig.1 に、用いたDNNモデルの模式図が示されている。

Pfauらの論文は20ページもあって読むのも理解するのもたいへんなのだが、参考のためにと思って引用しているこのSinitskiyらの論文は、62ページ（本文7ページ）もある。

準備が整ってきたようなので、FermiNetにフォーカスしようかと思ったのだが、根底にある量子物理、シュレーディンガーの波動方程式、波動関数、密度汎関数、多体電子系、スピン、強相関、・・・、これらに対する強い興味と理解がないと、何をやっているのかわからない。

ここで偶然出会ったA. V. Sinitskiy and V. S. Pandeの論文は、分子を扱っていて、他の論文をみると、生体分子とタンパク質 との相互作用を計算機シミュレーションで調べているようだ。さらに、上記論文の1つ前の論文もある。Deep Neural Network Computes Electron Densities and Energies of a Large Set of Organic Molecules Faster than Density Functional Theory (DFT), Anton V. Sinitskiy, Vijay S. Pande

ということだが、A. V. Sinitskiyらの研究は、別にフォローすることにして、ここでは、FermiNetを、とことん理解することにしよう。

11月19日（木）

FermiNetの全体像

文字が小さくて見えないので拡大してみよう。

入力するのは原子核と電子の座標だけで、ネットワークの形状と四則演算、行列演算との組み合わせによって、波動関数が表現されます、ということのようなのだが、確かに、アルゴリズムの最上段と最下段を見るとそうなっている。

ついでに、変数間の関係式も張り付けておこう。

PauliNetのHermann先生は、論文Deep neural network solution of the electronic Schrodinge equationの中で、次のように書いている。

The parallel work of Pfau et al. (2019) follows the same basic idea as ours, but differs in several significant aspects.

Their architecture does not encode any physical knowledge about wave functions besides the essential antisymmetry, which is compensated by a much larger number of optimized parameters.

Perhaps as a result of that, their ansatz achieves somewhat higher accuracy at the cost of being about two orders of magnitude more computationally expensive than ours.

この文章から、FermiNetは、反対称性以外に波動関数に関する物理学的知識を含んでいないと思い込み、自分の紹介記事にもそう書いたのだが、これは正しい認識だろうか。

次にPauliNetの模式図を示す。

Hartree Fock, Jastrow, Backflow, Electronic cusps, Equivariant Interaction Blockが、fixed functionもしくはtrainable functionとして組み込まれている。

Fermi netには、それらのphysical knowledgeを表現することができる変数は用意されているが、physical knowledgeが含まれているとは言えない、という理解でよいのだろうか。

11月20日（金）

B. Wave-function optimization

これが、FermiNetにphysical knowledgeを教え、学ばせる作業、ということかな。

波動関数のエネルギー期待値を最小化する、ということのようだが、Kronecker-factored approximate curvature (KFAC)、Fisher Information Matrix (FIM)など、ついていけなくなる。

大沢 和樹 氏の記事を一部転載させていただく。

Kronecker-factored Approximate Curvature (K-FAC) は（当時）University of Toronto の Ph.D. 学生であった James Martens らによって、2015年のICMLで提案された深層ニューラルネットワークのための最適化手法である。大規模な深層学習において応用が限られていた二次最適化手法のボトルネックである曲率 (Curvature) 計算の効率的な実現手法である。

自然勾配学習法(Natural Gradient Learning)は1998年にShun-ichi Amariによって提案された情報幾何に基づくニューラルネットワークの最適化手法である。自然勾配学習ではFisher情報行列を曲率として用いることで目的関数の地形を正確に捉え、「反復数」において学習の高速な収束を実現する。このため、自然勾配学習法は二次最適化の効率的な実現法としても知られる。

Natural Gradient Works Efficiently in Learning
Shun-ichi Amari
RIKEN Frontier Research Program, Saitama 351-01, Japan

This article introduces the Riemannian structures to the parameter spaces of multilayer perceptrons, blind source separation, and blind source deconvolution by means of information geometry. The natural gradient learningmethod is then introduced and is shown to be statistically efficient. This implies that optimal online learning is as efficient as optimal batch learning when the Fisher information matrix exists. It is also suggested that natural gradient learning might be easier to get out of plateaus than conventional
stochastic gradient learning.

KFACの論文：

Optimizing Neural Networks with Kronecker-factored Approximate Curvature
James Martens∗ and oger Grosse†
Department of Computer Science, University of Toronto

Abstract
We propose an efficient method for approximating natural gradient descent in neural networks which we call Kronecker-factored Approximate Curvature (K-FAC). K-FAC is based on an efficiently invertible approximation of a neural network’s Fisher information matrix which is neither diagonal nor low-rank, and in some cases is completely non-sparse. It is derived by approximating various large blocks of the Fisher (corresponding to entire layers) as being the Kronecker product of two much smaller matrices. While only several times more expensive to compute than the plain stochastic gradient, the updates produced by K-FAC make much more progress optimizing the objective, which results in an algorithm that can be much faster than stochastic gradient descent with momentum in practice. And unlike some previously proposed approximate natural-gradient/Newton methods which use high-quality non-diagonal curvature matrices (such as Hessian-free optimization), K-FAC works very well in highly stochastic optimization regimes. This is because the cost of storing and inverting K-FAC’s approximation to the curvature matrix does not depend on the amount of data used to estimate it, which is a feature typically associated only with diagonal or low-rank approximations to the curvature matrix.

optimizationの奥の深さを少し感じることができたような気がする。Optimizationの方法を理解するだけならもうすこし簡単だと思うのだが、ハミルトニアンと波動関数の式を目の前にしてoptimizationのアルゴリズムを理解することは、たいへん難しく感じる。

Ⅲ. RESULTS

ここから先は、他の手法と比較して、FermiNetの方がより正確に計算結果を出すことができるかということを示している。ちょっととばして先に進んでみよう。

APPENDIX A: EXPERIMENTAL SETUP

1. FermiNet architekuture and training

FermiNetは4層＋最終層

各層は、one-electron streamに対して256のhidden units、two-electron streamに対して32のhidden units

最終層はlinear、Laplacianが良く定義されて、全領域で正になるように、4層全てにtanh nonlinialityを用いている。

特に指定がなければ、16の行列を用いている。

表1に示したSethらの通常のVMC (Variational Monte Carlo)の結果は、50のconfiguration state function (CSF)を用いている。

CSFの行列の数は系に依存し、その数は数百から数千である。

対応するFermiNetのパラメータ数は、約700,000であり、正確な数は原子数や分子構造によって異なってくる。

＊以上がFermiNetの構造に関する本文より具体的な説明である。これでも、Fig.1の概略図との対応はわかりにくいが、なんとなくわかったような気にもなる。

optimizationとしてlocal energyを適用する前に、pySCFを用いて計算したHartree-Fock (HF)軌道に合致するように事前トレーニングを行っている。

この事前トレーニングは、optimizationに対して非常に効果的であるとのこと。

事前学習のlossの式が示されており、Hartree-Fock計算に用いるminimal basisはSTO-3Gであるとのこと。

少しとばす。

FermiNetはTensorFlowで書かれている。

20電子系に対しては、８台のV100 GPUを並列作動させている。より大きな系では16 GPUも用いられている。

etheneの計算には、8GPUで２日間を要するとのこと。

30電子のBicyclobutaneは、16GPUで1か月を要するとのこと。

デフォルトのパラメータが表4に示されている。ただし、Bicyclobutaneの場合には、batch sizaは半分にし、事前トレーニングの試行回数は桁で増やしているとのこと。

このブログの目的は、多電子系の電子状態の計算をANNを使ったプログラムで実行するところまでの道筋を記録することだった。しかし、ここまで見てきてわかったように、FermiNetは、計算コストが高すぎるように思う。

FermiNetの論文解読はこのへんで中断して、プログラムの中身をのぞいてみようか。

早速、GitHubにあるdeepmind/ferminetに行ってみましょう。

github.com

ここへは何回か来ているが、プログラムをちょっと覗いてみただけで、何もしていない。したがって、どうなるかまったくわからない。

FermiNet: Fermionic Neural Networks

An implementation of the algorithm and experiments defined in "Ab-Initio Solution of the Many-Electron Schroedinger Equation with Deep Neural Networks", David Pfau, James S. Spencer, Alex G de G Matthews and W.M.C. Foulkes, Phys. Rev. Research 2, 033429 (2020). FermiNet is a neural network for learning the ground state wavefunctions of atoms and molecules using a variational Monte Carlo approach.

Installation

pip install -e . will install all required dependencies. This is best done inside a virtual environment.

virtualenv -m python3.7 ~/venv/ferminet
source ~/venv/ferminet/bin/activate
pip install -e .

11月21日（土）

ここで壁にぶち当たりました。

GitHubのコードの利用の仕方を学ぶ必要があります。 

11月22日（日）

Introduvtion to GitHubを学習中

style=158 iteration=500

style=158 iteration=50

style=158 iteration=5

Kggle散歩（November 2020）

Kggle散歩（November 2020）

11月は、25日にLyftが、30日にMoAが終了する。

Lyftは、計算資源の確保が課題であり、MoAは、Public LBとCVを天秤にかけながら、性能を上げる方法を探ることが課題である。

11月1日（日）

Generative Deep Learning by David Foster : CHAPTER 1 : Generative Modeling

discriminativeとgenerative：discriminativeは、training datasetに含まれる特徴を把握して、test dataが何であるかを予測する。generativeは、training datasetに含まれない、新たなデータを作（創）り出す。

generative modelの定義：

A generative model describes how a dataset is generated, in terms of a probabilistic model. By sampling from this model, we able to able to generate new data.

ここに馬の画像データがある。新たに用意した画像が馬かどうかを判別することが、discriminative（識別）であり、馬の画像データに含まれていない馬の画像をつくるのが、generativeである。馬の画像をつくるためには、作られた画像が「馬」でなければならないので、馬であることを、馬の画像から学ぶのである。

元の画像に含まれず、かつ、元の画像に含まれていたがごとく、「リアル」であることが、generative modelの性能を測るものさしになる。

The Rise of Generative Modeling：

2018年に、NVIDIAからStyleGAN（非常にリアルな顔画像を生成）が発表され、

2019年に、OpenAIからGPT-2（導入文から完全なテキストを生成）が発表された。

6ページから7ページにかけて、著者のgenerative modelingに対する考え方が、簡潔に表現されていて、その内容が非常に興味深い。

As well as the practical uses of generative modeling (many of which are yet to be discovered) , there are three deeper reasons why generative modeling can be considered the key to unlocking a far more sophisticated form of artificial intelligence, that goes beyond what discriminative modeling alone can achieve.

このあと、約40行にわたってそのthree deeper reasonsが説明されている。

うまく要約できないし、全文掲載するのもはばかられるので、３つのパラグラフのはじめの方の文章を転記しておく。

First, purely from a theoretical point of view, we should not be content with only being able to excel at categorizing data but should also seek a more complete understanding of of how the data was generated in the first place.

Second, it is highly likely that generative modeling will be central to driving future developments in other fields of machine learning, such as reinforcement learning (the study of teaching agents to optimize a goal in an envilonment through trial and error).

Finally, if we are to truly say that we have built a machine that has acquired a form of intelligence that is comparable to a human's, generative modeling must surely be part of the solution. One of the finest example of a generative model in the natural world is the person reading this book. Take a moment to consider what an incredible generative model you are.

11月2日（月）

MoA：

先週、GPUを使わないで、CPUだけでパラメータ調整を行った。CPUだけだと、少ししか走らせることができないので、最も早く結果が分かる、最初のFoldのVal_lossを使うことにした。

モデルの性能を上げるために、チューニングを行った結果、最初のFoldのval_lossの値を、公開コードの初期条件で計算した場合よりも小さくすることができた。

良い結果が得られるだろうと思って、GPUが使えるようになった土曜日に、全体の計算をして、commit, submitしたところ、CVもpublic LBも公開コードより悪くなった。

期待外れの結果になったのは、最初のFOLDにoverfittしたのが、その原因だろうな。

Public_dataにoverfittして、private_dataのスコアが悪くなるのと同じようなことだな。

DNNではないので、計算時間が短く、チューニングの作業は比較的簡単に行えるのだが、見えないprivate_dataに適合するモデルに仕上げるチューニングは、難しい。

11月3日（火）

MoA： 

今日は、モデルの不具合に気づいたおかげで、CVが少し改善した。（epochsを50にしてearly stop=Trueにすると、なぜか収束が悪くなる。どうしてそうなるのかわからないので、とりあえず、early stoppingを使わないようにした。）

SEEDを変えたモデルのアンサンブルの効果を調べてみた。その効果は意外に大きかったので、それならばと、本命のモデルに適用してみたところ、効果は実験に使ったモデルの場合の1/3程度しかなく、少しがっかりした。原因は、おそらく、実験に使ったモデルの方が、FOLD間でのval_lossのばらつきが大きかったので、SEED間でのばらつきも実験に使ったモデルの方が大きかったため、アンサンブルの効果も大きかったのではないかと考えている。

3000人以上が参加していて、同一スコアにたくさん並んでいる。

上位のスコアの公開コードを見ると、public LBはCVとは連動しているようには見えず、public_dataにoverfittingしているのではないかと思う。CVもpublic LBも良好なコードも公開されているので、それらに勝るモデルにするには、CVだけでなく、public LBもある程度の値になっていないとダメだろうけど、それがどのあたりなのかは、わからない。

11月4日（水）

MoA：

NNの特徴は、深さだと思うのだが、どうなんだろう。

非線形活性化関数を通過する毎に非線形性が増して、より複雑な関係性を繋ぐことができるのではないだろうか。

浅いNNは従来の機械学習に劣り、深くすることによって、従来の機械学習を凌ぐことができるのではないだろうか。

DNNの世界から表データが取り残されているように思っていたら、TabNetというのが考案されたようだ。

TabNet: Attentive Interpretable Tabular Learning
Sercan O. Arık and Tomas Pfister, arXiv:1908.07442v4 [cs.LG] 14 Feb 2020

ABSTRACT
We propose a novel high-performance and interpretable canonical deep tabular data learning architecture, TabNet.

TabNet uses sequential attention to choose which features to reason from at each
decision step, enabling interpretability and more effcient learning as the learning capacity is used for the most salient features.

We demonstrate that TabNet outperforms other neural network and decision tree variants on a wide range of non-performance-saturated tabular datasets and yields interpretable feature attributions plus insights into the global model behavior.

Finally, for the first time to our knowledge, we demonstrate self-supervised learning for tabular data, significantly improving performance with unsupervised representation learning when unlabeled data is abundant.

11月5日（木）

Study：

量子多体問題を解く鍵である多体量子状態を完全に（近似ではなく）表現する波動関数をニューラルネットワークで表現する方法が注目されている。それを初めて具体化したのが次の研究のようである。

Solving the Quantum Many-Body Problem with Artificial Neural Networks

G. Carleo and Matthias Troyer, arXiv: 1606.02318v1 [cond-mat.dis-nn] 7 Jun 2016

この研究に至る前夜の状況が次の総説にまとめられているようである。

THE NONEQUILIBRIUM QUANTUM MANY-BODY PROBLEM AS A PARADIGM FOR EXTREME DATA SCIENCE
J. K. Freericks, B. K. Nikoli´c and O. Frieder,  arXiv:1410.6121v1 [cond-mat.str-el] 22 Oct 2014

Generating big data pervades much of physics.

But some problems, which we call extreme data problems, are too large to be treated within big data science.

The nonequilibrium quantum many-body problem on a lattice is just such a problem, where the Hilbert space grows exponentially with system size and rapidly becomes too large to fit on any computer (and can be effectively thought of as an infinite-sized data set).

Nevertheless, much progress has been made with computational methods on this problem, which serve as a paradigm for how one can approach and attack extreme data problems.

In addition, viewing these physics problems from a computer-science perspective leads to new approaches that can be tried to solve them more accurately and for longer times.

We review a number of these different ideas here.

Keywords: Nonequilibrium quantum many-body problem; extreme data science.

MoA：

CVかpublic LBか、ということだけでなく、val_log_lossの単純平均も重要だと思う。

CVとlog_lossは比例していない。 

log_lossのFoldごとのばらつきが大きいと、CVが小さくなる傾向にあるが、どういう計算をしているのか、よくわからない。

優先順位は、val_log_loss > CV > public LBというところかな。

11月6日（金）

Study：

以前に掲載したかもしれないが、今日は、波動関数をNNで表現するところにフォーカスしたいと思う。

Ab initio solution of the many-electron Schrödinger equation with deep neural networks
David Pfau, James S. Spencer, Alexander G. D. G. Matthews, and W. M. C. Foulkes

PHYSICAL REVIEW RESEARCH 2, 033429 (2020)

Deep neural network solution of the electronic Schrödinger equation
Jan Hermann, Zeno Schätzle, and Frank Noé, 

arXiv:1909.08423v5 [physics.comp-ph] 23 Sep 2020

明日は、FermiNetとPauliNetを理解したうえで、簡潔な日本語で説明できるようにしようと思っている。

MoA：

CPUを使って、NNのチューニングを行っていた。

2層、3層、4層、および5層のNNについて、log_lossが最小になる条件を探している。

11月7日（土）

MoA：

GPUを使うとサクサク進むが、細部にこだわりすぎることがあるので、要注意。

log_lossを小さくしていくのは、簡単ではないが、log_lossが小さくなっても、submitしてみたときにpublic LBが大きい値になると、これでいいのだろうかと、悩んでしまう。

FermiNetとPauliNet：

原理を正しく説明しようとしているのだが、正しく理解するのが難しくて、原稿の締め切りに間に合わない！

11月8日（日）

MoA：

今日は、最も基本的なhidden_layerが2層のNNモデルに集中してチューニングした。

val_log_lossは、これまでになく小さくなったが、public LBスコアは、改善せず、むしろ悪化した。何に注力すべきか迷う。

learning_rate, batch_size, hidden_size, dropout_probabilityなどの変更は常にやっているが、今回は、これまで以上に、変化率を小さくして検討している。そうすると、パラメータ間の相関がこれまでよりもよく見えるようになったと思う。それもそのはず、見ている数値の桁数が違うのだ。4桁目、5桁目、6桁までじっくり見ていると、見えなかったものが見えてくるのだ。活性化関数による違いもよく見える。

11月9日（月）

今日は、FermiNetとPauliNetの説明文を作成しよう。

第一原理量子化学計算、変分量子モンテカルロ、波動関数仮説

量子多体問題を厳密に解く

数原子、数十電子（2-30電子）を超えると計算機の能力を超える

近似計算しかできない

多体電子系波動関数をニューラルネットワークで表現する（ニューラルネットワーク量子状態：neural-network quantum states：NQS）

多体スピン構造の波動関数を、制限ボルツマンマシンによって表現する

ニューラルネットワークのパラメータ（多体電子波動関数）の最適化は、変分モンテカルロ法もしくは時間依存変分モンテカルロ法を用いて行う

PauliNet：ハートリーフォックベースラインや標準ジャストロー因子やバックフロー変換などの物理モデルから構成されているネットワーク

FermiNet：PauliNetの考案者らは、FelmiNetについて、物理学を組み込むことなく印象的な精度に到達している、と評価している：比較的単純な数学関数とディープニューラルネットワーク構造によって多電子系波動関数を表現

PauliNetは物理屋さん主導で、FermiNetは機械学習屋さん主導、の印象

11月10日（火）

DNNを用いた量子化学計算手法について、半ページほどにまとめた原稿を完成させて学会の編集部に送った。できれば、もう少し長い原稿を書きたいと思うが、それが読者に役に立つ内容にするためには、GitHubの公開コードを実際に使ってみて、実際に使うにはどうすれば良いのかを紹介できることが必要だな。

Kaggleの計算環境を使うのは筋違いだろうな。

パソコン環境だと、自分のGPUがもう古臭いからだめだろうな。

そうなると、google colabを使うことになるのか。 

 量子化学のブログを書いてみよう。

MoA：

dropoutとCVとpublic LBの相関を調べてみる。

自前の条件で計算した結果だけを比較してみると、dropoutは0.4以上よりも0.3以下の方がCVもpublic LBも小さくなる傾向がみられた。

public LBのスコアは、公開コードの条件では0.01839だが、自前の条件では0.0186+の後半の方だったのが、今日、やっと0.185+の前半の領域に入った。

CVが小さいところでpublic LBも小さくなってきたのは、良い傾向だと思っている。

今日は、CVを下げるために、hidden layerのユニット数の増減の幅をかなり小さくして、計算を繰り返した。パラメータの調整幅をこれまでにやったことがないくらいまで小さくしているので、まだまだ時間がかかりそうだ。

11月11日（水）

MoA：現在、3680チーム

今日もファインチューニングだ！

モデルの基本構造を変えずにCVを下げると、public LBのスコアの最後の桁が1だけ下がった。これを繰り返せばいいのだが、どんどん難しくなる。

11月12日（木）

MoA：現在、3730チーム 

今日もファインチューニングだ！

training中にあらわれるnanが気になりはじめた。

train_lossとval_lossがnanになる。discussionで問題提起して解釈や対策が書かれていて、その対策が役に立ったとの返信があるのだが、さっぱり理解できない。

コメントに気になる箇所があったので、weight_decayをデフォルトに戻したら、とんでもないことになった。

11月13日（金）

MoA：3762チーム

train_lossとval_lossがnanになる原因がわかった。

weight_decayの値を変えてみると、nanが生じやすくなったり、全く現れなくなることが、現象として把握できた。

weight_decayは、L2正則化のパラメータで、overfittingの抑制に効果があるということを、確認することもできた。

11月14日（土）

MoA：3798チーム

全結合層は2層、dropout=0.2、weight_decay=1e-6、こんな感じで、ようやく、0.184+になった。

気をよくして気合を入れて、CVを小さくすることができたので、期待してsubmitしたら、0.01858が現れてがっかりした。public_dataに適合しなくても、private_dataで良いスコアが出ればいいのだと思っていてもやはり気になるものだ。

何度も同じ言葉を並べてしまうが、頭を整理しながら進まないといけないな。

今日は、活性化関数や最適化関数をいくつか試してみて面白い結果も得られたので良しとしよう。

relu, leaky_relu, elu, seluなどを試してみたが、少しづつ違う結果になる。

reluでnanが発生しても、leaky_reluにすれば少し抑制され、さらに、eluにすればnanが現れなくなった。といっても、良いことばかりではない。reluでnanが頻繁に出現する条件では、eluで抑制できても、スコアは悪化するだけだった。

Adamの他に、AdamW, Adamax, SGD,などを試したが、Adamより良い条件は見つけられなかった。それぞれの特徴を生かすには、細かい調整も必要なので、良く調べてからでないと、どれが本当に合うのかは、わからない。

今日から1週間のGPUの割当は、37時間だが、今日だけで7時間使った。

11月15日（日）

MoA：

今日も、ちまちまと、チューニングしていた。

public LBのスコアは同じだったが、順位が少し変動した。 

11月16日（月）

MoA：

今日はじめて気がついた。

optim.lr_scheduler.OneCycleLR

これはすごい機能だと思う。

これに関わるパラメータの値によって、nanが現れたり消失したりする。

11月17日（火）

MoA：3,911 teams, 14 days to go

今日も、public LBを上げることに注力していた。

nanが発生しにくくなって計算できる領域は広がったが、public LBのスコアをよくする方向は、なかなか見えてこない。CVを下げるにはdropoutを大きくするのが効果的だが、public LBのスコアは良くならない。

それでもようやく0.01838に到達した。

11月18日（水）

MoA：3,958 teams, 13 days to go

今日もチューニング、チューニング、チューニング。

改善の見込みがありそうな条件だと思ったが、

CVもpublic LBも改善できなかった。

11月19日（木）

MoA：4,004 teams, 12 days to go

低スコアの公開コードが投稿されている。

なかなかやるもんだな。

今日もチューニング、チューニング、チューニング。

こんなことばっかりしとったら、あかん。

プログラミング技術が上がらん。

11月20日（金）

MoA：11 days to go

TabNetを勉強する予定だったが、進捗なし。

dropoutの比率に対するCVとpublic LBスコアの依存性を調べている。

11月21日（土）

MoA：4,072 teams, 10 days to go 

dropoutとの相関調査継続中。

TabNet：

TabNet: Attentive Interpretable Tabular Learning
Sercan O. Arık and Tomas Phister, Google Cloud AI
arXiv:1908.07442v4 [cs.LG] 14 Feb 2020

ABSTRACT
We propose a novel high-performance and interpretable canonical deep tabular data learning architecture, TabNet. TabNet uses sequential attention to choose which features to reason from at each decision step, enabling interpretability and more efficient learning
as the learning capacity is used for the most salient features. We demonstrate that TabNet outperforms other neural network and decision tree variants on a wide range of non-performance-saturated tabular datasets and yields interpretable feature attributions plus insights into the global model behavior. Finally, for the first time to our knowledge, we demonstrate self-supervised learning for tabular data, significantly improving performance with unsupervised representation learning when unlabeled data is abundant.

Overall, we make the following contributions in the design of our method:
(1) Unlike tree-based methods, TabNet inputs raw tabular data without any feature preprocessing and is trained using gradient descent-based optimization to learn flexible representations and enable flexible integration into end-to-end learning.
(2) TabNet uses sequential attention to choose which features to reason from at each decision step, enabling interpretability and better learning as the learning capacity is used for the most salient features (see Fig. 1). This feature selection is instancewise, e.g. it can be different for each input, and unlike other instance-wise feature selection methods like [6] or [61], TabNet employs a single deep learning architecture with end-to-end
learning.
(3) We show that the above design choices lead to two valuable properties: (1) TabNet outperforms or is on par with other tabular learning models on various datasets for classification and regression problems from different domains; and (2) TabNet enables two kinds of interpretability: local interpretability that visualizes the importance of input features and how they are combined, and global interpretability which quantifies the contribution of each input feature to the trained model.
(4) Finally, we show that our canonical DNN design achieves significant performance improvements by using unsupervised pre-training to predict masked features (see Fig. 2). Our work is the first demonstration of self-supervised learning for tabular data. 

とても良さそうな手法だけど、論文をいくら読んでもだめだな。

実際に使ってみないと。

GitHubに、TabNetが、いくつも出ています。

こういうのを使えないのがなさけない。

なんとかしなければ。

11月22日（日）

MoA：4,094 teams, 9 days to go

これまでよりスコアの良いコードを用いて、NNの部分だけ、チューニングしてみた。

自信を持って自分のチューニング結果をsubmitしたところ、最後の桁の数値が+2と+4になった。

公開するだけのことはある、と、感心するばかりである。

11月23日（月）

MoA：4,124 teams, 8 days to go

CVはほとんど変わらず、むしろ、わずかではあるが少し大きかったにもかかわらず、LBが、-4も下がった。 

こんなことがあると、CVが少し大きかったためにsubmitしていない計算条件がたくさん残っているのが気になる。その中に、宝物が隠れているかもしれない。

そうではなく、これが、もしかして、public dataへのoverfittingなのか？

11月24日（火）

MoA：4,122 teams, 7 days to go

昨日うまくいったベストLBモデルをさらに改良できないかとパラメータを変更してみたが、そう簡単にはいかない。

パラメータの、小さな変更によって改善されることを期待したが、いずれも、最後の桁が+2もしくは+3となった。

難しい。

11月25日（水）

MoA：

チューニングを繰り返すのみ。

月曜日にメダル圏内に入ったのに、もう、追い出されて、どんどん離れていく。

11月26日（木）

MoA：4,201 teams, 5 days to go

public LBスコアを上げることだけ考えてチューニングしている。

Lyft： 

本日午前9時00分終了。

課題に適合するモデルの選択と、train時間の確保が、後半の課題だった。

データが膨大で、前処理が複雑にみえて、不十分な取り組みとなってしまった。

複雑なデータに取り組む練習をしないと、こういう課題はクリヤできそうにない。

<雑談＞

自分は、この分野には、ディープラーニングから入った。データを呼び出し、それを、train_data, validation_data, test_dataに分け、DNNモデルに投入する。最初に使ったテキストでは、いわゆるデータの前処理は、簡素化されていた。ある程度、モデルが組めるようになったので、Kaggleに挑戦した。そこには大きな壁があった。データの前処理と後処理である。データサイエンスのテキストは、ディープラーニングのテキストとペアで購入していて、並行して勉強しようとしたのだが、面白くなかった。それに対して、ディープラーニングは、AIの歴史とともに語られ、インターネット、ビッグデータ、その集大成としてのディープラーニングというふうに続いていて、非常に興味が湧いた。

手元にあるデータサイエンスの本は、和訳で360ページくらいのものだが、機械学習の内容が始まるのは、165ページからである。単純にいえば、自分には、この前半部分の勉強が足りてない、ということになる。今日から、まず、前半部を勉強するとしよう。

Riid!：2,062 teams, a month to go

このコンペ、MoAが終われば集中して取り組むつもりだが、MoAはチューニングのみなので、計算の合間に、こちらも進める。

Riiid! Answer Correctness Prediction

Track knowledge states of 1M+ students in the wild

課題は、生徒の学習履歴から、正答率を予測することのようだ。

用いるデータは、EdNetと称するもののようだ。

EdNetというネーミングは、ImageNetを意識したものだろうか。

主催者がすでにそれらしい論文を出している。

SAINT+: Integrating Temporal Features for EdNet Correctness Prediction

DONGMIN SHIN, YUGEUN SHIM, HANGYEOL YU, SEEWOO LEE, BYUNGSOO KIM, and
YOUNGDUCK CHOI, Riiid! AI Research, Republic of Korea

arXiv:2010.12042v1 [cs.CY] 19 Oct 2020

11月27日（金）

MoA：4,232 teams, 4 days to go

最終日が近いので、とりあえず、LBスコアの良いモデルに対して、試行回数を増やすなどして、少しでも汎用性を高くしておこう。

試行回数を増やすと、順位が少し上がった。

• Riiid AIEd Challenge
• ：2,076 teams
• , a month to go

データベース、EdNetに関する論文を見ていたら、EdNetは、韓国の学生の約2年間にわたるTOEICの学習履歴データを収集したものであることがわかり、さらに、santaというワードが気になってgoogleで検索したら、次のような宣伝が出てきた。

SANTA TOEIC：

世界的な学会から認定されたAI技術を搭載したTOEIC®︎学習ソリューションです。
“AIチューター”が解答傾向から苦手問題を推測し、あなただけのカリキュラムを構築。
解くべき問題だけに集中することで、短期間で大幅なスコアアップを実現します。

すでに、スコア予測システムは出来上がっていて（上記論文ではAUCが0.80前後）、商品に組み込まれているようだな。さらに性能を向上させることを狙って、Kagglerの知恵を拝借ってことなのか。

Time-series API Details

• Refer to the starter notebook for an example of how to complete a submission. The time-series API has changed somewhat from previous competitions!

とりあえず、starter notebookを見る。

11月29日（日）

MoA：4,287 teams, 2 days to go

締め切りまで、あと2日、となった。

メダル圏内に0.01825が160件あまり、並んでいる。

公開コードがあるので、こういうことになるのだが、9日前に公開されたときには無視していた人たちも、間際になると、保険のつもりで使ってみるのだろうな。

かくいう自分も、最終投稿の2件のうちの1件はこれにしようかなと思って準備している。

11月30日（月）

MoA：4,332 teams

今日が実質、最終日だ。

とりあえず、メダル圏内に入った。

圏外で待つよりは、圏内で待つ方が、メダル獲得の可能性は高い、だろう、と思いたい。

12月1日（火）

MoA：4384チーム：終了

暫定結果だが、182位となり、銀メダル相当である。

このまま確定すれば、2個目のメダル獲得となり、エキスパートになる。

最終日の投稿結果を選んだことによって、銀メダル相当となった。

最終的に2件の投稿を選ぶのだが、このとき違うものを選んでいれば、違った結果になる。

過去に、メダル圏内の投稿結果を最終投稿として選ぶことができなかったことでメダルを逃したことが2回ある。1回は、public LBが良くなかったので仕方ないともいえるものであるが、もう1回は、Public LBスコアにこだわりすぎて、アンサンブルのし過ぎによるpublic_dataへのオーバーフィッティングを意識できなかったことによるものである。

さて、うまくいった原因を書きたいのだが、自分の今後の指針になるようなものは、残念ながら、いまのところ思いつかない。

style=157, iteration=1

style=157, iteration=20

style=157, iteration=500