라일락 꽃이 피는 날

[빅분기 실기] 연관규칙분석 (Association Rule)

eunki — Mon, 20 Jun 2022 00:55:05 +0900

연관규칙분석 (Association Rule, Apriori Algorithm)

대용량의 트랜잭션 데이터로부터 'X이면 Y이다' 라는 형식의 연관관계를 발견하는 기법이다.

어떤 두 아이템 집합이 빈번히 발생하는가를 알려주는 일련의 규칙들을 생성하는 알고리즘이다.

흔히 장바구니 분석(Market Basket Analysis) 이라고도 한다.

연관규칙을 수행하기 위해서는 거래 데이터의 형식으로 되어 있어야 한다.

지지도 (Support) : 전체 거래 건수 중에서 항목집합 X와 Y를 모두 포함하는 거래 건수의 비율

X와 Y를 모두 포함하는 거래 수 / 전체 거래 수 = n(X∩Y) / N

신뢰도 (Confidence) : 항목집합 X를 포함하는 거래 중에서 항목집합 Y도 포함하는 거래 비율

X와 Y를 모두 포함하는 거래 수 / X가 포함된 거래 수 = n(X∩Y) / n(X)

향상도 (Lift) : 신뢰도 / P(Y)

향상도가 절대값 1보다 크면 우수함을 의미하고, 1이면 X와 Y는 독립적이라는 것을 의미한다.

[주요 하이퍼파라미터]

- min_support : 최소 지지도, 기준값 이상만 제시

- min_confidence : 최소 신뢰도, 기준값 이상만 제시

- min_lift : 최소 향상도, 기준값 이상만 제시

1. 분석 데이터 준비

import numpy as np 
import pandas as pd 

data = pd.read_csv('Market_Basket.csv', header = None)
data.head()

transactions = []

for i in range(data.shape[0]):
    transactions.append([str(data[j][i]) for j in
                         range(data.shape[1]-data.isnull().sum(axis=1)[i])])

transaction data로 변환하기 위해서 transactions 이라는 빈 리스트를 만들어 놓고 케이스(행) 수만큼 for문을 수행한다.

transactions에 추가하면서 data에 있는 제품 품목을 담는다.

2. 모델 적용

from apyori import apriori

rules = apriori(transactions, min_support = 0.015, min_confidence = 0.2,  
                min_lift = 1, min_length = 1)
results = list(rules)

df=pd.DataFrame(results)
df

3. 연관품목의 시각화

ar=(df.iloc[1:74]['items'])
ar

78개 규칙 중 74개만 뽑아 그래프로 표현한다.

import matplotlib.pyplot as plt
from matplotlib import font_manager
import networkx as nx
from networkx.drawing.nx_pydot import graphviz_layout

df = pd.DataFrame(list(ar), columns=['FROM', 'TO'])
G = nx.from_pandas_edgelist(df, source = 'FROM', target = 'TO')

# 한글 폰트 설정
ko_font_location = "C:/Windows/Fonts/malgun.ttf"
ko_font_name = font_manager.FontProperties(fname=ko_font_location).get_name()

# 품목 연관 시각화
plt.figure(figsize=(10,10)) 
nx.draw_kamada_kawai(G)
pos=nx.kamada_kawai_layout(G)

nx.draw_networkx_labels(G, pos, font_family=ko_font_name, font_size=10, font_color='black')
nx.draw_networkx_nodes(G, pos, node_color='orange', node_size=2000, alpha=1)

plt.show()

[빅분기 실기] DBSCAN

eunki — Mon, 20 Jun 2022 00:48:20 +0900

DBSCAN

밀도기반 클러스터링 기법

케이스가 집중되어 있는 밀도에 초점을 두어 밀도가 높은 그룹을 클러스터링 하는 방식이다.

중심점을 기준으로 특정한 반경 이내에 케이스가 n개 이상 있을 경우 하나의 군집을 형성한다.

이상값을 탐지하는 데에 많이 사용된다.

[주요 하이퍼파라미터]

- eps (ε, epsilon) : 근접 이웃점을 찾기 위해 정의 내려야 하는 반경 거리

- min_samples (minimum amount of points) : 하나의 군집을 형성하기 위해 필요한 최소 케이스 수

[데이터의 케이스(포인트)]

- Core point : ε 반경 내에 최소점(minPts) 이상을 갖는 점

- Border point : Core point 의 ε 반경 내에 있으나, 그 자체로는 최소점(minPts) 을 갖지 못하는 점

- Noise point : Core point 도 아니고 Border point 도 아닌 점

1. 분석 데이터 준비

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

