時系列予測のための 5 つのディープラーニング モデルの比較

マクリダキス M-コンペティション シリーズ (M4 および M5 と呼ばれます) は、それぞれ 2018 年と 2020 年に開催されました (今年は M6 も開催されました)。ご存じない方のために説明すると、M シリーズ コンペティションは、時系列エコシステムの現状をまとめたもので、現在の予測理論と実践について実証的かつ客観的な証拠を提供するものと言えます。

2018 年の M4 の結果では、純粋な「ML」手法が従来の統計手法を大幅に上回ったことが示されましたが、これは当時は予想外のことでした。 2年後のM5[1]では、「ML」手法のみで最高得点が達成されました。そして、上位 50 はすべて基本的に ML ベースです (ほとんどがツリー モデル)。このコンペティションでは、LightGBM（時系列予測用）のほか、AmazonのDeepar [2]やN-Beats [3]もデビューしました。 N-Beats モデルは 2020 年にリリースされ、M4 競合の優勝者よりも 3% 優れた性能を発揮します。

最近の人工呼吸器圧力予測コンテストでは、リアルタイムの時系列課題に取り組むためにディープラーニング手法を使用することの重要性が実証されました。コンテストの目的は、機械肺内の圧力の時間的順序を予測することです。各トレーニング インスタンスは独自の時系列であるため、タスクは複数の時系列の問題になります。優勝チームは、LSTM ネットワークと Transformer ブロックを含む多層のディープ アーキテクチャを提出しました。

ここ数年で、MQRNN や DSSM など、多くの有名なアーキテクチャが公開されました。これらのモデルはすべて、ディープラーニングを使用した時系列予測の分野に多くの新たな貢献を果たしました。 Kaggle コンペティションでの優勝に加え、次のようなさらなる進歩ももたらしました。

• 汎用性: さまざまなタスクにモデルを使用できる能力。
• MLOP: モデルを本番環境で使用できる機能。
• 解釈可能性と説明可能性: ブラックボックス モデルはそれほど人気が​​ありません。

この記事では、時系列予測に特化した 5 つのディープラーニング アーキテクチャについて説明します。この論文の内容は次のとおりです。

1. N-BEATS(エレメントAI)
2. DeepAR (アマゾン)
3. 時空形成者[4]
4. 時間融合トランスフォーマー（TFT）（Google）[5]
5. TSFormer（時系列用MAE）[7]

Nビート

このモデルは、Yoshua Bengio 氏が共同設立した (残念ながら) 短命だった ElementAI 社から直接提供されたものです。最上位のアーキテクチャとその主要コンポーネントを図 1 に示します。

N-BEATS は、相互に前方接続と後方接続が積み重ねられた統合フィードフォワード ネットワークのディープ スタックに基づく純粋なディープ ラーニング アーキテクチャです。

各ブロックは、前のブロックのバックキャストによって生成された残差のみをモデル化し、このエラーに基づいて予測を更新します。この手順は、ARIMA モデルを適合する際の Box-Jenkins 法を模倣します。

このモデルの主な利点は次のとおりです。

表現力豊かで使いやすい: モデルは理解しやすく、モジュール構造になっており、時系列特徴エンジニアリングが最小限で済み、入力のスケーリングが不要になるように設計されています。

このモデルは複数の時系列に一般化することができます。つまり、わずかに異なる分布を持つ異なる時系列を入力として使用できます。 N-BEATS では、メタ学習を通じてこれが実現されます。メタ学習プロセスには、内部学習プロセスと外部学習プロセスという 2 つのプロセスが含まれます。内部学習プロセスはブロック内で発生し、モデルがローカルな時間的特徴を捉えるのに役立ちます。外部学習プロセスは積み重ねられたレイヤーで発生し、モデルがすべての時系列のグローバルな特徴を学習するのに役立ちます。

