출처: https://daebaq27.tistory.com/49

1. K-평균 군집화 (K-Means Clustering)

K-평균 군집화는 다음과 같은 과정을 통해 군집을 형성합니다.

  1. 초기 군집 중심 선택: $K$개의 군집 중심 $\mu_1, \mu_2, \ldots, \mu_K$를 초기화합니다.
  2. 군집 할당: 각 데이터 포인트 $x_i$를 가장 가까운 군집 중심에 할당합니다. 이는 다음과 같이 표현됩니다:여기서 $c_i$는 데이터 포인트 $x_i$가 할당된 군집의 인덱스입니다.
    $$
    c_i = \arg\min_{k} | x_i - \mu_k |^2
    $$
  3. 군집 중심 업데이트: 각 군집의 중심을 업데이트합니다. 새로운 군집 중심은 다음과 같이 계산됩니다:여기서 $N_k$는 군집 $C_k$에 속하는 데이터 포인트의 수입니다.
    $$
    \mu_k = \frac{1}{N_k} \sum_{x_i \in C_k} x_i
    $$
  4. 수렴 조건: 군집 중심이 더 이상 변화하지 않거나, 변화가 미미할 때까지 2번과 3번 과정을 반복합니다.

* 어떻게 이러한 것이 가능한가요?


클러스터 중심을 업데이트하는 과정이 효과적인 이유는 주로 다음과 같은 원리에 기반합니다:

최소화된 거리: 클러스터링의 목표는 각 데이터 포인트가 가장 가까운 클러스터 중심에 할당되도록 하는 것입니다. 클러스터 중심을 업데이트할 때, 각 클러스터에 속하는 데이터 포인트들의 평균을 계산함으로써, 해당 클러스터의 중심이 데이터 포인트들과의 거리를 최소화하도록 조정됩니다. 이는 유클리드 거리와 같은 거리 측정 방법을 사용하여 이루어집니다.

수렴성: 클러스터 중심을 반복적으로 업데이트하면, 클러스터 중심이 점차 안정된 위치로 수렴하게 됩니다. 초기 중심에서 시작하여 각 반복마다 중심을 조정함으로써, 클러스터 중심은 데이터의 분포에 맞춰 점점 더 정확한 위치로 이동하게 됩니다. 이 과정은 일반적으로 수렴 조건이 충족될 때까지 반복됩니다.

비용 함수의 최소화: 클러스터링 알고리즘, 특히 K-평균 알고리즘은 비용 함수(예: 클러스터 내 제곱 거리의 합)를 최소화하는 방식으로 작동합니다. 클러스터 중심을 업데이트하는 과정은 이 비용 함수를 줄이는 방향으로 진행되며, 이는 클러스터의 품질을 향상시키는 데 기여합니다.

데이터의 분포 반영: 클러스터 중심을 데이터 포인트의 평균으로 설정함으로써, 각 클러스터는 해당 클러스터에 속하는 데이터 포인트들의 분포를 잘 반영하게 됩니다. 이는 클러스터가 데이터의 구조를 잘 포착하도록 도와줍니다.

이러한 원리들 덕분에 클러스터 중심을 업데이트하는 과정은 효과적이며, 클러스터링의 품질을 높이는 데 중요한 역할을 합니다.

 

2. 실루엣 분석 (Silhouette Analysis)

 

실루엣 분석(Silhouette Analysis)은 군집화의 품질을 평가하는 방법 중 하나로, 각 데이터 포인트가 얼마나 잘 군집화되었는지를 측정합니다. 실루엣 값은 -1에서 1 사이의 값을 가지며, 값이 클수록 해당 데이터 포인트가 잘 군집화되었다고 볼 수 있습니다. 또한 비지도 학습의 경우에는 판단 근거가 없기 때문에 이러한 방법을 가용합니다. 

실루엣 값 $s(i)$는 다음과 같이 정의됩니다:

1. $a(i)$: 데이터 포인트 $i$와 같은 군집에 속하는 다른 모든 데이터 포인트와의 평균 거리입니다. 즉, $a(i)$는 데이터 포인트 $i$가 속한 군집 내에서의 응집도를 나타냅니다.

2. $b(i)$: 데이터 포인트 $i$와 가장 가까운 다른 군집의 데이터 포인트들과의 평균 거리입니다. 즉, $b(i)$는 데이터 포인트 $i$가 속하지 않은 군집과의 분리도를 나타냅니다.

이 두 값을 사용하여 실루엣 값을 다음과 같이 계산합니다:

$$
s(i) = \frac{b(i) - a(i)}{\max(a(i), b(i))}
$$

여기서:

- $s(i) \approx 1$: 데이터 포인트 $i$가 잘 군집화되었음을 나타냅니다.
- $s(i) \approx 0$: 데이터 포인트 $i$가 경계에 위치해 있음을 나타냅니다.
- $s(i) < 0$: 데이터 포인트 $i$가 잘못된 군집에 속해 있음을 나타냅니다.