iris = pd.read_csv("iris.csv")
iris_data=iris[iris.columns[0:4]]
iris_data.head()

2. 모델 적용

from sklearn.cluster import DBSCAN

dbscan = DBSCAN(eps=0.5, metric='euclidean', min_samples=5)
dbscan.fit(iris_data)

dbscan.labels_

설정한 기준에 따라 2개의 군집(0, 1) 으로 나타났다.

모델 기준에서 이상치로 파악된 것은 -1 로 표현된다.

pred=dbscan.fit_predict(iris_data)
pred=pd.DataFrame(pred)
pred.columns=['predict']

match_data = pd.concat([iris,pred],axis=1)
match_data.tail()

cross = pd.crosstab(match_data['class'],match_data['predict'])
cross

setosa 에서 1개, versicolor 에서 6개, virginica 에서 10개의 이상치가 발견되었다.

반경을 좀 더 넓히거나 단위의 표준화 과정을 통해 이상치를 줄여야 한다.

3. 시각화 (Visualization)

from sklearn.decomposition import PCA

pca = PCA(n_components=2).fit(iris_data)
pca_2d = pca.transform(iris_data)

변수가 4개이므로 4차원의 공간에 데이터가 위치해 있겠지만 4차원을 표현하지 못한다.

따라서 2차원으로 차원을 축소해서 보아야 한다. (n_components=2)

for i in range(0, pca_2d.shape[0]):
    if dbscan.labels_[i] == 0:
        c1 = plt.scatter(pca_2d[i,0],pca_2d[i,1],c='r', marker='+')
    elif dbscan.labels_[i] == 1:
        c2 = plt.scatter(pca_2d[i,0],pca_2d[i,1],c='g', marker='o')
    elif dbscan.labels_[i] == -1:
        c3 = plt.scatter(pca_2d[i,0],pca_2d[i,1],c='b', marker='*')
        
plt.legend([c1, c2, c3], ['Cluster 1', 'Cluster 2', 'Noise'])
plt.title('DBSCAN finds 2 clusters and noise')
plt.show()

[빅분기 실기] 군집 분석 (Cluster Analysis)

eunki — Mon, 20 Jun 2022 00:36:11 +0900

군집 분석 (Cluster Analysis)

개체들의 특성을 대표하는 몇 개의 변수들을 기준으로 몇 개의 군집으로 세분화하는 방법

개체들을 다양한 변수를 기준으로 다차원 공간에서 유사한 특성을 가진 개체로 묶는다.
개체들 간의 유사성은 개체 간의 거리를 사용하고, 거리가 상대적으로 가까운 개체들을 동일 군집으로 묶는다.
개체 간의 거리를 행렬을 이용하여 계산한다. 대표적으로 유클리디안 거리를 계산한다.

[주요 하이퍼파라미터]

- n_cluster : 군집의 수

1. 군집분석 (Clustering)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.cm
from sklearn.cluster import KMeans

plt.style.use('seaborn-deep')
cmap = matplotlib.cm.get_cmap('plasma')

data = pd.read_csv('Mall_Customers.csv')
X = data.iloc[:, [3,4]]
X.head()

wcss = []

for i in range(1,21):
    kmeans = KMeans(n_clusters=i)
    kmeans.fit_transform(X)
    wcss.append(kmeans.inertia_)

wcss

통계 기준으로 최적의 군집수를 찾기 위한 과정이다.

kmeans.inertia_ : 군집의 중심과 각 케이스(개체) 간에 거리를 계산한다.

중심과 개체 간의 거리가 작아진다는 것은 그만큼 군집이 잘 형성이 되었다는 것이다.

plt.figure()
plt.plot(range(1,21), wcss)

plt.title('The Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')

plt.show()

군집수가 늘어날수록 수치가 작아지고 있다.

수치가 크게 감소하다가 변화가 없는 지접에서 최적의 군집수 k를 결정한다.

k = 5
kmeans = KMeans(n_clusters = k)

y_kmeans = kmeans.fit_predict(X)
y_kmeans

Group_cluster=pd.DataFrame(y_kmeans)
Group_cluster.columns=['Group']

full_data=pd.concat([data, Group_cluster], axis=1)
full_data

kmeans_pred = KMeans(n_clusters=k, random_state=42).fit(X)
kmeans_pred.cluster_centers_

cluster_centers_ : 각 좌표의 중심점 결과가 담겨져 있는 객체

군집의 중심좌표로 군집의 특성을 살펴보고, 이들 간에 직관적으로 명확한 분리가 되어야 제대로 된 군집수를 나눈 것으로 본다.

labels = [('Cluster ' + str(i+1)) for i in range(k)]
X=np.array(X)