二重残差スタッキング: 残差接続とスタッキングの考え方は非常に巧妙で、ほぼすべてのタイプのディープ ニューラル ネットワークで使用されています。 N-BEATS の実装にも同じ原則が適用されますが、いくつかの追加の変更が加えられています。各ブロックには 2 つの残差ブランチがあり、1 つはルックバック ウィンドウ (バックキャストと呼ばれる) で実行され、もう 1 つは予測ウィンドウ (フォーキャストと呼ばれる) で実行されます。

連続する各ブロックは、前のブロックによって再構築されたバックキャストによって生成された残差のみをモデル化し、このエラーに基づいて予測を更新します。これにより、モデルは有用なプッシュバック信号をより適切に近似できるようになります。一方、最終的なスタック予測は、すべての部分予測の階層的な合計としてモデル化されます。このプロセスは、ARIMA モデルに対する Box-Jenkins アプローチをシミュレートします。

解釈可能性: モデルには、一般型と解釈可能型の 2 つのバリエーションがあります。一般的なバリエーションでは、ネットワークは各ブロックの完全に接続されたレイヤーの最終的な重みを任意に学習します。解釈可能なバリアントでは、各ブロックの最後のレイヤーが削除されます。次に、バックキャストと予測のブランチに、トレンド (単調関数) と季節性 (周期的循環関数) をモデル化する特定のマトリックスを掛け合わせます。

注: オリジナルの N-BEATS 実装は、単変量時系列に対してのみ機能します。

ディープAR

ディープラーニングと自己回帰特性を組み合わせた新しい時系列モデル。図 2 は DeepAR の最上位アーキテクチャを示しています。

このモデルの主な利点は次のとおりです。

DeepAR は複数の時系列で非常にうまく機能します。わずかに異なる分布を持つ複数の時系列を使用してグローバル モデルが構築されます。多くの現実のシナリオにも適用できます。たとえば、電力会社は、消費パターンが異なる（つまり、分布が異なる）顧客ごとに電力予測サービスを開始したいとします。

DeepAR では、履歴データに加えて、既知の将来の時系列 (自己回帰モデルの機能) や追加の静的プロパティも使用できます。前述の電力需要予測シナリオでは、追加の時間変数として月（1〜12 の値を持つ整数）を使用できます。各顧客が電力消費を測定するセンサーに関連付けられていると仮定すると、追加の静的変数は、sensor_id や customer_id のようなものになります。

MLP や RNN などのニューラル ネットワーク アーキテクチャを時系列予測に使用することに慣れている場合、重要な前処理手順は、正規化または標準化手法を使用して時系列をスケーリングすることです。 DeepAR では、基礎となるモデルが各時系列 i の自己回帰入力 z を係数 v_i (時系列の平均値) でスケーリングするため、これを手動で行う必要はありません。具体的には、論文のベンチマークで使用されているスケーリング係数の式は次のとおりです。

ただし、実際には、ターゲット時系列のサイズが大きく異なる場合は、前処理中に独自のスケーリングを適用する必要がある場合があります。たとえば、エネルギー需要予測のシナリオでは、データセットには中電圧電力顧客 (メガワット単位で電力を消費する小規模工場など) と低電圧顧客 (キロワット単位で電力を消費する家庭など) が含まれる場合があります。

DeepAR は将来の値を直接出力するのではなく、確率的な予測を行います。これはモンテカルロサンプリングの形式で行われます。これらの予測は、分位損失関数を使用して分位予測を計算するために使用されます。このタイプの損失に詳しくない人のために説明すると、分位点損失は推定値を計算するだけでなく、その値の周りの予測区間を計算するためにも使用されます。

スペースタイムフォーマー

単変量時系列では時間依存性が最も重要です。しかし、複数の時系列シナリオでは、物事はそれほど単純ではありません。たとえば、天気予報のタスクがあり、5 つの都市の気温を予測するとします。これらの都市が 1 つの国に属していると仮定しましょう。これまで見てきたことを踏まえると、DeepAR を使用して各都市を外部の静的共変量としてモデル化することができます。

