๋ฐ์ํ
์๊ณ์ด ๋ฐ์ดํฐ
์๊ณ์ด ๋ฐ์ดํฐ๋ ์๊ฐ ์์๋๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ ํฌ์ธํธ์ ์ฐ์์ ๋๋ค.
์๊ณ์ด ๋ฐ์ดํฐ์ ํน์ฑ
- ์ถ์ธ (Trend): ์ฅ๊ธฐ์ ์ธ ๋ฐ์ดํฐ ์ฆ๊ฐ ๋๋ ๊ฐ์ ๊ฒฝํฅ์ ๋ํ๋
๋๋ค.
- ์: ํ์ฌ ๋งค์ถ์ด ํด๋ง๋ค ์ฆ๊ฐํ๋ ๊ฒฝ์ฐ.
- ๊ณ์ ์ฑ (Seasonality): ํน์ ์๊ฐ ํจํด์ด ๋ฐ๋ณต๋๋ ํ์์ผ๋ก, ์ฃผ๊ธฐ์ ์ธ ๋ณ๋์ ํฌํจํฉ๋๋ค.
- ์: ์ฌ๋ฆ์ฒ ์์ด์คํฌ๋ฆผ ํ๋งค๋ ์ฆ๊ฐ.
- ์ฃผ๊ธฐ์ฑ (Cyclicality): ๋ถ๊ท์น์ ์ธ ๊ฐ๊ฒฉ์ผ๋ก ๋ฐ๋ณต๋๋ ๋ณ๋์ ๋ํ๋
๋๋ค.
- ์: ๊ฒฝ์ ํธํฉ๊ณผ ๋ถํฉ ์ฃผ๊ธฐ.
- ์ก์ (Noise): ๋ฐ์ดํฐ์ ํฌํจ๋ ๋ถ๊ท์นํ ๋ณ๋์ผ๋ก, ์์ธก์ ๋ฐฉํด๊ฐ ๋๋ ์์์ ๋๋ค.
์๊ณ์ด ๋ถ์ ๋ฐฉ๋ฒ
์๊ณ์ด ๋ถํด๋ ์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ๊ตฌ์ฑํ๋ ์ฌ๋ฌ ์์(์ถ์ธ, ๊ณ์ ์ฑ, ์ฃผ๊ธฐ์ฑ, ์ก์)๋ฅผ ๋ถ๋ฆฌํ์ฌ ๋ถ์ํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
- ๊ฐ๋ฒ ๋ชจํ (Additive Model): ์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ณ ์์ธ์ ํจ๊ณผ๋ฅผ ๊ตฌ๋ถํ๊ณ ํจ๊ป ๋ํ์ฌ ๋ชจํํํฉ๋๋ค.
- ์: ์๊ณ์ด = ์ถ์ธ + ๊ณ์ ์ฑ + ์ํ์ฑ + ์ก์
- ์น๋ฒ ๋ชจํ (Multiplicative Model): ๋ฐ์ดํฐ๊ฐ ์ฆ๊ฐํ๋ฉด ๊ณ์ ํจํด๋ ์ฆ๊ฐํ๋ค๊ณ ๊ฐ์ ํ๋ ๋ชจํ์
๋๋ค.
- ์: ์๊ณ์ด = ์ถ์ธ * ๊ณ์ ์ฑ * ์ํ์ฑ * ์ก์
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.tsa.seasonal import seasonal_decompose
# ๊ฐ์์ ์๊ณ์ด ๋ฐ์ดํฐ ์์ฑ
date_rng = pd.date_range(start='1/1/2020', end='1/1/2022', freq='M')
data = pd.Series(np.random.randn(len(date_rng)), index=date_rng)
# ์๊ณ์ด ๋ถํด
result = seasonal_decompose(data, model='additive')
result.plot()
plt.show()
ํต๊ณ์ ๋ฐฉ๋ฒ
1. ์ด๋ ํ๊ท (Moving Average): ๋ฐ์ดํฐ์ ๋จ๊ธฐ ๋ณ๋์ ํํํํ์ฌ ์ถ์ธ๋ฅผ ํ์ ํฉ๋๋ค.
data['moving_avg'] = data.rolling(window=3).mean()
data.plot()
plt.show()
2.์ง์ ํํ (Exponential Smoothing): ์ต๊ทผ ๊ด์ธก๊ฐ์ ๋ ํฐ ๊ฐ์ค์น๋ฅผ ๋๋ ๋ฐฉ๋ฒ์ ๋๋ค.
from statsmodels.tsa.holtwinters import SimpleExpSmoothing
model = SimpleExpSmoothing(data).fit()
data['exp_smoothing'] = model.fittedvalues
data.plot()
plt.show()
์๊ณ์ด ์์ธก
- ARIMA ๋ชจ๋ธ (Autoregressive Integrated Moving Average): ์๊ณ์ด ๋ฐ์ดํฐ์ ์์ธก์ ์์ฃผ ์ฌ์ฉ๋๋ ๋ชจ๋ธ์ ๋๋ค.
from statsmodels.tsa.arima.model import ARIMA
model = ARIMA(data, order=(5,1,0))
model_fit = model.fit()
data['forecast'] = model_fit.predict(start=len(data), end=len(data)+12, dynamic=True)
data[['value', 'forecast']].plot()
plt.show()
์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ๋ฐ์ํ๋ ์ฃผ์ ๋ฌธ์ ์ ํด๊ฒฐ์ฑ
๋ฌธ์
- ์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ๋๋ ๋ณดํต 2๊ฐ์ง์ ๋ฌธ์ ๊ฐ ๋ฐ์ํฉ๋๋ค. ๊ฒฐ์ธก์น(Missing Values), ์ด์์น(Outliers). 2๊ฐ์ง์ ๋ฌธ์ ๊ฐ ๋ฐ์ํฉ๋๋ค. ํ๋ฒ ์ค๋ช ํด ๋ณด๊ฒ ์ต๋๋ค.
- ๊ฒฐ์ธก์น (Missing Values): ํน์ ์์ ์ ๋ฐ์ดํฐ๊ฐ ๋๋ฝ๋๋ ๋ฌธ์ ์ ๋๋ค.
- ์ด์์น (Outliers): ์์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ ๋ฐ์ดํฐ ํฌ์ธํธ๋ก, ์ผ๊ด์ฑ ์๋ ๋ฐ์ดํฐ ํฌ์ธํธ๋ฅผ ์๋ฏธํฉ๋๋ค.
- ๊ทธ๋ฌ๋ฉด ์ด ๋ฌธ์ ๋ค์ ์ด๋ป๊ฒ ํด๊ฒฐ ํด์ผ ํ ๊น์? ํด๊ฒฐ์ฑ ์ ํ๋ฒ ์ ์ํด ๋ณด๊ฒ ์ต๋๋ค.
ํด๊ฒฐ์ฑ
1. ๊ฒฐ์ธก์น ์ฒ๋ฆฌ
- ๋ณด๊ฐ๋ฒ (Interpolation): ๊ฒฐ์ธก์น๋ฅผ ์ฃผ๋ณ ๋ฐ์ดํฐ๋ก ๋ณด๊ฐํ์ฌ ์ฑ์๋๋ค.
data.interpolate(method='linear', inplace=True)
- ํ๊ท ๋์ฒด: ๊ฒฐ์ธก์น๋ฅผ ํด๋น ์ด์ ํ๊ท ๊ฐ์ผ๋ก ๋์ฒดํฉ๋๋ค.
data.fillna(data.mean(), inplace=True)
2. ์ด์์น ํ์ง ๋ฐ ์ฒ๋ฆฌ
Z-์ ์์ IQR ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ ์ด์์น๋ฅผ ํ์งํ๊ณ ์ฒ๋ฆฌํฉ๋๋ค.
- Z-์ ์ (Z-score)
from scipy import stats
data['z_score'] = np.abs(stats.zscore(data['value']))
outliers = data[data['z_score'] > 3]
- IQR (Interquartile Range) ๋ฐฉ๋ฒ
Q1 = data['value'].quantile(0.25)
Q3 = data['value'].quantile(0.75)
IQR = Q3 - Q1
outliers = data[(data['value'] < (Q1 - 1.5 * IQR)) | (data['value'] > (Q3 + 1.5 * IQR))]
3. ์ฐจ๋ถ (Differencing)
- ์ถ์ธ ๋ฐ ๊ณ์ ์ฑ์ ์ ๊ฑฐํ์ฌ ์๊ณ์ด์ ์์ ํํฉ๋๋ค.
data['differenced'] = data['value'].diff()
data['differenced'].dropna().plot()
plt.show()
๋ค๋ณ๋ ๋ถ์
๋ค๋ณ๋ ๋ถ์์ ์ฌ๋ฌ ๋ณ์ ๊ฐ์ ๊ด๊ณ๋ฅผ ๋์์ ๋ถ์ํ๋ ํต๊ณ ๊ธฐ๋ฒ์ ๋๋ค.
- ์ฌ๋ฌ ํ์์ด๋ ์ฌ๊ฑด์ ๋ํ ์ธก์ ์น๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ๋ถ์ํ์ง ์๊ณ ๋์์ ํ๋ฒ์ ๋ถ์ํ๋ ํต๊ณ์ ๊ธฐ๋ฒ ์ ๋๋ค.
- ์ด๋ ๋ณต์กํ ๋ฐ์ดํฐ ์งํฉ์์ ๋ณ์๋ค ๊ฐ์ ์ํธ์์ฉ์ ์ดํดํ๊ณ , ์ค์ํ ํจํด๊ณผ ์ธ์ฌ์ดํธ๋ฅผ ๋์ถํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
๋ค๋ณ๋ ๋ฐ์ดํฐ์ ์ดํด
๋ค๋ณ๋ ๋ถ์์ ๋ณ์๋ค ๊ฐ์ ์ํธ์์ฉ๊ณผ ๋ณต์กํ ๊ด๊ณ๋ฅผ ์ดํดํ๊ณ ์์ธกํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ณ์๋ค ๊ฐ์ ์ํธ์์ฉ ํ์
- ๋ค๋ณ๋ ๋ถ์์ ๋จ๋ณ๋ ๋ถ์์์๋ ๊ฐ๊ณผํ ์ ์๋ ๋ณ์๋ค ๊ฐ์ ์ํธ์์ฉ์ ํ์ ํ ์ ์์ต๋๋ค. ์ด๋ ๋ณ์๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก๊ฐ ์๋๋ผ ์ํธ ์์กด์ ์ผ๋ก ์์ฉํ ๋ ํนํ ์ค์ํฉ๋๋ค.
- ์: ์๋น์ ๋ฐ์ดํฐ์์ ์ฐ๋ น๊ณผ ์๋ ์์ค์ด ๋์์ ๊ตฌ๋งค ํจํด์ ์ํฅ์ ๋ฏธ์น ์ ์์ต๋๋ค.
- ๋ณต์กํ ๊ด๊ณ ํฌ์ฐฉ
- ๋ค๋ณ๋ ๋ฐ์ดํฐ๋ ๋ณ์๋ค ๊ฐ์ ๋ณต์กํ ๊ด๊ณ๋ฅผ ํฌ์ฐฉํ ์ ์์ด, ๋จ์ํ ๊ด๊ณ ๋ถ์์ ๋์ด ๋ ๊น์ ์ธ์ฌ์ดํธ๋ฅผ ์ ๊ณตํฉ๋๋ค.
- ์: ๊ณ ๊ฐ ์ธ๋ถํ๋ฅผ ํตํด ๊ณ ๊ฐ๋ค์ ๋ค์ํ ํน์ฑ์ ๊ธฐ๋ฐ์ผ๋ก ๊ทธ๋ฃน์ ๋๋๊ณ , ๊ฐ ๊ทธ๋ฃน์ ํ๋ ํจํด์ ๋ถ์ํ ์ ์์ต๋๋ค.
- ํจํด ์์ธก
- ๋ค๋ณ๋ ๋ถ์ ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ์์ ํจํด์ ์์ธกํ๊ณ , ๋ฏธ๋์ ํ๋์ด๋ ๊ฒฐ๊ณผ๋ฅผ ์์ธกํ ์ ์์ต๋๋ค.
- ์: ์ฌ๋ฌ ๋ณ์๋ฅผ ๊ณ ๋ คํ์ฌ ์๋น์ ๊ตฌ๋งค ํ๋์ ์์ธกํ๊ณ , ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ง์ผํ ์ ๋ต์ ์ธ์ธ ์ ์์ต๋๋ค.
์๊ด ๋ถ์
์๊ด ๋ถ์์์ ๋๊ฐ์ ์๊ด๊ณ์์ธ ํผ์ด์จ, ์คํผ์ด๋ง ์๊ด๊ณ์์ ๋ฐํ์ฌ ์์ ๋ณด๊ฒ ์ต๋๋ค.
ํผ์ด์จ ์๊ด๊ณ์ (Pearson Correlation)
- ์ ์: ๋ ๋ณ์ ๊ฐ์ ์ ํ ๊ด๊ณ์ ๊ฐ๋์ ๋ฐฉํฅ์ ์ธก์ ํ๋ ํต๊ณ์ ๋ฐฉ๋ฒ์ ๋๋ค.
- ํน์ง:
- ์ฐ์์ ์ธ ์์น ๋ฐ์ดํฐ ๊ฐ์ ์ ํ ๊ด๊ณ๋ฅผ ์ธก์ ํฉ๋๋ค.
- ๋ฐ์ดํฐ๊ฐ ์ฐ์์ ์ด๊ณ ์ ๊ท ๋ถํฌ๋ฅผ ๋ฐ๋ฅด๋ ๊ฒฝ์ฐ์ ์ ํฉํฉ๋๋ค.
- ๊ณ์ฐ ๋ฐฉ๋ฒ:
- ํผ์ด์จ ์๊ด๊ณ์๋ -1์์ 1 ์ฌ์ด์ ๊ฐ์ ๊ฐ์ง๋ฉฐ, 1์ ์๋ฒฝํ ์์ ์๊ด๊ด๊ณ, -1์ ์๋ฒฝํ ์์ ์๊ด๊ด๊ณ, 0์ ์๊ด๊ด๊ณ๊ฐ ์์์ ์๋ฏธํฉ๋๋ค.
import numpy as np
from scipy.stats import pearsonr
# ์์ ๋ฐ์ดํฐ
x = np.random.rand(100)
y = np.random.rand(100)
# ํผ์ด์จ ์๊ด๊ณ์ ๊ณ์ฐ
corr, _ = pearsonr(x, y)
print(f'Pearson correlation coefficient: {corr}')
# Pearson correlation coefficient: -0.09606113577342046
์คํผ์ด๋ง ์๊ด๊ณ์ (Spearman Correlation)
- ์ ์: ๋ ๋ณ์์ ์์์ ๊ธฐ๋ฐํ์ฌ ๊ด๊ณ๋ฅผ ์ธก์ ํ๋ ๋น๋ชจ์์ ๋ฐฉ๋ฒ์ ๋๋ค.
- ํน์ง:
- ์์ ๊ธฐ๋ฐ์ ๋น์ ํ ๊ด๊ณ๋ฅผ ์ธก์ ํฉ๋๋ค.
- ๋ฐ์ดํฐ๊ฐ ์ ๊ท ๋ถํฌ๋ฅผ ๋ฐ๋ฅด์ง ์๊ฑฐ๋ ์์ํ ๋ฐ์ดํฐ์ผ ๋ ์ ์ฉํฉ๋๋ค.
- ๊ณ์ฐ ๋ฐฉ๋ฒ:
- ์คํผ์ด๋ง ์๊ด๊ณ์๋ -1์์ 1 ์ฌ์ด์ ๊ฐ์ ๊ฐ์ง๋ฉฐ, 1์ ์๋ฒฝํ ์์ ์์ ์๊ด๊ด๊ณ, -1์ ์๋ฒฝํ ์์ ์์ ์๊ด๊ด๊ณ, 0์ ์์ ์๊ด๊ด๊ณ๊ฐ ์์์ ์๋ฏธํฉ๋๋ค.
from scipy.stats import spearmanr
# ์์ ๋ฐ์ดํฐ
x = np.random.rand(100)
y = np.random.rand(100)
# ์คํผ์ด๋ง ์๊ด๊ณ์ ๊ณ์ฐ
corr, _ = spearmanr(x, y)
print(f'Spearman correlation coefficient: {corr}')
# Spearman correlation coefficient: 0.07144314431443144
์ฃผ์ฑ๋ถ ๋ถ์ (PCA, Principal Component Analysis)
์ฃผ์ฑ๋ถ ๋ถ์(PCA)์ ๊ณ ์ฐจ์ ๋ฐ์ดํฐ์ ์ฐจ์์ ์ถ์ํ์ฌ ๊ฐ์ฅ ์ค์ํ ํน์ฑ์ ์ถ์ถํ๋ ํต๊ณ ๊ธฐ๋ฒ์ ๋๋ค.
- PCA๋ ๋ฐ์ดํฐ์ ๋ถ์ฐ์ด ์ต๋๊ฐ ๋๋ ๋ฐฉํฅ์ ์ฐพ์, ์ค์ํ ์ ๋ณด๋ฅผ ์ ์งํ๋ฉด์ ์ฐจ์์ ์ถ์ํฉ๋๋ค.
- ํ๋ฒ ์ฃผ์ฑ๋ถ ๋ถ์์ ๋จ๊ณ๋ฅผ ํ๋ฒ ์ค๋ช ํด ๋ณด๊ฒ ์ต๋๋ค.
1. ๋ฐ์ดํฐ ํ์คํ
- ๊ฐ ๋ณ์์ ํ๊ท ์ 0, ํ์คํธ์ฐจ๋ฅผ 1๋ก ๋ง์ถ์ด ๋ชจ๋ ๋ณ์์ ๋น์ค์ ๋ง์ถฅ๋๋ค.
- ์ด๋ ๋ณ์๊ฐ ์๋ก ๋ค๋ฅธ ๋จ์๋ฅผ ๊ฐ์ง ๋, ๋ถ์ ๊ฒฐ๊ณผ์ ๋ฏธ์น๋ ์ํฅ์ ์ค์ด๊ธฐ ์ํด ํ์ํฉ๋๋ค.
from sklearn.preprocessing import StandardScaler
# ์์ ๋ฐ์ดํฐ ์์ฑ
import numpy as np
import pandas as pd
data = np.random.rand(100, 5)
df = pd.DataFrame(data, columns=['A', 'B', 'C', 'D', 'E'])
# ๋ฐ์ดํฐ ํ์คํ
scaler = StandardScaler()
data_std = scaler.fit_transform(df)
2. ๊ณต๋ถ์ฐ ํ๋ ฌ ๊ณ์ฐ
- ํ์คํ๋ ๋ฐ์ดํฐ์ ๋ณ์๋ค ๊ฐ์ ์ ํ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ ๊ณต๋ถ์ฐ ํ๋ ฌ์ ๊ณ์ฐํฉ๋๋ค.
# ๊ณต๋ถ์ฐ ํ๋ ฌ ๊ณ์ฐ
cov_matrix = np.cov(data_std.T)
print("Covariance Matrix:\n", cov_matrix)
3. ๊ณ ์ ๊ฐ ๋ถํด
- ๊ณต๋ถ์ฐ ํ๋ ฌ์ ๊ณ ์ ๊ฐ๊ณผ ๊ณ ์ ๋ฒกํฐ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
- ๊ณ ์ ๋ฒกํฐ๋ ๋ฐ์ดํฐ์ ๋ถ์ฐ์ด ์ต๋์ธ ๋ฐฉํฅ์ ๋ํ๋ด๋ฉฐ, ๊ณ ์ ๊ฐ์ ๊ทธ ๋ถ์ฐ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ ๋๋ค.
# ๊ณ ์ ๊ฐ๊ณผ ๊ณ ์ ๋ฒกํฐ ๊ณ์ฐ
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
print("Eigenvalues:\n", eigenvalues)
print("Eigenvectors:\n", eigenvectors)
4. ์ฃผ์ฑ๋ถ ์ ํ
- ๊ฐ์ฅ ํฐ ๊ณ ์ ๊ฐ์ ํด๋นํ๋ ๊ณ ์ ๋ฒกํฐ๋ถํฐ ์์๋๋ก ์ฃผ์ฑ๋ถ์ผ๋ก ์ ํํฉ๋๋ค.
- ์ผ๋ฐ์ ์ผ๋ก, ์ ์ฒด ๋ถ์ฐ์ ๋๋ถ๋ถ์ ์ค๋ช ํ๋ ๋ช ๊ฐ์ ์ฃผ์ฑ๋ถ๋ง ์ ํํฉ๋๋ค.
# ๊ณ ์ ๊ฐ ์ ๋ ฌ
idx = np.argsort(eigenvalues)[::-1]
eigenvalues = eigenvalues[idx]
eigenvectors = eigenvectors[:, idx]
# ์ฃผ์ฑ๋ถ ์ ํ (์: 2๊ฐ)
n_components = 2
selected_eigenvectors = eigenvectors[:, :n_components]
print("Selected Eigenvectors:\n", selected_eigenvectors)
5. ์๋ก์ด ํน์ฑ ๊ณต๊ฐ์ผ๋ก ๋ฐ์ดํฐ ํฌ์
- ์ ํ๋ ์ฃผ์ฑ๋ถ์ ์๋ ๋ฐ์ดํฐ๋ฅผ ํฌ์ํ์ฌ ์ฐจ์์ ์ถ์ํฉ๋๋ค.
- ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ์ ์ฃผ์ ์ ๋ณด๋ฅผ ์ ์งํ๋ฉด์ ์ฐจ์์ ์ค์ผ ์ ์์ต๋๋ค.
# ๋ฐ์ดํฐ ํฌ์
principal_components = data_std.dot(selected_eigenvectors)
print("Principal Components:\n", principal_components)
์์ธ ๋ถ์ (Factor Analysis)
์์ธ ๋ถ์์ ๋ณ์๋ค ์ฌ์ด์ ๊ด๊ณ๋ฅผ ๋ถ์ํ์ฌ ๋ช ๊ฐ์ง ์ ์ฌ์ ์ธ ์์ธ์ผ๋ก ์์ฝํ๋ ํต๊ณ์ ๋ฐฉ๋ฒ์ ๋๋ค.
- ์ด ๋ฐฉ๋ฒ์ ๊ด์ธก๋ ๋ณ์๋ค ๋ค์ ์จ์ด ์๋ ์ ์ฌ์ ์์ธ์ ๋ฐ๊ฒฌํ๋ ๋ฐ ์ค์ ์ ๋ก๋๋ค.
- ์์ธ ๋ถ์์ ๋ฐ์ดํฐ์ ์ ์ฌ์ ๊ตฌ์กฐ๋ฅผ ๋ชจ๋ธ๋งํ๊ณ , ๊ด์ธก๋ ๋ณ์๋ค์ ๋ณ๋์ฑ์ ์ค๋ช ํ ์ ์๋ ๊ณตํต ์์ธ์ ์ฐพ์๋ด์ด ๋ณ์์ ์๋ฅผ ์ค์ด๊ณ ๋ฐ์ดํฐ์ ๊ตฌ์กฐ๋ฅผ ์ดํดํ๋ ๋ฐ ๋์์ ์ค๋๋ค.
์์ธ ๋ถ์์ ํน์ง
์์ธ ๋ถ์์ ์ฃผ๋ก 3๊ฐ์ง์ ํน์ง์ด ์์ต๋๋ค.
- ์ ์ฌ์ ์์ธ ๋ฐ๊ฒฌ: ๋ณ์๋ค์ด ํ๋ ์ด์์ ๋น๊ด์ธก๋ ์ ์ฌ ๋ณ์(์์ธ)์ ์ํด ์ํฅ์ ๋ฐ๋๋ค๋ ๊ฐ์ ํ์ ๋ถ์์ด ์ด๋ฃจ์ด์ง๋๋ค.
- PCA์์ ์ฐจ์ด์ : PCA๋ ์ฃผ๋ก ๋ฐ์ดํฐ์ ๋ถ์ฐ์ ์ต๋ํํ๋ ๋ฐฉํฅ์ ์ฐพ๋ ๋ฐ ์ค์ ์ ๋๋ ๋ฐ๋ฉด, ์์ธ ๋ถ์์ ๋ฐ์ดํฐ ๋ด ์ ์ฌ์ ๊ตฌ์กฐ๋ฅผ ๋ชจ๋ธ๋งํ๋ ๋ฐ ์ด์ ์ ๋ง์ถฅ๋๋ค.
- ์์ฉ ๋ถ์ผ: ์ฌ๋ฆฌํ, ์ฌํ๊ณผํ, ๋ง์ผํ ๋ฑ์์ ์ค๋ฌธ์ง ๋ฐ์ดํฐ์ ๊ตฌ์กฐ๋ฅผ ๋ถ์ํ๋ ๋ฐ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
from sklearn.decomposition import FactorAnalysis
# ์์ธ ๋ถ์ ์ ์ฉ
fa = FactorAnalysis(n_components=2)
factors = fa.fit_transform(data_std)
# ๊ฒฐ๊ณผ ์๊ฐํ
import matplotlib.pyplot as plt
plt.scatter(factors[:, 0], factors[:, 1])
plt.xlabel('Factor 1')
plt.ylabel('Factor 2')
plt.title('Factor Analysis Result')
plt.show()
์์ธ ๋ถ์์ ๋ชฉ์
์์ธ ๋ถ์์ ๋ชฉ์ ์ ๋ฐํ์ฌ ์ค๋ช ์ ํด๋ณด๊ฒ ์ต๋๋ค.
- ๋ณ์ ์ถ์: ์ฌ๋ฌ ๊ฐ์ ๋ณ์๋ค์ ํ๋์ ์์ธ์ผ๋ก ๋ฌถ์ด ๋ฐ์ดํฐ์ ์ฐจ์์ ์ค์ ๋๋ค.
- ๋ถํ์ํ ๋ณ์ ์ ๊ฑฐ: ์์ธ์ ํฌํจ๋์ง ์๊ฑฐ๋ ์ค์๋๊ฐ ๋ฎ์ ๋ณ์๋ฅผ ํ์ํ์ฌ ์ ๊ฑฐํ ์ ์์ต๋๋ค.
- ๋ณ์ ํน์ฑ ํ์ : ๊ด๋ จ๋ ๋ณ์๋ค์ด ๋ฌถ์ฌ ์์ธ๋ค์ ์ํธ ๋ ๋ฆฝ์ ์ธ ํน์ฑ์ ํ์ ํ ์ ์์ต๋๋ค.
๋ฐ์ํ
'๐ Data Analysis' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Data Analysis] ๊ธฐ๋ณธ ์ฐจํธ ์ ํ ๋ฐ ์ฌ์ฉ๋ฒ (0) | 2024.07.25 |
---|---|
[Data Analysis] Data Visualization (๋ฐ์ดํฐ ์๊ฐํ) & ์๊ฐ์ ์ธ์ง (0) | 2024.07.25 |
[Data Analysis] ๊ฐ์ค ๊ฒ์ ๊ณผ A/B Test, ์๋๋ฆฌ์ค (0) | 2024.07.20 |
[Data Analysis] ๊ธฐ์ด ํต๊ณ, ์๊ด & ์ธ๊ณผ๊ด๊ณ (0) | 2024.07.18 |
[Data Analysis] ๋ฐ์ดํฐ์ ์ข ๋ฅ์ ์์ฑ & ๋ฐ์ดํฐ ํ์ (EDA) (0) | 2024.07.18 |