[Kaggle] Credit Card Anomaly Detection

221102 작성

<본 블로그는 kaggle의 ysjang0926님의 notebook 을 참고해서 공부하며 작성하였습니다>

https://www.kaggle.com/code/ysjang0926/kor-introduction-to-anomaly-detection-r01/notebook

[kor]Introduction to Anomaly Detection_r01

 

 

 

🍊 신용 카드 사기 감지

: 신용 카드 회사는 사기성 신용 카드 거래를 인식하여 고객이 구매하지 않은 항목에 대해 요금을 청구하지 않도록 하는 것이 중요

• Dataset

: 유럽 카드 소지자가 2013년 9월에 신용 카드로 거래한 내용이 포함됨

: 284,807건의 거래 중 492건의 사기가 발생한 이틀 동안 발생한 거래

: 데이터 세트는 매우 불균형적이며 긍정적 클래스(사기)는 모든 거래의 0.172%를 차지

: PCA 변환의 결과인 숫자 입력 변수만 포함됨

: 기능 V1, V2, … V28은 PCA로 얻은 주요 구성 요소이며 PCA로 변환되지 않은 유일한 기능은 '시간'과 '양'

     : '시간'에는 각 트랜잭션과 데이터 세트의 첫 번째 트랜잭션 사이에 경과된 시간(초)이 포함

     : 'Amount' 기능은 거래 금액이며, 이 기능은 예제 종속 비용에 민감한 학습에 사용

     : 'Class'는 응답 변수이며 사기의 경우 값 1을 취하고 그렇지 않은 경우 0을 취함

: 클래스 불균형 비율이 주어지면 AUPRC(정밀도 재현율 곡선 아래 영역)를 사용하여 정확도를 측정

• 이상치

- Anomaly

: 대부분의 데이터와 본질적인 특성이 다르며, 기존 분포에서 멀리 떨어져 있어 전혀 다른 방식으로 생성되었을 것으로 추정되는 관측치

: 다른 매커니즘에 의해 발생된 것처럼 다른 관측치와는 매우 다른 관측치

- Novelty

: 본질적인 데이터는 같지만 유형이 다른 관측치

: 데이터에서 이전에 관찰되지 않은 새로운 패턴을 가진 관측치
: Novelty 데이터는 Anomaly로 간주되지 않고 Normal 데이터 범주로 포함되기 때문에 차이가 있음

- Outlier

: 데이터의 전체적인 패턴에서 벗어난 관측치

: 데이터가 시계열이냐 아니냐로 구분됩니다. (시간과의 관계 여부)

• Anomaly : 시간 또는 순서가 있는 흐름에 따른 패턴이 보편적인 패턴들과 다른 관측치
• Outlier : 시간과 관련 없이 대상을 표현하는 관측치들의 위치를 보고 보편적인 패턴과 벗어난 관측치

 

 

🍊 코드 구현

1. Data load

from keras.layers import Input, Dense
from keras.models import Model, Sequential
from keras import regularizers
from sklearn.model_selection import train_test_split 
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, accuracy_score
from sklearn.manifold import TSNE
from sklearn import preprocessing 
import matplotlib.pyplot as plt
import pandas as pd 
import numpy as np
import seaborn as sns
sns.set(style="whitegrid")
np.random.seed(203)

data = pd.read_csv("creditcard.csv")
data.head()

- Time : 이 트랜잭션과 데이터세트의 첫 번째 트랜잭션 사이에 경과된 시간(초)
- v1 ~ v28 : 사용자 ID 및 민감한 기능을 보호하기 위한 PCA 차원 축소(v1-v28)의 결과
- Amount : 거래 금액- Class : Target 변수(0: 정상, 1: 비정상)   
    - 총 284,807건의 거래내역이 제공   
    - 사기 거래(Fraud Transaction)는 492건

 

 

colors = ["#0101DF", "#DF0101"]
LABELS = ["Non-Fraud", "Fraud"]

sns.countplot('Class', data=data, palette=colors)
plt.title('Class Distribution \n (0 : Non-Fraud / 1 : Fraud)', fontsize=13)
plt.xticks(range(2), LABELS)
plt.xlabel("Class")
plt.ylabel("Frequency");

 

vc = data['Class'].value_counts().to_frame().reset_index()

vc['percent'] = vc["Class"].apply(lambda x : round(100*float(x) / len(data), 2))

vc = vc.rename(columns = {"index" : "Target", "Class" : "Count"})
vc

 

• amount와 time 분포

fig, ax = plt.subplots(1, 2, figsize=(18,4))

amount_val = data['Amount'].values
time_val = data['Time'].values

sns.distplot(amount_val, ax=ax[0], color='r')
ax[0].set_title('Distribution of Transaction Amount', fontsize=14)
ax[0].set_xlim([min(amount_val), max(amount_val)])

sns.distplot(time_val, ax=ax[1], color='b')
ax[1].set_title('Distribution of Transaction Time', fontsize=14)
ax[1].set_xlim([min(time_val), max(time_val)])

 

 

 

