극심한 데이터 희소성 시나리오에서의 자율 도심 항공 모빌리티 (UAM) 경로 설정을 위한 자기지도 학습 기반 시계열 패턴 마이닝

서론: 실험실에서의 유레카 모먼트

새벽 3시, 나는 프로토타입 도심 항공 모빌리티 (Urban Air Mobility, UAM) 드론에서 생성된 들쭉날쭉하고 불완전한 텔레메트리 (Telemetry) 로그로 가득 찬 화면을 응시하고 있었다. 데이터는 악몽 같았다. 스위스 치즈처럼 구멍이 숭숭 뚫린 넓은 공백이 존재했고, 타임스탬프 (Timestamp)는 너무 불규칙해서 표준적인 시계열 분석 (Time-series analysis)을 거부할 정도였다. 나의 임무는 밀집된 도심 협곡을 항행하는 자율 eVTOL (Electric Vertical Takeoff and Landing, 전기 수직 이착륙기) 항공기를 위한 경로 설정 (Routing) 알고리즘을 구축하는 것이었지만, 데이터셋은 거의 쓸모가 없는 수준이었다. 전통적인 강화학습 (Reinforcement Learning, RL) 방식은 조밀하게 라벨링된 궤적 (Trajectories)을 요구했다. 지도학습 (Supervised Learning)은 정답 경로 (Ground truth routes)가 필요했다. 하지만 둘 다 존재하지 않았다.

그러던 중, 비디오 시퀀스 (Video sequences)를 위한 대조 학습 (Contrastive Learning)에 관한 논문을 다시 읽다가 문득 생각이 스쳤다. 만약 라벨 없이도 시계열 패턴 (Temporal patterns)을 마이닝할 수 있다면 어떨까? 드론 자체의 센서 스트림(Sensor streams)—GPS, IMU, 돌풍, 배터리 방전 곡선(Battery discharge curves)—에는 암시적인 구조가 포함되어 있었다. 핵심은 신경망 (Neural network)이 파편화된 데이터로부터라도 도심 공역의 리듬을 학습하도록 강제하는 자기지도 학습 (Self-supervised) 목적 함수 (Objective)를 설계하는 것이었다. 이 글은 극심한 데이터 희소성 상황에서 UAM 경로 설정을 위한 자기지도 시계열 패턴 마이닝 (Self-Supervised Temporal Pattern Mining, SSTPM)에 대한 나의 여정을 기록한다.

기술적 배경: 희소성의 역설

도심 항공 모빌리티 데이터가 본질적으로 희소한 이유
도심 항공 모빌리티는 독특한 데이터 희소성 문제에 직면해 있다. 매일 테라바이트 단위의 라벨링된 주행 데이터를 생성하는 자율주행 자동차와 달리, UAM 항공기는 희귀하며, 비행 시간은 짧고 (10~30분), 모든 미션은 높은 위험을 수반하는 이상치 (Anomaly)이다. 샌프란시스코 상공의 테스트 비행에서 얻은 실제 UAM 텔레메트리를 탐색하며 나는 다음과 같은 사실을 발견했다:

• 시간적 공백 (Temporal gaps): 도심 협곡에서의 GPS 차폐 (GPS occlusion)로 인해 타임스탬프의 40~70%가 누락됨.
• 불규칙한 샘플링 (Irregular sampling): 센서들이 동기화 없이 서로 다른 속도로 보고함 (GPS는 1 Hz, IMU는 100 Hz).

