hyerimir_archive

# 정상성 : 추세와 계절성을 갖지 않는 진동하는 데이터
# 주기성 행동을 가지고 있지만, 주기가 특정 패턴을 갖지 않고 시계열을 관측하는 어떠한 시점에서도
# 똑같은 모양일 것이다

# ARIMA 모형을 적용하기 위해서는, 추세와 계절성이 없는 정상성을 지닌 데이터여야 함

# 정상성 검정 - Augmented Dickey-Fuller Test
# 정상성을 알아보기 위한 단위근 검정 방법
# 귀무가설 : 데이터가 정상성을 갖지 않는다(변동이 있다)
# 대립가설 : 데이터가 정상성을 갖는다
# adfuller(x, maxlag, regression, autolag)

import pandas as pd
data = pd.read_csv('../data/arima_data.csv', names = ['day', 'price'])
data.head(3)

data.info()

data['day'] = pd.to_datetime(data['day'], format = '%Y-%m-%d')
data.set_index('day', inplace = True)
data.head(3)

train_len = int(len(data) * 0.8)
training = data[:train_len]
test = data.drop(training.index)

# 귀무가설 : 데이터가 정상성을 갖지 않는다(변동이 있다)
# 대립가설 : 데이터가 정상성을 갖는다

from statsmodels.tsa.stattools import adfuller
adf = adfuller(training, regression = 'ct')

# adf statistic
adf[0]

# p-value
adf[1]
# 단위근 검정에서 p-value가 0.05보다 크므로, 귀무가설을 기각할 수 없음
# 정상성을 갖지 않는 것으로 판단됨

# 차분 후 단위근 검정 재실시
# 차분 : 비정상성을 정상성으로 만들기 위해, 관측값들의 차이를 계산하는 것
# 데이터프레임을 n차 차분하고, acf, pacf를 다시 구함

from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
diff_data = training.diff(1)
diff_data = diff_data.dropna()
diff_data.plot()

from statsmodels.tsa.stattools import adfuller
adf = adfuller(diff_data)

# adf statistic
adf[0]

# p-value
adf[1]
# p-value 값이 유의수준보다 작아, 정상성을 갖추고 있다고 판단

# ARIMA(p, d, q)의 파라미터 정하기
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
import numpy as np
import matplotlib.pyplot as plt

plot_pacf(diff_data) # AR(p)의 값 확인
plot_acf(diff_data) # MA(q)의 값 확인

plt.show()

# 0되기 전 값, 여기서는 acf, pacf 모두 2에서 절단점을 가짐
# p, d, q = 2, 1, 2

# SARIMA : 계절성 시계열 데이터에 대한 분석
# 계절성까지 고려한 ARIMA 모델

import pandas as pd
import matplotlib.pyplot as plt

data = pd.read_csv('../data/arima_data.csv', names = ['day', 'price'])
data['day'] = pd.to_datetime(data['day'], format = '%Y-%m-%d')
data.set_index('day', inplace = True)
s_data = data

train_len = int(len(s_data) * 0.7)
training = s_data[:train_len]
test = s_data.drop(training.index)

import matplotlib.pyplot as plt
training.plot()
plt.show()

import statsmodels.api as sm
from statsmodels.tsa.statespace.sarimax import SARIMAX

model = SARIMAX(training.price.values, order = (2,1,2),
	seasonal_order = (1,1,1,12), tremd = 'ct', enforce_stationarity = False,
    enforce_invertibility = False)

results = model.fit()
results.summary()

# 데이터 확인
# 시간 경과에 따른 표준화 잔차
# 히스토그램과 표준화 된 잔차의 추정된 밀도, 참조를 위해 그려진 Normal(0,1) alfeh
# 일반 기준선이 있는 일반 QQ 플롯

results.plot_diagnostics(figsize = (14, 10))
plt.show()

forecast_values = results.get_forecast(steps = len(test))
forecast_values.summary_frame()

ax = s_data.plot() # 실제값

