[’21 AAAI] Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting

1. 들어가며

시계열 데이터는 금융, 에너지, 기후, 의료 등 다양한 분야에서 필수적으로 활용되며, 정확한 예측이 중요한 역할을 합니다. 최근 Transformer 기반 모델들이 자연어 처리(NLP)에서 뛰어난 성능을 보이며 주목받았고, 이를 시계열 예측에도 적용하려는 연구가 활발히 이루어졌습니다. 하지만 기존 Transformer 기반 시계열 모델들은 몇 가지 중요한 한계를 가지고 있습니다.

먼저, self-attention 연산량이 너무 크다는 점이 문제로 지적됩니다. Transformer의 self-attention 메커니즘은 모든 입력 시점 간의 관계를 학습하기 때문에, 입력 길이가 N일 때 연산량이 O(N^2)으로 증가합니다. 시계열 데이터에서는 긴 입력 길이가 필수적인 경우가 많아, 이러한 연산량 증가가 모델의 실용성을 크게 저해하는 요인이 됩니다.

또한, 기존 Transformer 모델들은 autoregressive 방식으로 예측을 수행하기 때문에, 긴 예측 구간에서는 성능이 급격히 저하되는 문제가 있습니다. 일반적으로 Transformer 기반 시계열 예측 모델들은 하나의 예측값을 생성한 후 이를 다시 입력으로 사용하여 다음 값을 예측하는 방식을 따릅니다. 하지만 이 방식은 작은 예측 오차가 누적되면서 장기 예측의 신뢰도를 낮추는 결과를 초래합니다.

이러한 문제를 해결하기 위해 Informer가 제안되었습니다. Informer는 ProbSparse Self-Attention, Self-Attention Distillation, Generative Decoder라는 세 가지 핵심 기법을 활용하여 기존 Transformer의 연산량 문제를 해결하고, 장기 시계열 예측 성능을 향상시킨 모델입니다.

이번 포스팅에서는 기존 Transformer 기반 시계열 예측 모델들의 한계를 분석하고, Informer가 이를 어떻게 해결하는지 자세히 살펴보겠습니다. 또한, 실험 결과를 통해 Informer가 실제로 기존 모델들과 비교하여 어떤 성능을 보이는지 평가하고, 마지막으로 Informer의 장점과 한계를 정리하겠습니다. 먼저, 기존 Transformer 모델이 시계열 예측에서 어떤 문제를 가지고 있었는지 살펴보겠습니다.

2. 기존 방법의 한계

시계열 예측에서 Transformer 기반 모델들은 장기 예측(Long Sequence Time-Series Forecasting, LSTF) 문제를 해결하기 위해 도입되었습니다. Transformer는 자연어 처리(NLP) 분야에서 뛰어난 성능을 보이며, self-attention 메커니즘을 통해 긴 시퀀스에서도 중요한 정보를 학습할 수 있다는 강점을 가집니다. 하지만 시계열 데이터의 특성과 Transformer의 구조적 한계로 인해, 기존 모델들은 몇 가지 중요한 문제를 가지고 있습니다.

2.1 긴 예측 구간에서 성능이 급격히 하락

기존 Transformer 계열 모델들은 autoregressive 방식을 사용하여 시계열 예측을 수행합니다. 즉, 모델이 예측한 값을 다시 입력으로 사용하면서 순차적으로 다음 값을 예측하는 방식입니다. 이러한 방식은 단기 예측에서는 효과적일 수 있지만, 예측 구간이 길어질수록 작은 오차가 누적되면서 성능이 급격히 저하되는 문제가 발생합니다.

이 문제는 특히 시계열 데이터에서 장기 의존성(Long-Term Dependency)을 학습하는 것이 어렵기 때문에 발생합니다. Transformer 모델이 self-attention을 통해 장기 의존성을 학습할 수 있는 구조를 가지기는 하지만, 실제로는 예측한 값이 피드백되면서 발생하는 오차가 누적되기 때문에 예측 성능이 빠르게 저하됩니다. 특히, 시계열 데이터에서는 특정 주기성을 유지해야 하는 경우가 많지만, autoregressive 방식에서는 초반의 작은 예측 오류가 후반으로 갈수록 크게 누적되며 원래의 패턴을 유지하지 못하는 경우가 많습니다.