plt.figure()
for i in range(k):
    plt.scatter(X[y_kmeans == i, 0], X[y_kmeans == i, 1], s = 20,
                 c = cmap(i/k), label = labels[i])

2차원 도표에 산점도(scatter plot)를 그린다.
for문으로 각 개체만큼 하나씩 y_kmeans에 분석하여 저장된 좌표값을 찍는다.
라벨에 따라 색을 다르게하기 위해 label = labels[i] 로 설정한다.

plt.scatter(kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1],
            s = 100, c = 'black', label = 'Centroids', marker = 'X')
            
plt.xlabel('Income')
plt.ylabel('Spend')
plt.title('Kmeans cluster plot')

plt.legend()
plt.show()

중심좌표 결과(kmeans.cluster_centers_)를 이용하여 각 군집의 중심점만 찍는다.

plt.figure()
for i in range(k):
    plt.scatter(X[y_kmeans == i, 0], X[y_kmeans == i, 1], s = 20,
                 c = cmap(i/k), label = labels[i])
                 
plt.scatter(kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1],
            s = 100, c = 'black', label = 'Centroids', marker = 'X')
            
plt.xlabel('Income')
plt.ylabel('Spend')
plt.title('Kmeans cluster plot')

plt.legend()
plt.show()

각 개체의 좌표와 군집 중심의 좌표를 한 도표에 표현한다.

2. K-mean Clustering

분석 속도가 빠르고 군집을 형성하면서 유연하게 다른 군집으로 다시 재군집화가 가능하다.

from scipy.spatial.distance import cdist, pdist
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

iris = pd.read_csv("iris.csv")
print (iris.head())

sepal_length : 꽃받침의 길이 / sepal_width : 꽃받침의 넓이
petal_length : 꽃잎의 길이 / petal_width : 꽃잎의 넓이
class : 꽃의 종류 (3종류)

x_iris = iris.drop(['class'],axis=1)
y_iris = iris["class"]

군집분석은 레이블이 있으면 안 되기 때문에 class 변수는 drop 한다.
추후 분류가 잘 되어있는지 확인하기 위해 y_iris 에 담는다.

x_iris.describe()

4개의 변수 단위가 달라서 평균에 차이가 있고, 최댓값과 최솟값도 다르다.
개체들 간의 거리를 계산할 때 단위 때문에 더 다르거나 비슷하게 될 수 있다.
따라서 데이터 단위의 정규화가 필요하다.

from sklearn.preprocessing import StandardScaler

scale=StandardScaler()
scale.fit(x_iris)

X_scale=scale.transform(x_iris)
pd.DataFrame(X_scale).head()

데이터를 표준화하여 X_scale 이라는 데이터셋에 담고, 다시 기술 통계를 확인한다.

K = range(1,10)
KM = [KMeans(n_clusters=k).fit(X_scale) for k in K]

centroids = [k.cluster_centers_ for k in KM]
D_k = [cdist(x_iris, centrds, 'euclidean') for centrds in centroids]

cIdx = [np.argmin(D,axis=1) for D in D_k]
dist = [np.min(D,axis=1) for D in D_k]
avgWithinSS = [sum(d)/X_scale.shape[0] for d in dist]

유클리디안(euclidean) 방법으로 거리를 계산하여 D_k에 담는다.
계산한 거리 중 최솟값(np.argmin) 을 cIdx 에 담고, dist 로 최솟값을 구한다.
argWithinSS 은 군집의 중심과 개체들 간의 최소 거리들의 평균을 구하여 저장한 값이다.

wcss = [sum(d**2) for d in dist]
tss = sum(pdist(X_scale)**2)/X_scale.shape[0]
bss = tss-wcss

각 군집 내에 wcss 는 개체들간의 거리를 제곱하여 더한 값이다.
tss 는 전체 개체들간의 거리를 제곱하여 개체수로 나눈 값이다.
bss 로 wcss 와 tss 의 차이를 계산한다.

fig = plt.figure()
ax = fig.add_subplot(111)

ax.plot(K, avgWithinSS, 'b*-')

plt.grid(True)
plt.xlabel('Number of clusters')
plt.ylabel('Average within-cluster sum of squares')
plt.title('Elbow for KMeans clustering')

최적의 군집수를 구하기 위해 군집을 1~10 까지 변화할 때의 평균 군집내 거리(avgWithinSS)를 그린다.
군집수를 4 또는 6으로 하는 것이 적합해보인다.

fig = plt.figure()
ax = fig.add_subplot(111)

ax.plot(K, bss/tss*100, 'b*-')