실루엣 분석을 통해 각 데이터 포인트의 군집화 품질을 평가하고, 전체 군집화의 품질을 평균 실루엣 값으로 나타낼 수 있습니다. 평균 실루엣 값이 높을수록 군집화가 잘 이루어졌다고 판단할 수 있습니다. 

 

출처: https://daebaq27.tistory.com/49



3. DBSCAN (Density-Based Spatial Clustering of Applications with Noise)

DBSCAN은 밀도 기반 군집화 방법으로, 두 가지 주요 매개변수인 $\epsilon$ (반경)과 $minPts$ (최소 포인트 수)를 사용합니다.

  1. 핵심 포인트: 데이터 포인트 $p$가 핵심 포인트가 되기 위한 조건은 다음과 같습니다:여기서 $N_\epsilon(p)$는 포인트 $p$의 $\epsilon$ 반경 내에 있는 이웃 포인트의 수입니다.
    $$
    |N_\epsilon(p)| \geq minPts
    $$
  2. 군집 형성: 핵심 포인트를 중심으로 이웃 포인트를 확장하여 군집을 형성합니다. 이 과정은 재귀적으로 진행되어 새로운 핵심 포인트가 발견될 때마다 계속됩니다.

 

4. Gaussian Mixture Model (GMM)

GMM은 데이터가 여러 개의 가우시안 분포로 구성되어 있다고 가정합니다. 각 군집의 확률 밀도 함수는 다음과 같이 표현됩니다:

$$
p(x) = \sum_{k=1}^{K} \pi_k \mathcal{N}(x | \mu_k, \Sigma_k)
$$

여기서:

  • $K$는 군집의 수
  • $\pi_k$는 군집 $k$의 혼합 계수 (모든 $\pi_k$의 합은 1)
  • $\mathcal{N}(x | \mu_k, \Sigma_k)$는 평균 $\mu_k$와 공분산 $\Sigma_k$를 가진 가우시안 분포입니다.

이러한 수학적 표현들은 군집화 알고리즘의 작동 원리를 이해하는 데 도움이 됩니다. 각 알고리즘은 데이터의 특성과 요구 사항에 따라 선택될 수 있습니다.

 

5. 구현코드

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# 데이터 생성
n_samples = 300
n_clusters = 4
X, y = make_blobs(n_samples=n_samples, centers=n_clusters, cluster_std=0.60, random_state=0)

# K-means 군집화
kmeans = KMeans(n_clusters=n_clusters)
y_kmeans = kmeans.fit_predict(X)

# 실루엣 점수 계산
silhouette_avg = silhouette_score(X, y_kmeans)
print(f'평균 실루엣 점수: {silhouette_avg:.2f}')

# 군집화 결과 시각화
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, s=50, cmap='viridis')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75, marker='X')
plt.title('K-means 군집화 결과')
plt.xlabel('특징 1')
plt.ylabel('특징 2')
plt.show()

 

출처: https://angeloyeo.github.io/2019/07/27/PCA.html


PCA 란?


주성분 분석(Principal Component Analysis, PCA)은 고차원 데이터의 차원을 축소하는 기법으로, 데이터의 분산을 최대화하는 방향으로 새로운 축을 찾는 방법입니다. PCA는 데이터의 구조를 이해하고 시각화하는 데 유용하며, 노이즈를 줄이고 계산 효율성을 높이는 데도 사용됩니다.

PCA의 주요 단계는 다음과 같습니다:

  1. 데이터 정규화: 각 특성의 평균을 0으로, 분산을 1로 맞추기 위해 데이터를 정규화합니다. 이는 각 특성이 동일한 중요성을 가지도록 하기 위함입니다.
  2. 공분산 행렬 계산: 정규화된 데이터의 공분산 행렬을 계산합니다. 이 행렬은 각 특성 간의 관계를 나타냅니다.
  3. 고유값 및 고유벡터 계산: 공분산 행렬의 고유값과 고유벡터를 계산합니다. 고유값은 각 주성분의 중요도를 나타내며, 고유벡터는 새로운 축을 정의합니다.
  4. 주성분 선택: 고유값이 큰 순서대로 주성분을 선택합니다. 이 주성분들은 데이터의 분산을 최대한 설명하는 방향입니다.
  5. 데이터 변환: 선택한 주성분을 사용하여 원래 데이터를 새로운 축으로 변환합니다. 이 과정에서 차원이 축소됩니다.


PCA는 이미지 압축, 데이터 시각화, 노이즈 제거 등 다양한 분야에서 활용됩니다. 그러나 PCA는 선형 기법이기 때문에 비선형 데이터에는 적합하지 않을 수 있습니다. 이러한 경우에는 t-SNE, UMAP 등의 다른 차원 축소 기법을 고려할 수 있습니다.

1. 데이터 정규화

주어진 데이터 행렬 $X$가 $m$개의 샘플과 $n$개의 특성으로 구성되어 있다고 가정합니다. 각 특성의 평균을 0으로 만들기 위해, 각 특성의 평균을 계산하고 이를 데이터에서 빼줍니다.

$$
X' = X - \mu
$$

여기서 $\mu$는 각 특성의 평균 벡터입니다.

2. 공분산 행렬 계산

