채린's datascience

VIF란?

다중공선성을 진단하기 위해 사용되는지수로
독립변수가 여러개 있을 때, 특정 독립변수를 종속변수로하고 나머지 독립변수를 독립변수로 하여 회귀분석을 수행한다. 각 회귀식의 결정계수를 계산하여 1/1-R^2값으로 VIF를 정의한다.
상관관계가 높은 독립변수는 추정된 계수가 분산이 커진다. 얼마나 커지는지 확인할 수 있는게 VIF값이고 VIF가 크다는것은 다른 변수들로 설명가능함을 나타낸다. 
 
https://direction-f.tistory.com/46

http://web.vu.lt/mif/a.buteikis/wp-content/uploads/PE_Book/4-5-Multiple-collinearity.html

 
만약 데이터프레임 안에 범주형 변수가 3개이고, 수치형 변수가 3개인 경우에는 다음과 같이 GVIF 함수를 수정할 수 있습니다.

```python
def calculate_GVIF(all_vars, var):
    """
    Calculate GVIF for one categorical variable (var) and other variables (all_vars)
    """
    # Create correlation matrix (A) of the categorical variable (var)
    A = pd.get_dummies(all_vars[var], drop_first=True).corr().to_numpy()

    # Select the names of all other categorical variables
    cat_columns = [col for col in all_vars.columns if all_vars[col].dtype == 'object' and col != var]

    # Create correlation matrix (B) of other categorical variables
    B = pd.get_dummies(all_vars[cat_columns], drop_first=True).corr().to_numpy()

    # Select the numeric columns
    num_columns = [col for col in all_vars.columns if all_vars[col].dtype in ['int64', 'float64']]

    # Create correlation matrix (C) of numeric variables
    C = all_vars[num_columns].corr().to_numpy()

    # Calculate GVIF
    GVIF = (np.linalg.det(A) * np.linalg.det(B)) / np.linalg.det(C)

    return GVIF
```

이 함수는 범주형 변수에 대한 GVIF를 계산하는 함수이며, 다른 범주형 변수와 수치형 변수 간의 상호작용을 고려하여 GVIF를 계산합니다. 함수를 사용하기 전에, 데이터프레임에서 범주형 변수와 수치형 변수의 이름을 적절히 지정해주어야 합니다.

def calculate_GVIF(all_vars, var):

    """Calculate GVIF between one non-numeric variarble (var) and other variables (all_vars)"""

    # Create correlation matrix (A) of non-numeric variable (var)
    A = pd.get_dummies(all_vars[var], drop_first = True).corr().to_numpy()
    
    # Seperate non-numeric variable name (var) from other variable names
    columns = list(all_vars.columns)
    columns.remove(var)

    # Create correlation matrix (B) of other variables
    B = pd.get_dummies(all_vars[columns], drop_first = True).corr().to_numpy()

    # Create correlation matrix (C) of all variables
    C = pd.get_dummies(all_vars, drop_first = True).corr().to_numpy()

    # Calculate GVIF
    GVIF = (np.linalg.det(A)*np.linalg.det(B)) / np.linalg.det(C)

    return GVIF

다중분류의 경우 불균형문제를 해결하기 위해 아래와같은 처리를 시도할 수 있다.

• Under Sampling 
• Simple Over Sampling 
• Algorithm Over Sampling | 알고리즘을 통한 오버샘플링(SMOTE, ADASYN)
• Cost-sensitive learning

python에서 imblearn이라는 패키지에서 sampling function들을 사용할 예정이다.

# 필요 모듈 임포트
import imblearn
print(imblearn.__version__)

import pandas as pd
from collections import Counter
from matplotlib import pyplot


# 필요 함수 정의
def count_and_plot(y): 
    counter = Counter(y)
    for k,v in counter.items():
        print('Class=%d, n=%d (%.3f%%)' % (k, v, v / len(y) * 100))
    pyplot.bar(counter.keys(), counter.values())
    pyplot.show()