pred_ci = pd.DataFrame(forecast_values.conf_int())
pred_ci.index = list(test.index)

ax.fill_between(pred_ci.index, pred_ci.iloc[:,0], pred_ci.iloc[:,1], color = 'gray', alpha = 0.5)

predicted = pd.DataFrame(forecast_values.predicted_mean)
predicted.index = list(test.index)
predicted.columns = ['Forecasts']
predicted.plot(ax = ax, label = 'Forecasts')

plt.legend()
plt.show()

from sklearn.metrics import r2_score
r2_score(predicted, test)

# 시계열 분해
# 시계열 분해(time series decomposition)는 시계열 자료를 추세(trend), 계절성(seasonality), 잔차(residual)로 분해하는 기법
# 추세변동 : x 값인 시간에 따라, y인 종속변수 값이 달라진다는 것
# 계절변동 : 특정 주기별
# 순환변동 : 추세변동 + 계절변동
# 불규칙변동 : 잔차

# 시계열 분해 방법
# 데이터를 보고, 시계열의 주기적 반복/계절성이 있는지 확인
# 가법모형과 승법모형 중 무엇이 더 적합할 지 판단

# 시계열에서 추세를 뽑아내기 위해, 중심이동평균(centered moving average)을 이용
# 원자료에서 추세 분해값을 빼줍니다(detrend)
# 그러면 계절요인과 불규칙 요인만 남게 됨

# 계절주기로 detrend 이후 남은 값의 합을 나누어 계절평균(average seasonality)을 구하기

# 원래의 값에서 추세와 계절성 분해 값을 빼주면 불규칙요인(random irregular factor)이 남게됨
# 시계열 분해 후에 추세와 계절성을 제외한 잔차는 특정한 패턴없이 무작위 분포를 띠고 작은 값이면
# 추세와 계절성으로 모형화가 잘 이루어진 데이터임
# 이는 시계열 자료의 특성을 이해하고 예측하는데 활용 가능

# 만약 시계열 분해 후의 잔차에 특정 패턴이 존재하면 잔차에 대해서만 다른 모형을 추가로 적합

import pandas as pd
data = pd.read_csv('../data/arima_data.csv', names = ['day', 'price'])
data.info()
# 이때 날짜 데이터의 형식이 object형으로 확인됨

data['day'] = pd.to_datetime(data['day'], format = '%Y-%m-%d')
# 날짜 데이터를 index로 지정해야함
data.set_index('day', inplace = True)

from statsmodels.tsa.seasonal import seasonal_decompose
import matplotlib.pyplot as plt

ts = data
result = seasonal_decompose(ts, model = 'additive')

plt.rcParams['figure.figsize'] = [12,8]
result.plot()
plt.show()

# Arima 분석
# Autoregressive integrated MovingAverage
# 과거의 데이터를 사용하는 것 넘어 과거의 데이터가 지니고 있었던 추세까지 반영함

# AR(자기상관) : 이전의 값이 이후의 값에 영향을 미치고 있는 상황 -> p
# MA(이동평균) : 랜덤 변수의 평균값이 지속적으로 증가하거나 감소하는 추세 -> q
# 차분 : 비정상성을 정상성으로 만들기 위해, 관측값들의 차이를 계산 -> d

import pandas as pd
import matplotlib.pyplot as plt

data = pd.read_csv('../data/arima_data.csv'), names = ['day', 'price'])
data['day'] = pd.to_datetime(data['day'], format = '%Y-%m-%d')
data.set_index('day', inplace = True)

# train, test 데이터 구분
train_len = int(len(data) * 0.8)
training = data[:train_len]
test = data.drop(training.index)

# 시계열 데이터 확인하기
training.plot()
plt.show()
# 추세도 있고, 계절성도 있는 것으로 보임

from statsmodels.tsa.stattools import adfuller
adf = adfuller(data, regression = 'ct')

# adf statistic
print(adf[0])

# p-value
print(adf[1])

# 이때 정상성이 아님을 확인

