Viewability 예측 모델 개발 튜토리얼

data_jeong·2024년 5월 20일
Viewabilitymlops예측모델
0

블루베리팀 팀원 교육 자료 

목록 보기
17/17
post-thumbnail

안녕하세요! 이번 튜토리얼에서는 머신러닝을 활용하여 온라인 광고의 Viewability를 예측하는 모델을 개발하는 과정을 단계별로 살펴보겠습니다. 실습을 통해 데이터 수집, 전처리, 모델링, 평가 등 머신러닝 프로젝트의 전체 과정을 경험할 수 있습니다.

목차

  1. Viewability 예측 모델 소개
  2. 개발 환경 설정
  3. 데이터 수집 및 탐색
    3.1. 데이터 수집
    3.2. 데이터 탐색
  4. 데이터 전처리
    4.1. 결측값 처리
    4.2. 범주형 변수 인코딩
    4.3. 특성 스케일링
  5. 특성 엔지니어링
    5.1. 도메인 지식 기반 특성 생성
    5.2. 통계량 기반 특성 생성
  6. 모델 선택 및 학습
    6.1. 로지스틱 회귀
    6.2. 랜덤 포레스트
    6.3. 뉴럴 네트워크
  7. 모델 평가
    7.1. 평가 지표
    7.2. 교차 검증
  8. 모델 튜닝
    8.1. 그리드 서치
    8.2. 랜덤 서치
  9. 모델 해석
    9.1. 피쳐 중요도
    9.2. SHAP 값
  10. 모델 배포
    10.1. 모델 저장 및 로드
    10.2. 실시간 예측 API 구현
  11. 프로젝트 회고

1. Viewability 예측 모델 소개

온라인 광고에서 Viewability란 광고가 사용자에게 실제로 노출되었는지를 나타내는 지표입니다. 광고주 입장에서는 광고비 지출 대비 실제 노출 효과를 파악하는 것이 중요하므로 Viewability 지표를 근거로 광고 효과를 판단하게 됩니다.

Viewability 기준은 다음과 같이 정의됩니다:

  • 디스플레이 광고: 광고 면적의 50% 이상이 1초 이상 연속 노출
  • 비디오 광고: 동영상 면적의 50% 이상이 2초 이상 연속 재생

Viewability 측정은 실제 사용자의 브라우저 환경에서의 광고 요소 노출 여부를 JavaScript 등의 기술을 활용하여 측정하게 됩니다.

Viewability가 중요한 이유는 다음과 같습니다:

  1. 광고 효과 측정: Viewability 측정을 통해 실제로 사용자에게 노출된 광고량을 파악하고 이를 기준으로 광고 효과를 평가할 수 있습니다. 이를 통해 광고 캠페인의 성과를 정확히 판단하고 효율적인 광고 전략 수립이 가능해집니다.
  2. 광고비 최적화: Viewability가 낮은 광고 구매를 피함으로써 광고 예산 낭비를 방지할 수 있습니다. 광고주는 Viewability가 보장되는 광고 상품에 예산을 집중함으로써 광고비 효율을 높일 수 있습니다.
  3. 사용자 경험 향상: 사용자의 관심사나 행동 패턴과 무관한 광고가 무분별하게 노출될 경우 사용자 경험이 저하될 수 있습니다. Viewability를 고려한 광고 노출은 사용자 관점에서도 양질의 광고를 접할 수 있는 기회를 제공합니다.

위 다이어그램은 Viewability 측정 로직을 간단히 표현한 것입니다. 광고 요소(Ad element)의 노출 면적과 노출 시간을 측정하여 Viewability 기준에 부합하는지 판단하고, 그 결과에 따라 Viewable Impression 또는 Non-viewable Impression으로 분류합니다.

본 튜토리얼에서는 이러한 Viewability 예측을 머신러닝 기법으로 자동화하는 방법에 대해 다룹니다. 대량의 광고 노출 로그 데이터를 활용하여 광고 Viewability 예측 모델을 개발함으로써 광고 효과 평가 및 예산 운용 최적화에 도움을 줄 수 있습니다.

2. 개발 환경 설정