클래스에 하나도 존재하지 않는 경우도 있을 것이고 예측하려는 타켓의 수는 모두 다를 것이다. 

Under sampling은 가장 작은 class의 개수에 맞춰 샘플개수가 줄어들 것이고, Over는 가장큰 수에 맞춰 증가할 것이다. 

Under sampling은 잠재적 정보량이 많은 데이터를 지울 수 있는 문제가 있다. RandomUnderSampler는 Undersampler의 한 방법이고 다른 방법들도 많이 있다. 

from imblearn.under_sampling import RandomUnderSampler
X_resampled, y_resampled = RandomUnderSampler(random_state=0).fit_resample(X, y)
count_and_plot(y_resampled)

Oversamping은 같은 데이터를 복제하여 over-fitting 문제를 야기한다. 

from imblearn.over_sampling import RandomOverSampler
X_resampled, y_resampled = RandomOverSampler(random_state=0).fit_resample(X, y)
count_and_plot(y_resampled)

SMOTE sampling은 

1. 먼저 소수 클래스에서 각각의 샘플들의 knn(k-nearest neighbors)을 찾는다.
2. 그리고 그 이웃들 사이에 선을 그어 무작위 점을 생성한다.

from imblearn.over_sampling import SMOTE
X_resampled, y_resampled = SMOTE(random_state=0).fit_resample(X, y)
count_and_plot(y_resampled)

ADASYN은 SMOTE의 개선된 버전이다. 동일한 프로세스를 진행한 후 점들에 임의의 작은 값을 더해줌으로써 조금 더 사실적인 데이터가 생성된다. 즉 모든 표본이 약간 더 분산된다.

다음과 같이 실행할 수 있다.

from imblearn.over_sampling import ADASYN
strategy = {1:76, 2:76, 3:76, 5:76, 6:76, 7:76}
X_resampled, y_resampled = ADASYN(sampling_strategy=strategy).fit_resample(X, y)
count_and_plot(y_resampled)

출처: https://dining-developer.tistory.com/27

python
import lightgbm as lgb
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

train_data = lgb.Dataset(X_train, label=y_train)

parameters = {
    'objective': 'multiclass',
    'num_class': 3,
    'metric': 'multi_logloss',
    'boosting_type': 'gbdt',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9
}

lgb_model = lgb.train(parameters,
                      train_data,
                      valid_sets=[train_data],
                      num_boost_round=100,
                      early_stopping_rounds=10)

y_pred = lgb_model.predict(X_test)
y_pred = [list(x).index(max(x)) for x in y_pred]

accuracy = accuracy_score(y_test, y_pred)

print(f"Accuracy: {accuracy}")

Light GBM 

light gradient boosting model의 장점은 말 그대로  속도가 빠르며, GPU 계산을 지원하는 것입니다. 

Leaf-wise model(아래로 tree를 확장하는 구조, 다른 tree 모델은 수평적으로 확장)이며 max loss 를 가지는 리프노드를 계속적으로 분활하여 생성한다. => 틀린 부분에 가중치를 더해 학습한다. 

부스팅

부스팅은 기존에 있는 예측기를 조금씩 발전시켜서 여러 트리를 합하여 의사결정하는 방식이다.

두가지 방식이 있는데, 

1. adaboost: 중요한 데이터에 weight를 주는 방식 

2. GBDT: 딥러닝의 loss function처럼 오차를 훈련시켜 gradient를 활용해 모델을 개선하는 방식 (XGboost, LGBM이 이런 방식)

Gradient Boosting Decision Tree

decision tree를 만들때,  gradient boosting을 활용한다. 

손실함수를 가장 큰폭으로 줄일 수 있는 부분에서 leaf를 나눈다. 

GOSS(Gradient Based One-Side Sampling)