言い換えれば、モデルは時間的関係と空間的関係の両方を考慮に入れます。これが、Spacetimeformer の中心的なアイデアです。モデルを使用してこれらの都市/場所間の空間関係を活用し、モデルが時間的関係と空間的関係の両方を同時に考慮するため、追加の有用な依存関係を学習します。

時空シーケンスの詳細な研究

名前が示すように、このモデルは内部的にトランスフォーマーベースの構造を使用します。時系列予測にトランスフォーマーベースのモデルを使用する場合、時間を考慮した埋め込みを生成するための一般的な手法は、入力をTime2Vec[6]埋め込み層に渡すことです（NLPタスクではTime2Vecの代わりに位置エンコーディングベクトルを使用します）。この手法は単変量時系列には非常に有効ですが、多変量時間入力には意味がありません。言語モデリングでは、文中の各単語は埋め込みによって表され、単語は本質的に語彙の一部であるのに対し、時系列はそれほど単純ではないのかもしれません。

多変量時系列では、特定の時間ステップ t での入力は x_1,t、x2,t、x_m,t の形式になります。ここで、x_i,t は特徴 i の値であり、m は特徴/シーケンスの合計数です。入力を Time2Vec レイヤーに渡すと、時間埋め込みベクトルが生成されます。この埋め込みは実際には何を表しているのでしょうか? 答えは、入力セット全体を単一のエンティティ (トークン) として表すということです。したがって、モデルは時間ステップ間の時間的ダイナミクスのみを学習しますが、特徴/変数間の空間関係は学習しません。

Spacetimeformer は、入力を時空シーケンスと呼ばれる大きなベクトルに平坦化することでこの問題を解決します。入力に ​​N 個の変数が含まれ、T 個の時間ステップに編成されている場合、結果の時空間シーケンスには (NxT) のラベルが付きます。下の図 3 はこれをよりよく示しています。

論文には次のように書かれています。「(1) 時間情報を含む多変量入力形式。デコーダー入力の欠損値（“？”）は、予測を行う際にゼロに設定されます。(2) 時系列は Time2Vec レイヤーを通過し、周期的な入力パターンを表す周波数埋め込みを生成します。(3) バイナリ埋め込みは、値がコンテキストとして与えられているか、予測する必要があるかを示します。(4) 各時系列の整数インデックスは、ルックアップテーブル埋め込みを使用して「空間」表現にマッピングされます。(5) フィードフォワードレイヤーを使用して、各時系列の Time2Vec 埋め込みと変数値を投影します。(6) 時間、変数、および指定された埋め込みにわたる値を合計すると、入力として時間と変数空間の間のより長いシーケンスにまたがることができる MSA が生成されます。」

言い換えれば、最終的なシーケンスは、時間、空間、コンテキスト情報を統一的に組み合わせた埋め込みをエンコードします。しかし、このアプローチの欠点は、シーケンスが非常に長くなり、リソースが二次関数的に増加する可能性があることです。これは、各トークンがアテンション メカニズムに従って他のトークンに対してチェックされるためです。著者らは、より大きなシーケンスに適した Performer attention メカニズムと呼ばれる、より効率的なアーキテクチャを使用しました。

時間融合トランスフォーマー

Temporal Fusion Transformer (TFT) は、Google がリリースした Transformer ベースの時系列予測モデルです。 TFTは以前のモデルよりも多用途です。

TFT の最上位アーキテクチャを図 4 に示します。このモデルの主な利点は次のとおりです。

前述のモデルと同様に、TFT は複数の異種時系列でのモデルの構築をサポートしています。

TFT は、次の 3 種類の機能をサポートしています: i) 将来の入力が既知の時間変動データ、ii) これまでのところのみわかっている時間変動データ、iii) カテゴリ/静的変数 (時間不変機能とも呼ばれます)。したがって、TFT は以前のモデルよりも汎用性が高くなっています。前述の電力需要予測シナリオでは、これまで知られていない時間変動特性として湿度レベルを使用したいと考えています。これは TFT では可能ですが、DeepAR では不可能です。

図 5 は、これらすべての機能の使用方法の例を示しています。