먼저 개발 환경을 설정하겠습니다. 데이터 분석 및 머신러닝 실습을 위해 필요한 라이브러리는 다음과 같습니다:

  • NumPy: 벡터 및 행렬 연산 라이브러리
  • Pandas: 데이터 처리 및 분석 라이브러리
  • Scikit-learn: 머신러닝 알고리즘 및 평가 지표 제공 라이브러리
  • TensorFlow: 딥러닝 라이브러리
  • Matplotlib: 데이터 시각화 라이브러리
  • Seaborn: Matplotlib 기반 고수준 데이터 시각화 라이브러리

아래 명령어를 실행하여 필요한 라이브러리를 설치합니다:

pip install numpy pandas scikit-learn tensorflow matplotlib seaborn shap

Jupyter Notebook이나 Google Colab 등의 대화형 개발 환경을 사용하면 편리하게 실습을 진행할 수 있습니다.

3. 데이터 수집 및 탐색

3.1. 데이터 수집

Viewability 예측 모델 학습을 위해서는 광고 노출 및 클릭 데이터가 필요합니다. 실제로는 광고 플랫폼의 API를 통해 데이터를 수집하거나, 로그 데이터를 ETL 처리하여 사용하게 됩니다.

튜토리얼에서는 데이터 수집 과정을 간소화하기 위해 모델링에 필요한 핵심 정보만 포함된 데이터를 생성하도록 하겠습니다.

import numpy as np
import pandas as pd

# 샘플 데이터 생성
n_samples = 100000
ad_id = np.arange(1, n_samples+1)
ad_size = np.random.choice(['Small', 'Medium', 'Large'], size=n_samples, p=[0.3, 0.5, 0.2])
ad_position = np.random.choice(['Top', 'Middle', 'Bottom'], size=n_samples, p=[0.2, 0.3, 0.5])
device_type = np.random.choice(['Mobile', 'Tablet', 'Desktop'], size=n_samples, p=[0.4, 0.3, 0.3])
viewability = np.random.choice([0, 1], size=n_samples, p=[0.4, 0.6])

# DataFrame 생성
data = pd.DataFrame({
    'ad_id': ad_id,
    'ad_size': ad_size,
    'ad_position': ad_position,
    'device_type': device_type,
    'viewability': viewability
})

위 코드는 NumPy의 random 모듈을 사용하여 10만 개의 샘플 데이터를 생성합니다. 각 샘플은 광고 ID, 광고 크기, 광고 위치, 디바이스 타입, Viewability 여부 등의 정보를 포함합니다.

실제 데이터라면 이 외에도 광고주, 광고 카테고리, 사용자 인구통계 정보 등 다양한 관련 변수가 포함될 수 있습니다. 주어진 데이터를 잘 이해하고 모델에 유의미한 변수를 선별하는 것이 중요합니다.

3.2. 데이터 탐색

수집된 데이터의 특성을 파악하기 위해 탐색적 데이터 분석(Exploratory Data Analysis, EDA)을 수행합니다. 주요 체크 포인트는 다음과 같습니다:

  • 데이터 크기 및 형태
  • 변수 유형 및 분포
  • 결측치 여부
  • 변수 간 상관관계
  • 클래스 불균형 여부
# 데이터 크기 및 형태 확인
print(data.shape)

# 첫 5개 샘플 확인
print(data.head())

# Viewability 분포 확인
print(data['viewability'].value_counts(normalize=True))

# 요약 통계량 확인
print(data.describe())

# 변수 간 상관관계 확인
print(data.corr())

# 변수 분포 시각화
import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(12, 8))
plt.suptitle("Variable Distribution", fontsize=16)

plt.subplot(2, 2, 1)
sns.countplot(x='ad_size', data=data)
plt.xlabel('Ad Size')

plt.subplot(2, 2, 2)
sns.countplot(x='ad_position', data=data)
plt.xlabel('Ad Position')

plt.subplot(2, 2, 3)
sns.countplot(x='device_type', data=data)
plt.xlabel('Device Type')

plt.subplot(2, 2, 4)
sns.countplot(x='viewability', data=data)
plt.xlabel('Viewability')

plt.tight_layout()
plt.show()

