마크리다키스 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 대회에서 우승한 것 외에도 다음과 같은 더 많은 진전을 이루었습니다.
이 문서에서는 시계열 예측을 전문으로 하는 5가지 딥 러닝 아키텍처에 대해 설명합니다. 논문은 다음과 같습니다.
이 패턴은 (불행히도) 단명한 ElementAI 회사에서 직접 나온 것입니다. 이 회사는 Yoshua Bengio가 공동 설립했습니다. 최상위 아키텍처와 주요 구성 요소는 그림 1에 나와 있습니다.
N-BEATS는 순방향 및 역방향 연결을 통해 상호 연결되는 통합 피드포워드 네트워크의 딥 스택을 기반으로 하는 순수 딥 러닝 아키텍처입니다. .
각 블록은 이전 백캐스트에서 생성된 잔여 오류만 모델링한 다음 이 오류를 기반으로 예측을 업데이트합니다. 이 프로세스는 ARIMA 모델을 피팅할 때 Box-Jenkins 방법을 시뮬레이션합니다.
다음은 이 모델의 주요 장점입니다.
표현력 및 사용 용이성: 모델은 이해하기 쉽고 모듈식 구조를 가지며 최소한의 시계열 특성 엔지니어링이 필요하고 입력 확장이 필요하지 않도록 설계되었습니다.
모델에는 여러 시계열에 걸쳐 일반화하는 기능이 있습니다. 즉, 분포가 약간 다른 다양한 시계열을 입력으로 사용할 수 있습니다. N-BEATS에서는 메타러닝을 통해 구현됩니다. 메타러닝 과정은 내부 학습 과정과 외부 학습 과정의 두 가지 과정으로 구성됩니다. 내부 학습 프로세스는 블록 내부에서 발생하며 모델이 로컬 시간적 특징을 포착하는 데 도움이 됩니다. 외부 학습 프로세스는 레이어 스택에서 발생하며 모델이 모든 시계열의 전역 기능을 학습하는 데 도움이 됩니다.
이중 잔여 스태킹: 잔여 연결 및 스태킹 아이디어는 매우 영리하며 거의 모든 유형의 심층 신경망에서 사용됩니다. 동일한 원칙이 N-BEATS 구현에 적용되지만 몇 가지 추가 수정이 있습니다. 각 블록에는 두 개의 잔여 분기가 있습니다. 하나는 룩백 윈도우(백캐스트라고 함)에서 실행되고 다른 하나는 예측 윈도우(예측을 위해 호출됨)에서 실행됩니다.
각 연속 블록은 이전 블록의 재구성된 백캐스트에서 발생한 잔차만 모델링한 다음 해당 오류를 기반으로 예측을 업데이트합니다. 이는 모델이 유용한 백캐스트 신호를 더 잘 근사화하는 데 도움이 되며, 최종 스택 예측 예측은 모든 부분 예측의 계층적 합계로 모델링됩니다. ARIMA 모델의 Box-Jenkins 방법을 시뮬레이션하는 것이 바로 이 프로세스입니다.
해석 가능성: 모델은 보편적인 것과 해석 가능한 것의 두 가지 변형으로 제공됩니다. 일반 변형에서는 네트워크가 각 블록의 완전 연결 레이어의 최종 가중치를 임의로 학습합니다. 해석 가능한 변형에서는 각 블록의 마지막 레이어가 제거됩니다. 그런 다음 백캐스트 및 예측 분기에 추세(단조 함수) 및 계절성(순환 순환 함수)을 시뮬레이션하는 특정 행렬이 곱해집니다.
참고: 원래 N-BEATS 구현은 단변량 시계열에서만 작동합니다.
딥 러닝과 자동 회귀 기능을 결합한 새로운 시계열 모델입니다. 그림 2는 DeepAR의 최상위 아키텍처를 보여줍니다.
이 모델의 주요 장점은 다음과 같습니다.
DeepAR은 여러 시계열에서 매우 잘 작동합니다. 전역 모델은 분포가 약간 다른 여러 시계열을 사용하여 구축됩니다. 많은 실제 시나리오에도 적용 가능합니다. 예를 들어, 전력 회사는 각 고객에 대해 전력 예측 서비스를 시작하려고 할 수 있습니다. 각 고객은 서로 다른 소비 패턴(즉, 서로 다른 분포를 의미)을 가지고 있습니다.
DeepAR은 과거 데이터 외에도 알려진 미래 시계열(자동 회귀 모델의 특징) 및 추가 정적 속성을 사용할 수도 있습니다. 앞서 언급한 전력 수요 예측 시나리오에서 추가 시간 변수는 월(1-12 사이의 값을 갖는 정수)이 될 수 있습니다. 각 고객이 전력 소비를 측정하는 센서와 연결되어 있다고 가정하면 추가 정적 변수는 sensor_id 또는 customer_id와 같습니다.
시계열 예측을 위해 MLP 및 RNN과 같은 신경망 아키텍처를 사용하는 데 익숙하다면 주요 전처리 단계는 정규화 또는 정규화 기술을 사용하여 시계열을 확장하는 것입니다. 기본 모델이 각 시계열 i에 대한 자동 회귀 입력 z를 해당 시계열의 평균인 배율 인수 v_i로 조정하기 때문에 DeepAR에서는 수동 작업이 필요하지 않습니다. 구체적으로 논문의 벤치마크에 사용된 스케일링 계수 방정식은 다음과 같습니다.
그러나 실제로 대상 시계열의 크기가 크게 달라지는 경우 여전히 전처리 중에 자체 스케일링을 적용해야 합니다. 예를 들어, 에너지 수요 예측 시나리오에서 데이터 세트에는 중간 전압 고객(예: 소규모 공장, 메가와트 단위로 전기 소비)과 저전압 고객(예: 킬로와트 단위로 전기 소비)이 포함될 수 있습니다.
DeepAR은 미래 값을 직접 출력하는 대신 확률론적 예측을 합니다. 이는 몬테카를로 샘플로 수행됩니다. 이러한 예측은 분위수 손실 함수를 사용하여 분위수 예측을 계산하는 데 사용됩니다. 이러한 유형의 손실에 익숙하지 않은 사람들을 위해 분위수 손실은 추정치뿐만 아니라 해당 값에 대한 예측 간격을 계산하는 데 사용됩니다.
시간 의존성은 단변량 시계열에서 가장 중요합니다. 그러나 여러 시계열 시나리오에서는 상황이 그렇게 간단하지 않습니다. 예를 들어 일기 예보 작업이 있고 5개 도시의 기온을 예측한다고 가정해 보겠습니다. 이 도시들이 한 국가에 속해 있다고 가정해 봅시다. 지금까지 살펴본 내용을 바탕으로 DeepAR을 사용하고 각 도시를 외부 정적 공변량으로 모델링할 수 있습니다.
즉, 모델은 시간과 공간 관계를 모두 고려합니다. 이것이 Spacetimeformer의 핵심 아이디어입니다. 모델을 사용하여 이러한 도시/장소 간의 공간적 관계를 활용하고, 모델이 시간적 관계와 공간적 관계를 모두 고려하므로 추가로 유용한 종속성을 학습합니다.
이름에서 알 수 있듯이 이 모델은 내부적으로 트랜스포머 기반 구조를 사용합니다. 시계열 예측을 위해 변환기 기반 모델을 사용할 때 시간 인식 임베딩을 생성하는 데 널리 사용되는 기술은 Time2Vec [6] 임베딩 레이어를 통해 입력을 전달하는 것입니다(NLP 작업의 경우 Time2Vec 대신 위치 인코딩 벡터가 사용됨). 이 기술은 일변량 시계열에는 효과적이지만 다변량 시간 입력에는 적합하지 않습니다. 언어 모델링에서는 문장의 각 단어가 임베딩으로 표현되고 단어는 본질적으로 어휘의 일부인 반면 시계열은 그렇게 간단하지 않을 수 있습니다.
다변수 시계열에서 주어진 시간 단계 t에서 입력은 x_1,t, x2,t, x_m,t 형식입니다. 여기서 x_i,t는 특성 i의 값이고 m은 총 특성 수입니다. /시퀀스. Time2Vec 레이어를 통해 입력을 전달하면 시간적 임베딩 벡터가 생성됩니다. 이 임베딩은 실제로 무엇을 나타냅니까? 대답은 전체 입력 컬렉션을 단일 엔터티(토큰)로 표현한다는 것입니다. 따라서 모델은 시간 단계 사이의 시간적 역학만 학습하지만 특성/변수 간의 공간적 관계는 놓치게 됩니다.
Spacetimeformer는 입력을 시공간 시퀀스라는 큰 벡터로 평면화하여 이 문제를 해결합니다. 입력에 T 시간 단계로 구성된 N 변수가 포함되어 있는 경우 결과 시공간 시퀀스에는 (NxT) 레이블이 표시됩니다. 아래 그림 3은 이를 더 잘 보여줍니다.
논문에서는 다음과 같이 지적합니다. "(1) 시간 정보가 포함된 다변량 입력 형식. 디코더 입력에는 예측 시 누락된("?") 값이 있으며 0으로 설정됩니다. (2) 시계열은 Time2Vec을 통해 전달됩니다. (3) 이진 임베딩은 값이 컨텍스트로 제공되는지 아니면 예측이 필요한지 여부를 나타냅니다. (4) 각 시계열의 정수 인덱스를 "공간"에 매핑합니다. 5) 피드포워드 레이어를 활용하여 각 시계열의 Time2Vec 임베딩 및 변수 값을 투영합니다. (6) 값과 시간, 변수 및 주어진 임베딩을 합산하면 시간과 시간 사이의 MSA가 길어집니다.
즉, 최종 시퀀스는 시간적, 공간적, 맥락적 정보를 포함하는 통합 임베딩을 인코딩합니다. 그러나 이 방법의 단점은 시퀀스가 매우 길어져 리소스가 2차적으로 증가할 수 있다는 것입니다. . Attention 메커니즘에 따라 각 토큰이 서로 확인되기 때문입니다.
Temporal Fusion Transformer(TFT)는 Transformer 기반입니다. Google에서 출시한 시계열 예측 모델은 이전 모델보다 다재다능합니다. TFT의 최상위 아키텍처는 그림 4에 나와 있습니다. :앞서 언급한 모델과 마찬가지로 TFT는 여러 이종 시계열에 대한 모델 구축을 지원합니다. TFT 세 가지 유형의 기능을 지원합니다: i) 미래 입력이 알려진 시변 데이터 ii) 지금까지 알려진 시변 데이터 iii) 시불변 기능이라고도 알려진 범주형/정적 변수. 이전 모델에서 언급한 전력 수요 예측 시나리오에서는 습도 수준을 시간에 따라 변하는 기능으로 사용하려고 합니다. 이는 TFT에서만 가능하지만 DeepAR에서는 가능하지 않습니다.
그림 5는 그 예를 보여줍니다.
TSFormer
Transformer(TSFormer)를 기반으로 한 비지도 시계열 사전 훈련 모델로, MAE의 훈련 전략을 사용하고 데이터에서 매우 긴 종속성을 포착할 수 있습니다.
NLP와 시계열:
NLP 정보와 시계열 데이터는 어느 정도 동일합니다. 이는 순차 데이터와 지역성을 모두 구분합니다. 즉, 다음/이전 데이터 지점을 기준으로 합니다. 그러나 여전히 몇 가지 차이점이 있으며 NLP 작업에서와 마찬가지로 사전 훈련된 모델을 만들 때 고려해야 할 두 가지 차이점이 있습니다.
시계열 데이터의 밀도는 자연어 데이터보다 훨씬 낮습니다.NLP 데이터보다 긴 시계열 데이터가 필요합니다
TSFormer 소개
다음 4가지로 요약합니다.
은 데이터가 인코더에 들어가기 전 첫 번째 단계입니다. 입력 시퀀스(Sᶦ)는 길이가 L인 P 슬라이스로 분산되었습니다. 따라서 다음 시간 단계를 예측하는 데 사용되는 슬라이딩 윈도우의 길이는 P XL입니다.
마스킹 비율은 75%입니다(아마도 MAE와 동일한 매개변수를 사용하기 때문에 매우 높아 보입니다). 우리가 완료하려는 작업은 자체 감독 작업이므로 데이터가 적을수록 인코더의 계산이 빨라집니다. 속도.
이 작업을 수행하는 주된 이유(입력 시퀀스 세그먼트 마스킹)는 다음과 같습니다.
class Patch(nn.Module):<br>def __init__(self, patch_size, input_channel, output_channel, spectral=True):<br>super().__init__()<br>self.output_channel = output_channel<br>self.P = patch_size<br>self.input_channel = input_channel<br>self.output_channel = output_channel<br>self.spectral = spectral<br>if spectral:<br>self.emb_layer = nn.Linear(int(patch_size/2+1)*2, output_channel)<br>else:<br>self.input_embedding = nn.Conv2d(input_channel, output_channel, kernel_size=(self.P, 1), stride=(self.P, 1))<br>def forward(self, input):<br>B, N, C, L = input.shape<br>if self.spectral:<br>spec_feat_ = torch.fft.rfft(input.unfold(-1, self.P, self.P), dim=-1)<br>real = spec_feat_.real<br>imag = spec_feat_.imag<br>spec_feat = torch.cat([real, imag], dim=-1).squeeze(2)<br>output = self.emb_layer(spec_feat).transpose(-1, -2)<br>else:<br>input = input.unsqueeze(-1) # B, N, C, L, 1<br>input = input.reshape(B*N, C, L, 1) # B*N, C, L, 1<br>output = self.input_embedding(input) # B*N, d, L/P, 1<br>output = output.squeeze(-1).view(B, N, self.output_channel, -1)<br>assert output.shape[-1] == L / self.P<br>return output
마스킹을 생성하는 함수는 다음과 같습니다.
class MaskGenerator(nn.Module):<br>def __init__(self, mask_size, mask_ratio, distribution='uniform', lm=-1):<br>super().__init__()<br>self.mask_size = mask_size<br>self.mask_ratio = mask_ratio<br>self.sort = True<br>self.average_patch = lm<br>self.distribution = distribution<br>if self.distribution == "geom":<br>assert lm != -1<br>assert distribution in ['geom', 'uniform']<br>def uniform_rand(self):<br>mask = list(range(int(self.mask_size)))<br>random.shuffle(mask)<br>mask_len = int(self.mask_size * self.mask_ratio)<br>self.masked_tokens = mask[:mask_len]<br>self.unmasked_tokens = mask[mask_len:]<br>if self.sort:<br>self.masked_tokens = sorted(self.masked_tokens)<br>self.unmasked_tokens = sorted(self.unmasked_tokens)<br>return self.unmasked_tokens, self.masked_tokens<br>def geometric_rand(self):<br>mask = geom_noise_mask_single(self.mask_size, lm=self.average_patch, masking_ratio=self.mask_ratio) # 1: masked, 0:unmasked<br>self.masked_tokens = np.where(mask)[0].tolist()<br>self.unmasked_tokens = np.where(~mask)[0].tolist()<br># assert len(self.masked_tokens) > len(self.unmasked_tokens)<br>return self.unmasked_tokens, self.masked_tokens<br>def forward(self):<br>if self.distribution == 'geom':<br>self.unmasked_tokens, self.masked_tokens = self.geometric_rand()<br>elif self.distribution == 'uniform':<br>self.unmasked_tokens, self.masked_tokens = self.uniform_rand()<br>else:<br>raise Exception("ERROR")<br>return self.unmasked_tokens, self.masked_tokens에는 입력 임베딩, 위치 인코딩 및 Transformer 블록이 포함됩니다. 인코더는 마스크되지 않은 패치에서만 실행될 수 있습니다(이것은 MAE 방법이기도 함).
선형 투영을 사용하여 마스크되지 않은 공간을 잠재 공간으로 변환하는 입력 임베딩을 얻습니다. 공식은 아래에서 볼 수 있습니다.
W와 B는 학습 가능한 매개변수이고 U는 차원의 모델 입력 벡터입니다.
간단한 위치 인코딩 레이어는 새로운 순차 정보를 추가하는 데 사용됩니다. 사인보다 더 나은 성능을 표시하는 데 도움이 되는 "학습 가능"이라는 단어가 추가되었습니다. 따라서 학습 가능한 위치 임베딩은 시계열에 대해 좋은 결과를 보여줍니다.
class LearnableTemporalPositionalEncoding(nn.Module):<br>def __init__(self, d_model, dropout=0.1, max_len: int = 1000):<br>super().__init__()<br>self.dropout = nn.Dropout(p=dropout)<br>self.pe = nn.Parameter(torch.empty(max_len, d_model), requires_grad=True)<br>nn.init.uniform_(self.pe, -0.02, 0.02)<br><br>def forward(self, X, index):<br>if index is None:<br>pe = self.pe[:X.size(1), :].unsqueeze(0)<br>else:<br>pe = self.pe[index].unsqueeze(0)<br>X = X + pe<br>X = self.dropout(X)<br>return X<br>class PositionalEncoding(nn.Module):<br>def __init__(self, hidden_dim, dropout=0.1):<br>super().__init__()<br>self.tem_pe = LearnableTemporalPositionalEncoding(hidden_dim, dropout)<br>def forward(self, input, index=None, abs_idx=None):<br>B, N, L_P, d = input.shape<br># temporal embedding<br>input = self.tem_pe(input.view(B*N, L_P, d), index=index)<br>input = input.view(B, N, L_P, d)<br># absolute positional embedding<br>return input
이 논문에서는 4개 레이어의 Transformer를 사용하는데, 이는 컴퓨터 비전 및 자연어 처리 작업에서 일반적인 것보다 적은 수입니다. 여기에 사용된 Transformer는 아래 그림 4와 같이 원본 논문에서 언급된 가장 기본적인 구조입니다.
class TransformerLayers(nn.Module):<br>def __init__(self, hidden_dim, nlayers, num_heads=4, dropout=0.1):<br>super().__init__()<br>self.d_model = hidden_dim<br>encoder_layers = TransformerEncoderLayer(hidden_dim, num_heads, hidden_dim*4, dropout)<br>self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)<br>def forward(self, src):<br>B, N, L, D = src.shape<br>src = src * math.sqrt(self.d_model)<br>src = src.view(B*N, L, D)<br>src = src.transpose(0, 1)<br>output = self.transformer_encoder(src, mask=None)<br>output = output.transpose(0, 1).view(B, N, L, D)<br>return output
디코더에는 일련의 Transformer 블록이 포함되어 있습니다. 모든 패치에 적용되며(반대로 MAE는 패치에 이미 위치 정보가 있으므로 위치 임베딩이 없음) 레이어 수는 단 하나이며 간단한 MLP를 사용하여 출력 길이를 각 패치와 동일하게 만듭니다. 길이.
각 데이터 포인트(i)에 대한 마스킹 패치를 계산하고, 주 시퀀스와 재구성된 시퀀스의 손실 함수로 mae(Mean-Absolute-Error)를 선택합니다.
전체 아키텍처입니다
다음은 코드 구현입니다.
def trunc_normal_(tensor, mean=0., std=1.):<br>__call_trunc_normal_(tensor, mean=mean, std=std, a=-std, b=std)<br>def unshuffle(shuffled_tokens):<br>dic = {}<br>for k, v, in enumerate(shuffled_tokens):<br>dic[v] = k<br>unshuffle_index = []<br>for i in range(len(shuffled_tokens)):<br>unshuffle_index.append(dic[i])<br>return unshuffle_index<br>class TSFormer(nn.Module):<br>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):<br>super().__init__()<br>self.patch_size = patch_size<br>self.seleted_feature = selected_feature<br>self.mode = mode<br>self.spectral = spectral<br>self.patch = Patch(patch_size, in_channel, out_channel, spectral=spectral)<br>self.pe = PositionalEncoding(out_channel, dropout=dropout)<br>self.mask = MaskGenerator(mask_size, mask_ratio, distribution=distribution, lm=lm)<br>self.encoder = TransformerLayers(out_channel, L)<br>self.decoder = TransformerLayers(out_channel, 1)<br>self.encoder_2_decoder = nn.Linear(out_channel, out_channel)<br>self.mask_token = nn.Parameter(torch.zeros(1, 1, 1, out_channel))<br>trunc_normal_(self.mask_token, std=.02)<br>if self.spectral:<br>self.output_layer = nn.Linear(out_channel, int(patch_size/2+1)*2)<br>else:<br>self.output_layer = nn.Linear(out_channel, patch_size)<br>def _forward_pretrain(self, input):<br>B, N, C, L = input.shape<br># get patches and exec input embedding<br>patches = self.patch(input) <br>patches = patches.transpose(-1, -2) <br># positional embedding<br>patches = self.pe(patches)<br><br># mask tokens<br>unmasked_token_index, masked_token_index = self.mask()<br>encoder_input = patches[:, :, unmasked_token_index, :] <br># encoder<br>H = self.encoder(encoder_input) <br># encoder to decoder<br>H = self.encoder_2_decoder(H)<br># decoder<br># H_unmasked = self.pe(H, index=unmasked_token_index)<br>H_unmasked = H<br>H_masked = self.pe(self.mask_token.expand(B, N, len(masked_token_index), H.shape[-1]), index=masked_token_index)<br>H_full = torch.cat([H_unmasked, H_masked], dim=-2) # # B, N, L/P, d<br>H = self.decoder(H_full)<br># output layer<br>if self.spectral:<br># output = H<br>spec_feat_H_ = self.output_layer(H)<br>real = spec_feat_H_[..., :int(self.patch_size/2+1)]<br>imag = spec_feat_H_[..., int(self.patch_size/2+1):]<br>spec_feat_H = torch.complex(real, imag)<br>out_full = torch.fft.irfft(spec_feat_H)<br>else:<br>out_full = self.output_layer(H)<br># prepare loss<br>B, N, _, _ = out_full.shape <br>out_masked_tokens = out_full[:, :, len(unmasked_token_index):, :]<br>out_masked_tokens = out_masked_tokens.view(B, N, -1).transpose(1, 2)<br>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<br>label_masked_tokens = label_full[:, :, masked_token_index, :].contiguous()<br>label_masked_tokens = label_masked_tokens.view(B, N, -1).transpose(1, 2)<br># prepare plot<br>## note that the output_full and label_full are not aligned. The out_full in shuffled<br>### therefore, unshuffle for plot<br>unshuffled_index = unshuffle(unmasked_token_index + masked_token_index)<br>out_full_unshuffled = out_full[:, :, unshuffled_index, :]<br>plot_args = {}<br>plot_args['out_full_unshuffled'] = out_full_unshuffled<br>plot_args['label_full'] = label_full<br>plot_args['unmasked_token_index'] = unmasked_token_index<br>plot_args['masked_token_index'] = masked_token_index<br>return out_masked_tokens, label_masked_tokens, plot_args<br>def _forward_backend(self, input):<br>B, N, C, L = input.shape<br># get patches and exec input embedding<br>patches = self.patch(input) <br>patches = patches.transpose(-1, -2) <br># positional embedding<br>patches = self.pe(patches)<br>encoder_input = patches # no mask when running the backend.<br># encoder<br>H = self.encoder(encoder_input) <br>return H<br>def forward(self, input_data):<br><br>if self.mode == 'Pretrain':<br>return self._forward_pretrain(input_data)<br>else:<br>return self._forward_backend(input_data)이 문서를 읽은 후 이것이 기본적으로 MAE의 복사본, 또는 시계열의 MAE라고 할 수 있다는 것을 알았습니다. 예측 단계도 MAE와 유사하며, 인코더의 출력을 기능으로 사용하고 기능 데이터를 다운스트림 작업에 대한 입력으로 제공합니다. 관심이 있는 경우 원본 논문을 읽고 논문에 제공된 코드를 살펴보세요. .
위 내용은 시계열 예측을 위한 5가지 딥러닝 모델 비교 요약의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