GBDT에서는 기울기(Gradient)로 학습을  한다. 각 데이터 별로 기울기가 작으면 훈련 오차가 작다는 것을 의미하므로, 이는 학습이 잘 되었다는 뜻이다.

• 큰 Gradient(훈련이 잘 안된)를 갖는 데이터 개체들은 원하는 만큼 남겨두고(예를 들어, 30%, a = 0.3), 작은 Gradient를 갖는 데이터 개체들에서는 무작위 샘플링을 진행한다. 이때 작은 gradient 데이터셋에서 일부를 버림. 그래서 이런 방법은 작은 gradient만 drop하는 one-side sampling 이다. 
• 하지만 만약 gradient가 적다고 해서 버려버리면, 데이터 분포자체가 왜곡되기 때문에 이 상태에서 훈련하면 정확도가 낮아지게 되는데 따라서 낮은 gradient의 값들(예를 들어, 10%, b= 0.1)은 가져와서 버린 샘플만큼 뻥튀기한다. 1 – a / b 를 곱해서 수를 맞춰준다. 
• 일단 제일 큰 gradient를 가지는 (절대값으로) 놈부터 랭크를 시킨다. 그리고 큰 gradient를 가지는 애들은 100%를 취하고(예시로는, 전체의 30% 모두 사용), 작은 gradient 애들은 작은 비율만 선택한다. a와 b는 임의 선택.
• 그리고 분기를 계산할때는 보통은 분산을 계산하게 되는데 아무래도 gradient가 적은 데이터는 샘플링이 되었으므로 적어진 비율만큼 다시 1 – a / b 를 반영해주어 분산을 계산한 후, 정보이득이 제일 큰 쪽으로 분기를 한다.

참고: http://machinelearningkorea.com/2019/09/25/lightgbm%EC%9D%98-%ED%95%B5%EC%8B%AC%EC%9D%B4%ED%95%B4/

https://study2give.tistory.com/entry/%EB%A8%B8%EC%8B%A0%EB%9F%AC%EB%8B%9D-%EC%86%90%EC%8B%A4%ED%95%A8%EC%88%982-%EC%97%94%ED%8A%B8%EB%A1%9C%ED%94%BCEntropy

https://hoonst.github.io/2020/11/15/Algorithms-for-Hyperparameter-Optimization/

https://velog.io/@suminwooo/%EB%AA%A8%EB%8D%B8-%ED%8A%9C%EB%8B%9D1

Bayesian Optimization 방법은 좋은 성능에 비해 느리다는 단점이 있다. 게다가 sequential하게 진행되는 거라 병렬처리도 어렵다.

이를 개선할 수 있는 방법으로 hyperband가 있으며 빠르며 좋은 성능을 보여준다. Hyperband는 Successive HAlving(SHA) 방법을 기반으로 한다.

1. SHA(Succesive HAlving Algorithm)

Bandit 기반의 하이퍼파라메터 최적화 기법이다. MAB(Multi Armed Bandit)문제를 해결하는데 두가지 방법이 있다. 

한가지는 가장 큰 보상을 찾는 팔을 찾는 법, 다른 하나는 Exploitation-Exploration trade-off를 해결하는 것이다. 

SHA는 전자인 Best Armed Identification에 기반을 두고 있다. 

SHA는 주오진 Budget안에서 hyperparamter 조합을 랜덤하게 선택하여 loss를 평가한다. budget을 늘려가면서 성능이 떨어지는 비율을 정해 hyperparameter조합을 제거해나가는 방법이다. 이 방법은 몇개의 hyperparamter로 시작하지, 어떤 구간에서 줄여나갈지를 정해줘야한다. 이를 개선한것이 hyperband알고리즘이다. 

2. hyperband 알고리즘

https://pod3275.github.io/paper/2019/05/23/Hyperband.html

https://simpling.tistory.com/52

https://repositorio.pucrs.br/dspace/bitstream/10923/15244/2/Bandit_Based_Automated_Machine_Learning.pdf