Data-SSung

머신러닝 파이프라인 완벽 가이드: 프로젝트 성공의 핵심 워크플로우

Data-SSung — Thu, 3 Jul 2025 23:54:52 +0900

머신러닝 파이프라인이란?

머신러닝 파이프라인은 데이터 수집부터 모델 배포까지의 전체 과정을 체계적으로 관리하는 자동화된 워크플로우입니다. 마치 공장의 생산라인처럼 각 단계가 순차적으로 연결되어 있어, 효율적이고 일관된 머신러닝 개발을 가능하게 합니다.

왜 파이프라인이 중요할까요?

1. 재현성 보장

동일한 결과를 언제든지 다시 만들어낼 수 있습니다
실험 결과의 신뢰성을 높입니다

2. 자동화를 통한 효율성

반복적인 작업을 자동화하여 시간을 절약합니다
휴먼 에러를 최소화합니다

3. 협업 개선

팀원들과 일관된 방식으로 작업할 수 있습니다
코드의 가독성과 유지보수성이 향상됩니다

머신러닝 파이프라인의 7단계 워크플로우

1단계: 문제 정의 및 목표 설정

모든 머신러닝 프로젝트의 출발점입니다. 명확한 문제 정의 없이는 성공적인 프로젝트를 기대하기 어렵습니다.

핵심 질문들:

해결하고자 하는 비즈니스 문제는 무엇인가?
머신러닝이 정말 필요한 문제인가?
성공 지표는 무엇으로 측정할 것인가?

예시:

문제: 고객 이탈 예측
목표: 이탈 가능성이 높은 고객을 사전에 식별하여 맞춤형 마케팅 실시
성공 지표: 정밀도 85% 이상, 재현율 80% 이상

2단계: 데이터 수집 및 탐색

양질의 데이터는 머신러닝의 생명선입니다. 가비지 인, 가비지 아웃(Garbage In, Garbage Out)이라는 말처럼 데이터 품질이 모델 성능을 결정합니다.

데이터 수집 방법:

내부 데이터베이스
외부 API
웹 크롤링
공개 데이터셋

탐색적 데이터 분석(EDA) 체크리스트:

# 기본 정보 확인
print(f"데이터 크기: {df.shape}")
print(f"결측값: {df.isnull().sum()}")
print(f"데이터 타입: {df.dtypes}")

# 통계적 요약
df.describe()

# 상관관계 분석
correlation_matrix = df.corr()

3단계: 데이터 전처리 및 특성 공학

원시 데이터를 모델이 학습할 수 있는 형태로 변환하는 과정입니다. 전체 머신러닝 프로젝트 시간의 약 60-70%를 차지하는 중요한 단계입니다.

주요 전처리 작업:

결측값 처리:

# 수치형 데이터: 평균/중앙값으로 대체
df['age'].fillna(df['age'].median(), inplace=True)

# 범주형 데이터: 최빈값으로 대체
df['category'].fillna(df['category'].mode()[0], inplace=True)

이상치 탐지 및 처리:

# IQR 방법을 이용한 이상치 탐지
Q1 = df['price'].quantile(0.25)
Q3 = df['price'].quantile(0.75)
IQR = Q3 - Q1
outliers = df[(df['price'] < Q1 - 1.5 * IQR) | (df['price'] > Q3 + 1.5 * IQR)]

특성 공학 예시:

# 새로운 특성 생성
df['age_group'] = pd.cut(df['age'], bins=[0, 18, 35, 50, 100], labels=['청소년', '청년', '중년', '노년'])
df['income_per_family'] = df['income'] / df['family_size']

4단계: 모델 선택 및 학습

문제 유형에 따라 적절한 알고리즘을 선택하고 모델을 학습시킵니다.

문제 유형별 알고리즘 선택:

문제 유형 추천 알고리즘 특징

회귀 문제	Linear Regression, Random Forest, XGBoost	연속값 예측
분류 문제	Logistic Regression, SVM, Random Forest	범주 예측
군집화	K-Means, DBSCAN	비지도 학습

모델 학습 코드 예시:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 학습
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 예측 및 평가
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"정확도: {accuracy:.4f}")

5단계: 모델 평가 및 검증

모델의 성능을 객관적으로 평가하고 실제 환경에서의 성능을 예측합니다.

평가 지표:

분류 문제: 정확도, 정밀도, 재현율, F1-score, AUC-ROC
회귀 문제: MSE, RMSE, MAE, R²