2.2 Transformer 기반 모델의 연산량 문제

Transformer 모델에서 가장 큰 연산량을 차지하는 부분은 self-attention 연산입니다. 기존 Transformer 모델들은 입력 길이가 N일 때, self-attention을 계산하는 데 O(N^2)의 연산량이 필요합니다. NLP에서는 문장의 길이가 비교적 짧기 때문에 이러한 연산량이 크게 문제되지 않지만, 시계열 데이터에서는 길이가 수백에서 수천에 이르는 경우가 많아 연산량이 급격히 증가하는 문제가 발생합니다.

이를 해결하기 위해 기존 연구에서는 다양한 방법들이 제안되었습니다.

Sparse Attention: 일부 연구에서는 self-attention 연산을 효율적으로 수행하기 위해 sparse attention 방식을 도입하였습니다. 예를 들어, Longformer나 Sparse Transformer와 같은 모델들은 전체 attention을 계산하는 대신, 일부 중요한 패턴만 선택하여 attention을 수행하는 방식으로 연산량을 줄였습니다.

Low-rank Approximation: Linformer와 같은 모델들은 self-attention 행렬을 저차원으로 근사하는 방식으로 연산량을 줄이려는 시도를 했습니다.

Local Attention: 일부 연구에서는 전체 입력을 고려하는 것이 아니라, 특정 구간 내에서만 attention을 수행하는 방식으로 연산량을 절감하는 방법을 제안하였습니다.

하지만 이러한 방법들은 근본적으로 Transformer의 구조를 변경하는 것이 아니기 때문에, 완전한 해결책이 되지는 못했습니다. 예를 들어, sparse attention 방식은 특정 패턴을 강조하는 데에는 효과적이지만, 여전히 전체적인 self-attention 구조를 유지하고 있기 때문에 계산량 감소에 한계가 있습니다. 마찬가지로, low-rank approximation 방법은 정보 손실이 발생할 가능성이 있어 정확도 저하의 위험이 존재합니다.

2.3 기존 해결책의 한계

기존 연구들은 Transformer의 연산량 문제를 해결하기 위해 다양한 접근 방식을 시도하였지만, 다음과 같은 근본적인 한계를 가집니다.

첫째, sparse attention이나 local attention을 사용하면 중요한 시점 간의 관계를 놓칠 가능성이 있습니다. Transformer의 self-attention은 원래 모든 시점 간의 관계를 학습할 수 있도록 설계되었는데, 특정 부분만 선택하여 attention을 수행할 경우 장기적인 의존성을 온전히 반영하지 못할 수 있습니다.

둘째, autoregressive 방식으로 예측을 수행하는 기존 Transformer 모델들은 예측값을 입력으로 다시 사용해야 하기 때문에, 작은 오차가 누적되는 문제를 피할 수 없습니다. 이로 인해 예측 구간이 길어질수록 성능이 급격히 하락하는 현상이 발생합니다.

이러한 한계를 극복하기 위해 Informer는 ProbSparse Self-Attention, Self-Attention Distillation, Generative Decoder라는 새로운 접근 방식을 도입하여 Transformer 기반 시계열 예측 모델의 연산량 문제를 해결하고, 장기 예측 성능을 향상시켰습니다. 다음 장에서는 Informer가 이러한 문제를 어떻게 해결했는지 자세히 살펴보겠습니다.

3. 제안 방법 : Informer

Informer는 기존 Transformer 기반 시계열 예측 모델들이 가진 연산량 문제와 장기 예측 성능 저하 문제를 해결하기 위해 ProbSparse Self-Attention, Self-Attention Distillation, Generative Decoder라는 세 가지 핵심 기법을 도입하였습니다.

3.1 효율적인 Self-Attention (Efficient Self-Attention)

Transformer 모델에서 self-attention 연산은 입력 길이가 길어질수록 연산량이 기하급수적으로 증가하는 문제가 있습니다. 기존 self-attention 방식은 모든 쿼리(query)와 키(key) 간의 연산을 수행하기 때문에, 입력 길이가 N일 때 O(N^2)의 연산량을 필요로 합니다. 이를 해결하기 위해 Informer는 ProbSparse Self-Attention 기법을 제안하였습니다.