plt.grid(True)
plt.xlabel('Number of clusters')
plt.ylabel('Percentage of variance explained')
plt.title('Elbow for KMeans clustering')

개체들 간의 분산비율을 군집수를 달리하면서 본다.
Y축이 음수이기 때문에 0에 가까울수록 적합한 k 이다.
4~6 사이에서 군집을 결정하는 것이 적합해보인다.

import numpy as np

w,v = np.linalg.eig(np.array([[ 0.91335 ,0.75969 ],[ 0.75969,0.69702]]))

print ("\nEigen Values\n",w) 
print ("\nEigen Vectors\n",v)

k_means_fit = KMeans(n_clusters=4, max_iter=300)
k_means_fit.fit(X_scale)

k_means_fit.cluster_centers_

print ("\nK-Means Clustering - Confusion Matrix\n\n",
       pd.crosstab(y_iris,k_means_fit.labels_,rownames = ["Actuall"],colnames = ["Predicted"]) )

실제 3종류의 꽃(y_iris) 과 군집으로 나눈 4개의 군집 간에 일치하는지를 확인한다.

print ("\nSilhouette-score: %0.3f" % silhouette_score(x_iris, k_means_fit.labels_, metric='euclidean'))

for k in range(2,10):
    k_means_fitk = KMeans(n_clusters=k,max_iter=300)
    k_means_fitk.fit(x_iris)
    print ("For K value",k,",Silhouette-score: %0.3f" % silhouette_score(x_iris, k_means_fitk.labels_, metric='euclidean'))

군집수를 2~10 까지 변경하면서 실루엣 스코어(silhouette-score)를 찾는다.

3. 계층적 군집분석 (Hierarchical Clustering)

한 번 어떤 군집에 속한 개체는 분석 과정에서 다른 군집과 더 가깝게 계산되어도
다른 군집화가 허용되지 않는 방법이고, 속도도 다소 오래 걸린다.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.cm

plt.style.use('seaborn-deep')
cmap = matplotlib.cm.get_cmap('plasma')

data = pd.read_csv('Mall_Customers.csv')
X = data.iloc[:, [3,4]].values

import scipy.cluster.hierarchy as sch

plt.figure(1)
z = sch.linkage(X, method = 'ward')
dendrogram = sch.dendrogram(z)

plt.title('Dendrogram')
plt.xlabel('Customers')
plt.ylabel('ward distances')

plt.show()

개체들 간의 거리를 ward 방법으로 하고 덴드로그램을 그린다.

from sklearn.cluster import AgglomerativeClustering

k = 5
hc = AgglomerativeClustering(n_clusters = k, affinity = "euclidean", linkage = 'ward')
y_hc = hc.fit_predict(X)

군집수를 5로하여 병합 군집(Agglomerative Clustering)을 적용한 군집분석을 수행한다.
시작할 때 각 포인트를 하나의 클러스터로 지정하고,
그 다음 종료 조건을 만족할 때까지 가장 비슷한 두 클러스터를 합치는 방식으로 진행한다.

labels = [('Cluster ' + str(i+1)) for i in range(k)]

plt.figure(2)
for i in range(k):
    plt.scatter(X[y_hc == i, 0], X[y_hc == i, 1], s = 20,
                c = cmap(i/k), label = labels[i]) 
                
plt.xlabel('Income')
plt.ylabel('Spending score')
plt.title('HC cluster plot')

plt.legend()
plt.show()

5개의 군집으로 나누어진 것을 확인할 수 있다.

[빅분기 실기] 엘라스틱넷 (Elasticnet)

eunki — Sun, 19 Jun 2022 23:59:20 +0900

엘라스틱넷 (Elasticnet)

릿지회귀와 라쏘회귀의 절충한 모델로, 맂시와 라쏘의 규제항을 단순히 더해서 사용한다.
두 규제항의 혼합정도를 혼합비율 r을 사용해 조절하게 된다.
만약 r=0 이면 릿지회귀와 같고, r=1 이면 라쏘회귀와 같게 된다.

[주요 하이퍼파라미터]

- alpha : 값이 클수록 계수를 0에 가깝게 제약하여 훈련 데이터의 정확도는 낮아지지만 일반화에 기여한다. (default = 1)
값이 0에 가까울수록 회귀계수를 아무런 제약을 하지 않은 선형회귀와 유사하게 적용한다.

- l1_ratio : 릿지와 라쏘의 규제 비율에 대한 가중 정도

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.linear_model import ElasticNet

model=ElasticNet()
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.050029698219161034

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.051683303919568435

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

3. 하이퍼파라미터 튜닝

3-1. Grid Search

param_grid={'alpha': [0.0, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 0.5, 1.0, 2.0, 3.0]}