TFT は解釈可能性を非常に重視しています。具体的には、変数選択コンポーネント (上の図 4 を参照) を活用することで、モデルは各機能の影響を正常に測定できます。したがって、モデルは特徴の重要性を学習していると言えます。

一方、TFT は新しい解釈可能なマルチヘッド アテンション メカニズムを提案します。このレイヤーのアテンション ウェイトにより、レビュー期間中にどのタイム ステップが最も重要であるかが明らかになります。これらの重みを視覚化すると、データセット全体にわたって最も重要な季節パターンが明らかになります。

予測区間: DeepAR と同様に、TFT は分位回帰を使用して予測区間と予測値を出力します。

要約すると、ディープラーニングは間違いなく時系列予測の分野に革命をもたらしました。比類のないパフォーマンスに加えて、上記のすべてのモデルには共通点が 1 つあります。それは、複数の多変量時間データを最大限に活用し、外部情報を使用して予測パフォーマンスを前例のないレベルまで向上させることです。ただし、ほとんどの自然言語処理 (NLP) タスクでは、事前トレーニング済みのモデルが使用されます。 NLP タスクのフィードは、ほとんどが人間が生成したデータであり、豊富で優れた情報で満たされており、ほぼデータ ユニットと見なすことができます。時系列予測では、このような事前トレーニング済みモデルが不足していることが感じられます。なぜ、NLP の場合と同じように、時系列でもこれを活用できないのでしょうか?

最後に紹介するモデルは TSFormer です。このモデルは 2 つの観点を考慮しています。入力から出力まで 4 つの部分に分割し、Python 実装コード (公式からも提供されています) を提供します。このモデルはつい最近リリースされたばかりなので、ここでは重点的に紹介します。

TS元

これは、MAE のトレーニング戦略を使用し、データ内の非常に長い依存関係をキャプチャできる Transformer (TSFormer) に基づく教師なし時系列事前トレーニング モデルです。

NLP と時系列:

ある意味では、NLP 情報と時系列データは同じです。これらは、連続したデータであり、局所性に敏感であり、次の/前のデータ ポイントに関連しています。ただし、いくつかの違いがあり、NLP タスクの場合と同様に、事前トレーニング済みモデルを作成するときに、次の 2 つの違いを考慮する必要があります。

• 時系列データの密度は自然言語データの密度よりもはるかに低い
• NLPデータよりも長い時系列データが必要です

TSFormer の紹介

TSFormer は MAE のメイン アーキテクチャに似ています。データはエンコーダーを通過し、次にデコーダーを通過します。最終的な目標は、欠落した (人工的にマスクされた) データを再構築することです。

それを次の4つのポイントにまとめます。

1. マスキング

データがエンコーダーに入る前のステップとして。 入力シーケンス (Sᶦ) は長さが L の P 個のスライスに分散されています。したがって、次のタイムステップを予測するために使用されるスライディングウィンドウの長さは P XL です。

マスキング率は 75% です (MAE と同じパラメータを使用しているため、非常に高いように見えます)。自己教師ありタスクを完了しているため、データが少ないほどエンコーダーの計算が速くなります。

これを実行する主な理由（入力シーケンスのセグメントをマスクする）は次のとおりです。

• パッチは個々のポイントよりも優れています。
• 下流モデルの使用が簡単になります（STGNNは細胞セグメントを入力として受け取ります）
• エンコーダの入力サイズは分解できます。

クラス Patch(nn.Module):
 def __init__(self、patch_size、input_channel、output_channel、spectral=True):
スーパー().__init__()
自己.出力チャンネル = 出力チャンネル
self.P = パッチサイズ
自己入力チャンネル = 入力チャンネル
自己.出力チャンネル = 出力チャンネル
self.spectral = スペクトル
スペクトルの場合:
 self.emb_layer = nn.Linear(int(patch_size/2+1)*2, 出力チャンネル)
