[기술서적] 파이썬을 활용한 금융 분석 - 통계분석 중 머신러닝

 

 

파이썬을 활용한 금융분석 - 이브 힐피시 책 내용을 기반으로 colab, jupyter notebook 으로 직접 코드 구현해보며 공부한 내용이다.

 

 

 

 

비지도 학습

 

사람의 지도 없이 데이터에서 인사이트를 발견할 수 있다는 사실에 근거를 두고 있는 학습 방법.

ex) k-means 클러스터링 알고리즘

 

 

먼저 k-means 클러스터링을 설명하기 위한 샘플 데이터를 제작

 

import numpy as np
import pandas as pd
import datetime as dt
from pylab import mpl, plt

plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
np.random.seed(1000)
np.set_printoptions(suppress=True, precision=4)
%matplotlib inline

from sklearn.datasets import make_blobs

#4개의 중심을 가진 250개 데이터 생성
X, y = make_blobs(n_samples=250, centers=4,
                 random_state=500, cluster_std=1.25)

plt.figure(figsize = (10, 6))
plt.scatter(X[: , 0] , X[:, 1] , s=50)

 

클러스터링 알고리즘 샘플 데이터 시각

 

 

 

* k-means 클러스터링

 

기본 단계

: 모형 클래스 임포트 -> 모형 객체 생성 -> 데이터에 모형 객체를 훈련 -> 훈련된 모형을 사용해 일부 데이터 결과 예측

 

 

# scikit-learn 모형 클래스 import
from sklearn.cluster import KMeans

model = KMeans(n_clusters = 4, random_state = 0) # 모형 객체 생성
model.fit(X) # 모형 객체 데이터에 맞게 훈련

# 주어진 데이터 클러스터 예측
KMeans(algorithm='auto' , copy_x = True, init='k-means++', max_iter=300,
      n_clusters=4, n_init=10,  
      random_state=0, tol=0.0001, verbose=0)

# 예측된 클러스터 중 일부
y_kmeans = model.predict(X)

#시각화
plt.figure(figsize=(10,6))
plt.scatter(X[:, 0], X[:, 1] , c=y_kmeans, cmap='coolwarm')

 

예제 데이터 클러스터 시각화 결과

 

 

* 가우스 혼합 모형

 

클러스터링을 대체할 수 있는 예로 가우스 혼합 모형 사용.

from sklearn.cluster import KMeans

model = KMeans(n_clusters = 4, random_state = 0)

model.fit(X)
KMeans(algorithm='auto' , copy_x = True, init='k-means++', max_iter=300,
      n_clusters=4, n_init=10,  
      random_state=0, tol=0.0001, verbose=0)

y_kmeans = model.predict(X)

#가우시안 혼합 모형
from sklearn.mixture import GaussianMixture

model = GaussianMixture(n_components=4, random_state=0)
model.fit(X)

GaussianMixture(covariance_type='full' , init_params='kmeans',
               max_iter=100, means_init=None, n_components=4, n_init=1, precisions_init = None,
               random_state=0, reg_covar=1e-06, tol=0.001, verbose=0,
               verbose_interval=10, warm_start=False, weights_init=None)

y_gm = model.predict(X)

(y_gm == y_kmeans).all()
# True 리턴

 

 

 

지도 학습

 

관측된 데이터나 알려진 결과를 이용해 학스블 지도한다.

데이터 내부에 머신러닝이 학습해야 할 내용이 이미 포함되어 있음을 의미.

 

앞선 클러스터링의 경우 알고리즘이 레이블을 0,1,2,3 부여할 수 있으나 지도학습에서는 레이블이 이미 주어져 있음.

훈련 단계에서 알고리즘은 주어진 특징의 조합을 사요해 정확한 레이블을 고르는 방법을 학습하게 되는 것을 의미.

 

활용되는 분류 알고리즘 종류

- 가우스 나이브 베이즈 Gaussian Naive Bayes

- 로지스틱 회귀 logistic regression

- 의사결정 나무 Decision tree

- 심층 신경망 Deep Neural Network

- 서포트 벡터 머신 Support Vector Machine

 

 

 

먼저 scikit-learn 분류문제에 샘플 데이터를 생성 (0과 1로 이루어진 이진 레이블)

from sklearn.datasets import make_classification

n_samples = 100

X, y = make_classification(n_samples = n_samples, n_features = 2,
                          n_informative = 2, n_redundant = 0,
                          n_repeated = 0, random_state = 250)

plt.figure(figsize=(10,6))
plt.scatter(x=X[:, 0] , y=X[:, 1], c=y, cmap='coolwarm')

 

분류 알고리즘에 사용할 샘플 데이터 시각화

 

 

 

* 가우스 나이브 베이즈

 

가우스 나이브 베이즈(GNB)는 클래스가 많은 분류에 적합한 분류 알고리즘이다.

from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score
 
#가우스 나이브 베이즈 모델
model = GaussianNB()

model.fit(X, y)
GaussianNB(priors=None, var_smoothing=1e-09)

#확률에 기반해 데이터 이진 클래스 예측
pred = model.predict(X)