희소한 보상 신호 (Sparse reward signals): 드론은 미션당 단 한 번의 "안전 착륙" 보상만을 받을 수도 있으며, 이는 강화학습 (RL)을 비실용적으로 만듭니다. 자기지도 학습 (Self-Supervised Learning, SSL)의 계시: LSTM, Transformer, 그래프 신경망 (Graph Neural Networks)과 같은 전통적인 접근 방식은 모두 조밀하고 규칙적인 시계열 (Time series) 데이터를 필요로 합니다. 하지만 자기지도 학습 (SSL)은 해결책을 제시합니다. 핵심 아이디어는 모델이 레이블 없이도 시간적 역학 (Temporal dynamics)을 포착하도록 강제하는 사전 과제 (Pretext task)를 설계하는 것입니다. TimeSformer 및 VideoMAE와 같은 비디오 이해 모델에 대한 저의 연구를 통해, 마스킹 (Masking)과 재구성 (Reconstruction)을 불규칙한 시계열에 맞게 조정할 수 있음을 깨달았습니다. 핵심 통찰 (Key insight): (데이터 공백으로 인해 실패하기 쉬운) 미래 값을 예측하는 대신, 샘플링 불규칙성에 불변하는 시간적 임베딩 (Temporal embeddings)을 학습할 수 있습니다. 모델은 단순히 관찰된 데이터뿐만 아니라 기상 패턴, 교통 혼잡 주기, 배터리 성능 저하 곡선과 같은 근본적인 프로세스를 이해해야 합니다.

구현 세부 사항: SSTPM 프레임워크 구축
아키텍처 개요
저는 세 가지 구성 요소로 이루어진 시스템을 설계했습니다:
시간적 인코더 (Temporal Encoder): 불규칙하게 샘플링된 시퀀스를 처리하는 마스크드 오토인코더 (Masked Autoencoder, MAE) 변형 모델입니다.
패턴 마이너 (Pattern Miner): 유사한 시간적 패턴을 클러스터링하는 자기지도 대조 손실 (Self-supervised contrastive loss)입니다.
경로 플래너 (Routing Planner): 학습된 임베딩을 경로 최적화에 사용하는 경량화된 정책 네트워크 (Policy network)입니다.

코드 예시 1: 불규칙 시계열 마스킹

import torch
import torch.nn as nn
import numpy as np

class IrregularMasking :
    """
    공백이 있는 불규칙한 시계열을 위한 이진 마스크를 생성합니다.
    """
    def __init__ ( self , mask_ratio = 0.6 ):
        self . mask_ratio = mask_ratio

    def create_mask ( self , timestamps , values ):
        """
        timestamps: 누락된 타임스탬프를 -1로 표시한 (batch, seq_len)
        values: (batch, seq_len, feat_dim)
        """
        mask = torch . ones_like ( timestamps , dtype = torch . bool )
        # 누락된 타임스탬프를 마스킹된 것으로 표시
        mask [ timestamps == - 1 ] = False
        # 추가적인 가시적 타임스탬프를 무작위로 마스킹
        visible_indices = torch . where ( mask )[ 0 ]
        num_to_mask = int ( len ( visible_indices ) * self .

마스크 비율(mask_ratio) ) mask_indices = visible_indices [ torch . randperm ( len ( visible_indices ))[: num_to_mask ]] mask [ mask_indices ] = False return mask 코드 예시 2: 자기지도 시간적 대비 손실 (Self-Supervised Temporal Contrastive Loss)
클래스 TemporalContrastiveLoss ( nn . Module ):
""" 시간적 시퀀스를 위해 조정된 NT-Xent loss. """
def __init__ ( self , temperature = 0.1 ): super (). __init__ () self . temperature = temperature
def forward ( self , z_i , z_j ):
""" z_i, z_j: (batch, seq_len, embedding_dim) - 두 개의 증강된 뷰(augmented views)의 임베딩 """
batch_size , seq_len , dim = z_i . shape # 대비 학습을 위해 시퀀스 차원 평탄화 z_i_flat = z_i . view ( - 1 , dim ) # (batch*seq_len, dim)
z_j_flat = z_j . view ( - 1 , dim ) # 임베딩 정규화
z_i_flat = nn . functional . normalize ( z_i_flat , dim = 1 )
z_j_flat = nn . functional . normalize ( z_j_flat , dim = 1 ) # 유사성 행렬 계산 sim_matrix = torch . matmul ( z_i_flat , z_j_flat . T ) / self . temperature # 레이블: 양의 쌍(positive pairs)은 대각선 요소임 labels = torch . arange ( batch_size * seq_len , device = z_i . device )
loss = nn . CrossEntropyLoss ()( sim_matrix , labels )
return loss 코드 예시 3: 패턴 인식 경로 정책 (Pattern-Aware Routing Policy)
클래스 PatternAwareRouter ( nn . Module ):
""" 경로 계획을 위해 학습된 시간적 임베딩을 사용함. """
def __init__ ( self , embedding_dim = 128 , action_dim = 4 ): super (). __init__ () self . embedding_proj = nn . Linear ( embedding_dim , 64 )
self . policy = nn . Sequential ( nn . Linear ( 64 + 3 , 128 ), # 3은 현재 위치(x,y,z)를 의미
n . ReLU (), nn . Linear ( 128 , action_dim ) # 상하좌우(up, down, left, right) 방향
)
def forward ( self , temporal_embedding , current_position ):
""" temporal_embedding: (batch, seq_len, embedding_dim)
current_position: (batch, 3) """
# 시간적 컨텍스트 집계 ctx = self . embedding_proj ( temporal_embedding . mean ( dim = 1 )) # 현재 위치와 결합 state = torch .