それ以外：
 self.input_embedding = nn.Conv2d(入力チャンネル、出力チャンネル、カーネルサイズ=(self.P, 1)、ストライド=(self.P, 1))
 def forward(自分自身、入力):
 B、N、C、L = 入力形状
自己スペクトルの場合:
 spec_feat_ = torch.fft.rfft(input.unfold(-1, self.P, self.P), dim=-1)
実数 = spec_feat_.実数
画像 = spec_feat_.画像
spec_feat = torch.cat([実数, 虚数], dim=-1).squeeze(2)
出力 = self.emb_layer(spec_feat).transpose(-1, -2)
それ以外：
 input = input.unsqueeze(-1) # B、N、C、L、1
 input = input.reshape(B*N, C, L, 1) # B*N, C, L, 1
出力 = self.input_embedding(入力) # B*N, d, L/P, 1
出力 = output.squeeze(-1).view(B, N, self.output_channel, -1)
 output.shape[-1] == L / self.P であるとアサートする
出力を返す

マスクを生成する関数は次のとおりです。

クラスMaskGenerator(nn.Module):
 def __init__(self、mask_size、mask_ratio、distribution='uniform'、lm=-1):
スーパー().__init__()
自己.mask_size = マスクサイズ
自己.mask_ratio = マスク比率
自己ソート = True
自己平均パッチ = lm
 self.distribution = 配布
self.distribution == "geom"の場合:
 lm != -1 をアサートする
['geom', 'uniform'] での分布をアサートする
定義uniform_rand(self):
マスク = リスト(範囲(int(self.mask_size)))
ランダムシャッフル(マスク)
マスクの長さ = int(self.mask_size * self.mask_ratio)
 self.masked_tokens = マスク[:mask_len]
 self.unmasked_tokens = マスク[マスク長:]
自己ソートの場合:
 self.masked_tokens = ソート済み(self.masked_tokens)
 self.unmasked_tokens = ソート済み(self.unmasked_tokens)
 self.unmasked_tokens、self.masked_tokensを返す
定義:
 mask = geom_noise_mask_single(self.mask_size, lm=self.average_patch, masking_ratio=self.mask_ratio) # 1: マスクあり、0: マスクなし
self.masked_tokens = np.where(mask)[0].tolist()
 self.unmasked_tokens = np.where(~mask)[0].tolist()
 # len(self.masked_tokens) > len(self.unmasked_tokens) をアサートする
self.unmasked_tokens、self.masked_tokensを返す
def forward(self):
 self.distribution == 'geom'の場合:
 self.unmasked_tokens、self.masked_tokens = self.geometric_rand()
 elif self.distribution == 'uniform':
 self.unmasked_tokens、self.masked_tokens = self.uniform_rand() です。
それ以外：
例外("ERROR")を発生させる
self.unmasked_tokens、self.masked_tokensを返す

2. コーディング

これには、入力埋め込み、位置エンコーディング、および Transformer ブロックが含まれます。 エンコーダーはマスクされていないパッチに対してのみ実行できます (これは MAE のアプローチでもあります)。

入力埋め込み

線形投影は、入力の埋め込みを取得するために使用され、マスクされていない空間を潜在空間に変換します。 その式は以下のとおりです。

W と B は学習可能なパラメータであり、U は次元のモデル入力ベクトルです。

位置エンコーディング

新しい連続情報を追加するには、単純な位置エンコーディング レイヤーを使用します。 「学習可能」という単語が追加され、sine よりも優れたパフォーマンスを示すのに役立ちます。 したがって、学習可能な位置埋め込みは時系列に対して良好な結果を示します。

クラス LearnableTemporalPositionalEncoding(nn.Module):
 def __init__(self, d_model, dropout=0.1, max_len: int = 1000):
スーパー().__init__()
 self.dropout = nn.Dropout(p=ドロップアウト)
 self.pe = nn.Parameter(torch.empty(max_len, d_model), requires_grad=True)
 nn.init.uniform_(自己.pe、-0.02、0.02)

 def forward(自己, X, インデックス):