데이터 탐색을 통해 데이터의 전반적인 특성을 파악하고, 전처리 및 특성 엔지니어링 방향을 계획할 수 있습니다. 예를 들어, 클래스 불균형이 심할 경우 이를 해소하기 위한 오버 샘플링, 언더 샘플링 등의 기법을 적용할 수 있습니다.

4. 데이터 전처리

머신러닝 모델에 원본 데이터를 바로 입력할 수는 없습니다. 결측치 처리, 인코딩, 스케일링 등 데이터 전처리 과정을 거쳐 모델 학습에 적합한 형태로 변환해야 합니다.

4.1. 결측값 처리

데이터에 결측값(Missing value)이 있는 경우 이를 적절히 처리해야 합니다. 결측값 처리 방법은 데이터의 특성과 업무 로직에 따라 선택할 수 있습니다.

  • 결측치가 있는 샘플 제거
  • 평균, 중앙값 등 통계값으로 대체
  • 최빈값 등 예측값으로 대체
  • 결측 여부 자체를 특성으로 사용
# 결측치 확인
print(data.isnull().sum())

# 결측치 샘플 제거
data.dropna(inplace=True)

샘플 데이터의 경우 결측치가 없으므로 바로 다음 단계로 넘어가겠습니다.

4.2. 범주형 변수 인코딩

머신러닝 모델은 일반적으로 숫자형 데이터를 입력으로 받습니다. 따라서 범주형 변수는 숫자형으로 인코딩 해야 합니다.

  • Label Encoding: 범주에 정수 값을 순차적으로 배정
  • One-Hot Encoding: 각 범주를 이진 변수로 변환
  • Ordinal Encoding: 범주에 순서가 있는 경우, 순서에 따라 정수 값 배정
from sklearn.preprocessing import LabelEncoder, OneHotEncoder

# Label Encoding
le = LabelEncoder()
data['ad_size_encoded'] = le.fit_transform(data['ad_size'])
data['ad_position_encoded'] = le.fit_transform(data['ad_position'])
data['device_type_encoded'] = le.fit_transform(data['device_type'])

# One-Hot Encoding
ohe = OneHotEncoder(handle_unknown='ignore')
one_hot_vars = ['ad_size', 'ad_position', 'device_type']
one_hot_data = ohe.fit_transform(data[one_hot_vars]).toarray()
one_hot_df = pd.DataFrame(one_hot_data, columns=ohe.get_feature_names_out(one_hot_vars))
data = pd.concat([data, one_hot_df], axis=1)

Label Encoding은 간단하지만 범주 간 순서나 간격에 대한 의미가 없는 경우 사용에 주의해야 합니다. 트리 기반 모델에는 인코딩 방식의 영향이 적지만, 로지스틱 회귀 등 선형 모델의 경우 One-Hot Encoding을 주로 사용합니다.

4.3. 특성 스케일링

특성의 스케일이 다르면 모델 학습에 악영향을 줄 수 있습니다. 따라서 일괄적인 스케일로 맞추는 작업이 필요합니다.

  • Min-Max Scaling: 최소값을 0, 최대값을 1로 맞추어 스케일링
  • Standard Scaling: 평균을 0, 분산을 1로 맞추어 스케일링
from sklearn.preprocessing import MinMaxScaler, StandardScaler

# Min-Max Scaling
scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(data[['ad_id']])
data[['ad_id']] = scaled_data

# Standard Scaling
scaler = StandardScaler()
scaled_data = scaler.fit_transform(data[['ad_id']])
data[['ad_id']] = scaled_data

트리 기반 모델의 경우 특성의 스케일에 영향을 받지 않으므로 스케일링이 필수는 아닙니다. 그러나 선형 모델이나 신경망 모델 등에서는 스케일링이 중요한 전처리 작업이 됩니다.


위 다이어그램은 데이터 전처리 과정에서 사용되는 주요 클래스 간의 관계를 나타냅니다. DataPreprocessing은 fit()과 transform() 메서드를 제공하는 추상 클래스이며 MissingValueImputer, Encoder, Scaler 등의 구체적인 전처리 클래스가 이를 상속받아 구현됩니다.