cat ([ ctx , current_position ], dim =- 1 ) # 출력 액션 확률 (Output action probabilities)
action_logits = self . policy ( state )
return torch . softmax ( action_logits , dim =- 1 )

훈련 전략 (Training Strategy)
이 아키텍처를 실험하면서, 극도로 희소한 데이터(extremely sparse data)의 경우 표준적인 대조 학습 (contrastive learning)이 붕괴된다는 것을 발견했습니다. 해결책은 다중 스케일 시간적 증강 (multi-scale temporal augmentation)이었습니다:

def augment_temporal ( sequence , mask , scale_factor = 0.5 ):
    """ 서브샘플링 (subsampling) 및 보간 (interpolating)을 통해 양성 쌍 (positive pairs)을 생성합니다. """
    # 가시적인 타임스탬프 서브샘플링
    visible_idx = torch . where ( mask )[ 0 ]
    num_keep = int ( len ( visible_idx ) * scale_factor )
    keep_idx = visible_idx [ torch . randperm ( len ( visible_idx ))[: num_keep ]]

    # 원래 길이로 보간
    augmented = torch . zeros_like ( sequence )
    augmented [ keep_idx ] = sequence [ keep_idx ]

    # 간극에 대한 선형 보간 (Linear interpolation)
    for i in range ( len ( keep_idx ) - 1 ):
        start , end = keep_idx [ i ], keep_idx [ i + 1 ]
        if end - start > 1 :
            augmented [ start : end + 1 ] = torch . linspace ( sequence [ start ], sequence [ end ], end - start + 1 )
    return augmented

실제 응용 분야: 연구실에서 하늘로 (Real-World Applications: From Lab to Sky)
사례 연구: 샌프란시스코 어반 캐년(Urban Canyon) 항법

샌프란시스코 금융 지구를 항행하는 시뮬레이션된 UAM 함대에 SSTPM 프레임워크를 배치했습니다. 베이스라인(baseline)—표준 PPO 기반의 강화학습 (RL) 에이전트—는 데이터가 희소한 조건에서 성공적인 경로가 12%에 불과하여 처참하게 실패했습니다. 반면 저의 SSTPM 에이전트는 다음과 같은 성과를 보였습니다:

- 100회의 자기지도 (self-supervised) 에포크 (epochs) 이후 경로 완수율 97%
- 풍향/풍속 패턴을 학습함으로써 에너지 효율 3.2배 향상
- 건물과의 충돌 0건 (베이스라인은 8건)