インデックスがNoneの場合:
 pe = self.pe[:X.size(1), :].unsqueeze(0)
それ以外：
 pe = self.pe[インデックス].unsqueeze(0)
 X = X + ペ
X = 自己ドロップアウト(X)
 Xを返す
クラス PositionalEncoding(nn.Module):
 def __init__(self, hidden_​​dim, dropout=0.1):
スーパー().__init__()
 self.tem_pe = 学習可能な時間的位置エンコーディング(hidden_​​dim、ドロップアウト)
 def forward(self, input, index=None, abs_idx=None):
 B、N、L_P、d = 入力形状
# 時間的埋め込み
入力 = self.temp_pe(input.view(B*N, L_P, d), インデックス = インデックス)
入力 = input.view(B, N, L_P, d)
 # 絶対位置埋め込み
入力を返す

トランスブロック

この論文では 4 層のトランスフォーマーを使用していますが、これはコンピューター ビジョンや自然言語処理のタスクで一般的に使用される層数よりも少ない数です。ここで使用されるトランスフォーマーは、以下の図 4 に示すように、元の論文で言及されている最も基本的な構造です。

クラス TransformerLayers(nn.Module):
 def __init__(self, hidden_​​dim, nlayers, num_heads=4, dropout=0.1):
スーパー().__init__()
 self.d_model = 隠し次元
エンコーダーレイヤー = TransformerEncoderLayer(hidden_​​dim, num_heads, hidden_​​dim*4, ドロップアウト)
 self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)
 def forward(self, src):
 B、N、L、D = src.shape
 src = src * math.sqrt(self.d_model)
 src = src.view(B*N, L, D)
 src = src.transpose(0, 1)
出力 = self.transformer_encoder(src, マスク = なし)
出力 = output.transpose(0, 1).view(B, N, L, D)
出力を返す

3. デコード

デコーダーは一連の Transformer ブロックで構成されています。これはすべてのパッチに適用可能であり (対照的に、MAE ではパッチにすでに位置情報があるため位置埋め込みはありません)、レイヤーは 1 つだけであり、出力の長さが各パッチの長さに等しくなる単純な MLP を使用します。

4. 復興目標

各データポイント（i）に対してマスクされたパッチが計算され、メインシーケンスと再構築されたシーケンスの損失関数としてmae（平均絶対誤差）が選択されます。

これが全体的なアーキテクチャです。

コードの実装は次のとおりです。

定義trunc_normal_(テンソル、平均=0.、標準偏差=1.):
 __call_trunc_normal_(テンソル、平均=平均、標準偏差=標準偏差、a=-標準偏差、b=標準偏差)
 def unshuffle(shuffled_tokens):
辞書 = {}
 enumerate(shuffled_tokens) 内の k、v について:
 dic[v] = k
アンシャッフルインデックス = []
 i が範囲(len(shuffled_tokens))内にある場合:
 unshuffle_index.append(dic[i])
 unshuffle_indexを返す
クラス TSFormer(nn.Module):
 def __init__(self、patch_size、in_channel、out_channel、dropout、mask_size、mask_ratio、L=6、distribution='uniform'、lm=-1、selected_feature=0、mode='Pretrain'、spectral=True):
スーパー().__init__()
自己.patch_size = パッチサイズ
self.seleted_feature = 選択された機能
自己.mode = モード
self.spectral = スペクトル
self.patch = Patch(patch_size, in_channel, out_channel, spectral=スペクトル)
 self.pe = 位置エンコーディング(out_channel、ドロップアウト=ドロップアウト)
 self.mask = MaskGenerator(mask_size、mask_ratio、distribution=分布、lm=lm)
 self.encoder = TransformerLayers(out_channel, L)
 self.decoder = TransformerLayers(out_channel, 1)
 self.encoder_2_decoder = nn.Linear(out_channel, out_channel)
 self.mask_token = nn.Parameter(torch.zeros(1, 1, 1, out_channel))
 trunc_normal_(self.mask_token、std=.02) を返します。