5. 특성 엔지니어링

모델 학습에 사용할 특성(feature)을 생성하고 선택하는 과정을 특성 엔지니어링이라고 합니다. 좋은 특성을 만드는 것은 모델 성능에 큰 영향을 미치므로 도메인 지식을 바탕으로 충분한 고민과 실험이 필요합니다.

5.1. 도메인 지식 기반 특성 생성

광고 도메인에 대한 이해를 바탕으로 Viewability 예측에 유용할 것으로 판단되는 특성을 생성할 수 있습니다.

# 광고 면적 특성
data['area'] = data.apply(lambda x: x['ad_size_Large'] * 3 + x['ad_size_Medium'] * 2 + x['ad_size_Small'] * 1, axis=1)

# 광고 위치 점수 특성
data['position_score'] = data.apply(lambda x: x['ad_position_Top'] * 3 + x['ad_position_Middle'] * 2 + x['ad_position_Bottom'] * 1, axis=1)

# 디바이스 타입 점수 특성
data['device_score'] = data.apply(lambda x: x['device_type_Desktop'] * 3 + x['device_type_Tablet'] * 2 + x['device_type_Mobile'] * 1, axis=1)

위 코드는 광고 크기, 위치, 디바이스 타입 등의 정보를 조합하여 새로운 특성을 생성하는 예시입니다. 숫자가 클수록 Viewability에 긍정적인 영향을 줄 것으로 가정하고 있습니다.

5.2. 통계량 기반 특성 생성

통계량을 활용하여 새로운 특성을 생성할 수도 있습니다. 예를 들어, 각 광고 크기별 Viewability 비율을 계산하여 새로운 특성으로 추가할 수 있습니다.

# 광고 크기별 Viewability 비율 계산
size_viewability = data.groupby('ad_size')['viewability'].mean()

# Viewability 비율 매핑
data['size_viewability_ratio'] = data['ad_size'].map(size_viewability)

도메인 지식과 데이터 탐색을 바탕으로 다양한 아이디어를 실험해 보는 것이 좋습니다. 특성 엔지니어링은 모델 성능 향상에 있어 가장 중요한 작업 중 하나입니다.

       +-----------------+
       |   Raw Data      |
       +-----------------+
                |
                v
       +-----------------+
       | Domain Knowledge|
       +-----------------+
                |
                v
       +-----------------+
       |   Feature Idea  |
       +-----------------+
                |
                v
       +-----------------+
       |  Feature Creation |
       +-----------------+
                |
                v
       +-----------------+
       | Feature Selection|
       +-----------------+
                |
                v
       +-----------------+
       |  Preprocessed   |
       |     Data        |
       +-----------------+

위 그림은 특성 엔지니어링 프로세스를 나타낸 것입니다. 원본 데이터에서 출발하여 도메인 지식을 바탕으로 특성 아이디어를 도출하고, 이를 바탕으로 새로운 특성을 생성합니다. 생성된 특성 중 유의미한 것을 선택하여 최종 전처리된 데이터를 완성하게 됩니다.

6. 모델 선택 및 학습

전처리된 데이터를 사용하여 본격적으로 모델을 학습해 보겠습니다. 머신러닝 알고리즘은 데이터 특성과 문제 유형에 따라 적합한 것이 다릅니다. Viewability 예측의 경우 이진 분류(binary classification) 문제이므로 이에 맞는 알고리즘을 선택할 수 있습니다.

6.1. 로지스틱 회귀

로지스틱 회귀는 대표적인 이진 분류 알고리즘입니다. 선형 결정 경계를 학습하므로 해석이 용이하다는 장점이 있습니다.

from sklearn.linear_model import LogisticRegression

# 입력 특성과 타겟 변수 분리
X = data.drop(['ad_id', 'ad_size', 'ad_position', 'device_type', 'viewability'], axis=1)
y = data['viewability']

# 로지스틱 회귀 모델 학습
lr_model = LogisticRegression(random_state=42)
lr_model.fit(X, y)

6.2. 랜덤 포레스트

랜덤 포레스트는 의사결정나무 모델을 앙상블한 알고리즘입니다. 높은 정확도와 견고성(robustness)으로 인기 있는 알고리즘 중 하나입니다.