기존 self-attention 방식에서는 모든 query가 key와의 유사도를 계산하여 attention score를 구하지만, 시계열 데이터에서는 모든 시점이 동등한 중요도를 가지지 않으며, 일부 특정 시점들이 더 중요한 역할을 할 가능성이 높습니다. Informer는 이러한 특성을 활용하여 중요한 query만을 선택적으로 사용하여 연산을 수행하는 방식을 적용하였습니다.

연산 과정은 다음과 같습니다. 먼저, self-attention에서 사용될 query를 중요도 순으로 정렬합니다. Query의 중요도는 해당 query가 전체 key와 얼마나 강한 관계를 가지는지를 나타내며, 이는 각 query의 attention score를 기반으로 계산됩니다. 수식으로는 다음과 같이 표현됩니다.

이 값이 클수록 query는 key와 강한 연관성을 가지며, attention 연산에서 중요한 역할을 합니다.

이후 중요도가 높은 query를 선별하는 과정이 이루어집니다. 전체 query 중에서 가장 중요한 k개의 query를 선택하고, 나머지는 연산에서 제외합니다. 이렇게 선택된 query만을 이용하여 key-value 연산을 수행하면 self-attention의 연산량을 크게 줄일 수 있습니다. 기존 self-attention이 모든 query와 key의 관계를 계산했던 것과 달리, Informer는 특정 query만을 선택하여 연산을 수행하기 때문에, 기존 O(N^2)의 연산량을 O(Nlog⁡N)으로 줄일 수 있습니다. 이 방식은 불필요한 연산을 제거하면서도 핵심 정보를 학습할 수 있도록 하였으며, 기존 Transformer 대비 10배 이상의 속도 향상을 달성할 수 있도록 하였습니다.

3.2 Self-Attention Distillation

기존 Transformer 모델들은 self-attention 레이어를 깊게 쌓아 네트워크를 구성합니다. 하지만 시계열 데이터에서는 모든 self-attention 레이어가 동일한 수준의 정보를 학습하는 것이 아니라, 특정 레이어에서 핵심적인 정보를 더 많이 포함하는 경우가 많습니다. 기존 Transformer 모델에서는 이러한 정보를 효율적으로 압축하지 못하고, 불필요한 연산이 계속 반복된다는 한계가 있었습니다. Informer는 이러한 문제를 해결하기 위해 Self-Attention Distillation 기법을 도입하였습니다.

이 과정에서는 각 self-attention 레이어에서 얻어진 attention 행렬을 분석하고, 가장 중요한 정보를 포함하는 key-value 조합을 선택하는 방식으로 진행됩니다. 먼저, 각 레이어에서 계산된 attention 행렬 A(l)을 기반으로, 높은 중요도를 가지는 key-value 쌍을 선별합니다. 이렇게 선택된 정보는 다음 레이어로 전달되며, 중요도가 낮은 key-value 조합은 제거되거나 가중치가 낮춰집니다.

이러한 distillation 과정을 통해 네트워크가 깊어질수록 불필요한 연산을 줄일 수 있으며, 최적의 key-value 정보만이 유지되도록 설계됩니다. 결과적으로 기존 Transformer보다 적은 레이어를 사용하면서도 동일한 수준의 성능을 유지할 수 있습니다. 이 방법을 통해 학습 속도를 향상시키고, 메모리 사용량을 감소시킬 수 있어 보다 효율적인 시계열 예측이 가능해집니다.

3.3 Generative Decoder

Transformer 기반의 기존 시계열 예측 모델들은 autoregressive 방식으로 출력을 생성합니다. 즉, 하나의 예측 값을 생성한 후 이를 다시 입력으로 사용하여 다음 값을 예측하는 방식입니다. 이러한 방식은 짧은 예측 구간에서는 효과적일 수 있지만, 예측 구간이 길어질수록 작은 오차가 누적되면서 성능이 급격히 저하되는 문제가 발생합니다.