自己スペクトルの場合:
 self.output_layer = nn.Linear(out_channel, int(patch_size/2+1)*2)
それ以外：
 self.output_layer = nn.Linear(out_channel, patch_size)
 def _forward_pretrain(自己、入力):
 B、N、C、L = 入力形状
# パッチを取得し、入力埋め込みを実行する
パッチ = self.patch(入力)
パッチ = パッチ.転置(-1, -2)
 # 位置埋め込み
パッチ = self.pe(パッチ)

 # マスクトークン
マスクされていないトークンインデックス、マスクされたトークンインデックス = self.mask()
エンコーダ入力 = パッチ[:, :, マスクされていないトークンインデックス, :]
 # エンコーダー
H = 自己.エンコーダ(エンコーダ入力)
 # エンコーダからデコーダへ
H = self.encoder_2_decoder(H)
 # デコーダー
# H_unmasked = self.pe(H, インデックス=unmasked_token_index)
 H_マスクなし = H
 H_masked = self.pe(self.mask_token.expand(B, N, len(masked_token_index), H.shape[-1]), index=masked_token_index)
 H_full = torch.cat([H_unmasked, H_masked], dim=-2) # # B、N、L/P、d
 H = 自己デコーダー(H_full)
 # 出力層
自己スペクトルの場合:
 # 出力 = H
 spec_feat_H_ = 自己.出力レイヤー(H)
実数 = spec_feat_H_[..., :int(self.patch_size/2+1)]
画像 = spec_feat_H_[..., int(self.patch_size/2+1):]
 spec_feat_H = torch.complex(実数、虚数)
 out_full = torch.fft.irfft(spec_feat_H)
それ以外：
 out_full = 自己.出力レイヤー(H)
 # 損失を準備する
B、N、_、_ = アウトフルシェイプ
out_masked_tokens = out_full[:, :, len(unmasked_token_index):, :]
 out_masked_tokens = out_masked_tokens.view(B, N, -1).transpose(1, 2)
 label_full = input.permute(0, 3, 1, 2).unfold(1, self.patch_size, self.patch_size)[:, :, :, self.seleted_feature, :].transpose(1, 2) # B、N、L/P、P
 label_masked_tokens = label_full[:, :, masked_token_index, :].contiguous()
 label_masked_tokens = label_masked_tokens.view(B, N, -1).transpose(1, 2)
 # プロットを準備する
## output_fullとlabel_fullが揃っていないことに注意してください。shuffledのout_fullは
### したがって、プロットのシャッフルを解除します
アンシャッフルされたインデックス = アンシャッフル(マスクされていないトークンインデックス + マスクされたトークンインデックス)
 out_full_unshuffled = out_full[:, :, unshuffled_index, :]
プロット引数 = {}
 plot_args['out_full_unshuffled'] = out_full_unshuffled
 plot_args['label_full'] = label_full
 plot_args['unmasked_token_index'] = マスクされていないトークンインデックス
plot_args['マスクされたトークンインデックス'] = マスクされたトークンインデックス
out_masked_tokens、label_masked_tokens、plot_args を返す
def _forward_backend(自分自身、入力):
 B、N、C、L = 入力形状
# パッチを取得し、入力埋め込みを実行する
パッチ = self.patch(入力)
パッチ = パッチ.転置(-1, -2)
 # 位置埋め込み
パッチ = self.pe(パッチ)
 encoding_input = patches # バックエンドを実行するときにマスクなし。
 # エンコーダー
H = 自己.エンコーダ(エンコーダ_入力)
 Hを返す
def forward(self, input_data):

 self.mode == 'Pretrain'の場合:
 self._forward_pretrain(input_data) を返します。
それ以外：
 self._forward_backend(input_data) を返します。

この論文を読んでみて、基本的にはMAEのコピー、つまり時系列用のMAEと言えることがわかりました。予測段階もMAEに似ており、エンコーダの出力を特徴として使用して、下流のタスクの入力として特徴データを提供します。興味があれば、元の論文を読んで、論文に記載されているコードを見てください。