교차 검증 예시:

from sklearn.model_selection import cross_val_score

# 5-fold 교차 검증
cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"교차 검증 평균 정확도: {cv_scores.mean():.4f} (+/- {cv_scores.std() * 2:.4f})")

6단계: 하이퍼파라미터 튜닝

모델의 성능을 최적화하기 위해 하이퍼파라미터를 조정합니다.

그리드 서치 예시:

from sklearn.model_selection import GridSearchCV

# 하이퍼파라미터 범위 설정
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5, 10]
}

# 그리드 서치 실행
grid_search = GridSearchCV(RandomForestClassifier(), param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print(f"최적 하이퍼파라미터: {grid_search.best_params_}")
print(f"최고 점수: {grid_search.best_score_:.4f}")

7단계: 모델 배포 및 모니터링

학습된 모델을 실제 환경에 배포하고 지속적으로 모니터링합니다.

배포 방법:

API 서버: Flask, FastAPI를 이용한 웹 API
클라우드 서비스: AWS SageMaker, Google Cloud ML Engine
엣지 배포: 모바일 앱, IoT 기기

모니터링 요소:

모델 성능 지표 추적
데이터 드리프트 감지
시스템 리소스 모니터링

파이프라인 자동화 도구들

1. Scikit-learn Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier

# 파이프라인 생성
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', RandomForestClassifier())
])

# 한 번에 전처리와 학습 수행
pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)

2. MLflow

실험 추적 및 관리
모델 버전 관리
모델 배포 자동화

3. Apache Airflow

복잡한 워크플로우 스케줄링
의존성 관리
장애 복구 기능

실전 파이프라인 구현 예시

다음은 고객 이탈 예측 파이프라인의 전체 코드입니다:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import joblib

class CustomerChurnPipeline:
    def __init__(self):
        self.scaler = StandardScaler()
        self.label_encoder = LabelEncoder()
        self.model = RandomForestClassifier(n_estimators=100, random_state=42)
        
    def preprocess_data(self, df):
        """데이터 전처리"""
        # 결측값 처리
        df['age'].fillna(df['age'].median(), inplace=True)
        
        # 범주형 변수 인코딩
        df['gender_encoded'] = self.label_encoder.fit_transform(df['gender'])
        
        # 특성 생성
        df['tenure_years'] = df['tenure'] / 12
        
        # 수치형 특성 정규화
        numerical_features = ['age', 'tenure', 'monthly_charges']
        df[numerical_features] = self.scaler.fit_transform(df[numerical_features])
        
        return df
    
    def train(self, X, y):
        """모델 학습"""
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        
        # 모델 학습
        self.model.fit(X_train, y_train)
        
        # 평가
        y_pred = self.model.predict(X_test)
        print("분류 리포트:")
        print(classification_report(y_test, y_pred))
        
        return self.model
    
    def save_model(self, filepath):
        """모델 저장"""
        joblib.dump(self.model, filepath)
    
    def load_model(self, filepath):
        """모델 로드"""
        self.model = joblib.load(filepath)

# 사용 예시
pipeline = CustomerChurnPipeline()
# 데이터 로드 및 전처리
df = pd.read_csv('customer_data.csv')
df_processed = pipeline.preprocess_data(df)
# 모델 학습
X = df_processed.drop('churn', axis=1)
y = df_processed['churn']
pipeline.train(X, y)
# 모델 저장
pipeline.save_model('churn_model.pkl')

파이프라인 최적화 팁

1. 버전 관리

데이터, 코드, 모델 모두 버전을 관리하세요
Git + DVC(Data Version Control) 조합을 추천합니다

2. 로깅 및 모니터링

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def train_model(X, y):
    logger.info("모델 학습 시작")
    # 모델 학습 코드
    logger.info("모델 학습 완료")

3. 테스트 자동화

import unittest

class TestPipeline(unittest.TestCase):
    def test_data_preprocessing(self):
        # 전처리 테스트
        pass
    
    def test_model_training(self):
        # 모델 학습 테스트
        pass

마무리

머신러닝 파이프라인은 성공적인 머신러닝 프로젝트의 핵심입니다. 체계적인 워크플로우를 구축하면 다음과 같은 이점을 얻을 수 있습니다:

재현 가능한 결과: 언제든지 동일한 결과를 얻을 수 있습니다
효율적인 개발: 자동화를 통해 시간을 절약할 수 있습니다
안정적인 운영: 체계적인 모니터링으로 안정적인 서비스를 제공할 수 있습니다