from statsmodels.graphics.tsaplots import plot_acf, plot_pacf

diff_data = training.diff(1) # 차분, d = 1
diff_data = diff_data.dropna()

diff_data.plot()

from statsmodels.tsa.stattools import adfuller
adf = adfuller(diff_data, regression = 'ct')

# adf statistic
print(adf[0])

# p-value
print(adf[1])

# 차분하고 정상성을 갖춤

# ARIMA(p, d, q)의 파라미터 정하기
# ACF plot과 PACF plot을 통해 AR 및 MA의 모수를 추정함

# ACF : Lag에 따른 관측치들 사이의 관련성을 측정하는 함수
# PACF : k 이외의 모든 다른 시점 관측치의 영향력을 배제한 후, 두 관측치의 관련성을 측정하는 함수

from statsmodels.graphics.tsaplots import plot_acf, plot_pacf

plot_pacf(diff_data) # AR(p) 값 확인 가능

plot_acf(diff_data) # MA(q) 값 확인 가능

plt.show()

# 모형 만들기 ARIMA
trainig.price.values # 배열 형태로

from statsmodels.tsa.arima.model import ARIMA
import statsmodels.api as sm

model = ARIMA(training.price.values, order = (2,1,2), trend = 'ct')
res = model.fit()
res.summary()
# summary()를 통해 평가하기 어려움

plt.plot(res.predict())
plt.plot(training.price.values)

forecast_data = res.forecast(steps = len(test), alpha = 0.1)
# test 데이터 길이만큼 예측

pred_y = forecast_data
test_y = test.values

plt.plot(pred_y, color = 'gold')
plt.plot(test_y, color = 'green')
plt.show()

from sklearn.metrics import r2_score
r2_score(pred_y, test_y)

regid = pred_y - test_y

import numpy as np
np.sqrt(np.sum(regid**2)/len(test_y))

# 연관분석 - Run-test
# 연속적인 관측값들이 임의적으로 나타난 것인지 검정

# 귀무가설 : 연속적인 관측값이 임의적이다
# 대립가설 : 연속적인 관측값이 임의적이 아니다(즉, 연관이 있다)

# 22회 기출
import pandas as pd
data = # 배열 형태로 주어짐

test_df = pd.DataFrame(data, columns = ['product'])

# 이산형변수로 변환
test_df.loc[test_df['product'] == 'a', 'product'] = 1
test_df.loc[test_df['product'] == 'b', 'product'] = 0

from statsmodels.sandbox.stats.runs import runstest_1samp
runstest_1samp(test_df['product']) # 시리즈 형태로 들어감

# 유의 수준 0.05 보다 p-value 값이 크므로, 귀무가설 기각하지 못함
# 상품 a와 b의 구매에 연관선이 없다고 결론

# 연관분석(Association analysis)
# If-then인 조건과 반응 형태로 이루어져 있음

# 연관규칙 분석에 사용되는 척도
# 지지도 : 전체 거래 중 항목 A와 항목 B를 동시에 포함하는 거래의 비율
# 신뢰도 : 항목 A를 포함한 거래 중에서 항목 A와 항목 B가 같이 포함될 확률로 연관성의 정도 파악
# 향상도 : A가 구매되지 않았을 때 품목 B의 구매확률에 비해 A가 구매되었을 때 품목 B의 구매확률 증가비
# 서로 관련 없는 경우에는 향상도 값이 1임

# Apriori 알고리즘
# 최소지지도보다 큰 지지도 값을 갖는 품목의 집합을 빈발항목집단이라고 함
# 모든 품목 집합에 대한 지지도를 전부 계산하는 것이 아니라, 최소 지지도 이상의 빈발항목집단을 찾은 후
# 그것들에 대해서만 계산

# apriori 함수에 틀어갈 트랜잭션 데이터를 만드는 함수
# from mlxtend.preprocessing import TransactionEncoder
te = TransactionEncoder()
te_result = te.fit(dataset).transform(dataset)

# 연관규칙분석
df = pd.read_csv('../data/groceries.csv')