from sklearn.ensemble import RandomForestClassifier

# 랜덤 포레스트 모델 학습
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X, y)

6.3. 뉴럴 네트워크

딥러닝 기반의 뉴럴 네트워크 모델은 복잡한 비선형 패턴을 학습할 수 있어 높은 성능을 기대할 수 있습니다.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# 뉴럴 네트워크 모델 구성
model = Sequential([
    Dense(64, activation='relu', input_shape=(X.shape[1],)),
    Dense(32, activation='relu'),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 모델 학습
model.fit(X, y, epochs=50, batch_size=32, validation_split=0.2)

뉴럴 네트워크 모델은 과적합(overfitting)에 유의해야 합니다. 적절한 regularization 기법을 적용하고, 검증 데이터 성능을 모니터링해야 합니다.


위 시퀀스 다이어그램은 사용자가 모델을 학습하고 예측 결과를 얻는 과정을 나타냅니다. 사용자는 전처리된 데이터를 불러와 모델을 초기화하고 학습 데이터를 사용하여 모델을 학습합니다. 학습된 모델은 입력 데이터에 대한 예측값을 반환합니다.

7. 모델 평가

7.1. 평가 지표

분류 모델의 성능 평가를 위해서는 accuracy, precision, recall, F1-score 등의 지표를 사용할 수 있습니다.

  • Accuracy: 전체 예측 중 맞춘 예측의 비율
  • Precision: Positive로 예측한 것 중 실제 Positive의 비율
  • Recall: 실제 Positive 중 Positive로 예측한 비율
  • F1-score: Precision과 Recall의 조화평균
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# 로지스틱 회귀 모델 평가
lr_pred = lr_model.predict(X)
print("Logistic Regression")
print("Accuracy: {:.4f}".format(accuracy_score(y, lr_pred)))
print("Precision: {:.4f}".format(precision_score(y, lr_pred)))
print("Recall: {:.4f}".format(recall_score(y, lr_pred)))
print("F1-score: {:.4f}".format(f1_score(y, lr_pred)))

# 랜덤 포레스트 모델 평가
rf_pred = rf_model.predict(X)
print("\\nRandom Forest")
print("Accuracy: {:.4f}".format(accuracy_score(y, rf_pred)))
print("Precision: {:.4f}".format(precision_score(y, rf_pred)))
print("Recall: {:.4f}".format(recall_score(y, rf_pred)))
print("F1-score: {:.4f}".format(f1_score(y, rf_pred)))

# 뉴럴 네트워크 모델 평가
nn_pred = model.predict(X)
nn_pred = (nn_pred > 0.5).astype(int).ravel()
print("\\nNeural Network")
print("Accuracy: {:.4f}".format(accuracy_score(y, nn_pred)))
print("Precision: {:.4f}".format(precision_score(y, nn_pred)))
print("Recall: {:.4f}".format(recall_score(y, nn_pred)))
print("F1-score: {:.4f}".format(f1_score(y, nn_pred)))

모델의 실제 성능은 테스트 데이터셋에 대한 평가로 확인해야 합니다. 학습 데이터에 대해서만 높은 성능을 보이는 경우 과적합일 가능성이 있습니다.

7.2. 교차 검증

단순히 전체 데이터를 학습과 평가로 나누는 것은 편향된 결과를 낳을 수 있습니다. 교차 검증(cross validation)을 통해 데이터를 여러 번 분할하고 평가하여 모델 성능을 일반화할 수 있습니다.

from sklearn.model_selection import cross_val_score

# 로지스틱 회귀 모델 교차 검증
lr_scores = cross_val_score(lr_model, X, y, cv=5)
print("Logistic Regression Cross Validation Scores: ", lr_scores)
print("Logistic Regression Cross Validation Average Score: {:.4f}".format(lr_scores.mean()))

# 랜덤 포레스트 모델 교차 검증
rf_scores = cross_val_score(rf_model, X, y, cv=5)
print("\\nRandom Forest Cross Validation Scores: ", rf_scores)
print("Random Forest Cross Validation Average Score: {:.4f}".format(rf_scores.mean()))

k-겹 교차 검증(kfold cross validation)은 데이터를 k개의 폴드로 나누어 k번의 학습과 평가를 반복하는 방법입니다. 각 반복에서 하나의 폴드를 평가에 사용하고 나머지 k-1개 폴드는 학습에 사용합니다. 최종 성능은 k번의 평가 점수의 평균으로 구합니다.


위 그림은 5-겹 교차 검증의 한 반복을 나타냅니다. Fold 1~4는 학습에, Fold 5는 검증에 사용되었고, 이 과정을 5번 반복하여 평균 점수를 얻게 됩니다.

8. 모델 튜닝

8.1. 그리드 서치

머신러닝 모델의 성능은 하이퍼파라미터 설정에 따라 크게 달라질 수 있습니다. 그리드 서치는 하이퍼파라미터 조합을 미리 정해 모든 경우를 탐색하는 방법입니다.

from sklearn.model_selection import GridSearchCV

# 하이퍼파라미터 그리드 설정
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [4, 6, 8, 10],
    'min_samples_split': [2, 4, 6]
}

# 그리드 서치 객체 생성
grid_search = GridSearchCV(rf_model, param_grid, cv=5, n_jobs=-1)

# 그리드 서치 수행
grid_search.fit(X, y)

print("Best parameters: ", grid_search.best_params_)
print("Best score: {:.4f}".format(grid_search.best_score_))

8.2. 랜덤 서치

그리드 서치는 탐색 대상이 많아질수록 시간이 오래 걸리는 단점이 있습니다. 랜덤 서치는 하이퍼파라미터 범위를 설정하고 무작위로 조합을 샘플링하여 탐색하는 방법입니다.

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

# 하이퍼파라미터 범위 설정
param_dist = {
    'n_estimators': randint(50, 200),
    'max_depth': randint(4, 10),
    'min_samples_split': randint(2, 6)
}

# 랜덤 서치 객체 생성
random_search = RandomizedSearchCV(rf_model, param_dist, cv=5, n_iter=10, n_jobs=-1)

# 랜덤 서치 수행
random_search.fit(X, y)

print("Best parameters: ", random_search.best_params_)
print("Best score: {:.4f}".format(random_search.best_score_))

베이지안 최적화 등 더 효율적인 하이퍼파라미터 최적화 기법도 존재합니다. 모델과 데이터셋의 특성에 맞는 방법을 선택하는 것이 좋습니다.

9. 모델 해석

9.1. 피쳐 중요도

트리 기반 모델은 피쳐의 상대적 중요도를 직접 제공합니다. 피쳐 중요도를 통해 예측에 영향을 미치는 주요 변수를 파악할 수 있습니다.

# 피쳐 중요도 확인
importances = rf_model.feature_importances_
indices = np.argsort(importances)[::-1]

print("Feature Importances:")
for f in range(X.shape[1]):
    print("%d. %s (%f)" % (f + 1, X.columns[indices[f]], importances[indices[f]]))

# 피쳐 중요도 시각화
plt.figure(figsize=(10,6))
plt.title("Feature Importances")
plt.bar(range(X.shape[1]), importances[indices])
plt.xticks(range(X.shape[1]), X.columns[indices], rotation=90)
plt.show()

9.2. SHAP 값
SHAP(SHapley Additive exPlanations)는 피쳐 간의 상호작용을 고려한 피쳐 기여도를 계산하는 방법입니다. 개별 예측 인스턴스에 대한 설명력이 높다는 장점이 있습니다.

import shap

# SHAP 값 계산
explainer = shap.TreeExplainer(rf_model)
shap_values = explainer.shap_values(X)

# SHAP 값 시각화
shap.summary_plot(shap_values, X)
  +-----------------+
  |   Prediction    |
  +-----------------+
           ^
           |
           |
  +-----------------+
  |  Feature Values |
  +-----------------+
           ^
           |
           |
  +-----------------+
  |   SHAP Values   |
  +-----------------+
           ^
           |
           |
  +-----------------+
  |     Model       |
  +-----------------+

위 그림은 SHAP 값 계산 과정을 나타낸 것입니다. 모델이 피쳐 값을 입력받아 예측값을 계산하고, 이 예측값을 설명하기 위해 각 피쳐 값에 대한 SHAP 값이 계산됩니다. SHAP 값은 피쳐 값이 예측에 미친 영향을 정량화한 값입니다.

모델 해석은 블랙박스 모델의 예측 근거를 이해하고, 피쳐 엔지니어링 방향을 결정하는 데 도움이 됩니다. 도메인 전문가와의 협업을 통해 더욱 의미 있는 해석이 가능할 것입니다.

10. 모델 배포

10.1. 모델 저장 및 로드

학습된 모델을 저장하고 필요할 때 로드하여 사용할 수 있습니다. Pickle, Joblib 등의 라이브러리를 사용할 수 있습니다.

import joblib

# 모델 저장
joblib.dump(rf_model, 'rf_model.pkl')

# 모델 로드
loaded_model = joblib.load('rf_model.pkl')

10.2. 실시간 예측 API 구현

학습된 모델을 활용하여 실시간 예측 서비스를 제공할 수 있습니다. Flask 등의 웹 프레임워크를 사용하여 API를 구현할 수 있습니다.

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json(force=True)
    data = pd.DataFrame.from_dict(data)

    # 전처리
    data = preprocess_data(data)

    # 예측
    prediction = loaded_model.predict(data)

    return jsonify({'prediction': prediction.tolist()})

if __name__ == '__main__':
    app.run(port=5000, debug=True)


위 시퀀스 다이어그램은 클라이언트가 API에 예측 요청을 보내고 결과를 받는 과정을 나타냅니다. API는 받은 데이터를 전처리하고 모델에 입력하여 예측값을 계산한 후, 이를 클라이언트에게 반환합니다.

11. 프로젝트 회고

이번 튜토리얼에서는 Viewability 예측 모델을 개발하는 전체 과정을 실습해 보았습니다. 데이터 수집, 전처리, 특성 엔지니어링, 모델링, 평가, 튜닝, 해석, 배포 등 머신러닝 프로젝트의 주요 단계를 경험할 수 있었습니다.

핵심 내용을 요약하면 다음과 같습니다:

  • 도메인 지식과 EDA를 바탕으로 데이터를 이해하고 문제를 정의합니다.
  • 결측치 처리, 인코딩, 스케일링 등 데이터 전처리를 수행합니다.
  • 도메인 지식과 데이터 분석을 활용하여 유의미한 특성을 생성합니다.
  • 로지스틱 회귀, 랜덤 포레스트, 뉴럴 네트워크 등 다양한 알고리즘을 학습하고 비교합니다.
  • 교차 검증을 통해 모델 성능을 일반화하고, 하이퍼파라미터 튜닝을 수행합니다.
  • 피쳐 중요도, SHAP 값 등을 활용하여 모델을 해석합니다.
  • 모델을 저장하고 실시간 예측 API를 구현하여 배포합니다.

실제 프로젝트에서는 더 큰 규모의 데이터를 다뤄야 할 것입니다. 데이터 파이프라인 구축, 분산 처리, 모델 서빙 등 추가적인 엔지니어링 역량이 필요합니다.

또한 모델 성능 향상을 위해 피쳐 엔지니어링과 앙상블 등 더 다양한 기법을 시도해 볼 수 있습니다. 유사도 메트릭 학습, 전이 학습, Adversarial validation 등 새로운 접근 방식을 적용하는 것도 좋은 경험이 될 것입니다.

무엇보다 비즈니스 관점에서 모델의 실제 효용성을 검토하는 것이 중요합니다. 모델 성능뿐 아니라 해석 가능성, 공정성, 설명 가능성 등 다양한 측면을 고려해야 합니다.

이번 튜토리얼이 여러분의 머신러닝 프로젝트에 작은 도움이 되었기를 바라며, 앞으로도 다양한 도메인에 머신러닝을 적용하여 새로운 가치를 창출하시길 응원하겠습니다.

긴 글 읽어주셔서 감사합니다!

profile
data_jeong
데이터를 주력으로 하는 잡부입니다!
이전 포스트

협업을 위한 깃 : Trunk Based Development 전략!

0개의 댓글