KNN(K-Nearest Neighbors) 알고리즘 완벽 가이드

Data-SSung — Wed, 2 Jul 2025 23:25:15 +0900

개요

KNN(K-Nearest Neighbors)은 머신러닝의 가장 직관적이고 간단한 알고리즘 중 하나입니다. "유유상종"이라는 속담처럼, 비슷한 특성을 가진 데이터들은 비슷한 결과를 가질 것이라는 가정에 기반합니다.

KNN 알고리즘이란?

KNN은 게으른 학습(Lazy Learning) 알고리즘으로, 별도의 훈련 과정 없이 새로운 데이터가 들어올 때 기존 데이터와의 거리를 계산하여 가장 가까운 K개의 이웃을 찾아 예측을 수행합니다.

주요 특징

비모수적(Non-parametric): 데이터의 분포에 대한 가정이 없음
인스턴스 기반 학습: 모든 훈련 데이터를 메모리에 저장
지연 학습: 예측 시점에 계산 수행

작동 원리

1. 거리 계산

새로운 데이터 포인트와 모든 훈련 데이터 간의 거리를 계산합니다.

유클리드 거리 (가장 일반적)

d = √[(x₁-x₂)² + (y₁-y₂)²]

맨하탄 거리

d = |x₁-x₂| + |y₁-y₂|

민코프스키 거리

d = (Σ|xᵢ-yᵢ|ᵖ)^(1/p)

2. K개의 최근접 이웃 선택

계산된 거리를 기준으로 가장 가까운 K개의 데이터 포인트를 선택합니다.

3. 예측 수행

분류 문제: 다수결 투표

K개 이웃 중 가장 많은 클래스로 분류

회귀 문제: 평균값 계산

K개 이웃의 타겟 값 평균 또는 가중 평균

핵심 매개변수

K값 선택

K값이 작을 때 (K=1, 3, 5)

장점: 지역적 패턴을 잘 포착
단점: 노이즈에 민감, 과적합 위험

K값이 클 때 (K=15, 20+)

장점: 노이즈에 강함, 안정적 예측
단점: 지역적 패턴 무시, 과소적합 위험

최적 K값 선택 방법

교차 검증을 통한 성능 평가
일반적으로 √n (n: 훈련 데이터 수)을 시작점으로 사용
홀수 선택 (분류에서 동점 방지)

장단점 분석

장점

구현 용이성: 알고리즘이 직관적이고 간단
범용성: 분류와 회귀 모두 적용 가능
비선형 패턴 처리: 복잡한 결정 경계 학습 가능
새로운 데이터 적응: 온라인 학습 가능

단점

계산 복잡도: O(n) - 모든 훈련 데이터와 거리 계산 필요
메모리 사용량: 모든 훈련 데이터를 저장해야 함
차원의 저주: 고차원에서 성능 저하
불균형 데이터: 다수 클래스에 편향

성능 최적화 방법

1. 데이터 전처리

# 특성 스케일링 (필수!)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

2. 차원 축소

# PCA를 통한 차원 축소
from sklearn.decomposition import PCA
pca = PCA(n_components=10)
X_reduced = pca.fit_transform(X)

3. 효율적인 탐색 알고리즘

KD-Tree: 저차원 데이터에 효과적
Ball Tree: 고차원 데이터에 적합
LSH (Locality Sensitive Hashing): 근사 최근접 이웃 탐색

실제 적용 예시

1. 추천 시스템

from sklearn.neighbors import NearestNeighbors

# 사용자-아이템 행렬 기반 협업 필터링
model = NearestNeighbors(n_neighbors=5, metric='cosine')
model.fit(user_item_matrix)

# 유사한 사용자 찾기
distances, indices = model.kneighbors(user_profile)

2. 이상치 탐지

from sklearn.neighbors import LocalOutlierFactor

# LOF를 이용한 이상치 탐지
lof = LocalOutlierFactor(n_neighbors=20)
outlier_scores = lof.fit_predict(data)

3. 분류 문제

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV

# 하이퍼파라미터 튜닝
param_grid = {
    'n_neighbors': [3, 5, 7, 9, 11],
    'weights': ['uniform', 'distance'],
    'metric': ['euclidean', 'manhattan']
}