정규화된 데이터 $X'$의 공분산 행렬 $C$를 계산합니다. 공분산 행렬은 다음과 같이 정의됩니다.

$$
C = \frac{1}{m-1} (X')^T X'
$$

여기서 $C$는 $n \times n$ 크기의 행렬로, 각 특성 간의 공분산을 나타냅니다.

3. 고유값 및 고유벡터 계산

공분산 행렬 $C$의 고유값 $\lambda$와 고유벡터 $v$를 구합니다. 고유값 문제는 다음과 같이 표현됩니다.

$$
C v = \lambda v
$$

여기서 $\lambda$는 고유값, $v$는 고유벡터입니다. 고유값이 클수록 해당 고유벡터가 나타내는 방향이 데이터의 분산을 더 많이 설명합니다.

4. 주성분 선택

고유값을 내림차순으로 정렬하고, 상위 $k$개의 고유벡터를 선택하여 주성분을 형성합니다. 이 고유벡터들은 새로운 축을 정의합니다.

5. 데이터 변환

선택한 주성분을 사용하여 원래 데이터를 새로운 축으로 변환합니다. 선택한 $k$개의 고유벡터를 행렬 $W$로 구성하고, 이를 사용하여 변환된 데이터 $Y$를 계산합니다.

$$
Y = X' W
$$

여기서 $Y$는 차원 축소된 데이터입니다.

이 과정을 통해 PCA는 데이터의 차원을 축소하면서도 데이터의 분산을 최대한 보존하는 새로운 표현을 제공합니다. PCA는 데이터 시각화, 노이즈 제거, 특성 선택 등 다양한 분야에서 활용됩니다.

 

import numpy as np
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# 보스턴 주택 데이터셋 로드
boston = load_boston()
X = pd.DataFrame(boston.data, columns=boston.feature_names)
y = boston.target

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 데이터 표준화
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# PCA 적용
pca = PCA(n_components=5)  # 주성분 수를 5로 설정
X_train_pca = pca.fit_transform(X_train_scaled)
X_test_pca = pca.transform(X_test_scaled)

# 다중 회귀 모델 학습
model = LinearRegression()
model.fit(X_train_pca, y_train)

# 예측
y_pred = model.predict(X_test_pca)

# 성능 평가
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

 

출처: https://brunch.co.kr/@jennyjang93/30


0. 회귀 분석(Regression)이란?


회귀 분석은 머신러닝에서 연속적인 값을 예측하는 데 활용되는 기법으로, 입력 변수와 출력 변수 간의 관계를 학습합니다. 주로 가격 예측, 수요 예측, 트렌드 분석 등에 효과적이며, 데이터의 패턴을 파악해 미래 값을 예측하는 데 강점을 가집니다. 특히, 과적합 방지를 위한 정규화 기법(L1, L2)과 배치 정규화 등을 적용하면 더욱 일반화된 모델을 만들 수 있습니다.


1. 회귀 분석(Regression) 개요

회귀 분석은 입력 변수 \( X \)와 출력 변수 \( Y \) 간의 관계를 모델링하는 과정입니다. 일반적으로 다음과 같이 표현됩니다:

$$
Y = f(X) + \epsilon
$$

여기서:

  • \( Y \) : 출력 변수(종속 변수)
  • \( X \) : 입력 변수(독립 변수)
  • \( f(X) \) : 입력 변수 \( X \)에 대한 함수
  • \( \epsilon \) : 모델이 설명하지 못하는 오차 항

 

2. 선형 회귀(Linear Regression)

선형 회귀는 입력 변수와 출력 변수 간의 선형 관계를 가정하는 기법입니다.

단순 선형 회귀의 경우:

$$
Y = \beta_0 + \beta_1 X + \epsilon
$$

다중 선형 회귀의 경우:

$$
Y = \beta_0 + \beta_1 X_1 + \beta_2 X_2 + \dots + \beta_n X_n + \epsilon
$$

 

3. 배치 정규화 (Batch Normalization, BN)

배치 정규화는 각 층의 입력을 정규화하여 학습을 빠르고 안정적으로 만드는 기법입니다.

미니배치의 평균과 분산은 다음과 같이 계산됩니다:

$$
\mu_B = \frac{1}{m} \sum_{i=1}^{m} x_i
$$

$$
\sigma_B^2 = \frac{1}{m} \sum_{i=1}^{m} (x_i - \mu_B)^2
$$

정규화 (Normalization)를 수행하면:

$$
\hat{x}_i = \frac{x_i - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}}
$$

이후, 스케일링(Scale) 및 이동(Shift)을 적용하여 최종 변환을 수행합니다:

$$
y_i = \gamma \hat{x}_i + \beta
$$

 

4. 정규화 기법 (L1, L2 Regularization)

과적합을 방지하기 위해 사용되는 정규화(Regularization) 기법입니다.

 

🔹 L1 정규화 (Lasso Regression)

$$
\text{Loss} = \text{MSE} + \lambda \sum_{j=1}^{n} |\beta_j|
$$

🔹 L2 정규화 (Ridge Regression)

