출처: 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://www.csharpstudy.com/CSharp/CSharp-event.aspx

대리자 (Deligate)는 무엇인가?

  • 대리자와 같은 이벤트는 런타임에 바인딩 메커니즘
  • 이벤트의 형식은 대리자 형
    • 대리자(Delegate)는 C#에서 메서드에 대한 참조를 나타내는 특별한 형식
    • 대리자를 사용하면 메서드를 변수처럼 사용할 수 있음
    • 아래와 같이 event 키워드를 사용할 수 있음 아래를 보면 FileLister안에 Progress가 있는 것이 보임
public event EventHandler<FileListArgs> Progress;



======>

public class FileListArgs : EventArgs
{
    public string FoundFile { get; set; }
}

public class FileLister
{
    public event EventHandler<FileListArgs> Progress;

    public void ListFiles(string directory)
    {
        foreach (var file in Directory.GetFiles(directory))
        {
            OnProgress(new FileListArgs { FoundFile = file });
        }
    }

    protected virtual void OnProgress(FileListArgs e)
    {
        Progress?.Invoke(this, e);
    }
}

 

  • FileLister 이라는 Class 안에 Progress 이벤트를 통해서 += 로 이벤트를 등록할 수 있다. 
  • 또한 ?. 연산자를 통해서 이벤트에 대한 구독자가 없을 때 이벤트를 발생시키지 않도록 할 수 있다. 
Progress?.Invoke(this, new FileListArgs(file));

+ Recent posts