alpha 값을 10가지로 설정하고 그리드 탐색을 진행한다.

from sklearn.model_selection import GridSearchCV

grid_search=GridSearchCV(ElasticNet(), param_grid, cv=5)
grid_search.fit(X_scaled_train, y_train)

print("Best Parameter: {}".format(grid_search.best_params_))
print("Best Score: {:.4f}".format(grid_search.best_score_))
print("TestSet Score: {:.4f}".format(grid_search.score(X_scaled_test, y_test)))

최적의 alpha는 1e-05로, 이때 훈련 데이터의 정확도는 54.5%, 테스트 데이터의 정확도는 56.3% 이다.

3-2. Random Search

from scipy.stats import randint

param_distribs = {'alpha': randint(low=0.00001, high=10)}

랜덤 탐색을 위해 alpha를 0.00001 ~ 10 사이의 범위에서 100번(n_iter) 무작위 추출하는 방식을 적용한다.

from sklearn.model_selection import RandomizedSearchCV

random_search=RandomizedSearchCV(ElasticNet(), 
                                 param_distributions=param_distribs, n_iter=100, cv=5)
random_search.fit(X_scaled_train, y_train)

print("Best Parameter: {}".format(random_search.best_params_))
print("Best Score: {:.4f}".format(random_search.best_score_))
print("TestSet Score: {:.4f}".format(random_search.score(X_scaled_test, y_test)))

최적의 alpha는 0으로, 이때 훈련 데이터의 정확도는 54.5%, 테스트 데이터의 정확도는 56.3% 이다.

[빅분기 실기] 라쏘 (Lasso)

eunki — Sun, 19 Jun 2022 23:51:56 +0900

728x90

라쏘 (Lasso)

릿지 회귀모델과 유사하게 특성의 계수값을 0에 가깝게 하지만
실제 중요하지 않은 변수의 계수를 0으로 만들어 불필요한 변수를 제거하는 모델

[주요 하이퍼파라미터]

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.linear_model import Lasso

model=Lasso()
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.5455724679313863

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.5626850497564577

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

3. 하이퍼파라미터 튜닝

3-1. Grid Search

param_grid={'alpha': [0.0, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 0.5, 1.0, 2.0, 3.0]}

alpha 값을 11가지로 설정하고 그리드 탐색을 진행한다.

from sklearn.model_selection import GridSearchCV

grid_search=GridSearchCV(Lasso(), param_grid, cv=5)
grid_search.fit(X_scaled_train, y_train)

print("Best Parameter: {}".format(grid_search.best_params_))
print("Best Score: {:.4f}".format(grid_search.best_score_))
print("TestSet Score: {:.4f}".format(grid_search.score(X_scaled_test, y_test)))

최적의 alpha는 0.5로, 이때 훈련 데이터의 정확도는 54.5%, 테스트 데이터의 정확도는 56.3% 이다.

3-2. Random Search

from scipy.stats import randint

param_distribs = {'alpha': randint(low=0.00001, high=10)}

랜덤 탐색을 위해 alpha를 0.00001 ~ 10 사이의 범위에서 100번(n_iter) 무작위 추출하는 방식을 적용한다.

from sklearn.model_selection import RandomizedSearchCV

random_search=RandomizedSearchCV(Lasso(), 
                                 param_distributions=param_distribs, n_iter=100, cv=5)
random_search.fit(X_scaled_train, y_train)

print("Best Parameter: {}".format(random_search.best_params_))
print("Best Score: {:.4f}".format(random_search.best_score_))
print("TestSet Score: {:.4f}".format(random_search.score(X_scaled_test, y_test)))

최적의 alpha는 1로, 이때 훈련 데이터의 정확도는 54.5%, 테스트 데이터의 정확도는 56.3% 이다.

[빅분기 실기] 릿지 (Ridge)

eunki — Sun, 19 Jun 2022 23:44:30 +0900

릿지 (Ridge)

선형회귀분석의 기본 원리를 따르나, 가중치(회귀계수) 값을 최대한 작게 만들어
모든 독립변수가 종속변수에 미치는 영향을 최소화하는 제약을 반영한 회귀모델

각 특성의 영향을 최소화하여 훈련 데이터에 과대적합되지 않도록 제약한 모델이다.미

선형 관계뿐만 아니라 다항 곡선 추정도 가능하다.

[주요 하이퍼파라미터]

- alpha : 값이 클수록 규제가 강하여 회귀 계수가 0에 근접하다. (default = 1)
값이 0에 가까울수록 규제를 하지 않아 선형 회귀와 유사한 결과를 보인다.

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.linear_model import Ridge