# 컬럼이 없어서, 마지막 행에 값 추가
df.loc[9834, 'citrus fuit, semi-finished bread, margarine, ready soups'] = df.columns.values[0]

df_split = df.iloc[:, 0].str.split(',', expand = True)
df_split.values
df_split_ary = df_split.values
list(filter(None, df_split_ary[0]))

groceries = []
for i in range(len(df_split_ary)):
	temp = list(filter(None, df_split_ary[i]))
    groceries.append(temp)

from mlxtend.preprocessing import TransactionEncoder
import pandas as pd

te = TransactionEncoder()
groceries_tr = te.fit(groceries).transform(groceries)
groceries_tr = pd.DataFrame(groceries_tr, columns = te.columns_)

from mlxtend.frequent_patterns import apriori

# 지지도가 5% 이상인 빈번 항목 집합 탐색
groceries_ap = apriori(groceries_tr, min_support = 0.05, use_colnames = True)

from mlxtend.frequent_patterns import association_rules

# 신뢰도가 0.3% 이상인 빈번 항목 집합 탐색
association_rules(groceries_ap, metric = 'confidence', min_threshold = 0.3)

# 여러 기준 충족하는 빈번 항목 집합 탐색
rules = association_rules(groceries_ap, metric = 'lift', min_threshold = 3)
rules['antecedent_len'] = rules['antecedents'].apply(lambda x : len(x))

rules[(rules['antecednet_len'] >= 1) & (rules['confidence'] > 0.4) & (rules['lift'] > 1)]

# 자기조직화지도
# 대뇌피질과 시각피질의 학습 과정을 모델화하여 자율학습에 의한 클러스터링을 수행하는 알고리즘
# Map size를 설정(군집의 수를 차원의 수로 맞추어야 함)
# default map을 조금씩 수정해서 데이터 분포 형태에 map을 근사

import pandas as pd
import numpy as np
iris = pd.read_csv('../data/iris.csv')

y = iris['target']
X = iris.drop('target', axis = 1)

# feature scaling
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxSclaer(feature_range = (0,1))
X = scaler.fit_transform(X)

# 설치필요함
# ! pip install sklearn-som
from sklearn_som.som import SOM

iris_som = SOM(m = 3, n = 1, dim = 4)
# 여기서 dim은 변수의 개수
iris_som.fit(X, epochs = 100)

predictions = iris_som.predict(X)
iris['cluster'] = predictions

# 군집결과 시각화
import seaborn as sns
import matplotlib.pyplot as plt

sns.pairplot(iris, diag_kind = 'kde', hue = 'cluster', palette = 'bright')
plt.show()

# 17회 기출
# 데이터를 7:3으로 나누고, train 데이터셋을 som 알고리즘으로 군집화
# test 데이터셋에 대한 오분류표 구하기

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, test_size = 0.3,
	random_state = 2021)
    
som = SOM(m=3, n=1, dim = 4)
som.fit(X_train)

y_pred = som.predict(X_test)

result = pd.DataFrame()
result['y_test'] = y_test
result['y_pred'] = y_pred

result.loc[result['y_test'] == 'Iris-setosa', 'target_num'] = 0
result.loc[result['y_test'] == 'Iris-virginica', 'target_num'] = 2
result.loc[result['y_test'] == 'Iris-versicolor', 'target_num'] = 1

from sklearn.metrics import accuracy_score, confusion_matrix, roc_auc_score, classification_report
accuracy_score(result['target_num'], result['y_pred'])
confusion_matrix(result['target_num'], result['y_pred'])
print(classification_report(result['target_num'], result['y_pred']))

# 혼합 분포 군집
# 모형기반(model-based) 군집방법
# 데이터가 k개의 모수적 모형의 가중합으로 표현되는 모집단 모형으로부터 나왔다는 가정
# k개의 각 모형은 군집이며, 각 데이터는 추정된 k개의 모형 중 어느 모형으로부터 나옸을 확률이 높은지에 따라
# 군집의 분류가 만들어짐 -> 최대우도 추정법