2. 데이터 전처리

- 가장 큰 문제 중 하나는 사기 거래가 0.17%에 불과하기 때문에 대상의 불균형이 매우 크다는 점

- non-fraud 거래내역의 1,000행만 사용

non_fraud = data[data['Class'] == 0].sample(1000)
fraud = data[data['Class'] == 1]

df = non_fraud.append(fraud).sample(frac=1).reset_index(drop=True)
X = df.drop(['Class'], axis = 1).values
Y = df["Class"].values

 

 

3. 시각화

- t-SNE(t-Distributed Stochastic Neighbor Embedding)란?
    - 높은 차원의 복잡한 데이터를 2차원에 차원 축소하는 방법
    - 고차원 데이터의 시각화에 용이하게 사용되며 차원 축소할 때는 비슷한 구조끼리 데이터를 정리한 상태이므로 데이터 구조를 이해
    - 고차원 공간에서의 각 데이터 포인트 주변으로 유사도를 계산하여, 각 데이터 포인트를 2차원에서 원본 특성 공간에서 비슷한 데이터 구조는 가깝게 비슷하지 않은 데이터 구조는 멀리 떨어지게 만드며, 즉 이웃 데이터 포인트에 대한 정보를 보존하려고 노력

- PCA와 차이점
    - PCA는 linear한 방법을 사용하지만, t-SNE는 비선형적인 방법의 차원축소 방법
    - PCA : 공분산 행렬에서 고유벡터를 계산
    - t-SNE : 고차원 공간에서의 점들의 유사성과 그에 해당하는 저차원 공간에서의 점들의 유사성을 계산
    - t-SNE는 input feature를 확인하기 어렵기 때문에 t-SNE 결과만 가지고 무언가를 추론하기 어려움 (t-SNE는 주로 시각화 툴로 사용)

- t-SNE 구하는 방법
    - 각 데이터 포인트 주변으로 유사도를 구해 클러스터를 만듦
    - 관심 데이터 포인트를 하나 잡고, 그 값을 평균으로 갖는 정규분포그래프를 그림
        - → 주변의 데이터의 경우(같은 클러스터) 유사도가 높게 나오고,(정규분포의 확률값) 먼 데이터는 유사도가 낮음
    - 모든 데이터 포인트에 대한 유사도를 그려, 상관계수그래프처럼 나열함
        - → 같은 클러스터는 높은 유사도를 지님
    - 임의로 낮은 차원으로 데이터 포인트를 사영시키고, 데이터마다 유사도를 계산함.(정규분포로 했듯이)
    - t분포를 대신 사용하는데, 그래서 t-sne임
        - t-분포를 사용하는 이유는, 클러스터들을 좀더 성기게 분포시키기 위함

def tsne_plot(x1, y1, name="graph.png"):
    tsne = TSNE(n_components=2, random_state=0)
    X_t = tsne.fit_transform(x1)

    plt.figure(figsize=(12, 8))
    plt.scatter(X_t[np.where(y1 == 0), 0], X_t[np.where(y1 == 0), 1], marker='o', color='g', alpha=0.8, label='Non Fraud')
    plt.scatter(X_t[np.where(y1 == 1), 0], X_t[np.where(y1 == 1), 1], marker='o', color='r', alpha=0.8, label='Fraud')

    plt.legend(loc='best');
    plt.show();

• 모든 점은 거래(transaction)를 나타내며, Non-Fraud(비사기) 거래는 녹색으로 표시되고 Fraud(사기) 거래는 빨간색으로 표시
• 두 축은 tsne에 의해 추출된 성분

tsne_plot(X, Y, "original.png")

분류가 잘 안됨

 

 

4. AutoEncoder

- Autoencoder는 출력이 입력과 동일한 특수한 유형의 신경망(neural network) 아키텍처
- 입력 데이터의 극히 낮은 level을 학습하기 위해 unsupervised 방식으로 훈련되며, 그런 다음 이러한 낮은 level의 기능은 실제 데이터를 투영하기 위해 다시 변형
- 입력을 그대로 출력(복원)해내도록 하는 목적 함수를 갖는 항등 함수(identity function) 모델링
    - 입력된 데이터의 특성을 요약하는 Encoder(인코더)
    - 요약된 정보를 복원하는 Decoder(디코더)
    => 입력값을 답으로 주기 때문에 스스로 학습을 한다고 해서 자기지도학습

- 가정 : 정상 관측치들은 불량 관측치보다 더 잘 복원될 것
- 차원이 축소되는 부분을 Bottlenect(잠재벡터)이라고 하며, Autoencoder는 z 부분을 효과적으로 학습하는 것이 목적
- MSE 손실 함수를 사용하며, 중간에 위치한 몇 개의 뉴런의 병목(bottle-neck) 현상이 심하여 Decoder에서 원래 입력을 재생산하는 데 사용할 수 있는 저차원 코드로 입력을 압축하는 효과적인 표현을 생성해야함
- 고차원 공간 상의 입력 데이터를 저차원의 공간으로 맵핑(mapping)하여 잠재적인 변수로 표현(latent representation)하였다가, 다시 입력과 같은 고차원의 공간으로 복원해야 함
- 데이터가 잘 복원된 경우 저차원의 데이터 특성 공간을 잘 파악했다고 볼 수 있음