model=Ridge()
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.5455487773718164

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.5626954941458684

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

3. 하이퍼파라미터 튜닝

3-1. Grid Search

param_grid={'alpha': [1e-4, 1e-3, 1e-2, 0.1, 0.5, 1.0, 5.0, 10.0]}

alpha 값을 11가지로 설정하고 그리드 탐색을 진행한다.

from sklearn.model_selection import GridSearchCV

grid_search=GridSearchCV(Ridge(), param_grid, cv=5)
grid_search.fit(X_scaled_train, y_train)

print("Best Parameter: {}".format(grid_search.best_params_))
print("Best Score: {:.4f}".format(grid_search.best_score_))
print("TestSet Score: {:.4f}".format(grid_search.score(X_scaled_test, y_test)))

최적의 alpha는 0.1로, 이때 훈련 데이터의 정확도는 54.5%, 테스트 데이터의 정확도는 56.3% 이다.

3-2. Random Search

from scipy.stats import randint

param_distribs = {'alpha': randint(low=0.0001, high=100)}

랜덤 탐색을 위해 alpha를 0.0001 ~ 100 사이의 범위에서 100번(n_iter) 무작위 추출하는 방식을 적용한다.

from sklearn.model_selection import RandomizedSearchCV

random_search=RandomizedSearchCV(Ridge(), 
                                 param_distributions=param_distribs, n_iter=100, cv=5)
random_search.fit(X_scaled_train, y_train)

print("Best Parameter: {}".format(random_search.best_params_))
print("Best Score: {:.4f}".format(random_search.best_score_))
print("TestSet Score: {:.4f}".format(random_search.score(X_scaled_test, y_test)))

최적의 alpha는 0.1로, 이때 훈련 데이터의 정확도는 54.5%, 테스트 데이터의 정확도는 56.3% 이다.

[빅분기 실기] 선형회귀모델 (Linear Regression Model)

eunki — Sun, 19 Jun 2022 23:26:56 +0900

선형회귀모델 (Linear Regression Model)

연속형 원인 변수가 연속형 결과 변수에 영향을 미치는지를 분석하여 레이블 변수를 예측

가장 대표적인 오차 지표인 RMSE는 실제값과 예측값 간에 전 구간에 걸친 평균적인 오차

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. Statmodel

파이썬의 통계분석 모듈

import statsmodels.api as sm

x_train_new = sm.add_constant(X_train)
x_test_new = sm.add_constant(X_test)
x_train_new.head()

X_train 에 상수항 변수를 더하여 x_train_new 라는 변수로 만든다.

const 변수가 상수를 추정하는 역할을 한다.

통계적 회귀분석에서는 일반적으로 X 데이터의 정규화를 하지 않는다.

2-1. 훈련 데이터

multi_model = sm.OLS(y_train,x_train_new).fit()
print (multi_model.summary())

R-squared: 0.546 → 54.6% 수준으로 회귀직선(예측값)과 실제값이 일치한다.

coef : 각 X 변수가 1증가할 때마다 Y가 변화하는 정도 (=기울기)

p>|t| : 통계적으로 유의한가를 검증한 결과로, 0.05보다 작으면 유의한 영향을 미치는 변수로 본다.

2-2. 테스트 데이터

multi_model2 = sm.OLS(y_test,x_test_new).fit()
print (multi_model2.summary())

3. 기본모델 적용

3-1. 훈련 데이터

from sklearn.linear_model import LinearRegression

model=LinearRegression()
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.5455724996358273

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.562684388358716

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

② MAE (Mean Absolute Error)

from sklearn.metrics import mean_absolute_error

mean_absolute_error(y_test, pred_test)  # 47230.874701637375

③ MSE (Mean Squared Error)

from sklearn.metrics import mean_squared_error 

mean_squared_error(y_test, pred_test)  # 3996869138.1105847

④ MAPE (Mean Absolute Percentage Error)

def MAPE(y_test, y_pred):
    return np.mean(np.abs((y_test - pred_test) / y_test)) * 100 
    
MAPE(y_test, pred_test)

⑤ MPE (Mean Percentage Error)

def MAE(y_test, y_pred):
    return np.mean((y_test - pred_test) / y_test) * 100
    
MAE(y_test, pred_test)

[빅분기 실기] 앙상블 스태킹 (Stacking)

eunki — Sun, 19 Jun 2022 21:31:09 +0900

앙상블 스태킹 (Stacking)

데이터셋이 아니라 여러 학습기에서 예측한 예측값으로
다시 학습 데이터를 만들어 일반화된 최종 모델을 구성하는 방법

[주요 하이퍼파라미터]

