# 追記①Stacking 使っている特徴はテキストは[ディスカッション](https://www.guruguru.science/competitions/16/discussions/fb792c87-6bad-445d-aa34-b4118fc378c1/)参考にベクトル化して次元削減、カテゴリ変数はTabNetにはEmbeddingしてもらう、lgbmは基本CountEncodingしたものです。バリデーションはどちらもStratifiedKFold(n_splits=5)です。 | | CV | LB | | -------- | ------ | ------ | | TabNet | 1.1373 | 1.1164 | | LightGBM | 1.0456 | 1.0199 | | Stacking | 1.0357 | 1.0125 | lgbmのfeature_importancaは恐らく皆さんとそんなに変わらないのですが、TabNetの方はほとんどカテゴリ変数（object_collectionやmaterial、principal_makerなど…）が高くなっており、数値変数は見向きもしていない状態です（`n_steps`と`gamma`を調整してもダメ）。 Embeddingの次元数を今最大50にしているのを下げると数値変数にも注目してくれて、劇的ではないですが単体でのCVスコアも上がる傾向にありますが、あまり数値に注目させてもlgbmと差別化できなくなりそうなのでどっち方向に育てるか迷い中なのと、特徴選択が結構大事そうだなと思っているところです。 # はじめにまだコンペ始まってもいないですが、そろそろLightGBMに頼り続けてNNから逃げ続けるのを脱しようと、atmaCup10ではTabNet中心に戦うという自分ルールを課しました。まだ肝心な仕組みのところの理解ができていなかったりしますが、おおよそパラメータの意味などは分かってきたので学習記録を共有します。普段NN全然使わないので、間違った解釈等にお気づきの方はご指摘いただけると幸いです。 TabNetが効くお題なのかは分かりませんが…相性良さげなお題だったら追ってベースラインノートも添付したいと思います。 ※お断り - 正しい情報なのか全般不安ですが、特に不安なところは:cloud:マークを付けています。 - 記事中、モデルの構造を表した図を何枚か用いていますが図法の知識ゼロの見様見真似で作成しています。意味不明な点あればご指摘ください。 - TabNetには`pytorch-tabnet`という便利なライブラリがすでにあるので、TabNetを理解するというよりは`pytorch-tabnet`を理解する形で進めていきます。 - 本当はTransformerでやろうとしたけど自分にはまだ早そうでした:innocent: # 目次（リンクのさせ方わからない…） - TabNetとは - Links - pytorch-Tabnetの概要 - 各クラスの働きを理解する - TabNetで大事なパラメータの気持ち # TabNetとは - テーブルデータ向けのDNNモデル。 - 決定木的な学習をするらしく特徴量重要度も出せる。 - `pytorch-tabnet`という有志のライブラリを使えばsklearnチックにfit & predictだけで使える。 - 簡単に試せる！ # Links [論文](https://arxiv.org/pdf/1908.07442.pdf) [公式(Google Research)のrepogitory](https://github.com/google-research/google-research/tree/master/tabnet) [pytorch-tabnet（非公式）のrepogitory](https://github.com/dreamquark-ai/tabnet) [pytorch-tabnet作者によるYOUTUBEでの説明](https://www.youtube.com/watch?v=ysBaZO8YmX8) [(日本語)先人のまとめ①Zenn](https://zenn.dev/sinchir0/articles/9228eccebfbf579bfdf4) - 必読です。以降"Zenn"と書いてあったらこの記事のことを指します。「完璧でなくともZennを読んでTabNetがどんなものか雰囲気は掴めた」ことは前提に以降まとめています。 [(翻訳？)先人のまとめ②ICHI.PRO](https://ichi.pro/pytorch-de-no-tabnet-no-jisso-277727554318969) # pytorch-tabnetの概要 ![overview.png](https://storage.guruguru.science/uploads/a9e5bd25_d678_437b_a13e_3f53d8fbc3a9/overview.png) 上図は`pytorch-tabnet`を「使う」ことに注目した時に関わってくるメインのクラス等をまとめたものです。ただ使うだけなら上半分緑の部分の①～④を実施すればOKです。すなわち、 1. `TabNetPretrainer`にinputを渡して`fit()`。 2. 1のoutputとしてunsupervised_modelを取得。 - 公式の実装例からunsupervisedと記載していますがpretraindとかself-supervisedの方が個人的にはしっくりきます。何を事前学習しているかは後程触れますが、まずは[Zenn](https://zenn.dev/sinchir0/articles/9228eccebfbf579bfdf4)参照ください。 3. `TabNetRegressor` or `TabNetClassifier`にinputを渡して`fit()`。 - RegressorとClassifierの役割はその名の通りで、問題設定によって使い分けます。 - 省略していますが、マルチタスクに対応したクラスもあります。 - 2のunsupervised_modelを`fit()`時のパラメータに指定することで`load_weights_from_unsupervised()`というメソッドが呼び出され、その名の通り事前学習時の重みがセットされます。 4. `predict()`して予測結果を取得。の流れです。なお事前学習は必須ではないため、精度を犠牲にしても良ければ1と2のステップは飛ばすことも可能です。1~4の流れでの利用自体は、[公式実装例](https://github.com/dreamquark-ai/tabnet/blob/develop/pretraining_example.ipynb)と[Zennで紹介されている実装](https://www.kaggle.com/sinchir0/selfsupervisedtabnet-titanic-comparing-lgbm-nn)を参考にすれば容易かと思います。下半分のグレーの部分は直接呼び出すことはありませんがメインのクラスの継承関係他をまとめるために図にしました。後でそれぞれ細かく見ていきますが言葉にすると以下の様な状態です。 - `TabNetRegressor`と`TabNetClassifier`, `TabNetPretrainer`はいずれも`TabModel`を継承している。ただし以下の点で違いがある。 - ネットワークは別物。前者は`TabNet`、後者は`TabNetPretraining`をインスタンス化したもの。 - `RandomObfuscator`と`TabNetDecoder`は事前学習時にしか使わないが、その他のパーツは大体共通。 # 各クラスの働きを理解するここでいう「働き」とは特に言及がない限り`forward()`処理のことです。 ## TabNet以下のクラス先ほどの画像の左下の方のクラスから見ていきます。補足までに、途中から見るのは以下の理由です。 - `TabModel`はsklearnの`BaseEstimator`を継承、`TabNetReggressor`, `TabNetClassifier`はその`TabModel`を継承するクラス。ここで追加される変数やメソッドはそこまでTabNet独特のものではない。 - `TabNetTrainer`（事前学習用）は`TabNet`（学習用）の発展形なので後から見た方が良さそう。というわけで、`TabNet`以下の構成がどんな風になっているかを図にしたものが以下です。 ![TabNetClass.png](https://storage.guruguru.science/uploads/3e7f67fa_3fea_4c24_a447_8f17043ad7e9/TabNetClass.png) （あまりに一般的ではなさそうな表記の補足） - `Masked_x`と`prior`の$\otimes$：「乗算の結果に名前をつける」を省スペースでやりたくて付けています。入力が2つあるレイヤではありません。 - 括弧内の文字は入出力の列方向のサイズです。分かりづらいところについてのみ、スペースに無理矢理書いたため記載に統一ルールがなく、雰囲気で察して頂けると幸いです。 - **超注意** - サイズが$input$のところが複数ありますが、実際には`EmbeddingGenerator`を通ったときに$input$とは違うサイズになります（詳細は`EmbeddingGenerator`の項へ）。ただし、設定次第でサイズが変わらないこともあるのと、都度「Embedding後の～」と書いて冗長になることを嫌って$input$と書いています。以降の$input$表記ほぼすべてに同じことが言えるのでご注意ください。図に戻って、ラベルが緑系の大きなクラスはそれぞれ以下の様な働きです（もちろん記載以外にも機能ありますがざっくりと）。 - `TabNet`がやっているのは入力を`EmbeddingGenerator`でEmbeddingしているだけ。 - `TabNetNoEmbedding`がやっているのは`TabNetEncoder`の複数出力を足して全結合してるだけ。 - `TabNetEncoder`の働きがTabNetの本質。 [論文](https://arxiv.org/pdf/1908.07442.pdf)のFigure4(a)TabNet endoderの図と`TabNetNoEmbedding`以下の働きが対応します。`TabNet`が持っている`EmbeddingGenerator`の機能は`pytorch-tabnet`独自の機能です。データの流れに沿って順にみていきます。 ### EmbeddingGeneratorのお仕事 `forward()`メソッドを見ればなんとなくわかるかと思いますので、抜き出します。 ```python def forward(self, x): if self.skip_embedding: # no embeddings required return x cols = [] cat_feat_counter = 0 for feat_init_idx, is_continuous in enumerate(self.continuous_idx): # Enumerate through continuous idx boolean mask to apply embeddings if is_continuous: cols.append(x[:, feat_init_idx].float().view(-1, 1)) else: cols.append( self.embeddings[cat_feat_counter](x[:, feat_init_idx].long()) ) cat_feat_counter += 1 # concat post_embeddings = torch.cat(cols, dim=1) return post_embeddings ``` 1. 最初のif文では、Embeddingしない設定をしていた場合に入力をそのまま出力してreturn。 2. for文の中では以下の処理をしています。 1. 空のリストを用意しておく。 2. 連続値（パラメータ次第で離散値も一部含む、詳細はパラメータ説明の項で）の場合はほとんどいじらずにリストに加える。 3. 連続値でなかったら`nn.Embedding()`で埋め込みしてリストに加える。 3. リストを結合して出力。カテゴリ埋め込みについては良く知らなかったので[こちらのブログ](https://kaeru-nantoka.hatenablog.com/entry/2019/08/28/053420)が参考になりました。 ### TabNetEncoderのお仕事 TabNetの核心部分です。最初の`nn.BatchNorm1d`というかBatchNormalizationについてはこちらの[Qiita記事](https://qiita.com/cfiken/items/b477c7878828ebdb0387)などを参考ください。以降に出てくる謎のレイヤ`FeatTransformer`と`AttentiveTransformer`他の中身が以下です。[論文](https://arxiv.org/pdf/1908.07442.pdf)のFigure4(c), (d)$+\alpha$に対応します。TabNetにおいて主にどういう入出力になるかの情報も図に残しています。 ![Transformers.png](https://storage.guruguru.science/uploads/d8976e77_17ed_4938_ba8b_fe2cccf61283/Transformers.png) 先に細かなパーツを紹介して、後程メインの`FeatTransformer`と`AttentiveTransformer`を説明します。 ### GatedLinearUnit(GLU)のお仕事後程説明する`GBN`を通しているのが少し特殊ですが、要するにLSTMなどで使われるゲート的な役割を果たしていると思われます。情報の取捨選択的なことを行うやつです。詳細は[こちらのブログ](https://deeplearning.hatenablog.com/entry/convs2s)などをご参考ください。ここに渡されるパラメータとして`n_a`と`n_d`の2つがあり、出力サイズを決めます。サイズ変化がややこしいため視覚化します。 ![GLU.png](https://storage.guruguru.science/uploads/660d74f0_187c_41df_82f7_29ff03cbea9a/GLU.png) 言葉で説明すると以下の通りです。 1. $input$を`nn.Linear`を通して$2(n_{a}+n_{d})$に。 2. `GBN`（後述）を通ってもサイズは変わらないが、スライスして半分はシグモイド関数を通して、もう半分はそのままで乗算。 3. 結果として出力されるのは$(n_{a}+n_{d})$。 4. その後いくつかの処理を経て$n_{a}$の方は（次のステップの）`AttentiveTransformer`へ、$n_{d}$の方は`nn.ReLU`に渡される。流れとしてはこれで合ってると思うのですが、テーブルデータでこんなにスライスして別々の処理しても大丈夫な理由がいまいちピンときません:confused: ### GhostBatchNormalization(GBN)のお仕事（抜き出し再掲） ![GBN.png](https://storage.guruguru.science/uploads/7a703ec0_f086_49dd_b196_8e94d7c58475/GBN.png) 入力されたバッチをパラメータ`virtual_batch_size`ずつに更に分割し、それぞれで`nn.BatchNorm1d`を掛けた後に結合して出力します。[こちらのslideshare](https://www.slideshare.net/JiroNishitoba/20170629)によると学習率を高める働きがあるそうです。そんなに便利なら古今東西すべてのBatchNormlizationこれを使えばよいのでは？と素人は思うのですが、何にでもかんにでも使われていないことを見るに何かしらデメリットもあるのでしょうか。 ### FeatTransformerのお仕事（抜き出し再掲） ![FeatTransformer.png](https://storage.guruguru.science/uploads/57152f76_57dd_423c_9b4f_b327039b346d/FeatTransformer.png) TabNetのメイン機能その①です。仕事としては`GLU`が重なっていますので、情報のゲーティングをやっているのだと思います:cloud:拙い知識で論文を読む限りその後`nn.ReLU`を通ることでGBDTを模倣するようなのですが、何故そんなことができるのかは分かりません:sob: 構造を見ていきます。大きく分けるとSharedとSpecificsに分かれますが、働きとしては（Sharedの一番初めを除き）以下の動きで共通しています。※Specificsはライブラリでの名称に合わせていますが、論文等ではDesicion stepなどと記載されています。 1. 直前の出力とそれをGLUに通したものを足す 2. 1.に$\sqrt{0.5}$をかけるのループで一仕事になっており、SharedとSpecificsの違いは以下の通りです。 - Shared: 構造の中に何個も登場する`FeatTransformer`で共通のものを使う。ループ回数はパラメータ`n_shared`で指定する。 - Specifics: それぞれの`FeatTransformer`で個別のものを使う。ループ回数はパラメータ`n_independent`で指定する。入出力のサイズに注目すると以下の様になっています。 - 入力される値は以下の2パターンがあり、いずれもサイズは$input$。 - `EmbeddingGenerator`->`nn.BatchNorm1d`を通ってきたもの。 - `AttentiveTransformer`を通ってきた`Masked_x`。 - サイズ$n_{a}+n_{d}$で出力し、それを`split`して$n_{a}$は`AttentiveTransformer`へ渡され、$n_{d}$は`nn.ReLU`に渡され最後に各ステップの出力を合計、`nn.Linear`を通して最終出力になる。 ### Sparsemaxのお仕事 `AttentiveTransformer`に入る前に、そのパーツである`Sparsemax`についてです。仕組みは良く分かっていませんが要するに「極端なsoftmax」みたいです。そしてその進化系に`entmax`がおり、パラメータで`sparsemax`と`entmax`どちらを使うかを選ぶことができます。簡単に違いを試してみます。 ```python import torch import torch.nn.functional as F from pytorch_tabnet.sparsemax import Sparsemax, Entmax15 x = torch.Tensor([0, 0.1, 0.2, 0.5, 0.9]) print(x) # >>> tensor([0.0000, 0.1000, 0.2000, 0.5000, 0.9000]) print(F.softmax(x)) # >>> tensor([0.1345, 0.1486, 0.1643, 0.2218, 0.3308]) print(Entmax15()(x)) # >>> tensor([0.0607, 0.0879, 0.1200, 0.2464, 0.4850]) print(Sparsemax()(x)) # >>> tensor([0.0000, 0.0000, 0.0000, 0.3000, 0.7000]) ``` 入力xは適当な値です。`softmax`は"ソフト"にしつつ合計が1になる様に正規化します。`entmax`は"ソフトっぽさ"がなくなり、小さい値はより0に、大きい値はより1に近づいています。`sparsemax`は更に極端で、小さいものはすべて0になっています。使うものは使う、使わないものは使わないとはっきりさせることで、よりくっきりしたマスクを作ることに一躍買っていると思われます:cloud: アルゴリズムは難しく理解できていませんが、[こちらの記事](https://ichi.pro/dhi-pura-ningu-no-kasseika-kansu-softmax-kara-sparsemax-made-sugaku-no-shomei-88793804256342)などが参考になるかも知れません。 ### AttentiveTransformerのお仕事（抜き出し再掲） ![AttentiveTransformer.png](https://storage.guruguru.science/uploads/79173dae_0b19_4bd8_a56d_430e07121e34/AttentiveTransformer.png) TabNetのメイン機能その②です。最終的に前述の`sparsemax`（もしくは`entmax`）を通るので、各値を行方向に足したら1になるTensorが出力されます。また`prior`という昔の情報（詳しくは後述）を入力にしており、"Attentive"の名前の通り「過去の学習も踏まえてこのstepではどの特徴量に注目するか」を決めるマスクを作ります。 `AttentiveTransformer`は前後の入出力も含めて認識するのが大事だと思うので、3つ前の画像の`TabNetEncoder`部分を抜き出して再掲します。 ![TabNetEncoder.png](https://storage.guruguru.science/uploads/4a3fab50_14a9_4318_bddf_6ff9c8515480/TabNetEncoder.png) 以下のようなことが分かります。 - （step1は特殊なのでstep2に注目すると）入力は`FeatTransformer`の出力をsplitした片方と`prior`の2つ。 - 出力も以下の通り2つに分かれる。 - inputを`EmbeddingGenerator`->`nn.BatchNorm1d`に通したものと乗算して`Masked_x`になる出力。 - `gamma`との差をとったものを`prior`（$t-1$）と乗算して次の`prior`（$t$）になる出力。出力に注目して深掘りします。 #### Masked_x これはシンプルにinput（をちょっといじくったもの）にマスクを掛けたもの、という理解で良さそうです。特徴量が10個あるinputだとしたら、「1-8個目の特徴量のことは全然考えず、9個目のは0.3、10個目は0.7の力で見る」という様なことをやっているのかと。 #### prior - $(\gamma-Att)\otimes prior_{t-1}$で計算されます。 - $t=0$の時は$t-1$が存在しないので、$prior_{t-1}$の代わりに$input$サイズの`torch.ones`を使います。 - $\gamma$はパラメータ`gamma`でfloat1.0～2.0の範囲で指定します。すべての$\gamma$で共通の値になります。 - `AttentiveTransformer`で「今回はこれに注目する」とされた特徴のマスクの値は1に近くなるはずですが、stepを重ね$(\gamma-Att)$を繰り返していくとだんだんと強制的に0に近づいていきます:cloud: - 「1.0に近くするほど各Stepでバラバラな特徴選択を行うのかな？」と思ったのですが、同じデータで`gamma`を変化させてマスクの違いを見る限りはそんなこともなさそう（`gamma=1.0`の時に繰り返して選ばれる特徴がある、など）なので、よくわかりません:innocent: - 一応、ライブラリの説明にも以下文章があります。 > これはマスクにおける特徴の再利用のための係数です。1に近い値にすると、マスクの選択はレイヤー間の相関が最も少なくなります。 ### stepのお仕事（抜き出し再掲） ![steps.png](https://storage.guruguru.science/uploads/c790fd8f_b702_48cf_8ba0_d7086b6e7919/steps.png) stepはクラスではなくここまで見てきた一連の仕事の塊です。パラメータ`n_steps`で何step繰り返すかを指定します。値が大きいほど特徴選択→情報のゲーティングを繰り返すので説明力が増す一方で計算量＆過学習リスクがデメリットになりそうです:cloud: ## TabNetPreTrainer以下のクラス事前学習がどんなものかを見ていきます。`TabNetPreTrainer`はほぼ`BaseEstimator`的なポジションなので、`TabNetPreTraining`がどうなっているかで見ていきます。まず、以下の点を思い出しておいてください。 - `TabNetPreTrainer.fit`()を実行した事前学習済みモデルを、`TabNetReggressor`か`TabNetClassifier`の`fit()`時に渡すことで`load_weights_from_unsupervised()`というメソッドが呼び出され、事前学習時の重みがセットされます。 - [Zenn](https://zenn.dev/sinchir0/articles/9228eccebfbf579bfdf4)の通り事前学習は「マスクされた特徴を予測する」方法で行われます。何故この方法でターゲットの予測に役立つ重みが得られるのかは分かりません:sob: 以下が`TabNetPreTraining`の中身です。 ![TabNetPreTraining.png](https://storage.guruguru.science/uploads/fb71b87f_86f2_4b76_8051_5bd3eb6fdf5f/TabNetPreTraining.png) 処理の中心は（中身を記載すると図がややこしくなるので小さくしていますが）先ほどまで見ていた`TabNetEncoder`で通常の学習の場合と共通です。また、入力を最初に`EmbeddingGenerator`にかけるのも共通ですが、`RandomObfuscator`と`TabNetDecoder`が初出です。 ### RandomObfuscatorのお仕事事前学習の問題を作るべく特徴を歯抜けにします。また、`RandomObfuscator`の外側での計算ですがそれに合わせて初期化する`prior`も歯抜けにします（学習時は`torch.ones`で初期化される）。簡単なイメージで言うと以下のコードの通りです。各値は適当です。 ```python import torch torch.manual_seed(0) shape = (2, 10) input = torch.full(shape, 2) pretraining_raio = 0.5 # マスクする箇所をベルヌーイ分布に従って選ぶ（1:消す、0:残す） obfuscated_vars = torch.bernoulli(pretraining_raio * torch.ones(shape)) # >>> tensor([[1., 0., 1., 1., 1., 0., 1., 0., 1., 0.], # >>> [1., 1., 1., 1., 1., 0., 0., 0., 1., 1.]]) # マスクされた特徴量 masked_x = torch.mul(1 - obfuscated_vars, input) # >>> tensor([[0., 2., 0., 0., 0., 2., 0., 2., 0., 2.], # >>> [0., 0., 0., 0., 0., 2., 2., 2., 0., 0.]]) # priorは学習時はtorch.onesで初期化するが、マスクされた箇所はゼロにして除く(1:残っている、0:消えている) prior = 1 - obfuscated_vars # >>> tensor([[0., 1., 0., 0., 0., 1., 0., 1., 0., 1.], # >>> [0., 0., 0., 0., 0., 1., 1., 1., 0., 0.]]) ``` `pretraining_ratio`はパラメータで設定でき、初期値は0.5です。値が大きいほどマスクが強くなる＝事前学習時の問題が難しくなることになります。 ### TabNetDecoderのお仕事 [論文](https://arxiv.org/pdf/1908.07442.pdf)のFigure4(d)の図に対応します。`TabNetEncoder`は$n_{d}$サイズの出力を`n_step`分出します。学習時はこれを全部足した後に`nn.Linear`にかけて出力を得ていましたが、事前学習時はそれぞれ`FeatTransformer`を通した後に`nn.Linear`にかけ、最後に全部足します。これまた何でそうなるのかは分かりませんが、どうやら歯抜けになった特徴を予測していることになるみたいです:cloud: ### 損失の計算方法色々いじくったReconstruction Error（[こちらのQiita](https://qiita.com/kenmatsu4/items/b029d697e9995d93aa24)の中ほどに解説あり）が損失になります。ライブラリでは論文と異なりバッチでの平均損失を使っているそうです。inputに`EmbeddingGenarator`を掛けたものを正解ラベルとして学習します。 ## 特徴重要度を可視化する仕組みまず、TabNetには二つ重要度を表す指標があります。 1. Feature Importance(Global interpretability): `model.feature_importances_`にnumpy配列で保存されているもの。`plt.barh()`などに入れてやればGBDTでおなじみの感じのグラフになる。裏では`TabModel._compute_feature_importances()`で算出される。 2. Mask(Local interpretability): `model.explain()`で辞書として算出される。どのステップでどの特徴量に注目していたかがわかる。`imshow`()などに入れてやればヒートマップで分かりやすい。また、いずれも以下の様な特徴があります。 - 学習完了後、推論モード（`model.eval()`）に切り替えて算出される->学習時とはちょっと違う挙動で算出する。 - `TabNetEncoder`の一部分を抜き出したものを色々いじって算出される（以下図参照）。 ![importance.png](https://storage.guruguru.science/uploads/71bcf2f9_48a3_45b6_8d29_db23a2a2953b/importance.png) それぞれちょっとだけ中身を見てみます。 ### Feature Importance(Global interpretability) 元の出力が何なのかを良く分かっていないため、何故これが重要度を表すのかは分かっていませんがやっていることだけ記載します。 `nn.ReLU`以降の図式化されていない流れを大まかに説明すると、 1. 行方向に足したり、`AttentiveTransformer`の出力と乗算したり、列方向に足したりして`EmbeddingGenerator`を通した後の$input$サイズのベクトルを作る 2. `EmbeddingGenerator`でのカテゴリ埋め込みを加味した疎行列を作って1との内積をとる 3. 全部の重要度を足したら1になるようにして（$importance/sum(importance)$）出力する 1～2の流れを図にすると↓です。疎行列を作ってる右側の流れが2で、左下のベクトルが1のフローの産物です。青と赤の列がカテゴリ変数で、白の列が数値変数のイメージです。 ![feature_importance.png](https://storage.guruguru.science/uploads/417a2b42_70e1_42ed_858f_cf0bc0bcd3b7/feature_importance.png) ### Mask(Local interpretability) Maskを、先ほどのfeature importanceと同じ様にサイズ変換して出力します。各StepにおけるMaskは$input$のカテゴリ列を`EmbeddingGenerator`によって任意の次元に変えたサイズになっているため、それを元の形状に戻します。サイズ変換の方法は先ほどと同じなので飛ばし、[公式実装例](https://github.com/dreamquark-ai/tabnet/blob/develop/pretraining_example.ipynb)を使って出力されるMaskと形状を戻す前のMaskがどんなものか見てみます。まず、普通にMaskを確認する場合。 ```python explain_matrix, masks = clf.explain(X_test) fig, axs = plt.subplots(1, 3, figsize=(20,20)) for i in range(3): axs[i].imshow(masks[i][:25]) axs[i].set_title(f"mask {i}") ``` ![mask.png](https://storage.guruguru.science/uploads/000a9d59_96a1_4cc2_a265_106aee308349/mask.png) 上の図は各図が`n_steps=3`での各stepにおけるマスクを、横方向が各列、縦方向は行を意味しています。行は[:25]までの表示としています。 - mask0: 0,1,8,10,11,12,13列目に注目 - mask1: 3,4列目に注目 - mask2: 5,7,9列目に注目していることが視覚的に分かります。続いて、サイズを元に戻す前のマスクを見てみます。 ```python _mask = clf.network.tabnet.forward_masks(clf.network.embedder(torch.Tensor(X_train).to('cuda')))[1] fig, axs = plt.subplots(1, 3, figsize=(20,20)) for i in range(3): axs[i].imshow(_mask[i][:25].to('cpu').detach().numpy()) axs[i].set_title(f"mask {i}") ``` ![embedded_mask.png](https://storage.guruguru.science/uploads/a217c06b_76c0_4db9_bf7c_f5cc72738f05/embedded_mask.png) 公式実装例では14列あるデータのうち13列のカテゴリ変数を3次元に埋め込んでいるので、13*3+1=40列に変化しています。ちなみに元データの2列目が数値列なので、埋め込み後は6列目のみが数値列です（0-5列は元0-1列のカテゴリ変数を埋め込んだもの）。先ほどのマスクと、特にmask 1とmask2を見比べると以下のようなことが言えるかと思います。 - mask1: 注目しているのは距離をあけて1列ずつ。3次元に埋め込んだうちの2次元はあまり意味がないのかも知れない。 - mask2: mask1とは反対に強弱あれど3列ずつに注目している。こちらは全次元に意味がありそう。 # TabNetで大事なパラメータの気持ちほぼrepositoryの和訳しただけですがパラメータまとめていきます。タイトルは@nyk510さんの[勾配ブースティングで大事なパラメータの気持ち](https://nykergoto.hatenablog.jp/entry/2019/03/29/%E5%8B%BE%E9%85%8D%E3%83%96%E3%83%BC%E3%82%B9%E3%83%86%E3%82%A3%E3%83%B3%E3%82%B0%E3%81%A7%E5%A4%A7%E4%BA%8B%E3%81%AA%E3%83%91%E3%83%A9%E3%83%A1%E3%83%BC%E3%82%BF%E3%81%AE%E6%B0%97%E6%8C%81%E3%81%A1)リスペクトです（幾度となくお世話になっています）。 ## まとめ - rangeの列には指定可能な値の範囲を記載していますが、正しくはライブラリの推奨範囲です。range外の値を設定可能な項目もあります。 - 事前学習時に設定すべきもの、学習時に設定すべきもの、両方同じ値にすべきもの...等々ありそうですが、まだ詳細把握できていないのでその点は[公式実装例](https://github.com/dreamquark-ai/tabnet/blob/develop/pretraining_example.ipynb)等をご参考ください。 ### Model params | param | default | type | range | overview | | :----------------- | :----------------- | :----------------------- | :-------------------- | :----------------------------------------------------------- | | `n_d` | 8 | int | 8-64 | `nn.ReLU`の入出力サイズ、最終的に`nn.Linear`を通ってoutputになる
`n_a`と足した数が`FeatTransformer`の出力サイズ
値が大きいほど表現力と過学習のリスクがあがるらしい | | `n_a` | 8 | int | 8-64 | `AttentiveTransformer`への入力サイズ
`n_d`と足した数が`FeatTransformer`の出力サイズ
`n_d`と同じ値にしておくのが良いらしい | | `n_steps` | 3 | int | 3-10 | `TabNetEncoder`のstepを何回繰り返すか
たぶんGBDTで言うと木の深さ的なパラメータ:cloud: | | `gamma` | 1.3 | float | 1.0-2.0 | マスクの制御
詳細は「`AttentiveTransformer`のお仕事」の項参照 | | `cat_idxs` | [] | list of int | 列数 | `EmbeddingGenerator`に渡すカテゴリ変数の列インデックス
後程補足 | | `cat_dims` | [] | list of int | 列数 | `EmbeddingGenerator`に渡すカテゴリ変数の語彙数（と呼ぶのか？ユニーク数？）
後程補足 | | `cat_emb_dim` | 1 | int or list of int | 列数 | `EmbeddingGenerator`に渡すカテゴリ変数の埋め込み次元数
後程補足 | | `n_independent` | 2 | int | 1-5 | `FeatTransformer`での独立した`GLU`ループの数 | | `n_shared` | 2 | int | 1-5 | `FeatTransformer`での共有される`GLU`ループの数 | | `epsilon` | 1e-15 | float | - | 0除算用なのでいじらなくてOK | | `seed` | 0 | int | - | seed | | `momentum` | 0.02 | float | 0.01-0.4 | `nn.BatchNorm1d`に渡すやつ | | `clip_value` | None | float | - | 勾配クリッピングする値 | | `lambda_sparse` | 1e-3 | float | - | 曰く「値が大きいほど特徴選択時によりスパースなモデルになる。難しい問題には値を小さくすると良いかも。」とのことだが良く分かっていない
使われ方は損失計算時に`loss -= lambda_sparse * loss`している。
特徴がマスクされてスパースになりすぎることを避ける？学習がうまくいってないときに下げると良いのかも。 | | `optimizer_fn` | torch.optim.Adam | torch.optim | - | 最適化関数 | | `optimizer_params` | dict(lr=2e-2) | dict | - | 最適化関数のパラメータ | | `scheduler_fn` | None | torch.optim.lr_scheduler | - | スケジューラ― | | `scheduler_params` | ? | dist | - | スケジューラ―のパラメータ | | `model_name` | 'DreamQuarkTabNet' | str | - | 保存するときのモデルの名前 | | `saving_path` | './' | str | - | 保存先 | | `verbose` | 1 | int | - | 学習結果を何epoch毎に表示するか | | `device_name` | 'auto' | str | 'auto', 'cpu', 'gpu' | gpu使うかcpu使うか、オートで判定するか | | `mask_type` | 'sparsemax' | str | 'sparsemax', 'entmax' | `AttentiveTransformer`でマスク作るのにどっちの関数を使うか | ### Fit params | param | default | type | range | overview | | :------------------- | :------------------------ | :------------------------------- | :-------------------------------- | :----------------------------------------------------------- | | `X_train` | None | np.array | - | 学習データ | | `y_train` | None | np.array | - | ターゲット | | `eval_set` | None | list of touple(X, y) | - | 検証データ
一塊でもリストで渡さないといけないので注意 | | `eval_name` | None | list of str | - | eval_setの名前 | | `eval_metric` | None | list of str | - | eval_setの評価関数 | | `max_epochs` | 200 | int | - | epoch | | `patience` | 15 | int | - | early stoppingを判断するepoch数
0ならearly stoppingしない
early stoppingするとbest eposhの重みが自動的にfit後にロードされる | | `weihts` | 0 | int or dict | 0, 1, dict | `TabNetClassifier`向けのパラメータ、何かまだわかっていない
0: サンプリングしない
1: 自動サンプリング
dict: 重みを手動設定 | | `loss_fn` | cross_entropy
mse_loss | torch.loss or list of torch.loss | - | Loss funtion
`TabNetMultiTaskClassifier`を使う時はリストで渡せば別々の損失関数を使える | | `batch_size` | 1024 | int | large batch sizes are recommended | バッチサイズ | | `virtual_batch_size` | 128 | int | should divide `batch_size` | `GBN`でバッチサイズを更に分割する数 | | `num_workers` | 0 | int | - | `torch.utils.data.Dataloder`のやつ | | `drop_last` | False | bool | - | あまったbatchをdropするかどうか | | `callbacks` | None | list of callback function | - | 使い道分かってない | | `pretraining_ratio` | 0.5 | float | 0-1 | pretrain時にどれだけmaskするか
詳細は「`TabNetPreTraining`のお仕事」の項参照 | ## 何渡せば良いか分かりづらいパラメータの補足 - `cat_dims`と`cat_idxs`: list of int - 各カテゴリ列の語彙数と**列方向の**インデックス番号を対応する形でそれぞれリストにして渡します。 - 前処理部分は好みのものにアレンジしつつ、[実装例](https://github.com/dreamquark-ai/tabnet/blob/develop/pretraining_example.ipynb)をまねるのが良いと思います。 ```python # repositoryの実装例を少し改変して記載 nunique = train.nunique() types = train.dtypes categorical_columns = [] categorical_dims = {} # 前処理部分（タスクによって変える） for col in train.columns: if types[col] == 'object' or nunique[col] < 200: print(col, train[col].nunique()) l_enc = LabelEncoder() train[col] = train[col].fillna("VV_likely") train[col] = l_enc.fit_transform(train[col].values) categorical_columns.append(col) categorical_dims[col] = len(l_enc.classes_) else: train.fillna(train.loc[train_indices, col].mean(), inplace=True) features = [ col for col in train.columns if col != TARGET_COL] cat_idxs = [ i for i, f in enumerate(features) if f in categorical_columns] cat_dims = [ categorical_dims[f] for i, f in enumerate(features) if f in categorical_columns] ``` - for文でカテゴリ列名をリストに、列名と語彙数のセットを辞書にしておき、最後にリスト内包表記で求めるものを作成しています。 - for文内のif分岐で、dtypeがobjectの列だけでなくnuniqueが200未満の列もカテゴリとして処理しています。もちろんこの200は自由に変更可能です。ここでカテゴリとして処理されなかった列がすべて`EmbeddingGenerator`で連続値として扱われます。 - いずれかが空のリストだとEmbedding処理自体がスキップされます。自分で前処理をすべて行う場合には指定する必要はありません。 - 上記の実装をする場合の注意点として、`nn.Embedding()`の第一引数に語彙数が渡されるのですが、単語IDの最大値+1の数を渡す必要があります。私はラベルエンコーディングを`category_encoders.OrdinaryEncoder`で実施したところ1始まりで変換されていて沼に嵌りました。設定の問題？ - 語彙数が100なら単語IDは0～99で割り振る必要があります。1～100にするとErrorになります。 - `cat_emb_dim`: int or list of int - カテゴリ変数の埋め込み次元数を指定します。intを指定した場合はすべてのカテゴリ変数が同じint次元で埋め込まれます。intをlistで与えるときは`cat_dims`や`cat_idxs`と同じ順番で指定すると、それぞれの列を任意の次元で埋め込むことができます。

forum コメント・3件

コメント・3件