# 혼합분포모형으로 설명할 수 있는 데이터의 형태 : 다봉형

# 사용 알고리즘 : EM(Expectation - Maximization)
# 각 자료에 대해 Z의 조건부분포로부터 조건부 기대값을 구할 수 있음

# 장점 : kmeans보다 더 통계적으로 엄밀한 결과를 얻을 수 있음
# 단점 : 데이터가 커지면, 알고리즘 적용시 시간/계산 비용 증가, 이상치 자료에 민감

import pandas as pd
import numpy as np
import sklearn
from sklearn.preprocessing import StandardScaler # 이상치에 민감하니 정규화 필요
from sklearn.mixture import GaussianMixture

iris = pd.read_csv('../data/iris.csv')
df = iris.drop('target', axis = 1)
df.head()

scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

# 가우시안 혼합모델 구축
gmm = GaussianMixture(n_componenets = 3)
gmm.fit(df_scaled) # array형태
gmm_labels = gmm.predict(df_scaled)

df['gmm_cluster'] = gmm_labels
df['gmm_cluster'].value_counts()

# 군집별 통계량 확인
clusters = [0,1,2]
df.groupby('gmm_clutser').mean()
df.groupby('gmm_clutser').var()

# K-means
# 주어진 데이터를 k개의 클러스터로 묶는 알고리즘
# iris data로 kmeans 군집분석

import pandas as pd
from sklearn.cluster import KMeans

iris = pd.read_csv('../data/iris.csv')
X = iris.drop('target', axis = 1)

import seaborn as sns
import matplotlib.pyplot as plt
sns.pairplot(iris, diag_kind = 'kde', hue = 'target', palette = 'bright')
plt.show()

km = KMeans(n_clusters = 2, random_state = 1)
km.fit(X)

km.labels

# 최적의 클러스터 개수를 결정하는 방법
# 1. Calinski-Harabasz(콜린스키 하라바츠 지수)
from skleanr.metrics import calinski_harabasz_score
calinski_harabasz_score(X, km.labels_)

# 클러스터별 콜린스키 하라바츠 결과 비교
for k in range(2, 10):
	kmeans_model = KMeans(n_clusters = k, random_state = 1).fit(X)
    labels = kmeans_model.labels_
    print(calinski_harabasz_score(X, labels))

# 2. 엘보우 기법
import matplotlib.pyplot as plt
def elbow(X):
	sse = []
    for i in range(1, 11):
    	km = KMeans(n_clusters = i, random_state = 1)
        km.fit(X)
        sse.append(km.inertia_)
        
    plt.plot(range(1, 11), sse, marker = 'o')
    plt.xlabel('The Number of Clusters')
    plt.ylabel('SSE')
    plt.show()
    print(sse)
    
    
elbow(X)

# 최적의 k로 K-means 군집화 실행
km = KMeans(n_clusters = 3, random_state = 1)
km.fit(X)

new_labels = km.labels_
iris['cluster'] = new_labels

import seaborn as sns
import matplotlib.pyplot as plt

sns.pairplot(iris, diag_kind = 'kde', hue = 'cluster', palette = 'bright')
plt.show()

# 밀도기반 클러스터 DBSCAN
dbscan = DBSCAN(eps = 0.5, min_samples = 5).fit(X)
# 여기서 eps는 얼마나 가까운지 거리 조정을 의미하고, min_samples는 샘플수
# 생각보다 조정이 까다로움

dbscan.labels_

dbscan_df = X.copy()
dbscan_df['cluster'] = dbscan.labels_

# dbscan_df 시각화
# 군집결과 시각화
import seaborn as sns
import matplotlib.pyplot as plt
sns.pairplot(dbscan_df, diag_kind = 'kde', hue = 'cluster', palette = 'bright')
plt.show()