핵심은 시간적 인코더 (temporal encoder)가 반복되는 패턴—일일 풍향 변화, 교통 유발 난기류 주기, 심지어 에어컨 사용으로 인한 오후 5시의 배터리 소모 급증—을 인식하도록 학습했다는 점입니다.

Agentic AI 통합
시스템을 진정으로 자율적으로 만드는 방법을 탐구하면서, 저는 이를 계층적 에이전트 프레임워크 (hierarchical agentic framework)와 통합했습니다:

```python
class UAMAgent :
    """ 실시간 경로 설정을 위해 SSTPM을 사용하는 자율 에이전트. """
    def __init__ ( self , pattern_miner , router ):
        self . pattern_miner = pattern_miner
        self . router = router
        self . memory = deque ( maxlen = 1000 )

    def act ( self , sensor_stream ):
        # 최근 센서 데이터로부터 시계열 패턴 (temporal patterns) 마이닝
        pattern_embedding = self . pattern_miner . encode ( sensor_stream )
        # 다음 행동을 위해 라우터 (router)에 질의
        action = self . router ( pattern_embedding , self . get_position ())
        # 자기지도 업데이트 (self-supervised update)를 위해 경험 저장
        self . memory . append (( sensor_stream , action ))

        # 주기적인 자기지도 미세 조정 (self-supervised fine-tuning)
        if len ( self . memory ) % 100 == 0 :
            self . self_supervised_update ()
        return action

    def self_supervised_update ( self ):
        """ 새로운 데이터로부터의 온라인 자기지도 학습 (Online self-supervised learning). """
        batch = random . sample ( self . memory , min ( 32 , len ( self . memory )))
        streams = [ b [ 0 ] for b in batch ]

        # 증강 (augmentation)을 통해 양성 쌍 (positive pairs) 생성
        augmented_streams = [ augment_temporal ( s ) for s in streams ]

        # 대조 손실 (contrastive loss) 계산
        loss = self . contrastive_loss ( streams , augmented_streams )

        # 패턴 마이너 (pattern miner) 업데이트
        loss . backward ()
        self . optimizer . step ()

도전 과제 및 해결책

도전 과제 1: 온라인 학습 (Online Learning)에서의 파괴적 망각 (Catastrophic Forgetting)
에이전트가 지속적으로 자기지도를 수행하도록 처음 허용했을 때, 이전에 학습한 패턴을 빠르게 잊어버리는 문제가 발생했습니다. 해결책은 시계열 다양성 (temporal diversity)을 고려한 경험 재현 (experience replay)이었습니다:

class DiverseReplayBuffer :
    """ 버퍼가 다양한 시계열 패턴을 포함하도록 보장함. """
    def add ( self , experience ):
        # 시계열 패턴에 따라 경험을 클러스터링 (cluster)
        pattern_id = self . cluster ( experience [ 0 ]) # 센서 스트림 (sensor stream)
        self . buffers [ pattern_id ]. append ( experience )

        # 특정 패턴의 지배를 방지하기 위해 각 클러스터의 크기 제한
        if len ( self . buffers [ pattern_id ]) > 100 :
            self . buffers [ pattern_id ].

popleft()

도전 과제 2: 대조 학습 (Contrastive Learning)의 계산 비용
자기지도 학습 (Self-supervised learning)은 비용이 많이 드는 것으로 악명이 높습니다. 저는 학습 중에 시간적 서브샘플링 (temporal sub-sampling)을 사용하여 이를 최적화했습니다:

def efficient_training_loop ( model , data_loader , epochs = 100 ):
    for epoch in range ( epochs ):
        for batch in data_loader :
            # 대조 손실 (contrastive loss)을 위해 타임스탬프의 20%만 사용
            sampled_batch = sample_timestamps ( batch , ratio = 0.2 )
            # 재구성을 위한 전체 시퀀스 기반 순전파 (Forward pass)
            recon_loss = model . reconstruction_loss ( batch )
            # 샘플링된 서브셋에 대한 대조 손실 (Contrastive loss)
            contrastive_loss = model . contrastive_loss ( sampled_batch )
            total_loss = recon_loss + 0.3 * contrastive_loss
            total_loss . backward ( )

도전 과제 3: 다중 모달 센서 퓨전 (Multi-Modal Sensor Fusion) 처리
UAM 드론은 GPS, IMU, 기압계 (barometer), 카메라, 그리고 LiDAR를 탑재하고 있습니다. 모든 특징 (features)을 단순히 연결 (concatenate)하려 했던 저의 초기 시도는 실패했습니다. 돌파구는 교차 모달 시간적 정렬 (cross-modal temporal alignment)이었습니다:

class CrossModalAlignment ( nn . Module ):
    """ 
    서로 다른 센서 모달리티 (modalities) 간의 시간적 패턴을 정렬합니다. 
    """
    def forward ( self , gps_seq , imu_seq , camera_seq ):
        # 모든 모달리티를 동일한 시간 해상도로 투영 (Project)
        gps_aligned = self . interpolate ( gps_seq , target_len = 100 )
        imu_aligned = self . interpolate ( imu_seq , target_len = 100 )
        camera_aligned = self . interpolate ( camera_seq , target_len = 100 )
        
        # 교차 모달 대조 손실 (Cross-modal contrastive loss)
        loss = 0
        for mod1 , mod2 in [( gps_aligned , imu_aligned ), ( gps_aligned , camera_aligned ), ( imu_aligned , camera_aligned )]:
            loss += self . contrastive_loss ( mod1 , mod2 )
        return loss

양자 컴퓨팅 (Quantum Computing) 응용: 미래를 엿보다
최적화를 위한 양자 컴퓨팅 조사를 진행하던 중, SSTPM의 시간적 패턴 마이닝 (temporal pattern mining)이 양자 어닐링 (quantum annealing)을 사용하여 극적으로 가속화될 수 있음을 발견했습니다. 패턴 마이닝 문제는 지배적인 시간적 고유 모드 (temporal eigenmodes)를 찾는 문제로 귀결되며, 이는 양자 변분 알고리즘 (quantum variational algorithms)에 이상적으로 적합한 작업입니다.

양자 강화 패턴 마이닝 (Quantum-Enhanced Pattern Mining) # 개념적 양자 패턴 마이닝 (시뮬레이션)

def quantum_pattern_mining ( embeddings , num_qubits = 8 ):
    """ 양자 어닐링 (quantum annealing)을 사용하여 최적의 시계열 클러스터를 찾습니다. """
    # 임베딩 (embeddings)을 양자 상태로 인코딩
    q_embeddings = angle_encoding ( embeddings )
    # 클러스터 중심점 (cluster centroids)을 위한 변분 양자 고유값 솔버 (VQE)
    cluster_centroids = vqe ( q_embeddings , num_qubits )
    # 중심점을 다시 시계열 패턴으로 디코딩
    patterns = decode_quantum_state ( cluster_centroids )
    return patterns

양자 하드웨어가 실시간 UAM 경로 설정에 아직 실용적으로 적용될 단계는 아니지만, 이 접근 방식은 미래의 양자 프로세서에서 패턴 마이닝 시간을 수 시간에서 밀리초(milliseconds) 단위로 단축할 수 있습니다.

향후 연구 방향

1. 연합 자기지도 학습 (Federated Self-Supervised Learning)
   여러 대의 UAM 항공기가 원시 데이터 (raw data)를 공유하지 않고도 협력적으로 시계열 패턴을 학습할 수 있습니다. 저는 각 드론이 로컬 SSTPM 모델을 학습하고 암호화된 패턴 임베딩 (pattern embeddings)만을 공유하는 개인정보 보호 프레임워크를 탐구하고 있습니다.

2. 인과적 시계열 마이닝 (Causal Temporal Mining)
   현재의 SSTPM은 상관관계 (correlation)를 학습하며