#정확도 점수 계산
accuracy_score(y, pred) #0.87 도출

Xc = X[y == pred] #정답 플롯
Xf = X[y != pred] #오답 플롯

plt.figure(figsize = (10, 6))
plt.scatter(x=Xc[: , 0] , y=Xc[: , 1], c=y[y==pred], marker='o', cmap='coolwarm') #정답 O 표시
plt.scatter(x=Xf[:, 0], y=Xf[:, 1], c=y[y != pred], marker='x', cmap='coolwarm') #오답 X 표시

가우스 나이브 베이즈 구현 정답O, 오답X 스캐터 결과

 

 

* 로지스틱 회귀

 

로지스틱 회귀(LR)는 빠르고 대규모 확장 가능한 분류 알고리즘.

예제문제에서는 GNB보다 나은 성능 결과를 나타냄.

 

#로지스틱 회귀
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(C=1, solver='lbfgs')
model.fit(X, y)
LogisticRegression(C=1, class_weight=None, dual=False, fit_intercept=True,
                  intercept_scaling=1, max_iter=100, multi_class='warn',
                  penalty='12', random_state=None, solver='lbfgs', 
                  tol = 0.0001, verbose = 0, warm_start=False)

pred = model.predict(X)

accuracy_score(y, pred) #0.9 결과 도출

Xc = X[y == pred]
Xf = X[y != pred]

plt.figure(figsize = (10, 6))
plt.scatter(x = Xc[:, 0], y=Xc[:,1], c=y[y == pred],
           marker = 'o' , cmap='coolwarm')
plt.scatter(x = Xf[:, 0], y=Xf[:,1], c=y[y != pred],
           marker = 'x' , cmap='coolwarm')

 

로지스틱 회귀 구현 정답O, 오답X 스캐터 결과

 

 

 

* 의사결정 나무

 

의사결정 나무(DT) 또한 확장이 쉬운 분류 알고리즘 중 하나로 깊이를 1로 해도 GNB나 LR보다 조금 나은 성능 결과를 도출함.

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(max_depth = 1)
model.fit(X, y)

DecisionTreeClassifier(class_weight=None, criterion = 'gini', max_depth=1,
                      max_features=None, max_leaf_nodes=None, min_impurity_decrease=0.0,
                       min_samples_leaf=1, min_samples_split=2,
                      min_weight_fraction_leaf=0.0, random_state=None,
                      splitter='best')

pred=model.predict(X)

accuracy_score(y, pred) #0.92 도출

Xc = X[y == pred]
Xf = X[y != pred]

plt.figure(figsize = (10, 6))
plt.scatter(x=Xc[: , 0] , y=Xc[:, 1], c=y[y == pred],
           marker = 'o', cmap = 'coolwarm')
plt.scatter(x=Xf[: , 0] , y=Xf[:, 1], c=y[y != pred],
           marker = 'x', cmap = 'coolwarm')

 

의사결정나무 (depth 1) 구현 정답O, 오답X 스캐터 결과

 

만약 의사결정나무 알고리즘에서 깊이를 증가시킴에 따라 결과를 보고싶으면 아래와 같이 구현해보면 된다.

 

print('{:>8s} | {:8s}'.format('depth', 'accuracy'))
print(20 * '-')
for depth in range(1, 7):
    model = DecisionTreeClassifier(max_depth=depth)
    model.fit(X, y)
    acc = accuracy_score(y, model.predict(X))
    print('{:8d} | {:8.2f}'.format(depth, acc))

depth 6에 1.0 결과까지 도출됨

 

 

* 특징 변환

 

데이터의 특징을 변환하는 방법 실습.

StandardScaler, MinMaxScaler, Normalizer (norm 변환)

이후 원본 데이터와 변환된 데이터를 시각화 한다.

 

from sklearn import preprocessing

X[:5] #원본 데이터 확인

Xs = preprocessing.StandardScaler().fit_transform(X) #특징값을 평균 0, 표준편차 1인 표준정규분포로 변환
Xs[:5] #스탠다드 스케일러 데이터 확인

Xm = preprocessing.MinMaxScaler().fit_transform(X) #특징값을 최소/최대값 범위로 정해진 구간 분포로 변환
Xm[:5] #최대최소 스케일러 데이터 확인

Xn1 = preprocessing.Normalizer(norm = 'l1').transform(X)
Xn1[:5] #정규화 L1 norm (각 특성의 절대값 합이 1이 되도록)

Xn2 = preprocessing.Normalizer(norm='l2').transform(X)
Xn2[:5] #정규화 L2 norm (각 특성의 제곱의 합이 1이 되도록)

plt.figure(figsize = (10, 6))
markers = ['o', '.', 'x', '^', 'v']
data_sets = [X, Xs, Xm, Xn1, Xn2]
labels = ['raw', 'standard', 'minmax', 'norm(1)', 'norm(2)']

for x, m, l in zip(data_sets, markers, labels):
    plt.scatter(x=x[:, 0], y=x[:, 1], c=y,
               marker = m, cmap = 'coolwarm', label=l)
plt.legend()

 

원본, 변환 데이터들 시각화 결과