이를 해결하기 위해 Informer는 Generative Decoder를 도입하였습니다. 기존 autoregressive 방식과 달리, Generative Decoder는 한 번의 forward 연산을 통해 전체 예측 값을 생성하는 방식입니다. 즉, 이전 예측 값을 입력으로 사용할 필요 없이, 한 번의 계산만으로 다수의 예측 값을 동시에 생성할 수 있습니다.

이 방식은 기존 autoregressive 방식이 가진 오차 누적 문제를 해결하는 데 효과적입니다. 기존 방식에서는 하나의 예측 값이 잘못될 경우, 이후 예측 값에도 영향을 미쳐 오류가 점점 커지는 문제가 발생했습니다. 하지만 Generative Decoder 방식에서는 이러한 피드백 과정이 존재하지 않으므로, 장기 예측에서도 더 안정적인 성능을 유지할 수 있습니다. 또한, 한 번의 연산으로 모든 예측을 수행하기 때문에, 기존 방식보다 훨씬 빠르게 다수의 예측 값을 생성할 수 있습니다.

3.4 파이썬 코드로 구현하기

여기까지의 내용들을 바탕으로 Informer Architecture를 파이썬 코드로 구현하면 다음과 같습니다.

import torch
import torch.nn as nn
import torch.nn.functional as F

###############################################################################
# 1. ProbSparse Self-Attention (O(L²) → O(L logL)로 연산량 감소)
###############################################################################
class ProbSparseSelfAttention(nn.Module):
    def __init__(self, d_model, num_heads=8, dropout=0.1):
        super(ProbSparseSelfAttention, 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.dropout = nn.Dropout(dropout)

    def forward(self, x):
        batch, length, _ = 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)

        # Dot-Product Similarity
        scores = torch.matmul(q, k.transpose(-2, -1)) / self.head_dim ** 0.5

        # ProbSparse: 가장 중요한 Query-Key 쌍만 남기기 (상위 k개 선택)
        top_k = max(1, int(length * 0.1))  # 10% 만 유지
        sparse_scores, _ = torch.topk(scores, k=top_k, dim=-1)

        # Softmax 및 Dropout
        attn_weights = F.softmax(sparse_scores, dim=-1)
        attn_weights = self.dropout(attn_weights)

        # Self-Attention 적용
        output = torch.matmul(attn_weights, v)

        # 차원 변환 및 출력
        output = output.transpose(1, 2).contiguous().view(batch, length, self.d_model)
        output = self.out_proj(output)

        return output


###############################################################################
# 2. Self-Attention Distilling (메모리 사용량 절반으로 감소)
###############################################################################
class SelfAttentionDistilling(nn.Module):
    def __init__(self):
        super(SelfAttentionDistilling, self).__init__()
        self.pool = nn.MaxPool1d(kernel_size=2, stride=2)

    def forward(self, x):
        x = x.transpose(1, 2)  # (batch, length, d_model) → (batch, d_model, length)
        x = self.pool(x)  # 길이를 절반으로 줄임
        x = x.transpose(1, 2)  # 다시 원래 차원으로 변환
        return x


###############################################################################
# 3. Encoder Layer
###############################################################################
class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads=8, dropout=0.1):
        super(EncoderLayer, self).__init__()
        self.attn = ProbSparseSelfAttention(d_model, num_heads, dropout)
        self.distilling = SelfAttentionDistilling()
        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.attn(x)
        x = self.norm1(x + residual)

        # Self-Attention Distilling 적용 (길이를 절반으로 줄임)
        x = self.distilling(x)

        residual = x
        x = self.feedforward(x)
        x = self.norm2(x + residual)

        return x


###############################################################################
# 4. Generative Decoder Layer
###############################################################################
class GenerativeDecoderLayer(nn.Module):
    def __init__(self, d_model, num_heads=8, dropout=0.1):
        super(GenerativeDecoderLayer, self).__init__()
        self.self_attention = nn.MultiheadAttention(embed_dim=d_model, num_heads=num_heads, dropout=dropout)
        self.cross_attention = nn.MultiheadAttention(embed_dim=d_model, num_heads=num_heads, dropout=dropout)
        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)
        self.norm3 = nn.LayerNorm(d_model)

    def forward(self, x, enc_output):
        residual = x
        x, _ = self.self_attention(x, x, x)
        x = self.norm1(x + residual)

        residual = x
        x, _ = self.cross_attention(x, enc_output, enc_output)
        x = self.norm2(x + residual)

        residual = x
        x = self.feedforward(x)
        x = self.norm3(x + residual)

        return x