# n개의 군집으로 시작해 점차 군집의 개수를 줄여나가는 방법
# 종류 : 최단연결법, 최장연결법, 평균연결법, 와드연결법
# 군집분석시, 데이터의 모든 요소가 유한해야함(NaNs, infs가 없어야 함)

import pandas as pd
import numpy as np
from scipy.cluser.hierarchy import dendrogram, linkage, fcluster
from matplotlib import pyplot as plt

US = pd.read_csv('USArrest.csv')
US.hea()

US.columns = ['State', 'Murder', 'Assault', 'UrbanPop', 'Rape']
labelList = US.State.tolist()
US.head()

# 최단연결법
single = linkage(US.iloc[:, 1::], metric = 'euclidean', method = 'single')

# 덴드로그램 그리기
plt.figure(figsize = (10, 7))
dendrogram(single, orientation = 'top', labels = labelList, distnace_sort = 'descending',
	color_threshold = 25, show_leaf_counts = True)
plt.axhline(y=24, color = 'r', linewidth=1)
plt.show

# state마다 어떤 군집에 설정되었는지 확인
assignments = fcluster(single, 25, 'distance')
assignments

US['cluster'] = assignments

US.groupby('cluster').mean()

# 종속변수가 범주형 데이터인 것을 대상, 분류기법
# 일반적으로 종속변수가 이산형변수일 때, 종속변수의 level이 2개 이상일 때는 다항 로지스틱 회귀

import pandas as pd
import numpy as np

df_t = pd.read_csv('../data/titanic.csv')
df_t.head()

# 로지스틱 회귀분석 진행할 때, 결측치 있으면 안됨
# 전처리
df_t['age'] = df_t['age'].fillna(df_t['age'].median())

df_t['embark_town'].value_counts().index[0]
df_t['embark_town'] = df_t['embark_town'].fillna(df_t['embark_town'].value_counts().index[0])

# 더미변수화
df_t = pd.get_dummies(df_t, columns = ['sex', 'class', 'embark_town'])

# 전체 데이터 형식 float으로 변환
df_t = df_t.astype(float)

X = df_t.drop(['survived'], axis = 1)
y = df_t['survived']

y.value_counts()

# 홀드아웃 기법
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, test_size = 0.2, random_state = 42)

# 로지스틱 회귀 모델링
import statsmodels.api as sm
model = sm.Logit(y_train, X_train)
result = model.fit()

print(result.summary())

# 성능척도
print(result.aic)

# 적합한 회귀계수 해석할 때, 오즈비로 확인
np.exp(result.params)

# 다항 로지스틱 회귀모형
import pandas as pd
iris = pd.read_csv('../data/iris.csv')

X = iris.drop(['target'], axis = 1) # 데이터프레임 형태
y = iris.target # 시리즈 형태

y.value_counts()

from sklearn.model_selction import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, test_size = 0.3, random_state = 48)
y_test.value_counts()

# sklearn 모델은 l2 패널티를 이용하여 전통적 통계모델에서 다중공선성의 문제를 내부적으로 해결해줌
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(X_train, y_train)
print(model)

# 모델 평가
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, roc_auc_score
# sklearn에서는 확률값이 아니라 바로 범주형 형태로 결과값이 나옴
predicted = model.predict(X_test)

cm = confusion_matrix(y_test, predicted)
cmtb = pd.DataFrame(cm, columns = ['predicted_setosa', 'predicted_versicolor', 'predicted_virginica'],
	index = ['setosa', 'versicolor', 'virginica'])

# 정확도
accuracy_score(y_test, predicted)

# 분류 리포트 생성
class_report = classification_report(y_test, predicted)

# roc_auc_score
# 여기서는 예측값이 확률값 형태로 들어감
roc_auc_score(y_test, model.predict_proba(X_test), multi_class = 'ovr')

# 로지스틱 회귀계수 해석
model.intercept_
model.coef_

# 오즈비 계산하기
import numpy as np
np.exp(model.coef_)
# 다른 변수가 일정할 때, sepal width가 1단위 증가하면, iris-setosa로 분류될 확률이 2.393189배 증가한다