===> Autoencoder는 입력 데이터와 복원된 데이터 사이의 차이(재구축 오차, Reconstruction Error)를 계산하여 이상치를 탐지

• 1) Autoencoder는 어떤 데이터의 입력을 받은 후, 정보를 압축시켰다가 다시 확장하며 입력받은 것과 최대한 비슷한 결과값을 반환하는 '재구성'의 방법을 통해 특정 데이터의 패턴을 인코딩함
• 2) 신용카드 거래 데이터셋은 대부분 정상 거래 데이터로 이루어져 있으며, 이상 거래 데이터는 적게 포함되어 있는 불균형한 데이터셋임
• 3) Autoencoder 모델을 정상 거래 데이터만으로 학습시키면 이상 거래 데이터가 입력으로 주어지는 경우에는 재구성이 잘 안 되는데, 이 원리를 활용해 신용카드 이상 거래를 탐지함

## input layer 
input_layer = Input(shape=(X.shape[1],))

## encoding part
encoded = Dense(100, activation='tanh', activity_regularizer=regularizers.l1(10e-5))(input_layer)
encoded = Dense(50, activation='relu')(encoded)

## decoding part
decoded = Dense(50, activation='tanh')(encoded)
decoded = Dense(100, activation='tanh')(decoded)

## output layer
output_layer = Dense(X.shape[1], activation='relu')(decoded)

• Network의 구조(뉴런수)는 input → 100 → 50 → 50 → 100 → input으로, 가운데(Bottle-neck Layer) Dimension이 50임
• 시각화하는 과정에서 이를 다시 2차원으로 t-SNE를 활용하여 축소하고 시각화함

 

autoencoder = Model(input_layer, output_layer)

# adadelta : Adagrad, RMSprop, Momentum 모두를 합친 경사하강법
# Adadelta는 과거의 모든 그래디언트를 누적하는 대신 그래디언트 업데이트의 이동 창을 기반으로 학습률을 조정
autoencoder.compile(optimizer="adadelta", loss="mse")

 

• 각 변수의 범위가 다르기 때문에 Min-Max scaling을 통해 수준을 맞춰주는 작업을 수행

x = data.drop(["Class"], axis=1)
y = data["Class"].values

x_scale = preprocessing.MinMaxScaler().fit_transform(x.values)
x_norm, x_fraud = x_scale[y == 0], x_scale[y == 1]

• 모델 훈련

autoencoder.fit(x_norm[0:2000], x_norm[0:2000], 
                batch_size = 256, epochs = 10, 
                shuffle = True, validation_split = 0.20);

 

• sequential layers을 포함하는 또 다른 네트워크를 만들고, 잠재적인 변수로의 표현(latent representation)이 존재하는 세 번째 layer까지만 훈련된 가중치를 추가

hidden_representation = Sequential()
hidden_representation.add(autoencoder.layers[0])
hidden_representation.add(autoencoder.layers[1])
hidden_representation.add(autoencoder.layers[2])

 

• raw inputs을 예측하여 사기(Fraud)와 비사기(Non-Fraud)라는 두 가지 클래스에 대한 숨겨진 표현을 생성

norm_hid_rep = hidden_representation.predict(x_norm[:3000])
fraud_hid_rep = hidden_representation.predict(x_fraud)

 

• 사기(Fraud)와 비사기(Non-Fraud) 거래가 가시적(visible)이고 선형적으로(linearly) 분리할 수 있음을 알 수 있음

rep_x = np.append(norm_hid_rep, fraud_hid_rep, axis = 0)

y_n = np.zeros(norm_hid_rep.shape[0])
y_f = np.ones(fraud_hid_rep.shape[0])

rep_y = np.append(y_n, y_f)
tsne_plot(rep_x, rep_y, "latent_representation.png")

잘 분류

- 사기(Fraud)와 비사기(Non-Fraud) 거래가 가시적(visible)이고 선형적으로(linearly) 분리할 수 있음을 알 수 있음

 

 

 

5. Simple Linear Classifier

train_x, val_x, train_y, val_y = train_test_split(rep_x, rep_y, test_size=0.25)

clf = LogisticRegression(solver="lbfgs").fit(train_x, train_y)

pred_y = clf.predict(val_x)

print ("Classification Report: ")
print (classification_report(val_y, pred_y))

print ("")
print('Logistic Regression Accuracy Score: ', round(accuracy_score(val_y, pred_y) * 100, 3).astype(str) + '%')

• 총 873건의 Test Set 중 Non-Fraud는 742건 & Fraud는 114건
• Fraud는 129건 중 114건은 맞추고 16건은 틀린 것을 확인

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(y_pred=pred_y, y_true=val_y)
cmp = ConfusionMatrixDisplay(cm)

cmp.plot(cmap=plt.cm.Blues)