$$
\text{Loss} = \text{MSE} + \lambda \sum_{j=1}^{n} \beta_j^2
$$


4.5 BatchNormalization VS L1, L2 (Lasso, Ridge)

1. 목적의 차이:

  • Batch Normalization: 주로 신경망에서 사용되며, 각 층의 입력을 정규화하여 학습 속도를 높이고, 내부 공변량 변화(Internal Covariate Shift)를 줄이는 데 도움을 줍니다. 이는 모델의 안정성을 높이고, 더 깊은 네트워크를 효과적으로 학습할 수 있게 합니다.
  • Lasso 및 Ridge: 주로 회귀 분석에서 사용되며, 모델의 복잡성을 줄이고 과적합을 방지하기 위해 계수에 대한 규제를 적용합니다. Lasso는 L1 규제를 통해 일부 계수를 0으로 만들고, Ridge는 L2 규제를 통해 계수를 축소합니다.

2. 상호작용:

  • Batch Normalization은 각 층의 출력을 정규화하여 학습을 안정화하지만, 이 과정에서 Lasso나 Ridge와 같은 규제 기법이 적용되는 방식에 영향을 줄 수 있습니다. 예를 들어, Batch Normalization이 계수를 정규화하는 방식과 Lasso 또는 Ridge가 계수에 규제를 적용하는 방식이 서로 충돌할 수 있습니다.

3. 적용 시기:

  • 일반적으로 Batch Normalization은 활성화 함수 이전에 적용되며, Lasso와 Ridge는 손실 함수에 포함되어 계수에 대한 규제를 적용합니다. 이로 인해 두 기법을 함께 사용할 때는 적절한 순서와 방법을 고려해야 합니다.

4. 차이점

  • 그러나 전통적인 회귀 모델(예: 선형 회귀, 다항 회귀 등)에서는 Batch Normalization을 사용할 필요가 없습니다. 이러한 모델은 일반적으로 입력 데이터의 스케일링이나 정규화가 필요할 수 있지만, Batch Normalization의 개념은 신경망의 층에서의 정규화에 초점을 맞추고 있습니다.

 

5. 회귀 모델의 성능 평가

✅ 평균 제곱 오차 (Mean Squared Error, MSE)

$$
\text{MSE} = \frac{1}{N} \sum_{i=1}^{N} (Y_i - \hat{Y}_i)^2
$$

✅ 결정 계수 (R-squared)

$$ R^{2} = 1 - \frac{\sum_{i=1}^{N} (Y_i - \hat{Y}_i)^2}{\sum_{i=1}^{N} (Y_i - \bar{Y})^2} $$

 

여기서 \( \bar{Y} \)는 실제 값의 평균입니다.



6. 구현 코드

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, regularizers
import matplotlib.pyplot as plt

# 1. 랜덤 데이터 생성 (회귀 문제)
np.random.seed(42)
X = np.linspace(-3, 3, 300)
y = 2 * X + np.random.normal(0, 1, 300)  # 노이즈 추가

# 훈련 및 검증 데이터 나누기
X_train, X_test = X[:250], X[250:]
y_train, y_test = y[:250], y[250:]

# 데이터를 (N, 1) 형태로 변환
X_train = X_train.reshape(-1, 1)
X_test = X_test.reshape(-1, 1)

# 2. 모델 생성 함수
def build_model(use_bn=False, use_l1=False, use_l2=False):
    model = keras.Sequential()
    
    # 첫 번째 Dense 레이어 (입력층)
    if use_bn:
        model.add(layers.Dense(64, input_shape=(1,), activation=None, kernel_initializer='he_normal'))
        model.add(layers.BatchNormalization())  # 배치 정규화 적용
        model.add(layers.Activation('relu'))  # 배치 정규화 후 활성화 함수 적용
    else:
        reg = None
        if use_l1:
            reg = regularizers.l1(0.01)  # L1 정규화 적용
        elif use_l2:
            reg = regularizers.l2(0.01)  # L2 정규화 적용
            
        model.add(layers.Dense(64, input_shape=(1,), activation='relu', kernel_regularizer=reg))
    
    # 두 번째 Dense 레이어
    model.add(layers.Dense(32, activation='relu'))
    
    # 출력층
    model.add(layers.Dense(1))  # 선형 회귀이므로 activation 없음
    
    # 모델 컴파일
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    return model

# 3. 각각의 모델 생성
model_bn = build_model(use_bn=True)   # 배치 정규화 적용
model_l1 = build_model(use_l1=True)   # L1 정규화 적용
model_l2 = build_model(use_l2=True)   # L2 정규화 적용
model_base = build_model()            # 기본 모델 (정규화 없음)

# 4. 모델 학습
history_bn = model_bn.fit(X_train, y_train, epochs=100, verbose=0, validation_data=(X_test, y_test))
history_l1 = model_l1.fit(X_train, y_train, epochs=100, verbose=0, validation_data=(X_test, y_test))
history_l2 = model_l2.fit(X_train, y_train, epochs=100, verbose=0, validation_data=(X_test, y_test))
history_base = model_base.fit(X_train, y_train, epochs=100, verbose=0, validation_data=(X_test, y_test))