knn = KNeighborsClassifier()
grid_search = GridSearchCV(knn, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

성능 평가 지표

분류 문제

정확도(Accuracy): 전체 예측 중 맞힌 비율
정밀도(Precision): 양성 예측 중 실제 양성 비율
재현율(Recall): 실제 양성 중 예측한 양성 비율
F1-Score: 정밀도와 재현율의 조화 평균

회귀 문제

MAE (Mean Absolute Error): 절대 오차의 평균
MSE (Mean Squared Error): 제곱 오차의 평균
RMSE (Root Mean Squared Error): MSE의 제곱근
R² Score: 결정계수

실전 팁

1. 데이터 전처리가 핵심

모든 특성을 동일한 스케일로 정규화
범주형 변수는 원-핫 인코딩 적용
결측값 처리 필수

2. K값 선택 전략

작은 데이터셋: K = 3~7
중간 데이터셋: K = √n
큰 데이터셋: 교차 검증으로 최적화

3. 거리 메트릭 선택

연속형 데이터: 유클리드 거리
범주형 데이터: 해밍 거리
고차원 데이터: 코사인 유사도

4. 불균형 데이터 처리

가중치 적용 (weights='distance')
SMOTE 등으로 데이터 증강
계층적 샘플링 사용

결론

KNN은 간단하면서도 강력한 알고리즘입니다. 특히 지역적 패턴이 중요한 문제나 복잡한 결정 경계를 가진 데이터에서 우수한 성능을 보입니다. 하지만 적절한 전처리와 하이퍼파라미터 튜닝이 성공의 열쇠입니다.

언제 KNN을 사용해야 할까요?

데이터의 지역적 패턴이 중요한 경우
비선형 관계를 모델링해야 하는 경우
해석 가능한 모델이 필요한 경우
소규모~중규모 데이터셋을 다루는 경우

랜덤포레스트(Random Forest) 완벽 가이드: 숲으로 보는 머신러닝

Data-SSung — Mon, 30 Jun 2025 16:39:23 +0900

중요한 결정을 내려야 한다면, 한 명의 전문가 의견을 듣는 것과 여러 명의 전문가 의견을 종합하는 것 중 어느 것이 더 신뢰할 만할까요? 대부분 후자를 선택할 것입니다. 랜덤포레스트는 바로 이런 "집단 지성"의 개념을 머신러닝에 적용한 알고리즘입니다.

랜덤포레스트란?

랜덤포레스트는 앙상블(Ensemble) 학습법의 대표적인 예시로, 여러 개의 의사결정트리(Decision Tree)를 결합하여 예측 성능을 향상시키는 알고리즘입니다. 이름 그대로 "무작위로 만든 숲"이라는 뜻으로, 수많은 나무(의사결정트리)들이 모여 하나의 숲을 이루는 구조입니다.

핵심 아이디어

배깅(Bagging): 원본 데이터에서 복원추출로 여러 개의 부분 데이터셋 생성
랜덤 특성 선택: 각 노드에서 무작위로 선택된 특성들만 사용
다수결 투표: 분류는 투표, 회귀는 평균으로 최종 결과 결정

랜덤포레스트의 작동 원리

1단계: 부트스트랩 샘플링

원본 데이터에서 복원추출로 여러 개의 훈련 데이터셋을 만듭니다. 각 데이터셋은 원본과 같은 크기지만 일부 데이터는 중복되고 일부는 누락됩니다.

2단계: 랜덤 특성 선택

각 의사결정트리를 학습할 때, 모든 특성을 사용하지 않고 무작위로 선택된 일부 특성만 사용합니다. 일반적으로 전체 특성의 제곱근 개수만큼 선택합니다.

3단계: 의사결정트리 학습

각각의 부트스트랩 샘플과 랜덤 특성 조합으로 의사결정트리를 학습시킵니다. 이때 각 트리는 서로 다른 패턴을 학습하게 됩니다.

4단계: 예측 결합

분류: 모든 트리의 예측 결과를 투표로 결정
회귀: 모든 트리의 예측값의 평균을 계산

랜덤포레스트의 장점

1. 높은 예측 성능

개별 의사결정트리보다 일반적으로 더 높은 정확도를 보입니다. 여러 모델의 예측을 결합함으로써 각 모델의 오차가 상쇄되는 효과를 얻습니다.

2. 과적합 방지

개별 트리는 과적합될 수 있지만, 여러 트리의 결과를 평균내면서 과적합이 크게 줄어듭니다. 특히 노이즈가 많은 데이터에서 강건한 성능을 보입니다.

3. 특성 중요도 제공

각 특성이 예측에 얼마나 기여하는지 자동으로 계산해줍니다. 이는 특성 선택이나 도메인 이해에 매우 유용합니다.

4. 결측값 처리

결측값이 있어도 비교적 잘 작동하며, 대체 분할 기준을 사용해 처리할 수 있습니다.

5. 병렬 처리 가능

각 트리는 독립적으로 학습되므로 병렬 처리가 가능하여 학습 속도를 크게 향상시킬 수 있습니다.

랜덤포레스트의 단점

1. 해석성 부족

개별 의사결정트리는 해석하기 쉽지만, 수백 개의 트리가 결합된 랜덤포레스트는 해석이 어렵습니다.

2. 메모리 사용량

여러 개의 트리를 저장해야 하므로 메모리 사용량이 상당히 클 수 있습니다.

3. 예측 시간

많은 트리의 예측을 결합해야 하므로 단일 트리보다 예측 시간이 길어집니다.

4. 범주형 특성 편향

범주가 많은 특성에 편향될 수 있으며, 이는 특성 중요도 계산에 영향을 줄 수 있습니다.

실제 활용 사례

1. 금융 분야

신용 평가: 고객의 신용도 예측
사기 탐지: 이상 거래 패턴 식별
주가 예측: 다양한 금융 지표 기반 주가 움직임 예측

2. 의료 분야

질병 진단: 의료 영상이나 검사 결과 기반 진단 보조
약물 효과 예측: 환자 특성에 따른 치료 효과 예측

3. 마케팅

고객 세분화: 구매 패턴 기반 고객 그룹 분류
추천 시스템: 사용자 선호도 예측
이탈 예측: 고객 이탈 가능성 사전 감지

4. 제조업

품질 관리: 제품 불량 예측
예측 정비: 장비 고장 시점 예측

하이퍼파라미터 튜닝 가이드

주요 파라미터

n_estimators: 트리 개수 (100~1000, 많을수록 성능 향상되지만 계산 비용 증가)
max_depth: 트리 최대 깊이 (과적합 방지를 위해 제한)
min_samples_split: 노드 분할 최소 샘플 수 (2~20)
min_samples_leaf: 리프 노드 최소 샘플 수 (1~10)
max_features: 각 분할에서 고려할 특성 수 ('sqrt', 'log2', 또는 정수)

튜닝 전략

기본값으로 시작: 대부분의 경우 기본 설정도 좋은 성능을 보입니다
n_estimators 조정: 성능이 포화될 때까지 트리 개수를 늘려봅니다
과적합 방지: max_depth, min_samples_split 등으로 복잡도를 조절합니다
교차 검증 활용: 그리드 서치나 랜덤 서치로 최적 조합을 찾습니다

랜덤포레스트는 사용하기 쉽고 강력한 성능을 보이는 만능 알고리즘입니다. 특별한 데이터 전처리 없이도 좋은 결과를 얻을 수 있어 머신러닝 입문자부터 전문가까지 널리 사용되고 있습니다.

다만, 모든 문제에 완벽한 해답은 아닙니다. 해석성이 중요한 경우에는 단순한 모델을, 매우 큰 데이터셋에서는 더 효율적인 알고리즘을 고려해볼 필요가 있습니다.

그럼에도 불구하고 랜덤포레스트는 여전히 많은 실무 환경에서 첫 번째 선택지로 고려되는 신뢰할 만한 알고리즘입니다. 여러분도 다음 프로젝트에서 랜덤포레스트를 활용해 "숲의 지혜"를 경험해보시기 바랍니다.

Isolation Forest: 이상탐지의 새로운 패러다임

Data-SSung — Sun, 22 Jun 2025 23:02:15 +0900

데이터 분석을 하다 보면 이상한 데이터를 찾아야 하는 경우가 많음.
신용카드 사기 거래, 시스템 해킹 시도, 제조 설비 이상 등 우리 주변에는 탐지해야 할 이상값들이 넘쳐남.

이런 이상값을 효과적으로 찾아내는 Isolation Forest 알고리즘에 대해 알아보자.

Isolation Forest란?

Isolation Forest는 이상탐지(Anomaly Detection)를 위한 비지도 학습 알고리즘

핵심 아이디어는 매우 직관적!

"이상한 데이터는 정상 데이터보다 쉽게 고립(isolation)된다"

마치 파티에서 혼자만 다른 옷을 입고 온 사람이 금방 눈에 띄는 것처럼, 이상값은 적은 분할로도 다른 데이터와 분리됨

⚙️ 작동 원리

1️⃣ 랜덤 분할

데이터를 무작위로 특성(feature)을 선택해 분할
트리 구조로 데이터를 나누어감

2️⃣ 분할 깊이 측정

정상 데이터: 많은 분할이 필요 (깊은 위치)
이상 데이터: 적은 분할로 고립 (얕은 위치)

3️⃣ 점수 계산

분할 깊이가 얕을수록 → 이상값 점수 높음
분할 깊이가 깊을수록 → 정상값 점수 높음

✨ 주요 특징

장점

⚡ 빠른 속도

시간복잡도: O(n log n)
대용량 데이터 처리 가능

메모리 효율

전체 데이터를 메모리에 저장할 필요 없음
트리 구조만 유지

파라미터 단순

복잡한 하이퍼파라미터 튜닝 불필요
기본 설정으로도 좋은 성능

확장성

고차원 데이터에서도 효과적
실시간 처리 가능

한계점

정상 데이터 가정

대부분의 데이터가 정상이라고 가정
이상값 비율이 높으면 성능 저하

해석의 어려움

왜 이상값인지 구체적 이유 제공 어려움
블랙박스 특성

밀도 기반 한계

클러스터 내부의 이상값 탐지 어려움

실제 활용 사례

금융권: 사기 거래 탐지

정상 패턴: 평소 소비 금액, 자주 방문하는 가맹점
이상 패턴: 새벽 시간 고액 결제, 해외 이상 지역 사용
효과: 실시간 사기 거래 차단으로 고객 보호

IT 보안: 침입 탐지

정상 패턴: 일반적인 로그인 시간, 업무용 접근
이상 패턴: 비정상 시간대 접근, 권한 외 시도
효과: 해킹 시도 조기 차단

제조업: 설비 이상 감지

정상 패턴: 안정적인 온도, 압력, 진동 수치
이상 패턴: 급격한 수치 변동, 임계값 초과
효과: 설비 고장 예방, 생산 중단 최소화

의료: 이상 소견 발견

정상 패턴: 일반적인 혈압, 혈당, 콜레스테롤 수치
이상 패턴: 극단적으로 높거나 낮은 검사값
효과: 조기 진단으로 치료 효과 극대화

다른 이상탐지 방법과의 비교

방법속도메모리해석성고차원

방법	속도	메모리	해석	고차원
Isolation Forest	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐⭐⭐
LOF	⭐⭐	⭐⭐	⭐⭐⭐	⭐⭐
One-Class SVM	⭐⭐⭐	⭐⭐⭐	⭐	⭐⭐⭐
DBSCAN	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐

언제 사용하면 좋을까?

✅ 추천하는 경우

대용량 데이터 처리가 필요한 경우
실시간 이상탐지가 중요한 경우
빠른 프로토타이핑이 필요한 경우
고차원 데이터를 다루는 경우

❌ 피해야 하는 경우

이상값의 구체적 원인 파악이 중요한 경우
이상값 비율이 30% 이상인 경우
작은 데이터셋 (< 1000개)인 경우

마무리

Isolation Forest는 빠르고 효율적인 이상탐지 알고리즘으로, 특히 대용량 데이터와 실시간 처리가 필요한 환경에서 빛을 발합니다.

복잡한 파라미터 튜닝 없이도 좋은 성능을 내기 때문에, 이상탐지 입문자에게도 추천하는 방법입니다.

다만 해석성의 한계가 있으므로, 이상값의 구체적 원인 파악이 중요한 비즈니스라면 다른 방법과 함께 사용하는 것을 권장합니다!

mysql 기본 NULL 처리 함수들

Data-SSung — Tue, 17 Jun 2025 11:09:22 +0900

COALESCE (표준 SQL)

sql

COALESCE(col1, col2, '기본값')  -- 첫 번째 non-NULL 값 리턴
COALESCE(amount, 0)            -- amount가 NULL이면 0

IFNULL (MySQL 전용)

sql

IFNULL(amount, 0)              -- amount가 NULL이면 0
IFNULL(customer_name, '미등록') -- NULL이면 '미등록'

ISNULL / IS NULL

sql

-- 조건문에서
WHERE amount IS NULL           -- NULL 체크
WHERE amount IS NOT NULL       -- NOT NULL 체크
SELECT ISNULL(amount)          -- NULL이면 1, 아니면 0

2. 집계함수의 NULL 처리

COUNT

sql

COUNT(*)                 -- 모든 행 (NULL 포함)
COUNT(column)            -- NULL 제외
COUNT(DISTINCT column)   -- 중복+NULL 제외

SUM, AVG, MIN, MAX

sql

SUM(amount)              -- NULL 제외하고 합계
AVG(amount)              -- NULL 제외하고 평균
-- 결과가 NULL이면 COALESCE 사용
COALESCE(SUM(amount), 0)

3. 조건문에서 NULL 처리

CASE WHEN

sql

CASE 
    WHEN amount IS NULL THEN 0
    WHEN amount > 1000 THEN 'high'
    ELSE 'low'
END

IF 함수 (MySQL 전용)

sql

IF(amount IS NULL, 0, amount)  -- NULL이면 0, 아니면 원값

4. JOIN에서 NULL 처리

LEFT JOIN 후 NULL 처리

sql

SELECT 
    a.customer_id,
    COALESCE(b.order_count, 0) as order_count
FROM customers a
LEFT JOIN order_summary b ON a.customer_id = b.customer_id

5. 실무 패턴들

WHERE 절 NULL 처리

sql

-- 안전한 비교
WHERE COALESCE(amount, 0) > 100

-- NULL 포함 검색
WHERE name LIKE '%검색어%' OR name IS NULL

GROUP BY NULL 처리

sql

GROUP BY COALESCE(category, 'uncategorized')

ORDER BY NULL 처리

sql

ORDER BY COALESCE(order_date, '1900-01-01')  -- NULL을 맨 앞으로
ORDER BY order_date IS NULL, order_date      -- NULL을 맨 뒤로

6. 코테에서 자주 쓰는 패턴

sql

-- 매출 없는 고객도 0으로 표시
SELECT 
    customer_id,
    COALESCE(SUM(amount), 0) as total_sales
FROM orders
GROUP BY customer_id

-- 활동 없는 날도 0으로 표시  
SELECT 
    activity_date,
    COALESCE(COUNT(DISTINCT user_id), 0) as active_users
FROM calendar_dates
LEFT JOIN user_activity USING(activity_date)
GROUP BY activity_date

핵심: COUNT는 자동 NULL 처리, 나머지는 COALESCE/IFNULL 사용!

mysql 실무 적용 코딩 (월별 리텐션 분석)

Data-SSung — Tue, 17 Jun 2025 10:55:41 +0900

상황 : oo님 우리 회사 2025년 1~5월까지 월별 리텐션 분석 자료 부탁해요..asap

1단계 설계

리텐션 비중 : 월 방문자 수/첫 월 방문자 수
단계
- 고객별 첫 방문 월
- 고객별 월 데이터 셋팅
- 첫 월, 기준 월, 월 간 gap, 첫 월 유저 수, 기준 월 유저 수, 리텐션 비율

sql 쿼리 작성

-- inner join 
with cust_first_month as (
    --고객별 첫 방문 월
    select cust_id
    	, min(date_format(order_date, '%Y-%m')) first_ym 
    from orders
    group by cust_id
)
, cust_orders as (
	--고객별 월 데이터 셋팅
	select cust_id
    	, date_format(order_date, '%Y-%m') ym
	from orders
)
--첫 월, 기준 월, 월 간 gap, 첫 월 유저 수, 기준 월 유저 수, 리텐션 비율
select cm.first_month, co.ym
	, timestampdiff(month , str_to_date(cm.first_month, '%Y-%m'), str_to_date(co.ym, '%Y-%m')) month_gap
	, count(distinct cm.cust_id) first_cnt
    , count(distinct co.cust_id) reten_cnt
    , first_cnt/reten_cnt*100 retention_rate
from cust_first_month cm
inner join cust_orders co
	on cm.cust_id = co.cust_id
group by cm.first_month, co.ym
order by first_month, month_gap

/*
select *
from retention_tmp
where first_month = '2025-01' and month_gap <=6
*/
;
;

DATE_FORMAT(order_date, '%Y-%m')의 결과

변환 결과 문자열 (VARCHAR), DATETIME이 X
결과: '2025-01' (문자열)

MySQL 데이터 타입 변환 ( cast)

Data-SSung — Tue, 17 Jun 2025 10:30:41 +0900

sql

-- 숫자 변환
CAST(amount AS SIGNED)          -- 정수
CAST(amount AS DECIMAL(10,2))   -- 소수점
CAST(amount AS UNSIGNED)        -- 양의 정수

-- 문자열 변환  
CAST(user_id AS CHAR)           -- 문자열
CAST(user_id AS CHAR(10))       -- 길이 지정

-- 날짜 변환
CAST('2025-01-15' AS DATE)      -- 날짜
CAST('2025-01-15 14:30:00' AS DATETIME)  -- 날짜시간
CAST('2025-01-15 14:30:00' AS TIME)  -- 시간

mysql datediff vs timestampdiff

Data-SSung — Tue, 17 Jun 2025 10:08:41 +0900

함수별 특징

함수단위사용법

DATEDIFF	일(day)만	DATEDIFF(date1, date2)
TIMESTAMPDIFF	모든 단위	TIMESTAMPDIFF(MONTH/DAY/YEAR, date1, date2)

TIMESTAMPDIFF 장점:

MONTH, YEAR, QUARTER, WEEK 등 다양한 단위 지원
월말/월초 경계 처리가 정확

B3C 플랫폼 분석 리텐션 개념

Data-SSung — Tue, 17 Jun 2025 10:07:25 +0900

리텐션이란? 특정 기간에 가입한 고객들이 이후에도 계속 서비스를 이용하는 비율

1. 기본 리텐션 (N일 후 재방문율)

예시: 1월 가입자들의 1개월 후 리텐션

sql

-- 1월 신규 가입자 중 2월에도 활동한 비율
with jan_new_users as (
    select customer_id
    from users 
    where date_format(join_date, '%Y-%m') = '2025-01'
),
feb_active_users as (
    select distinct customer_id
    from user_activity
    where date_format(activity_date, '%Y-%m') = '2025-02'
)
select 
    count(distinct j.customer_id) as jan_new_users,
    count(distinct f.customer_id) as feb_retained_users,
    count(distinct f.customer_id) * 100.0 / count(distinct j.customer_id) as retention_rate
from jan_new_users j
left join feb_active_users f on j.customer_id = f.customer_id;

2. 코호트 리텐션 (월별 추적)

각 가입월별로 이후 월들의 리텐션 추적

sql

with first_activity as (
    select 
        customer_id,
        date_format(min(activity_date), '%Y-%m') as cohort_month
    from user_activity
    group by customer_id
),
monthly_activity as (
    select 
        customer_id,
        date_format(activity_date, '%Y-%m') as activity_month
    from user_activity
)
select 
    f.cohort_month,
    m.activity_month,
    timestampdiff(month, 
                  str_to_date(f.cohort_month, '%Y-%m'), 
                  str_to_date(m.activity_month, '%Y-%m')) as month_number,
    count(distinct f.customer_id) as cohort_size,
    count(distinct m.customer_id) as retained_users,
    count(distinct m.customer_id) * 100.0 / count(distinct f.customer_id) as retention_rate
from first_activity f
left join monthly_activity m on f.customer_id = m.customer_id
group by f.cohort_month, m.activity_month
order by f.cohort_month, month_number;

결과 예시:

cohort_month | activity_month | month_number | retention_rate
2025-01     | 2025-01       | 0            | 100.0%
2025-01     | 2025-02       | 1            | 65.5%
2025-01     | 2025-03       | 2            | 45.2%

mysql 실무 적용 코딩 (일별로 최근 30일에 대한 rolling mau 구하기)

Data-SSung — Tue, 17 Jun 2025 09:26:49 +0900

상황 : oo님 우리 회사 2025년 5월에 대해서 일별로 최근 30일에 대한 rolling mau 좀 구해주세요. ASAP!

1단계 설계

mau 개념 : 월별 활동 유저 수
일별 mau 개념 : 현재 일자 기준 최근 30일에 대해 활동 유저 수
로직 설계
- 기준 일자 생성
- 유저 데이터 붙이기(현재 일자부터 최근 30일일자까지)
- 일자별 유저 수 집계

sql 쿼리 작성

-- 일자별 유저 수 집계
select a.activity_date
	, count(distinct u.customer_id) user_cnt
from ( -- 기준 일자 생성
	select distinct activity_date
    from users
) a
-- 유저 데이터 붙이기(현재 일자부터 최근 30일일자까지)
inner join users u
	on u.activity_date between date_sub(a.activity_date, interval 29 day) and a.activity_date
group by a.activity_date

보고서 작성 끝!