- [’23 ICLR] PatchTST : A TIME SERIES IS WORTH 64 WORDS: LONG-TERM FORECASTING WITH TRANSFORMERS
- [’24 ICLR] ITRANSFORMER: INVERTED TRANSFORMERS ARE EFFECTIVE FOR TIME SERIES FORECASTING
- [’21 NeurIPS] Autoformer: Decomposition Transformers with Auto-Correlation for Long-Term Series Forecasting
1. 들어가며
시계열 예측은 금융, 에너지, 교통, 기후 변화 등 다양한 분야에서 필수적인 역할을 합니다. 정확한 시계열 예측을 통해 기업은 더 나은 의사 결정을 내릴 수 있으며, 효율적인 자원 관리와 리스크 예측이 가능해집니다. 최근 몇 년 동안 Transformer 기반 모델들이 자연어 처리(NLP) 분야에서 강력한 성능을 보이며 주목받았고, 이를 시계열 예측 문제에도 적용하려는 연구가 활발히 진행되었습니다.
기존의 시계열 예측 모델들은 RNN(Recurrent Neural Network)과 LSTM(Long Short-Term Memory)을 기반으로 설계되었지만, 긴 시계열 데이터를 다루는 데 한계를 가졌습니다. Transformer 기반 모델들은 self-attention을 활용하여 긴 시퀀스에서도 장기적인 의존성을 학습할 수 있는 강점을 가지며, 이를 활용한 시계열 예측 연구가 주목받기 시작했습니다. 하지만 Transformer 기반 시계열 모델들은 몇 가지 근본적인 문제점을 가지고 있습니다.
먼저, 기존 Transformer 기반 모델들은 self-attention 연산을 통해 모든 시점 간의 관계를 학습하는 방식을 사용합니다. 이 방식은 NLP와 같은 자연어 처리 작업에서는 효과적일 수 있지만, 시계열 데이터에서는 계산량이 급격히 증가하는 문제가 발생합니다. 특히, 입력 길이가 길어질수록 self-attention의 연산량이 O(N^2)으로 증가하여 실용적인 시계열 예측 모델로 활용하기 어려운 한계가 있습니다.
또한, Transformer 모델들은 일반적으로 point-wise self-attention을 사용하기 때문에, 시계열의 연속적인 패턴을 온전히 반영하지 못하는 문제가 있습니다. 시계열 데이터는 시간에 따른 흐름과 주기성을 가지는 특성이 있는데, 기존 Transformer 기반 모델들은 개별 시점 간의 관계를 독립적으로 학습하는 방식이므로 전체적인 시계열 구조를 제대로 반영하지 못할 가능성이 큽니다. 이러한 문제는 특히 장기 시계열 예측에서 성능 저하로 이어질 수 있습니다.
이러한 문제를 해결하기 위해 Autoformer가 제안되었습니다. Autoformer는 기존 Transformer 모델이 가진 단점을 극복하기 위해 Decomposition Mechanism과 Autocorrelation Mechanism을 도입한 새로운 구조의 시계열 예측 모델입니다. Decomposition Mechanism을 통해 입력 데이터를 추세(trend) 성분과 계절성(seasonal) 성분으로 분해하여 시계열 구조를 보다 효과적으로 학습할 수 있도록 하였으며, Autocorrelation Mechanism을 활용하여 self-attention을 대체하면서도 연산량을 줄이고, 시계열의 장기적인 주기성을 강조하는 방식으로 모델을 개선하였습니다.
이번 포스팅에서는 기존 Transformer 기반 시계열 모델이 가진 한계를 분석하고, Autoformer가 이를 어떻게 해결하는지 자세히 살펴보겠습니다. 또한, 실험 결과를 통해 Autoformer가 기존 모델들과 비교하여 얼마나 우수한 성능을 보이는지 평가하고, 마지막으로 Autoformer의 강점과 한계를 정리하겠습니다. 먼저, 기존 Transformer 기반 시계열 모델의 한계를 살펴보겠습니다.
2. 기존 방법의 한계
Transformer 모델은 자연어 처리(NLP) 분야에서 뛰어난 성능을 보이며 주목받았고, 이후 시계열 예측 문제에도 적용되기 시작했습니다. 하지만 시계열 데이터는 NLP에서 다루는 데이터와 몇 가지 근본적인 차이를 가지며, 기존 Transformer 구조가 이러한 특성을 충분히 반영하지 못한다는 한계가 존재합니다. 특히, self-attention 연산의 특성상 계산량이 급격히 증가하고, 시계열의 연속적인 패턴을 제대로 반영하지 못하는 문제가 발생합니다.
2.1 Self-attention 연산의 계산량 문제
Transformer 기반 모델에서 사용하는 self-attention 연산은 입력 길이에 대해 이차적인 연산량 증가를 초래합니다. 즉, 입력 데이터의 길이가 N일 때 self-attention의 연산량은 O(N^2)에 비례하여 증가하게 됩니다. 자연어 처리에서는 문장이 비교적 짧은 길이를 가지기 때문에 이러한 연산량 증가가 큰 문제가 되지 않지만, 시계열 데이터에서는 입력 길이가 길어질수록 계산 비용이 기하급수적으로 증가하는 문제가 발생합니다.
예를 들어, 금융 데이터나 기후 데이터와 같은 시계열 데이터는 수천 개의 연속적인 시점(time step) 데이터를 입력으로 사용해야 할 수도 있습니다. 하지만 기존 Transformer 기반 모델들은 이러한 긴 시계열 데이터를 다룰 때 효율적으로 학습하기 어렵습니다. 특히, 장기 예측을 수행하기 위해 입력 길이를 늘릴 경우, self-attention 연산의 높은 계산 비용으로 인해 학습과 추론 속도가 느려지고, 메모리 사용량이 급증하는 문제가 발생합니다.
2.2 Point-wise Self-attention의 한계
Transformer 모델에서 사용되는 self-attention은 입력 데이터의 각 위치마다 독립적으로 가중치를 계산하는 방식입니다. 이는 자연어 처리와 같이 개별 단어의 관계를 학습해야 하는 경우에는 적절한 방식일 수 있지만, 시계열 데이터에서는 적합하지 않을 수 있습니다.
시계열 데이터는 본질적으로 연속적인 패턴을 가지며, 시점 간의 관계가 강하게 유지되는 특성이 있습니다. 하지만 기존 Transformer 모델들은 self-attention을 통해 개별 시점의 가중치를 독립적으로 계산하기 때문에, 연속적인 패턴을 충분히 반영하지 못하는 한계가 있습니다. 다시 말해, 기존 모델들은 특정 시점에서의 중요도를 학습할 수 있지만, 전체적인 시계열 흐름을 효과적으로 포착하는 데에는 어려움이 있습니다.
이러한 문제로 인해, Transformer 기반 시계열 모델들은 종종 과적합(overfitting) 문제를 겪거나, 장기 예측 성능이 기대만큼 향상되지 않는 경우가 많습니다. 특히, 계절성과 같은 장기적인 주기성을 고려해야 하는 시계열 데이터에서는 이러한 문제가 더욱 두드러지게 나타납니다.
2.3 기존 Transformer 기반 모델들의 해결 시도
기존 연구들에서는 Transformer 모델의 이러한 문제를 해결하기 위해 다양한 방법을 시도해 왔습니다. Sparse Transformer와 같은 모델은 self-attention의 계산량을 줄이기 위해 일부 연결만을 학습하도록 하였고, Informer는 self-attention의 일부 연산을 샘플링 방식으로 최적화하여 연산량을 줄이는 방법을 제안하였습니다. 하지만 이러한 방법들은 여전히 self-attention 구조 자체를 유지하기 때문에 근본적인 연산량 문제를 완전히 해결하지는 못했습니다.
결과적으로, Transformer 기반 시계열 예측 모델들은 self-attention의 높은 계산량과 point-wise attention 방식으로 인해 시계열의 연속적인 패턴을 효과적으로 학습하지 못하는 문제가 존재합니다. 이러한 한계를 극복하기 위해 Autoformer에서는 self-attention을 대체하는 Autocorrelation Mechanism과 시계열 데이터를 효과적으로 분해하는 Decomposition Block을 제안하였습니다. 다음 장에서는 Autoformer가 기존 모델들과 어떻게 차별화되는지 살펴보겠습니다.
3. 제안 방법 : Autoformer
Autoformer는 Transformer 기반 시계열 예측 모델이 가진 한계를 해결하기 위해 두 가지 핵심 기법을 도입했습니다. 첫 번째는 Decomposition Mechanism으로, 입력 데이터를 추세(trend)와 계절성(seasonal) 성분으로 분해하여 시계열 패턴을 더 효과적으로 학습할 수 있도록 합니다. 두 번째는 Autocorrelation Mechanism으로, self-attention을 대체하여 주기성을 강조하는 연산을 수행하며, 연산량을 줄이면서도 장기적인 패턴 학습 성능을 향상시킵니다.
3.1 Decomposition: 시계열 데이터를 구조적으로 분해
기존 Transformer 기반 시계열 모델들은 입력 데이터를 그대로 모델에 전달하여 학습하는 방식을 사용했습니다. 하지만 시계열 데이터는 본질적으로 장기적인 추세(trend)와 일정한 주기를 갖는 계절성(seasonality) 성분으로 구성되는 경우가 많습니다. 기존 방법들은 이러한 구조를 명확하게 구분하지 않고 학습하기 때문에, 모델이 장기적인 패턴을 제대로 이해하지 못하고 과적합(overfitting)될 가능성이 있었습니다.
Autoformer는 Decomposition Block을 사용하여 입력 데이터를 추세와 계절성 성분으로 분해하는 방식을 도입하였습니다. 이 과정에서는 Pooling 연산과 Moving Average 연산이 활용됩니다.
먼저 Pooling 연산을 적용하여 시계열 데이터의 고주파 성분을 제거하고, 저주파 성분을 추출하는 방식으로 추세(trend) 성분을 분리합니다. 이는 장기적인 패턴을 학습하는 데 도움을 주며, 전체적인 방향성을 포착할 수 있도록 합니다.
그다음으로, Moving Average 연산을 통해 원본 데이터에서 추세 성분을 제거하고 계절성(seasonal) 성분을 분리합니다. 계절성 성분은 원래 데이터에서 추세 성분을 제거한 후 남는 변동 패턴이며, 이는 일정한 주기를 가지는 변동성을 반영하는 역할을 합니다.
이러한 분해 과정은 각 레이어에서 반복적으로 수행되며, 이를 통해 Autoformer는 기존 Transformer 모델보다 시계열 데이터를 구조적으로 이해하고, 장기적인 패턴과 주기성을 더 효과적으로 학습할 수 있도록 합니다.
3.2 Autocorrelation: 주기성을 강조하는 연산
Autoformer의 핵심적인 특징 중 하나는 self-attention을 대체하는 새로운 연산 방식인 Autocorrelation Mechanism입니다. 이는 시계열 데이터에서 반복되는 패턴을 찾아내고, 이를 기반으로 예측을 수행하는 방식입니다. 기존 self-attention 연산은 모든 시점 간 관계를 학습하는 방식이었기 때문에, 연산량이 O(N^2)로 증가하는 문제가 있었습니다. 반면, Autoformer는 Wiener–Khinchin 정리를 활용하여 FFT(Fast Fourier Transform)를 기반으로 한 Autocorrelation 연산을 수행함으로써 연산량을 O(NlogN) 수준으로 줄였습니다.
Autocorrelation(자기상관)은 시계열 데이터 내에서 주기성을 찾는 과정을 의미합니다. 이는 특정 시점의 데이터와 일정한 시간 간격을 두고 나타나는 데이터 간의 상관관계를 분석하는 방식입니다. 시계열 데이터는 일반적으로 특정 패턴이 반복되는 특성을 가지며, 이를 분석하면 장기적인 주기성을 효과적으로 학습할 수 있습니다.
Autocorrelation을 계산하는 방법은 다음과 같습니다.
- 시계열 데이터 x(t)를 일정한 시간 간격 τ만큼 이동시켜 원본 데이터와 비교
- 지연 시간 τ에 따라 x(t)와 x(t+τ)의 상관성을 계산
- 여러 시간 간격 τ에 대한 상관성을 구하여, 주기적으로 반복되는 패턴을 찾음
Autocorrelation을 직접 계산하는 방식은 계산량이 매우 크므로, Autoformer는 Wiener–Khinchin 정리를 활용하여 이를 효율적으로 계산합니다. 이 정리에 따르면, 자기상관 함수는 주어진 신호의 파워 스펙트럼과 푸리에 변환의 곱을 역변환한 것과 동일하다는 것이 증명됩니다. 이를 활용하면, 자기상관을 구할 때 직접적인 시간 도메인 계산 대신 FFT(Fast Fourier Transform)를 사용하여 주파수 도메인에서 연산을 수행한 후 다시 역변환(Inverse FFT, IFFT)을 적용할 수 있습니다.
Autoformer는 다음과 같은 절차를 통해 Autocorrelation을 계산합니다.
- 입력 시계열 데이터 x(t)에 대해 FFT를 적용하여 주파수 도메인으로 변환합니다.
- 변환된 데이터를 이용하여 자기상관 함수를 계산합니다.
- 계산된 값을 다시 IFFT를 적용하여 시간 도메인으로 변환합니다.
이 과정을 통해 연산량을 기존 self-attention 대비 O(N2)→O(NlogN) 수준으로 크게 줄일 수 있으며, 주기성을 더욱 효과적으로 학습할 수 있습니다.
위 그림은 Self Attention과 Auto Correlation 연산의 차이를 그림으로 표현하고 있는데요. Self Attention은 Sparse Attention, LogSparse Attention 등 더 적은 포인트를 보려고 노력했지만, 기본적으로 각 포인트들로 부터 상관관계를 계산하는 모습입니다. 반면 Auto Correlation은 포인트를 기반으로 연산하는것이 아닌, ‘반복 주기’를 찾아내기 위해 계산하는 모습을 볼 수 있습니다.
3.3 전체 Architecture
여기까지 Autoformer의 핵심 모듈 두가지인 Decomposition block과 Autocorrelation을 설명했습니다. 이제 이러한 핵심 기능들을 어떻게 조합하여 전체 Architecture를 구성했는지 살펴보겠습니다.
먼저 기존 Transformer와 동일하게 Encoder와 Decoder로 구성된 모습을 볼 수 있습니다. 앞서 설명한 두가지 핵심 모듈, 즉 Decomposition Block과 Auto Correlation Module이 포함된 모습인데요. Auto Correleation은 기존 Transformer에서의 Self Attention을 대체한다고 이해하면 되겠습니다. 기존 Self Attention 자리에 Auto Correlation Module이 들어가있는 모습입니다. 그리고 중간 중간 Decomposition Block이 들어가 있는데요. 이는 시계열 데이터를 Trend와 Seasonal로 분해하여 해당 시계열 데이터의 특성을 더 잘 파악할 수 있도록 도와주는 역할을 합니다.
3.4 파이썬 코드 구현
여기까지의 Autoformer 내용을 파이썬 코드로 구현하면 다음과 같습니다.
import torch
import torch.nn as nn
import torch.nn.functional as F
###############################################################################
# 1. Series Decomposition (추세 + 계절 분해)
###############################################################################
class SeriesDecomp(nn.Module):
def __init__(self, kernel_size=25):
super(SeriesDecomp, self).__init__()
self.kernel_size = kernel_size
self.avg_pool = nn.AvgPool1d(kernel_size=kernel_size, stride=1, padding=kernel_size//2)
def forward(self, x):
trend = self.avg_pool(x.transpose(1, 2)).transpose(1, 2) # (batch, length, d_model)
seasonal = x - trend
return seasonal, trend
###############################################################################
# 2. Auto-Correlation Mechanism (FFT 기반 자기상관 연산)
###############################################################################
class AutoCorrelation(nn.Module):
def __init__(self, dropout=0.1):
super(AutoCorrelation, self).__init__()
self.dropout = nn.Dropout(dropout)
def forward(self, x):
# FFT 변환 (주파수 도메인으로 이동)
freq_x = torch.fft.fft(x, dim=1) # (batch, length, d_model)
power_x = freq_x * torch.conj(freq_x) # 파워 스펙트럼 계산 (복소수 제곱)
# IFFT를 통해 자기상관 값 복원 (Wiener-Khinchin 정리 활용)
auto_corr = torch.fft.ifft(power_x, dim=1).real # (batch, length, d_model)
# 가장 높은 자기상관을 보이는 지연(lag) 선택 (Softmax 가중치 적용)
attn_weights = F.softmax(auto_corr, dim=1) # (batch, length, d_model)
attn_weights = self.dropout(attn_weights)
# 자기상관 기반 가중합 수행
output = torch.matmul(attn_weights.transpose(1, 2), x) # (batch, d_model, d_model)
return output
###############################################################################
# 3. Multi-Head Auto-Correlation Layer
###############################################################################
class AutoCorrelationLayer(nn.Module):
def __init__(self, d_model, num_heads=8, dropout=0.1):
super(AutoCorrelationLayer, self).__init__()
self.num_heads = num_heads
self.d_model = d_model
self.head_dim = d_model // num_heads
self.q_proj = nn.Linear(d_model, d_model)
self.k_proj = nn.Linear(d_model, d_model)
self.v_proj = nn.Linear(d_model, d_model)
self.out_proj = nn.Linear(d_model, d_model)
self.auto_corr = AutoCorrelation(dropout)
def forward(self, x):
batch, length, d_model = x.shape
# Query, Key, Value 생성
q = self.q_proj(x).view(batch, length, self.num_heads, self.head_dim).transpose(1, 2)
k = self.k_proj(x).view(batch, length, self.num_heads, self.head_dim).transpose(1, 2)
v = self.v_proj(x).view(batch, length, self.num_heads, self.head_dim).transpose(1, 2)
# Auto-Correlation을 Multi-Head 방식으로 적용
attn_output = self.auto_corr(q + k)
# 최종 출력 변환
attn_output = attn_output.transpose(1, 2).contiguous().view(batch, length, d_model)
output = self.out_proj(attn_output)
return output
###############################################################################
# 4. Autoformer Encoder & Decoder
###############################################################################
class EncoderLayer(nn.Module):
def __init__(self, d_model, dropout=0.1):
super(EncoderLayer, self).__init__()
self.auto_corr = AutoCorrelationLayer(d_model)
self.series_decomp = SeriesDecomp()
self.feedforward = nn.Sequential(
nn.Linear(d_model, d_model * 4),
nn.ReLU(),
nn.Linear(d_model * 4, d_model),
)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
def forward(self, x):
residual = x
x = self.auto_corr(x)
x = self.norm1(x + residual)
# 시계열 분해 수행
seasonal, trend = self.series_decomp(x)
x = seasonal
residual = x
x = self.feedforward(x)
x = self.norm2(x + residual)
return x
class DecoderLayer(nn.Module):
def __init__(self, d_model, dropout=0.1):
super(DecoderLayer, self).__init__()
self.auto_corr = AutoCorrelationLayer(d_model)
self.series_decomp = SeriesDecomp()
self.feedforward = nn.Sequential(
nn.Linear(d_model, d_model * 4),
nn.ReLU(),
nn.Linear(d_model * 4, d_model),
)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
def forward(self, x, enc_output):
residual = x
x = self.auto_corr(x)
x = self.norm1(x + residual)
seasonal, trend = self.series_decomp(x)
x = seasonal
residual = x
x = self.feedforward(x)
x = self.norm2(x + residual)
return x
###############################################################################
# 5. Autoformer Architecture
###############################################################################
class Autoformer(nn.Module):
def __init__(self, input_dim, d_model, output_dim, num_enc_layers=2, num_dec_layers=1, dropout=0.1):
super(Autoformer, self).__init__()
self.input_proj = nn.Linear(input_dim, d_model)
self.output_proj = nn.Linear(d_model, output_dim)
self.encoder_layers = nn.ModuleList(
[EncoderLayer(d_model, dropout) for _ in range(num_enc_layers)]
)
self.decoder_layers = nn.ModuleList(
[DecoderLayer(d_model, dropout) for _ in range(num_dec_layers)]
)
def forward(self, x_enc, x_dec):
x_enc = self.input_proj(x_enc)
x_dec = self.input_proj(x_dec)
for layer in self.encoder_layers:
x_enc = layer(x_enc)
x = x_dec
for layer in self.decoder_layers:
x = layer(x, x_enc)
output = self.output_proj(x)
return output4. 실험 결과
Autoformer의 성능을 검증하기 위해 다양한 시계열 데이터셋을 활용하여 실험을 진행했습니다. 주요 실험은 univariate forecasting과 multivariate forecasting 두 가지 설정에서 수행되었습니다.
4.1 Univariate 시계열 예측 성능
Autoformer는 univariate 데이터셋에서 기존의 대표적인 시계열 모델들과 비교되었습니다. 실험에서는 다양한 예측 길이(96, 192, 336, 720)를 설정하여 성능을 비교하였으며, 평가 지표로는 MSE(Mean Squared Error)와 MAE(Mean Absolute Error)가 사용되었습니다.
Autoformer는 전반적으로 기존 모델보다 낮은 MSE 및 MAE를 기록하며 장기 예측에서 강력한 성능을 보였습니다.
4.2 Multivariate 시계열 예측 성능
Multivariate 시계열 데이터셋에서도 Autoformer의 성능을 평가하였습니다. 실험에서는 Electricity, Traffic, Weather, Exchange 등의 데이터셋을 사용하였으며, Autoformer는 모든 예측 길이에서 기존 모델 대비 높은 성능을 보였습니다.
특히, Autoformer는 입력 길이가 길어질수록 성능 변화가 안정적인 특징을 보였습니다. 이는 장기 예측에서의 성능 저하를 줄이는 Autoformer의 강점으로 작용할 수 있음을 의미합니다. 실험 결과를 통해 Autoformer가 장기 시계열 예측에서 강력한 성능을 발휘할 수 있음을 확인할 수 있습니다.
5. 마치며
이번 포스팅에서는 Autoformer 모델이 기존 Transformer 기반 시계열 예측 모델들이 가진 문제를 어떻게 해결하는지 살펴보았습니다. 기존 Transformer 모델들은 self-attention을 기반으로 설계되어 있어 계산량이 많고, point-wise 연산 방식으로 인해 시계열의 연속적인 패턴을 제대로 학습하지 못하는 한계를 가지고 있었습니다. 이러한 문제를 해결하기 위해 Autoformer는 Decomposition Mechanism과 Autocorrelation Mechanism을 도입하여 시계열 데이터를 보다 효과적으로 학습할 수 있도록 설계되었습니다.
Autoformer의 첫 번째 핵심 기법인 Decomposition Mechanism은 시계열 데이터를 단순히 모델에 입력하는 것이 아니라, 먼저 추세(trend) 성분과 계절성(seasonal) 성분으로 분해하는 과정을 거치도록 하였습니다. 이를 통해 모델이 보다 구조적으로 시계열 데이터를 이해할 수 있도록 도와주며, 시계열의 장기적인 흐름과 반복적인 패턴을 명확하게 구분할 수 있게 되었습니다. 특히, Pooling과 Moving Average 연산을 적용하여 장기적인 추세를 보다 안정적으로 추출하고, 계절성을 명확히 반영할 수 있도록 하였습니다.
두 번째 핵심 기법인 Autocorrelation Mechanism은 기존의 self-attention을 대체하여 연산량을 줄이고 시계열의 주기성을 더욱 강조하는 방식으로 설계되었습니다. 기존 Transformer 모델들은 모든 시점 간의 관계를 학습하는 방식이었지만, Autoformer는 FFT(Fast Fourier Transform)를 활용한 Wiener–Khinchin 정리를 적용하여 반복되는 패턴을 효율적으로 학습할 수 있도록 하였습니다. 이를 통해 기존 self-attention의 연산량이 O(N^2)였던 것과 비교하여, Autoformer는 O(NlogN)의 연산량을 가지며 더 빠르고 효율적인 학습이 가능하다는 장점을 가집니다.
실험 결과를 통해 Autoformer가 univariate 및 multivariate 시계열 예측에서 기존 모델 대비 높은 성능을 보였다는 점을 확인할 수 있었습니다. 다양한 데이터셋에서 실험을 수행한 결과, Autoformer는 기존 Transformer 기반 모델들보다 장기적인 예측 성능이 뛰어나며, 특히 입력 길이가 길어질수록 성능 저하가 적어 안정적인 결과를 보였습니다. 이는 기존 모델들이 가지던 한계를 효과적으로 극복한 결과라고 볼 수 있습니다.
Autoformer는 기존 Transformer 기반 시계열 모델의 구조를 유지하면서도 연산량을 줄이고, 장기적인 시계열 패턴을 효과적으로 학습할 수 있도록 개선된 모델입니다. 특히, 자기상관(Auto-Correlation)을 활용한 패턴 학습과 FFT 기반의 연산 최적화는 향후 시계열 예측 연구에서 더욱 발전할 가능성이 높은 방향성을 제시하고 있습니다.
그러나 Autoformer에도 해결해야 할 과제가 남아 있습니다. 예를 들어, 매우 복잡한 시계열 데이터에서는 분해 과정이 최적의 방식이 아닐 수도 있으며, 특정 데이터셋에서는 기존 Transformer 계열 모델과 큰 성능 차이가 나지 않는 경우도 존재합니다. 또한, 계절성이 뚜렷하지 않은 데이터에서는 Autocorrelation Mechanism이 기존 self-attention보다 반드시 우수한 성능을 보장하는 것은 아니기 때문에, 다양한 시계열 데이터에 대한 추가적인 연구와 실험이 필요할 것입니다.
6. 참고자료