# 5. 학습 결과 비교
plt.figure(figsize=(12, 6))

plt.plot(history_base.history['val_loss'], label='No Regularization', linestyle='dashed')
plt.plot(history_bn.history['val_loss'], label='Batch Norm', linestyle='dotted')
plt.plot(history_l1.history['val_loss'], label='L1 Regularization')
plt.plot(history_l2.history['val_loss'], label='L2 Regularization')

plt.xlabel('Epochs')
plt.ylabel('Validation Loss')
plt.title('Effect of Batch Normalization & Regularization on Regression')
plt.legend()
plt.show()

# Bias-Variance Tradeoff

출처: https://www.youtube.com/watch?v=OYsOkOvzJlE

보팅, 배깅, 부스팅을 하기전에 Bias-Variance trade-off에 대해서 알아보자 위에 보이는 그림과 같이 편향과 분산이 모두 낮은 모델이 좋은 것이다. 하지만 현실에서는 Low Bias, Low Variance가 어렵습니다. 이를 해결 하기 위해 앙상블 기법을 통해서 해결할 수 있습니다. (Variance가 높을 수록 퍼져있고, Bias가 높을 수록 정답과의 거리가 멉니다.) #배깅이라고 표현된 부분을 보면 데이터들이 같은 수준에 있지만 각각 다른 차원에 존재 합니다. 이러한 경우에는 각가의 데이터가 같는 분포에 대한 왜곡을 줄이기 위하여 사용할 수 있습니다. 반대로 부스팅의 경우에는 한차원에 Variance가 낮은 형태로 존재할 수 있으나 Ground Truth로 부터 멀어질 수 있습니다. 이러한 약점을 해결 할 수 있기 때문에 두가지의 방법을 활용합니다. 

  • 배깅: Low Biance, High Variance에 효과적 
  • 부스팅: High Bias, Low Variance에 효과적 

 

1. 보팅 (Voting)

  • 여러 개의 개별 모델(예: 서로 다른 알고리즘 사용)이 예측한 결과를 종합하여 같은 데이터셋을 기준으로 최종 결과를 결정하는 방법.
  • 종류:
    • 하드 보팅 (Hard Voting): 다수결(최빈값)로 최종 예측 결정.
    • 소프트 보팅 (Soft Voting): 각 모델의 예측 확률 평균을 내어 결정.
  • 예제: 로지스틱 회귀, 랜덤포레스트, SVM 모델을 함께 사용해 다수결로 결정.

특징: 서로 다른 모델을 조합해 성능을 높일 수 있음.


2. 배깅 (Bagging, Bootstrap Aggregating)

  • 같은 알고리즘을 여러 개 학습하되, 각 모델을 다른 데이터 샘플(부트스트랩 샘플링)로 학습시키고 평균을 내는 방식.
  • 대표적인 알고리즘: 랜덤포레스트(Random Forest)
  • 목적: 분산(Variance) 감소 → 과적합 방지 효과.

특징: 개별 모델은 독립적으로 학습되며, 병렬 연산 가능. 과적합 방지에 효과적.


3. 부스팅 (Boosting)

  • 모델을 순차적으로 학습시키면서 이전 모델이 잘못 예측한 샘플에 가중치를 부여하여 보완하는 방식.
  • 대표적인 알고리즘:
    • AdaBoost (Adaptive Boosting)
    • Gradient Boosting (GBM)
    • XGBoost / LightGBM / CatBoost
  • 목적: 편향(Bias) 감소 → 강력한 성능.

특징: 이전 모델의 오류를 보완하며 학습하므로 성능이 좋지만, 과적합 가능성↑. 계산 비용이 높음.

 

= 하지만 그럼에도 불구하고 항상 단일모델 보다 성능이 좋은 것은 아닙니다. 대체로 좋을 뿐입니다.

 

4. 구현 코드 

랜덤포레스트(Random Forest)

 

출처: https://onceadayedu.tistory.com/107

 

랜덤 포레스트(Random Forest)는 앙상블 학습 기법 중 하나로, 여러 개의 결정 트리(Decision Tree)를 결합하여 예측 성능을 향상시키는 방법입니다. 주로 분류(classification)회귀(regression) 문제에 사용됩니다.

랜덤 포레스트(Random Forest)앙상블 학습 기법 중 하나, 여러 개의 결정 트리(Decision Tree)를 결합하여 예측 성능을 향상시키는 방법입니다. 주로 분류(classification)와 회귀(regression) 문제에 사용됩니다. 랜덤 포레스트의 주요 특징과 작동 방식은 다음과 같습니다:

 

1. 기본 개념

  • 결정 트리: 랜덤 포레스트는 여러 개의 결정 트리를 생성하고, 각 트리는 데이터의 서브셋을 사용하여 학습됩니다. 각 트리는 독립적으로 예측을 수행합니다.
  • 앙상블 학습: 여러 개의 모델을 결합하여 더 나은 성능을 얻는 방법입니다. 랜덤 포레스트는 다수결 투표(voting) 또는 평균(averaging) 방식을 사용하여 최종 예측을 결정합니다.

 