###############################################################################
# 5. Informer Model (Encoder + Generative Decoder)
###############################################################################
class Informer(nn.Module):
    def __init__(self, input_dim, d_model, output_dim, num_enc_layers=2, num_dec_layers=1, dropout=0.1):
        super(Informer, self).__init__()
        self.input_proj = nn.Linear(input_dim, d_model)
        self.output_proj = nn.Linear(d_model, output_dim)

        # Encoder: 여러 개의 Encoder Layer 쌓기
        self.encoder_layers = nn.ModuleList(
            [EncoderLayer(d_model, dropout=dropout) for _ in range(num_enc_layers)]
        )

        # Decoder: 여러 개의 Generative Decoder Layer 쌓기
        self.decoder_layers = nn.ModuleList(
            [GenerativeDecoderLayer(d_model, dropout=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)

        # Encoder 처리
        for layer in self.encoder_layers:
            x_enc = layer(x_enc)

        # Generative 방식의 Decoder 처리
        for layer in self.decoder_layers:
            x_dec = layer(x_dec, x_enc)

        # 최종 예측 출력
        output = self.output_proj(x_dec)
        return output


###############################################################################
# 6. 모델 실행 예제
###############################################################################
if __name__ == "__main__":
    batch_size = 8
    input_length = 96
    decoder_length = 96
    input_dim = 1
    d_model = 64
    output_dim = 1

    model = Informer(input_dim, d_model, output_dim, num_enc_layers=2, num_dec_layers=1)
    x_enc = torch.randn(batch_size, input_length, input_dim)
    x_dec = torch.randn(batch_size, decoder_length, input_dim)

    output = model(x_enc, x_dec)
    print("Output shape:", output.shape)  # 예상 결과: (batch, decoder_length, output_dim)

Encoder에서는 Self Attention 연산량을 줄이기 위해 주요 쿼리만 추출하는 과정이 포인트입니다. Self Attention Distillation에서는 Pooling 연산을 사용하여 Feature 사이즈를 줄이는게 포인트입니다. Decoder에서는 기존 Autoregressive 방식과 달리 Decoding된 Feature를 사용하여 한번에 모든 미래 값을 추론하는 과정이 포인트입니다.

4. 실험 결과

논문에서는 Informer 모델의 성능을 검증하기 위해 다양한 시계열 데이터셋을 활용하여 실험을 진행했습니다. 실험은 크게 Univariate Forecasting과 Multivariate Forecasting으로 나뉘며, 기존의 Transformer 계열 모델들과 비교하여 Informer의 성능을 분석했습니다.

4.1 Univariate Forecasting Results

단변량(Univariate) 시계열 예측 실험에서는 다양한 데이터셋을 사용하여 Informer의 성능을 평가했습니다. 기존 Transformer 계열 모델들과 비교했을 때, Informer는 긴 예측 길이에서도 비교적 안정적인 성능을 유지하는 것으로 나타났습니다. 특히, 예측 구간이 길어질수록 기존 Transformer 모델들의 성능이 급격히 저하되는 반면, Informer는 상대적으로 낮은 MSE와 MAE를 유지하며 더 정확한 예측을 수행하는 특징을 보였습니다.

4.2 Multivariate Forecasting Results

다변량(Multivariate) 시계열 예측 실험에서도 Informer는 기존 Transformer 기반 모델들보다 뛰어난 성능을 보여주었습니다. 특히, 긴 시계열 데이터를 다룰 때 계산 효율성이 크게 향상되었으며, 기존 Transformer 기반 모델보다 연산량이 적으면서도 높은 예측 정확도를 유지하는 점이 강조되었습니다.

5. 마치며

이번 포스팅에서는 Informer가 기존 Transformer 기반 시계열 예측 모델들이 가진 한계를 어떻게 극복하는지 살펴보았습니다. 기존 Transformer 모델들은 self-attention을 활용하여 장기 의존성을 학습할 수 있는 구조를 가지고 있지만, 연산량이 너무 크고, 긴 예측 구간에서 성능이 급격히 저하되는 문제를 가지고 있었습니다. 이러한 문제를 해결하기 위해 Informer는 ProbSparse Self-Attention, Self-Attention Distillation, Generative Decoder라는 세 가지 핵심 기법을 도입하여 Transformer의 성능을 유지하면서도 연산량을 줄이고 장기 예측 성능을 향상시키는 데 성공했습니다.

먼저, ProbSparse Self-Attention 기법을 통해 기존 self-attention의 O(N^2) 연산량을 O(Nlog⁡N) 수준으로 줄였습니다. 기존 Transformer 모델들은 모든 query와 key의 관계를 학습해야 했지만, Informer는 가장 중요한 query만을 선택적으로 사용하여 연산량을 감소시켰습니다. 이를 통해 기존 Transformer 모델들보다 훨씬 빠르게 시계열 데이터를 학습할 수 있으며, 긴 시계열 데이터에서도 보다 효과적으로 정보를 학습할 수 있었습니다.

다음으로, Self-Attention Distillation을 적용하여 불필요한 연산을 줄이고 네트워크를 경량화하는 방식으로 기존 Transformer 대비 더 적은 메모리와 연산량을 사용하면서도 성능을 유지할 수 있도록 설계되었습니다. 기존 Transformer 모델들은 self-attention을 여러 층 쌓아가는 방식이었지만, Informer는 각 레이어에서 중요한 key-value 조합만을 유지하는 방식으로 네트워크 구조를 더욱 효율적으로 만들었습니다.

마지막으로, Generative Decoder를 활용하여 기존 autoregressive 방식이 가진 오차 누적 문제를 해결하였습니다. 기존 Transformer 기반 시계열 예측 모델들은 하나의 예측값을 생성한 후 이를 다시 입력으로 사용하면서 예측을 수행했기 때문에, 작은 오차가 누적되면서 긴 예측 구간에서 성능이 급격히 저하되는 문제가 있었습니다. 그러나 Informer는 한 번의 forward 연산만으로 전체 예측값을 생성하는 Generative 방식의 Decoder를 도입하여 이러한 문제를 해결하였습니다. 이를 통해 긴 시계열 예측에서도 안정적인 성능을 유지하면서도 기존 autoregressive 방식보다 훨씬 빠른 속도로 예측을 수행할 수 있었습니다.

실험 결과를 통해 Informer가 기존 Transformer 모델들과 비교하여 긴 시계열 예측에서 더 높은 성능을 유지할 수 있으며, 연산량을 줄여 더욱 효율적인 학습이 가능하다는 점이 입증되었습니다. 특히, Self-Attention 연산량을 획기적으로 줄이면서도 기존 모델들과 동등하거나 더 나은 성능을 보여준 점은 Informer의 가장 큰 강점이라고 할 수 있습니다.

하지만 Informer에도 몇 가지 한계점이 존재합니다. 예를 들어, ProbSparse Self-Attention에서 중요한 query를 선택하는 방식이 특정한 시계열 데이터에 따라 최적화가 필요할 가능성이 있으며, Self-Attention Distillation 방식이 모든 유형의 시계열 데이터에서 최적의 구조를 제공하는지는 추가적인 검증이 필요합니다. 또한, Generative Decoder 방식이 항상 autoregressive 방식보다 우수한 성능을 보장하는 것은 아니므로, 데이터의 특성에 따라 적절한 방식을 선택하는 것이 중요할 수 있습니다.

그럼에도 불구하고, Informer는 기존 Transformer 기반 시계열 예측 모델들이 가진 핵심적인 문제들을 효과적으로 해결하며, 장기 예측이 필요한 다양한 도메인에서 활용될 가능성이 높은 모델입니다. 특히, 금융 시장 예측, 기후 변화 예측, 에너지 소비 패턴 분석 등 대규모 시계열 데이터를 다루는 분야에서 Informer의 효율성이 더욱 빛을 발할 것으로 기대됩니다.

6. 참고 자료

• Informer Paper
• Autoformer 논문 리뷰

Ffightingseok