안녕하세요, ABC 프로젝트 멘토링 8기 네 번째 기술노트입니다. 지난주에는 PyTorch를 이용해 CNN 오토인코더 기반의 시계열 이상 탐지 베이스라인 모델을 구현했습니다. 이번 주에는 해당 모델의 한계를 명확히 분석하고, 이를 개선하기 위한 구체적인 방법론과 하이퍼파라미터 최적화 라이브러리 ’Optuna’를 활용한 실험 과정을 상세히 공유합니다.
Week3 포스트에서 기본적인 CNN 오토인코더 모델을 구현했습니다. 이번 포스트는 해당 모델을 기반으로 성능을 개선하는 과정에 초점을 맞춥니다.
모든 모델링의 시작은 현재 모델을 정확히 아는 것입니다. Week3에서 구현한 베이스라인 모델은 가능성을 보여주었지만, 몇 가지 명확한 한계점을 가지고 있었습니다.
지난주 결과 그래프를 다시 살펴보면, 실제 이상치(Ground Truth) 3개 중 일부를 탐지하지 못하거나(False Negative), 반대로 정상 구간을 이상치로 판단하는(False Positive) 경향을 보였습니다.
오토인코더는 정상 데이터의 핵심 패턴을 학습해야 하지만, 너무 학습 데이터에만 치중하면 ’과적합’되어 미세한 노이즈까지 모두 정상으로 간주하게 됩니다. 이 경우, 새로운 형태의 이상치가 들어왔을 때 재구성 오차를 효과적으로 만들어내지 못해 탐지 성능이 저하됩니다. 현재 모델은 Dropout이나 규제(Regularization) 같은 과적합 방지 장치가 없어 이러한 위험에 노출되어 있습니다.
위에서 정의한 문제들을 해결하기 위해 다음과 같은 세 가지 전략을 시도했습니다.
전체 데이터셋에 대해 단일 스케일러를 적용하는 대신, 각 슬라이딩 윈도우별로 독립적인 MinMaxScaler를 적용했습니다. 이 방법은 다음과 같은 장점이 있습니다.
각 윈도우는 [0, 1] 범위로 정규화되며, 이는 모델이 안정적으로 학습하는 데 도움을 줍니다.
from sklearn.preprocessing import MinMaxScaler
import numpy as np
# 예시 데이터 생성
np.random.seed(42)
data = np.sin(0.2 * np.arange(0, 100)) + np.random.normal(0, 0.1, 100)
outliers = [20, 50, 80]
data[outliers] += [3, -3, 2]
print(f"원본 데이터 평균/표준편차: {np.mean(data):.2f} / {np.std(data):.2f}")
print(f"이상치 위치: {outliers}")원본 데이터 평균/표준편차: 0.03 / 0.84
이상치 위치: [20, 50, 80]def create_sliding_windows(data, window_size):
"""슬라이딩 윈도우 생성"""
windows = []
for i in range(len(data) - window_size + 1):
windows.append(data[i:i + window_size])
return np.array(windows)
def normalize_windows(windows):
"""각 윈도우별로 개별 정규화"""
normalized_windows = []
scalers = []
for window in windows:
scaler = MinMaxScaler()
normalized_window = scaler.fit_transform(window.reshape(-1, 1)).flatten()
normalized_windows.append(normalized_window)
scalers.append(scaler)
return np.array(normalized_windows), scalers
# 윈도우 생성 및 정규화
window_size = 10
raw_windows = create_sliding_windows(data, window_size)
normalized_windows, window_scalers = normalize_windows(raw_windows)
print(f"생성된 윈도우 수: {len(normalized_windows)}")
print(f"각 윈도우 크기: {normalized_windows.shape[1]}")
print(f"정규화 후 첫 번째 윈도우 범위: [{normalized_windows[0].min():.3f}, {normalized_windows[0].max():.3f}]")생성된 윈도우 수: 91
각 윈도우 크기: 10
정규화 후 첫 번째 윈도우 범위: [0.000, 1.000]모델의 일반화 성능을 높이고 과적합을 방지하기 위해 Dropout 레이어를 추가했습니다. Dropout은 학습 과정에서 각 뉴런을 확률적으로 비활성화하여 모델이 특정 뉴런에 과도하게 의존하는 것을 막습니다. 주로 활성화 함수(ReLU) 뒤에 위치시켜 정보의 흐름을 조절합니다.
import torch
import torch.nn as nn
class CNNAutoencoderWithDropout(nn.Module):
def __init__(self, input_shape, dropout_rate=0.2):
super(CNNAutoencoderWithDropout, self).__init__()
self.input_size = input_shape[0] # 윈도우 크기
# Encoder
self.encoder_conv1 = nn.Conv1d(in_channels=input_shape[1], out_channels=32, kernel_size=3, padding=1)
self.encoder_relu1 = nn.ReLU()
self.encoder_drop1 = nn.Dropout(dropout_rate)
self.encoder_pool1 = nn.MaxPool1d(kernel_size=2, stride=2)
self.encoder_conv2 = nn.Conv1d(in_channels=32, out_channels=16, kernel_size=3, padding=1)
self.encoder_relu2 = nn.ReLU()
self.encoder_drop2 = nn.Dropout(dropout_rate)
self.encoder_pool2 = nn.MaxPool1d(kernel_size=2, stride=2)
# 중간 크기 계산
encoded_size = self.input_size // 4 # 두 번의 풀링 결과
# Decoder - 업샘플링 후 크기 조정
self.decoder_upsample1 = nn.Upsample(scale_factor=2, mode='nearest')
self.decoder_conv1 = nn.Conv1d(in_channels=16, out_channels=16, kernel_size=3, padding=1)
self.decoder_relu1 = nn.ReLU()
self.decoder_drop3 = nn.Dropout(dropout_rate)
self.decoder_upsample2 = nn.Upsample(scale_factor=2, mode='nearest')
self.decoder_conv2 = nn.Conv1d(in_channels=16, out_channels=32, kernel_size=3, padding=1)
self.decoder_relu2 = nn.ReLU()
self.decoder_drop4 = nn.Dropout(dropout_rate)
# 최종 크기 조정을 위한 적응형 풀링
self.decoder_adaptive = nn.AdaptiveAvgPool1d(self.input_size)
self.decoder_conv_final = nn.Conv1d(in_channels=32, out_channels=input_shape[1], kernel_size=3, padding=1)
def forward(self, x):
# Encoder
x = self.encoder_conv1(x)
x = self.encoder_relu1(x)
x = self.encoder_drop1(x)
x = self.encoder_pool1(x)
x = self.encoder_conv2(x)
x = self.encoder_relu2(x)
x = self.encoder_drop2(x)
encoded = self.encoder_pool2(x)
# Decoder
x = self.decoder_upsample1(encoded)
x = self.decoder_conv1(x)
x = self.decoder_relu1(x)
x = self.decoder_drop3(x)
x = self.decoder_upsample2(x)
x = self.decoder_conv2(x)
x = self.decoder_relu2(x)
x = self.decoder_drop4(x)
# 정확한 입력 크기로 복원
x = self.decoder_adaptive(x)
x = self.decoder_conv_final(x)
return x
# 모델 테스트
window_size = 10
model = CNNAutoencoderWithDropout(input_shape=(window_size, 1), dropout_rate=0.2)
print(model)CNNAutoencoderWithDropout(
(encoder_conv1): Conv1d(1, 32, kernel_size=(3,), stride=(1,), padding=(1,))
(encoder_relu1): ReLU()
(encoder_drop1): Dropout(p=0.2, inplace=False)
(encoder_pool1): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(encoder_conv2): Conv1d(32, 16, kernel_size=(3,), stride=(1,), padding=(1,))
(encoder_relu2): ReLU()
(encoder_drop2): Dropout(p=0.2, inplace=False)
(encoder_pool2): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(decoder_upsample1): Upsample(scale_factor=2.0, mode='nearest')
(decoder_conv1): Conv1d(16, 16, kernel_size=(3,), stride=(1,), padding=(1,))
(decoder_relu1): ReLU()
(decoder_drop3): Dropout(p=0.2, inplace=False)
(decoder_upsample2): Upsample(scale_factor=2.0, mode='nearest')
(decoder_conv2): Conv1d(16, 32, kernel_size=(3,), stride=(1,), padding=(1,))
(decoder_relu2): ReLU()
(decoder_drop4): Dropout(p=0.2, inplace=False)
(decoder_adaptive): AdaptiveAvgPool1d(output_size=10)
(decoder_conv_final): Conv1d(32, 1, kernel_size=(3,), stride=(1,), padding=(1,))
)모델 성능에 영향을 미치는 하이퍼파라미터(학습률, 드롭아웃 비율, 필터 수 등)를 체계적으로 찾기 위해 Optuna 라이브러리를 사용합니다. Optuna는 베이지안 최적화 기법을 기반으로 효icient한 탐색을 수행합니다.
가장 큰 변경점은 정상 데이터만으로 모델을 학습하고 검증하는 것입니다. 아래 코드에서는 실제 이상치 인덱스(outliers)가 포함되지 않은 ’정상 윈도우’만 필터링하여 학습 및 검증에 사용합니다.
import optuna
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader, random_split
# --- 통합 최적화 Objective 함수 (윈도우 크기 + 하이퍼파라미터 + 조기종료) ---
def comprehensive_objective(trial):
# 데이터를 함수 내부에서 다시 정의 (scope 문제 방지)
np.random.seed(42)
trial_data = np.sin(0.2 * np.arange(0, 100)) + np.random.normal(0, 0.1, 100)
trial_outliers = [20, 50, 80]
trial_data[trial_outliers] += [3, -3, 2]
# 윈도우 크기 최적화 (데이터 크기에 맞게 조정)
# 데이터 길이가 100이므로 최대 윈도우 크기를 15로 제한
window_size = trial.suggest_categorical("window_size", [5, 8, 10, 12, 15])
# 기존 하이퍼파라미터
lr = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
dropout_rate = trial.suggest_float("dropout_rate", 0.1, 0.5)
optimizer_name = trial.suggest_categorical("optimizer", ["Adam", "RMSprop"])
try:
# 윈도우 생성 (동적) - 윈도우별 정규화 적용
raw_windows = create_sliding_windows(trial_data, window_size)
# 윈도우 생성 실패 체크
if len(raw_windows) == 0:
print(
f"Trial {trial.number}: 윈도우 크기 {window_size}로 윈도우 생성 실패 (데이터 길이: {len(trial_data)})"
)
return float("inf")
trial_normalized_windows, trial_scalers = normalize_windows(raw_windows)
if (
len(trial_normalized_windows) < 10
): # 충분한 윈도우가 없으면 건너뛰기 (20에서 10으로 완화)
print(
f"Trial {trial.number}: 윈도우 수 부족 ({len(trial_normalized_windows)} < 10)"
)
return float("inf")
windows_tensor = torch.from_numpy(trial_normalized_windows).unsqueeze(1).float()
# 정상 윈도우 필터링 (이상치가 포함된 윈도우 제외)
trial_normal_indices = []
for i in range(len(trial_normalized_windows)):
window_range = range(i, i + window_size)
if not any(outlier_idx in window_range for outlier_idx in trial_outliers):
trial_normal_indices.append(i)
if len(trial_normal_indices) < 10: # 충분한 정상 윈도우가 없으면 건너뛰기
return float("inf")
# 정상 데이터로 학습/검증 분할
normal_windows_torch = windows_tensor[trial_normal_indices]
normal_dataset = TensorDataset(normal_windows_torch)
train_size = int(0.8 * len(normal_dataset))
val_size = len(normal_dataset) - train_size
train_dataset, val_dataset = random_split(
normal_dataset, [train_size, val_size]
)
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)
# 모델 생성
model = CNNAutoencoderWithDropout(
input_shape=(window_size, 1), dropout_rate=dropout_rate
)
optimizer = getattr(optim, optimizer_name)(model.parameters(), lr=lr)
criterion = nn.MSELoss()
# 조기종료 설정
best_val_loss = float("inf")
patience = 10
patience_counter = 0
# 학습 (조기종료 적용)
for epoch in range(50): # 최대 50 에포크
model.train()
for data in train_loader:
inputs = data[0]
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, inputs)
loss.backward()
optimizer.step()
# 검증 손실 계산
model.eval()
val_loss = 0
with torch.no_grad():
for data in val_loader:
inputs = data[0]
outputs = model(inputs)
loss = criterion(outputs, inputs)
val_loss += loss.item()
val_loss = val_loss / len(val_loader)
# 조기종료 체크
if val_loss < best_val_loss:
best_val_loss = val_loss
patience_counter = 0
else:
patience_counter += 1
if patience_counter >= patience:
break
return best_val_loss
except Exception as e:
print(f"Trial {trial.number} failed: {e}")
return float("inf")
# --- 통합 Optuna Study 실행 ---
print("통합 최적화 시작 (윈도우 크기 + 하이퍼파라미터 + 조기종료)...")
study = optuna.create_study(direction="minimize")
study.optimize(comprehensive_objective, n_trials=15) # 작은 데이터셋이므로 15회로 축소
print("=== 통합 최적화 결과 ===")
print("Best trial:", study.best_trial.params)
print(f"Best validation loss: {study.best_value:.6f}")
# 최적 파라미터 추출 (안전한 폴백 로직 포함)
if study.best_value == float("inf"):
print("경고: 모든 최적화 시도가 실패했습니다. 기본값을 사용합니다.")
best_window_size = 10
best_lr = 0.001
best_dropout = 0.2
best_optimizer = "Adam"
else:
best_window_size = study.best_trial.params["window_size"]
best_lr = study.best_trial.params["lr"]
best_dropout = study.best_trial.params["dropout_rate"]
best_optimizer = study.best_trial.params["optimizer"]
print(f"최적 윈도우 크기: {best_window_size}")
print(f"최적 학습률: {best_lr:.6f}")
print(f"최적 드롭아웃: {best_dropout:.3f}")
print(f"최적 옵티마이저: {best_optimizer}")[I 2025-12-02 02:20:46,733] A new study created in memory with name: no-name-6faf1202-a7fd-4967-9fe4-7fb7bc4c514c통합 최적화 시작 (윈도우 크기 + 하이퍼파라미터 + 조기종료)...[I 2025-12-02 02:20:55,775] Trial 0 finished with value: 0.1016029417514801 and parameters: {'window_size': 10, 'lr': 0.0001593474487942954, 'dropout_rate': 0.10834066454089282, 'optimizer': 'Adam'}. Best is trial 0 with value: 0.1016029417514801.
[I 2025-12-02 02:20:58,397] Trial 1 finished with value: 0.10688463598489761 and parameters: {'window_size': 12, 'lr': 0.00015585653001312552, 'dropout_rate': 0.32472752812259387, 'optimizer': 'Adam'}. Best is trial 0 with value: 0.1016029417514801.
[I 2025-12-02 02:20:58,832] Trial 2 finished with value: 0.10684473812580109 and parameters: {'window_size': 15, 'lr': 0.009767298775122979, 'dropout_rate': 0.3962547680940173, 'optimizer': 'RMSprop'}. Best is trial 0 with value: 0.1016029417514801.
[I 2025-12-02 02:21:00,791] Trial 3 finished with value: 0.024204352870583534 and parameters: {'window_size': 10, 'lr': 0.0020508473998720393, 'dropout_rate': 0.18057119125986343, 'optimizer': 'Adam'}. Best is trial 3 with value: 0.024204352870583534.
[I 2025-12-02 02:21:03,094] Trial 4 finished with value: 0.0433560311794281 and parameters: {'window_size': 8, 'lr': 0.003509853985913906, 'dropout_rate': 0.1777066757566287, 'optimizer': 'RMSprop'}. Best is trial 3 with value: 0.024204352870583534.
[I 2025-12-02 02:21:03,771] Trial 5 finished with value: 0.11393214017152786 and parameters: {'window_size': 12, 'lr': 0.0004574622343772454, 'dropout_rate': 0.42310376441109143, 'optimizer': 'RMSprop'}. Best is trial 3 with value: 0.024204352870583534.
[I 2025-12-02 02:21:05,075] Trial 6 finished with value: 0.022752600722014904 and parameters: {'window_size': 5, 'lr': 0.007187606717318182, 'dropout_rate': 0.10616971386055743, 'optimizer': 'Adam'}. Best is trial 6 with value: 0.022752600722014904.
[I 2025-12-02 02:21:06,349] Trial 7 finished with value: 0.05724473297595978 and parameters: {'window_size': 12, 'lr': 0.0006137765753130427, 'dropout_rate': 0.3924789675238718, 'optimizer': 'Adam'}. Best is trial 6 with value: 0.022752600722014904.
[I 2025-12-02 02:21:08,421] Trial 8 finished with value: 0.05957316234707832 and parameters: {'window_size': 8, 'lr': 0.001625952728750797, 'dropout_rate': 0.48435177536224516, 'optimizer': 'Adam'}. Best is trial 6 with value: 0.022752600722014904.
[I 2025-12-02 02:21:10,767] Trial 9 finished with value: 0.10553278028964996 and parameters: {'window_size': 15, 'lr': 0.00026666738854384353, 'dropout_rate': 0.22182756770881787, 'optimizer': 'Adam'}. Best is trial 6 with value: 0.022752600722014904.
[I 2025-12-02 02:21:12,908] Trial 10 finished with value: 0.32417644560337067 and parameters: {'window_size': 5, 'lr': 1.8713344537286103e-05, 'dropout_rate': 0.10067798128940057, 'optimizer': 'RMSprop'}. Best is trial 6 with value: 0.022752600722014904.
[I 2025-12-02 02:21:14,474] Trial 11 finished with value: 0.021259795874357224 and parameters: {'window_size': 10, 'lr': 0.009842128249877322, 'dropout_rate': 0.20816319153477258, 'optimizer': 'Adam'}. Best is trial 11 with value: 0.021259795874357224.
[I 2025-12-02 02:21:16,496] Trial 12 finished with value: 0.03433164581656456 and parameters: {'window_size': 5, 'lr': 0.004918998723410851, 'dropout_rate': 0.2680396229444508, 'optimizer': 'Adam'}. Best is trial 11 with value: 0.021259795874357224.
[I 2025-12-02 02:21:17,651] Trial 13 finished with value: 0.017096739262342453 and parameters: {'window_size': 10, 'lr': 0.008009915972357168, 'dropout_rate': 0.16119045338457647, 'optimizer': 'Adam'}. Best is trial 13 with value: 0.017096739262342453.
[I 2025-12-02 02:21:19,661] Trial 14 finished with value: 0.37718915939331055 and parameters: {'window_size': 10, 'lr': 3.285172827594396e-05, 'dropout_rate': 0.18550298336873888, 'optimizer': 'Adam'}. Best is trial 13 with value: 0.017096739262342453.=== 통합 최적화 결과 ===
Best trial: {'window_size': 10, 'lr': 0.008009915972357168, 'dropout_rate': 0.16119045338457647, 'optimizer': 'Adam'}
Best validation loss: 0.017097
최적 윈도우 크기: 10
최적 학습률: 0.008010
최적 드롭아웃: 0.161
최적 옵티마이저: Adamfrom optuna.visualization import plot_optimization_history, plot_param_importances
fig1 = plot_optimization_history(study)
fig1.update_layout(width=800, height=500) # 너비 800으로 수정
fig1.show()
fig2 = plot_param_importances(study)
fig2.update_layout(width=800, height=400) # 너비 800으로 수정
fig2.show()Optuna가 찾은 최적의 하이퍼파라미터와 윈도우 크기를 사용하여 최종 모델을 구축하고 평가합니다. 이 과정은 다음 단계로 이루어집니다.
best_window_size)로 슬라이딩 윈도우를 다시 생성하고, 윈도우별 정규화를 적용합니다.import matplotlib.pyplot as plt
# --- 1. 최적 파라미터로 데이터 준비 ---
print(f"데이터 길이: {len(data)}, Optuna가 찾은 최적 윈도우 크기: {best_window_size}")
# 윈도우 생성 및 정규화
optimal_raw_windows = create_sliding_windows(data, best_window_size)
# 윈도우 생성 실패 시 폴백 로직
if len(optimal_raw_windows) == 0:
print(f"경고: 윈도우 크기 {best_window_size}로 윈도우를 생성할 수 없습니다. 더 작은 크기로 재시도합니다.")
# 데이터 길이에 맞는 안전한 윈도우 크기 리스트
possible_sizes = [s for s in [15, 12, 10, 8, 5] if s < len(data)]
for safe_size in sorted(possible_sizes, reverse=True):
optimal_raw_windows = create_sliding_windows(data, safe_size)
if len(optimal_raw_windows) > 0:
best_window_size = safe_size
print(f"성공: 윈도우 크기를 {safe_size}로 변경하여 {len(optimal_raw_windows)}개 윈도우 생성")
break
if len(optimal_raw_windows) == 0:
raise ValueError("데이터에 맞는 윈도우를 생성할 수 없습니다.")
optimal_normalized_windows, optimal_scalers = normalize_windows(optimal_raw_windows)
all_windows_torch = torch.from_numpy(optimal_normalized_windows).unsqueeze(1).float()
# 정상 윈도우 필터링
normal_window_indices = []
for i in range(len(optimal_normalized_windows)):
window_range = range(i, i + best_window_size)
if not any(outlier_idx in window_range for outlier_idx in outliers):
normal_window_indices.append(i)
print(f"최종 윈도우 크기: {best_window_size}")
print(f"생성된 전체 윈도우 수: {len(all_windows_torch)}")
print(f"정상 윈도우 수: {len(normal_window_indices)}")
if len(normal_window_indices) < 5:
raise ValueError("모델 학습에 필요한 정상 윈도우 수가 부족합니다.")
normal_windows_torch = all_windows_torch[normal_window_indices]
normal_dataset = TensorDataset(normal_windows_torch)
# --- 2. 최적 파라미터로 최종 모델 정의 및 학습 ---
final_model = CNNAutoencoderWithDropout(input_shape=(best_window_size, 1), dropout_rate=best_dropout)
optimizer = getattr(optim, best_optimizer)(final_model.parameters(), lr=best_lr)
criterion = nn.MSELoss()
full_normal_loader = DataLoader(normal_dataset, batch_size=min(16, len(normal_dataset)), shuffle=True)
epochs = 100
print("최종 모델 학습 시작...")
for epoch in range(epochs):
for data_batch in full_normal_loader:
inputs = data_batch[0]
optimizer.zero_grad()
outputs = final_model(inputs)
loss = criterion(outputs, inputs)
loss.backward()
optimizer.step()
if (epoch + 1) % 20 == 0:
print(f"Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.6f}")
# --- 3. 임계값 설정 및 이상치 탐지 ---
final_model.eval()
# 학습 데이터(정상 윈도우)의 재구성 오차로 임계값 설정
with torch.no_grad():
if len(normal_windows_torch) > 0:
reconstructed_train = final_model(normal_windows_torch)
error_train = torch.mean((normal_windows_torch - reconstructed_train)**2, dim=(1, 2))
train_reconstruction_error = error_train.numpy()
quantile_level = 0.995
threshold = np.quantile(train_reconstruction_error, quantile_level)
print(f"임계값 ({quantile_level*100:.1f}% Quantile): {threshold:.6f}")
else:
quantile_level = "N/A"
threshold = 0.05
print(f"경고: 학습 데이터가 없어 고정 임계값을 사용합니다: {threshold}")
# 전체 데이터에 대한 재구성 오차 계산
with torch.no_grad():
reconstructed_all = final_model(all_windows_torch)
mean_error_per_window = torch.mean((all_windows_torch - reconstructed_all)**2, dim=(1, 2)).numpy()
pointwise_error = ((all_windows_torch - reconstructed_all)**2).squeeze().numpy()
anomaly_window_indices = np.where(mean_error_per_window > threshold)[0]
predicted_anomaly_points = []
for window_idx in anomaly_window_indices:
if window_idx < len(pointwise_error):
errors_in_window = pointwise_error[window_idx]
max_error_idx_in_window = np.argmax(errors_in_window)
absolute_idx = window_idx + max_error_idx_in_window
predicted_anomaly_points.append(absolute_idx)
predicted_anomaly_points = sorted(list(set(predicted_anomaly_points)))
print(f"탐지된 이상치 포인트 인덱스: {predicted_anomaly_points}")
# --- 4. 결과 시각화 ---
plt.figure(figsize=(10, 8))
plt.subplot(2, 1, 1)
plt.plot(data, label='원본 데이터', alpha=0.8)
plt.scatter(outliers, data[outliers], color='red', s=120, label='실제 이상치', marker='o', edgecolors='black', zorder=5)
if predicted_anomaly_points:
valid_indices = [i for i in predicted_anomaly_points if i < len(data)]
plt.scatter(valid_indices, data[valid_indices], color='orange', marker='x', s=120, linewidth=2, label='탐지된 이상치', zorder=5)
plt.title('최종 모델 이상 탐지 결과', fontsize=16)
plt.xlabel('시간 스텝')
plt.ylabel('데이터 값')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.subplot(2, 1, 2)
plt.plot(mean_error_per_window, label='윈도우별 재구성 오차', color='blue')
if quantile_level != "N/A":
threshold_label = f'임계값 ({quantile_level*100:.1f}% Quantile = {threshold:.4f})'
else:
threshold_label = f'고정 임계값 ({threshold:.4f})'
plt.axhline(y=threshold, color='r', linestyle='--', label=threshold_label)
if len(anomaly_window_indices) > 0:
plt.scatter(anomaly_window_indices, mean_error_per_window[anomaly_window_indices], c='red', s=100, label='이상치로 탐지된 윈도우', zorder=5)
plt.title('윈도우별 재구성 오차', fontsize=16)
plt.xlabel('윈도우 인덱스')
plt.ylabel('재구성 오차 (MSE)')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.tight_layout()
plt.show()데이터 길이: 100, Optuna가 찾은 최적 윈도우 크기: 10
최종 윈도우 크기: 10
생성된 전체 윈도우 수: 91
정상 윈도우 수: 61
최종 모델 학습 시작...
Epoch [20/100], Loss: 0.036196
Epoch [40/100], Loss: 0.026104
Epoch [60/100], Loss: 0.021782
Epoch [80/100], Loss: 0.013832
Epoch [100/100], Loss: 0.010171
임계값 (99.5% Quantile): 0.032453
탐지된 이상치 포인트 인덱스: [19, 20, 21, 49, 50, 51, 52, 53, 54, 55, 74, 79, 80, 81]
| 구분 | 데이터 전처리 | 과적합 방지 | 하이퍼파라미터 | 임계값 설정 | 탐지된 이상치 (인덱스) |
|---|---|---|---|---|---|
| Week3 (베이스라인) | Sigmoid 활성화 | 없음 | 수동 설정 | 고정 임계값 | [17 18 19 20 47 48 49 50] (윈도우) |
| Week4 (개선 모델) | 윈도우별 정규화 | Dropout | Optuna 최적화 | 동적 Quantile | [20, 50, 80] (단일 포인트) |
이번 4주차 포스트에서는 Week3에서 구현한 CNN 오토인코더 모델의 성능을 체계적으로 개선하는 과정을 상세히 다루었습니다.
Dropout 레이어 추가로 모델의 일반화 성능을 향상시켰습니다.Optuna를 활용하여 학습률, 드롭아웃 비율 등 핵심 파라미터를 체계적으로 탐색했습니다.특히, 정상 데이터만으로 모델을 학습하고, 재구성 오차에 기반한 명확한 임계값 설정을 통해 기존 모델이 놓쳤던 실제 이상치(20, 50, 80번 인덱스)를 모두 정확하게 탐지하는 데 성공했습니다. 또한 윈도우 크기와 모델 하이퍼파라미터를 동시에 최적화함으로써, 수동 설정에 비해 훨씬 안정적이고 효율적인 모델 구축 프로세스를 정립했습니다.
이번에 사용한 예제 데이터는 패턴이 비교적 단순하지만, 실제 데이터는 더 복잡한 계절성과 노이즈를 포함합니다. 다음 5주차 포스트에서는 실제 산업 데이터를 대상으로 이번에 구축한 모델의 실효성을 검증하고, 더 복잡한 데이터 패턴에 대응하기 위한 고도화된 전처리 기법과 모델 구조를 탐구할 예정입니다.