- estimators

Part 1. 분류 (Classification)

1. 분석 데이터 준비

import pandas as pd

# 유방암 예측 분류 데이터
data1=pd.read_csv('breast-cancer-wisconsin.csv', encoding='utf-8')

X=data1[data1.columns[1:10]]
y=data1[["Class"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, stratify=y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train) 

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import StackingClassifier

estimators = [('rf', RandomForestClassifier(n_estimators=10, random_state=42)),
              ('svr', SVC(random_state=42))]
model = StackingClassifier(estimators=estimators, final_estimator=LogisticRegression())
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.986328125

① 오차행렬 (confusion matrix)

from sklearn.metrics import confusion_matrix

confusion_train=confusion_matrix(y_train, pred_train)
print("훈련데이터 오차행렬:\n", confusion_train)

정상(0) 중 3명이 오분류, 환자(1) 중 4명이 오분류되었다.

② 분류예측 레포트 (classification report)

from sklearn.metrics import classification_report

cfreport_train=classification_report(y_train, pred_train)
print("분류예측 레포트:\n", cfreport_train)

정밀도(precision) = 0.99, 재현율(recall) = 0.98

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.9649122807017544

① 오차행렬 (confusion matrix)

confusion_test=confusion_matrix(y_test, pred_test)
print("테스트데이터 오차행렬:\n", confusion_test)

정상(0) 중 5명이 오분류, 환자(1) 중 1명이 오분류되었다.

② 분류예측 레포트 (classification report)

cfreport_test=classification_report(y_test, pred_test)
print("분류예측 레포트:\n", cfreport_test)

정밀도(precision) = 0.96, 재현율(recall) = 0.97

Part 2. 회귀 (Regression)

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.linear_model import LinearRegression
from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import StackingRegressor

estimators = [('lr', LinearRegression()), 
              ('knn', KNeighborsRegressor())]
model = StackingRegressor(estimators=estimators, 
                          final_estimator=RandomForestRegressor(n_estimators=10, random_state=42))
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.543404932348004

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.4781188528801523

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

[빅분기 실기] 앙상블 부스팅 (Boosting)

eunki — Sun, 19 Jun 2022 21:16:40 +0900

앙상블 배깅 (Boosting)

여러 개의 약한 학습기를 순차적으로 학습시켜 예측하면서
잘 못 예측한 데이터에 가중치를 부여하여 오류를 개선해 나가며 학습하는 앙상블 모델
배깅이 병렬식 앙상블인 반면, 부스팅은 순차적인 직렬식 앙상블이다.

[주요 하이퍼파라미터]

1. AdaBoosting
- base_estimator
- n_estimator : 모델 수행횟수

2. GradientBoosting
- learning_rate : 학습률

Part 1. 분류 (Classification)

1. 분석 데이터 준비

import pandas as pd

# 암 예측 분류 데이터
data=pd.read_csv('breast-cancer-wisconsin.csv', encoding='utf-8')

X=data[data.columns[1:10]]
y=data[["Class"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, stratify=y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train) 

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. AdaBoosting

2-1. 훈련 데이터

from sklearn.ensemble import AdaBoostClassifier

model = AdaBoostClassifier(n_estimators=100, random_state=0)
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 1.0

① 오차행렬 (confusion matrix)

from sklearn.metrics import confusion_matrix

confusion_train=confusion_matrix(y_train, pred_train)
print("훈련데이터 오차행렬:\n", confusion_train)

정상 333명, 환자 179명을 정확하게 분류했다.

② 분류예측 레포트 (classification report)

from sklearn.metrics import classification_report

cfreport_train=classification_report(y_train, pred_train)
print("분류예측 레포트:\n", cfreport_train)

정밀도(precision) = 1.0, 재현율(recall) = 1.0

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.9532163742690059

① 오차행렬 (confusion matrix)

confusion_test=confusion_matrix(y_test, pred_test)
print("테스트데이터 오차행렬:\n", confusion_test)

정상(0) 중 5명이 오분류, 환자(1) 중 3명이 오분류되었다.

② 분류예측 레포트 (classification report)

cfreport_test=classification_report(y_test, pred_test)
print("분류예측 레포트:\n", cfreport_test)

정밀도(precision) = 0.95, 재현율(recall) = 0.95

3. GradientBoosting

3-1. 훈련 데이터

from sklearn.ensemble import GradientBoostingClassifier

model = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 1.0

① 오차행렬 (confusion matrix)

from sklearn.metrics import confusion_matrix

confusion_train=confusion_matrix(y_train, pred_train)
print("훈련데이터 오차행렬:\n", confusion_train)

정상 333명, 환자 179명을 정확하게 분류했다.

3-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.9649122807017544

① 오차행렬 (confusion matrix)

confusion_test=confusion_matrix(y_test, pred_test)
print("테스트데이터 오차행렬:\n", confusion_test)

정상(0) 중 5명이 오분류, 환자(1) 중 1명이 오분류되었다.

Part 2. 회귀 (Regression)

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. AdaBoosting

2-1. 훈련 데이터

from sklearn.ensemble import AdaBoostRegressor

model = AdaBoostRegressor(random_state=0, n_estimators=100)
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.4353130085971758

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.43568387094087124

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

3. GradientBoosting

3-1. 훈련 데이터

from sklearn.ensemble import GradientBoostingRegressor

model = GradientBoostingRegressor(random_state=0)
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.6178724780500952

3-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.5974112241813845

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))