2. 작동 방식

  • 부트스트랩 샘플링: 원본 데이터에서 중복을 허용하여 여러 개의 샘플을 무작위로 선택합니다. 각 샘플은 결정 트리를 학습하는 데 사용됩니다.
  • 특성 선택: 각 결정 트리를 생성할 때, 노드를 분할할 특성을 무작위로 선택합니다. 이 과정은 트리 간의 상관관계를 줄여줍니다.
    • 만약 모든 Feature를 학습하게 되면 분류기 끼리의 유의미한 특성을 만들어 내기가 쉽지 않습니다. 예를들어 키 / 몸무게 / 나이 이 세가지의 Feature을 가지고 있다고 가정해봅시다. 이렇게 세가지의 특성을 모두 학습시키는 것보다 키 - 몸무게 / 몸무게 - 나이 / 키 - 나이 이렇게 두가지로 묶어서 분류하는 것이 더 좋은 분류기를 만드는데 도움이 된다는 것입니다.  
  • 트리 생성: 각 샘플과 선택된 특성을 사용하여 결정 트리를 생성합니다. 이 과정은 일반적으로 깊이 제한 없이 진행되며, 과적합(overfitting)을 방지하기 위해 가지치기(pruning) 기법을 사용할 수 있습니다.
  • 예측: 새로운 데이터에 대해 각 트리가 예측을 수행하고, 최종 예측은 다수결 투표(분류의 경우) 또는 평균(회귀의 경우)으로 결정됩니다.

3. 장점

  • 높은 정확도: 여러 개의 트리를 결합하여 예측 성능이 향상됩니다.
  • 과적합 방지: 개별 트리가 과적합되는 경향이 있지만, 앙상블 방식으로 이를 완화할 수 있습니다.
  • 특성 중요도 평가: 각 특성이 예측에 얼마나 기여하는지를 평가할 수 있는 기능이 있습니다.

4. 단점

  • 모델 해석의 어려움: 여러 개의 트리를 결합하기 때문에 개별 트리의 해석이 어렵습니다.
  • 메모리 사용량: 많은 수의 트리를 생성하면 메모리 사용량이 증가할 수 있습니다.
  • 예측 속도: 많은 트리를 사용하기 때문에 예측 속도가 느릴 수 있습니다.

5. 코드 

 

https://twojun-space.tistory.com/124

 

 

경사하강법이란?



최적의 해를 도출하기 위하여 사용된 예측함수의 최솟값을 찾는 기법입니다.  가장 기본적인 형태의 경사하강법은 다음과 같이 표현될 수 있습니다:

\[ \theta = \theta - \alpha \cdot \nabla J(\theta) \]

여기서:
- \( \theta \)는 업데이트할 모델의 파라미터 벡터입니다.
- \( \alpha \)는 학습률(learning rate)이라고 불리는 스칼라 값입니다. 이 값은 경사하강법이 얼마나 큰 단계로 이동해야 하는지를 결정합니다.
- \( J(\theta) \)는 비용 함수(cost function)이며, 모델의 파라미터 \( \theta \)에 대한 손실(또는 비용)을 측정합니다.
- \( \nabla J(\theta) \)는 비용 함수 \( J(\theta) \)에 대한 기울기(gradient) 벡터입니다. 이는 모델 파라미터의 각 차원에 대한 손실 함수의 변화율을 나타냅니다.

이 수식은 다음과 같이 해석됩니다:
- 현재 모델의 파라미터 \( \theta \)에서 시작하여,
- 손실 함수의 기울기(gradient) 방향으로 학습률 \( \alpha \)의 크기로 이동하여,
- 새로운 모델 파라미터 \( \theta \)를 업데이트합니다.

이러한 단계를 반복하여 손실 함수가 최소가 되는 모델 파라미터를 찾습니다.

이 수식은 경사하강법 알고리즘의 핵심을 나타내며, 학습률과 손실 함수의 기울기를 이용하여 모델 파라미터를 업데이트합니다. 이러한 과정을 통해 모델은 데이터에 더 잘 적합되는 방향으로 조정됩니다.

 

경사하강법의 문제

이러한 경사하강 법에도 여러가지 문제 점들이 존재합니다.

  • Step Size가 너무 큰 경우: 극소점을 찾아갈 수 없게 됩니다.

  • Step SIze가 너무 작은 경우: 너무 많은 학습이 필요하게 될 수 있습니다.

  • Global Maximum이 아니라 Local Maximum에 빠지는 경우: 최적화된 지점을 찾아가지 못합니다. 

경사하강법의 종류

 

1. SDG(Stochastic Gradient Descent, SGD)

 

확률적 경사하강법(Stochastic Gradient Descent, SGD)은 경사하강법의 한 변종으로, 매 반복마다 무작위로 선택된 하나의 훈련 예제에 대해 기울기를 계산하고 파라미터를 업데이트합니다. 이는 전체 데이터 세트를 사용하는 것보다 훨씬 더 빠르게 수렴할 수 있습니다. 

SGD의 갱신 규칙은 다음과 같습니다:

\[ \theta = \theta - \alpha \cdot \nabla J_i(\theta) \]

여기서:
- \( \theta \)는 업데이트할 모델의 파라미터 벡터입니다.
- \( \alpha \)는 학습률(learning rate)입니다.
- \( J_i(\theta) \)는 \( i \)번째 훈련 예제에 대한 손실 함수입니다.
- \( \nabla J_i(\theta) \)는 \( i \)번째 훈련 예제에 대한 손실 함수의 기울기(gradient) 벡터입니다.

SGD는 전체 데이터 세트를 사용하지 않고 단일 데이터 포인트 또는 미니 배치에 대한 손실 함수의 기울기를 계산합니다. 이렇게 함으로써 계산 비용을 줄이고, 지역 최소값(local minima)에 빠지는 것을 피할 수 있습니다. 하지만 SGD는 노이즈가 많은 학습 과정을 가질 수 있고, 수렴이 불안정할 수 있습니다.

SGD의 장단점은 다음과 같습니다:
- 장점:
  - 계산 비용이 낮습니다. 전체 데이터 세트를 사용하지 않고 각 반복에서 단일 데이터 포인트 또는 미니 배치만 사용하기 때문에 더 빠릅니다.
  - 지역 최소값(local minima)에 빠질 가능성이 낮습니다. 무작위한 선택으로 인해 더 다양한 영역을 탐색할 수 있습니다.
- 단점:
  - 노이즈가 많을 수 있습니다. 각 반복에서 단일 데이터 포인트만 사용하기 때문에 최적화된 방향이 실제로는 아닐 수 있습니다.
  - 수렴이 불안정할 수 있습니다. 무작위한 선택으로 인해 수렴 속도가 느려질 수 있습니다.

 

2. Momentum

 

SGD는 머신러닝에서 널리 사용되며, 딥러닝에서도 많이 사용됩니다. 또한 SGD를 개선한 많은 변종이 있으며, 이들은 SGD의 단점을 보완하기 위해 설계되었습니다.

모멘텀(Momentum)은 경사 하강법의 변형 중 하나로, 이전 그래디언트의 방향을 고려하여 최적화 알고리즘의 속도를 조절하는 방법입니다. 이전의 그래디언트를 사용하여 현재의 그래디언트를 업데이트하므로써 진행 방향을 보다 일관되게 유지하는 데 도움이 됩니다.

모멘텀은 다음과 같이 수식으로 표현됩니다.

\[ v_{t+1} = \beta v_t + (1 - \beta) \nabla J(\theta_t) \]
\[ \theta_{t+1} = \theta_t - \eta v_{t+1} \]

여기서:
- \( \theta_t \)는 현재의 매개 변수 벡터입니다.
- \( \eta \)는 학습률(learning rate)로, 각각의 단계에서 얼마나 많이 업데이트할지를 결정합니다.
- \( \nabla J(\theta_t) \)는 손실 함수 \( J \)에 대한 매개 변수 \( \theta \)의 그래디언트(경사)입니다.
- \( v_t \)는 이전 단계에서의 모멘텀 벡터입니다.
- \( \beta \)는 모멘텀 상수로, 일반적으로 0.9와 같은 값으로 설정됩니다.

모멘텀은 경사 하강 과정에서 공을 내리는 것으로 비유될 수 있습니다. 초기에는 조금씩 내려가다가 언덕을 만나면 관성에 의해 공이 계속 내려갑니다. 이는 모멘텀이 이전 그래디언트의 방향을 고려하여 현재의 업데이트 방향을 결정하기 때문입니다.

모멘텀의 장점은 다음과 같습니다.
1. 지역 최솟값에서 빠져나오는 데 도움을 줍니다.
2. 발산하지 않고 빠르게 수렴할 수 있습니다.
3. 진동을 줄여줍니다.

모멘텀은 SGD와 같이 사용될 수 있으며, 일반적으로 SGD에 모멘텀을 적용한 SGD+Momentum이 널리 사용됩니다.

 

3. AdaGrad

물론입니다. Adagrad는 각 매개 변수마다 학습률을 조정하여 학습 과정을 안정화하는 최적화 알고리즘입니다. 이전에 많은 변화가 있었던 매개 변수는 작은 학습률을 갖게 되고, 드문 변화가 있었던 매개 변수는 큰 학습률을 갖게 됩니다.

Adagrad의 핵심 아이디어는 매개 변수마다 학습률을 조정하는 방식입니다. 이를 위해 각 매개 변수에 대한 그래디언트 제곱의 누적값을 저장하며, 이 값은 매개 변수마다 서로 다른 학습률을 만들어냅니다.

수식을 하나씩 살펴보겠습니다.

1. 누적 제곱 그래디언트:

\[ G_{t+1} = G_t + (\nabla J(\theta_t))^2 \]

여기서 \( G_{t+1} \)은 \( t+1 \) 시점에서의 매개 변수에 대한 그래디언트 제곱의 누적값입니다. \( \nabla J(\theta_t) \)는 손실 함수 \( J \)에 대한 \( \theta \)의 그래디언트(gradient)이며, \( \theta_t \)는 현재의 매개 변수 값입니다. 이전에 누적된 제곱 그래디언트와 현재의 그래디언트 제곱을 더하여 새로운 누적값을 계산합니다.