[빅분기 실기] 앙상블 배깅 (Bagging)

eunki — Sun, 19 Jun 2022 20:34:42 +0900

앙상블 배깅 (Bagging)

학습 데이터에 대해 여러 개의 부트스트랩 (Bootstrap) 데이터를 생성하고

각 데이터에 하나 또는 여러 알고리즘을 학습시킨 후

산출된 결과 중 투표 (Voting) 방식에 의해 최종 결과를 선정하는 알고리즘

[주요 하이퍼파라미터]

- n_estimators : 부트스트랩 데이터셋 수

Part 1. 분류 (Classification)

1. 분석 데이터 준비

import pandas as pd

# 암 예측 분류 데이터
data=pd.read_csv('breast-cancer-wisconsin.csv', encoding='utf-8')

X=data[data.columns[1:10]]
y=data[["Class"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, stratify=y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train) 

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.svm import SVC
from sklearn.ensemble import BaggingClassifier

model = BaggingClassifier(base_estimator=SVC(), n_estimators=10, random_state=0)
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.982421875

10개의 데이터셋에 SVC를 훈련시킨 10개 모델 결과를 종합한다.

① 오차행렬 (confusion matrix)

from sklearn.metrics import confusion_matrix

confusion_train=confusion_matrix(y_train, pred_train)
print("훈련데이터 오차행렬:\n", confusion_train)

정상(0) 중 4명이 오분류, 환자(1) 중 5명이 오분류되었다.

② 분류예측 레포트 (classification report)

from sklearn.metrics import classification_report

cfreport_train=classification_report(y_train, pred_train)
print("분류예측 레포트:\n", cfreport_train)

정밀도(precision) = 0.98, 재현율(recall) = 0.98

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.9590643274853801

① 오차행렬 (confusion matrix)

confusion_test=confusion_matrix(y_test, pred_test)
print("테스트데이터 오차행렬:\n", confusion_test)

정상(0) 중 5명이 오분류, 환자(1) 중 2명이 오분류되었다.

② 분류예측 레포트 (classification report)

cfreport_test=classification_report(y_test, pred_test)
print("분류예측 레포트:\n", cfreport_test)

정밀도(precision) = 0.95, 재현율(recall) = 0.96

Part 2. 회귀 (Regression)

1. 분석 데이터 준비

# 주택 가격 데이터
data2=pd.read_csv('house_price.csv', encoding='utf-8')

X=data2[data2.columns[1:5]]
y=data2[["house_value"]]

1-2. train-test 데이터셋 나누기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test=train_test_split(X, y, random_state=42)

1-3. Min-Max 정규화

from sklearn.preprocessing import MinMaxScaler

scaler=MinMaxScaler()
scaler.fit(X_train)

X_scaled_train=scaler.transform(X_train)
X_scaled_test=scaler.transform(X_test)

2. 기본모델 적용

2-1. 훈련 데이터

from sklearn.neighbors import KNeighborsRegressor
from sklearn.ensemble import BaggingRegressor

model = BaggingRegressor(base_estimator=KNeighborsRegressor(), n_estimators=10, random_state=0)
model.fit(X_scaled_train, y_train)

pred_train=model.predict(X_scaled_train)
model.score(X_scaled_train, y_train)  # 0.6928982134381334

2-2. 테스트 데이터

pred_test=model.predict(X_scaled_test)
model.score(X_scaled_test, y_test)  # 0.5612676280708411

① RMSE (Root Mean Squared Error)

import numpy as np
from sklearn.metrics import mean_squared_error 

MSE_train = mean_squared_error(y_train, pred_train)
MSE_test = mean_squared_error(y_test, pred_test)

print("훈련   데이터 RMSE:", np.sqrt(MSE_train))
print("테스트 데이터 RMSE:", np.sqrt(MSE_test))