2. 매개 변수 업데이트:

\[ \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{G_{t+1} + \epsilon}} \cdot \nabla J(\theta_t) \]

여기서 \( \eta \)는 학습률(learning rate)이며, \( \epsilon \)은 0으로 나누는 것을 방지하기 위한 작은 상수입니다. 새로운 매개 변수 값은 현재 매개 변수에서 학습률을 조정한 값으로 업데이트됩니다. 학습률은 각 매개 변수의 누적 제곱 그래디언트에 대해 제곱근을 취하여 조정됩니다.

이러한 방식으로 Adagrad는 매개 변수마다 적절한 학습률을 조절하여 학습 과정을 안정화시키고 빠른 수렴을 도모합니다.

 

4. RMSprop

RMSprop(Root Mean Square Propagation)는 Adagrad의 한계를 극복하기 위해 제안된 최적화 알고리즘 중 하나입니다. Adagrad는 그래디언트 제곱의 누적값을 이용하여 학습률을 조절하는데, 이로 인해 학습이 진행될수록 학습률이 너무 작아져서 일찍부터 더 이상의 학습이 이루어지지 않을 수 있습니다. RMSprop는 이러한 문제를 해결하기 위해 그래디언트 제곱의 누적값을 지수 이동 평균(Exponential Moving Average, EMA)으로 업데이트하여 학습률을 조절합니다.

수식은 다음과 같습니다.

\[ E[g^2]_t = \beta E[g^2]_{t-1} + (1 - \beta) (\nabla J(\theta_t))^2 \]

\[ \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{E[g^2]_t + \epsilon}} \cdot \nabla J(\theta_t) \]

여기서:
- \( E[g^2]_t \)는 \( t \) 시점에서의 그래디언트 제곱의 지수 이동 평균입니다.
- \( \beta \)는 이동 평균의 가중치를 제어하는 하이퍼파라미터입니다. 보통 0.9 정도로 설정됩니다.
- \( \eta \)는 학습률(learning rate)입니다.
- \( \epsilon \)은 0으로 나누는 것을 방지하기 위한 작은 상수입니다.
- \( \nabla J(\theta_t) \)는 손실 함수 \( J \)에 대한 \( \theta \)의 그래디언트(gradient)입니다.

RMSprop는 Adagrad와 비슷하지만, 그래디언트 제곱의 누적값을 이동 평균으로 업데이트하여 학습률이 너무 빨리 감소하는 문제를 완화합니다. 따라서 RMSprop는 더 안정적인 학습을 가능하게 하며, 많은 경우에서 Adagrad보다 더 효과적으로 작동할 수 있습니다.

 

5. Adam

 

Adam(Adaptive Moment Estimation)은 RMSprop과 모멘텀 최적화를 결합한 최적화 알고리즘으로, 그래디언트의 지수 이동 평균과 모멘텀의 개념을 활용하여 각 매개 변수마다 적응적인 학습률을 제공합니다. Adam은 다양한 하이퍼파라미터를 사용하여 학습률을 조정하고 최적화 과정을 안정화시키는 효과적인 방법을 제공합니다.

수식은 다음과 같습니다.

\[ m_t = \beta_1 m_{t-1} + (1 - \beta_1) \nabla J(\theta_t) \]
\[ v_t = \beta_2 v_{t-1} + (1 - \beta_2) (\nabla J(\theta_t))^2 \]
\[ \hat{m}_t = \frac{m_t}{1 - \beta_1^t} \]
\[ \hat{v}_t = \frac{v_t}{1 - \beta_2^t} \]
\[ \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t \]

여기서:
- \( m_t \)는 그래디언트의 지수 이동 평균입니다.
- \( v_t \)는 그래디언트 제곱의 지수 이동 평균입니다.
- \( \hat{m}_t \)와 \( \hat{v}_t \)는 편향 보정을 적용한 이동 평균입니다.
- \( \beta_1 \)와 \( \beta_2 \)는 이동 평균의 가중치를 제어하는 하이퍼파라미터입니다. 보통 \( \beta_1 = 0.9 \)와 \( \beta_2 = 0.999 \)로 설정됩니다.
- \( \eta \)는 학습률(learning rate)입니다.
- \( \epsilon \)은 0으로 나누는 것을 방지하기 위한 작은 상수입니다.
- \( \theta_t \)는 현재의 매개 변수 값입니다.
- \( \nabla J(\theta_t) \)는 손실 함수 \( J \)에 대한 \( \theta \)의 그래디언트(gradient)입니다.
- \( t \)는 현재의 반복 횟수를 나타냅니다.

Adam은 RMSprop과 모멘텀 최적화의 아이디어를 결합하여 학습률을 자동으로 조정하고 최적화 과정을 안정화시킵니다. 이를 통해 다양한 문제에 대해 빠르고 안정적으로 수렴할 수 있습니다.

+ Recent posts