채린's datascience

트랜스포머

정의

트랜스포머: 셀프어텐션 사용(단어간 장거리 종속성과 문맥 관계를 포착할 수 있게 하는 어텐션) 아키택처에서 파생된 AI 모델이며 사람의 언어를 이해 및 생성

종류

Language Modeling은 NLP의 하위분야로 '자동 인코딩 작업'과 '자기회귀 작업' 두가지 모델링 작업이 있음.

• 자동인코딩: 알려진 어휘에서 문장의 어느 부분이든 누락된 부분을 채우도록 모델에 요청. 예시로는 BERT. 트렌스포머의 인코더 부분에 해당. 마스크 없이 양방향 표현을 생성. 문장 분류 또는 토큰 분류에 주로 사용됨.
• 자기회귀(Autoregressive Language): 알려진 어휘에서 주어진 문장의 바로 다음에 가장 가능성 있는 토큰을 생성하도록 모델에 요청. 예시로는 GPT. 트렌스포머 모델의 디코더 부분에 해당

특징

2017년에 나온 트렌스포머는 seq2seq 모델이었음. 

아래 두가지 요소를 가지고 있음.

• 인코더: 문장을 핵심구성 요소로 분리, 벡터화하고 어텐션을 이용해 텍스트 맥락을 이해(텍스트 이해가 뛰어남)
• 디코더: 수정된 형식의 어텐션을 사용해 다음에 올 최적의 토큰을 예측하고 텍스트 생성(텍스트 생성이 뛰어남)

이 둘을 사용하면 seq2seq 모델이 됨.

BERT는 인코더, GPT는 디코더만 있는 모델, T5는 둘을 조합한 모델.

1.1 LLM의 작동원리

사전훈련(pre-training)과 파인튜닝되는지에 따라 성능이 결정됨. LLM기반 모델들은 언어와 단어의 관계를 배우고 이해하려는 훈련을 받음. 

Pre-training은 모델을 사전에 학습하는 것임. 예를 들면, BERT는 영어 위키백과(영어버전의 위키백과로 수집된 기사들)와 BookCorpus(다양한 장르의 소설, 비소설로 검증된 저자에 의해 영어로 작성된 문서들)에서 사전훈련 되었음. 

또한, 두가지 모델로 학습되는데 '마스크된 언어모델링'(한 문장 안에서 토큰의 상호작용을 인식하도록)과 '다음문장예측'(문장들 사이에서 토큰이 서로 어떻게 상호작용하는지) 모델링 작업을 수행하는데 전자는 개별 단어 임베딩을 가르치기 위함이고 후자는 전체 텍스트 시퀀스를 임베딩하는 방법을 학습하기 위함.

전이학습(Transfer Learning)

LLM내에서 전이학습은 말뭉치에서 사전훈련한 LLM을 가져와 작업 특정 데이터로 모델의 파라미터를 업데이트함.

이미 특정 언어와 언어간의 관계를 사전에 학습해서 새로운 작업에 성능 향상을 가능하게 함.

비지도 학습으로 일반적인 개념을 가르치고, 지도학습으로 모델을 파인튜닝

파인튜닝(Fine-tunning)

특정 작업의 성능을 향상시키기 위한 조정

어텐션(Attention)

다양한 가중치를 다르게 할당하는 메커니즘. 가장 중요한 정보를 강조 가능해짐. 

위 설명을 요약하자면, 

LLM은 큰 말뭉치에서 사전훈련되고 작은 데이터셋으로 파인튜닝됨. 트랜스포머는 고도의 병렬처리가 가능하여 빠르며 토큰 간의 장거리 의존성과 관계를 어텐션을 사용해서 포착 가능함. 특히, 어텐션이 Internal world model과 사람이 식별할 수 있는 규칙을 학습하는데 가장 주요한측면으로 보여지고 있음.

임베딩(Embedding)

단어, 구절, 토큰의 수학적 표현

토큰 임베딩(토큰의 의미를 임베딩), 세그먼트 임베딩, 위치임베딩(위치를 임베딩)등 여러 종류의 임베딩이 존재함.

텍스트가 토큰화되면 각 토큰에 임베딩이 주어지고 그 값들이 더해짐. 어텐션이 계산되기 전에 초기 임베딩을 갖게됨.

토큰화(Tokenization)

텍스트의 가장 작은 이해단위인 토큰으로 분해하는 과정

LLM에서는 전통적인 NLP에서 사용한 불용어제거, 어간추출, 잘라내기 등과 같은 것들이 필요하지 않음. 

out-of-vocaburary(OVV)구문을 어떻게 처리하나? 일단 더 작은 부분의 단어로 나눔. 

1.2 가장 많이 활용되는 LLM

BERT, T5(Google), GPT(OpenAI)은 트렌스포머 기반 아키텍쳐

BERT(Bidirectional Encoder Representation from Transformers)

문장의 양방향 표현을 구성하기 위해 어텐션 메커니즘을 사용하는 자동 인코딩 모델

문장 분류와 토큰 분류 작업에 이상적. 

Bidirectional: 자동 인코딩 언어 모델

Encoder: 트랜스포머에서 인코더만 활용

Representation: 어텐션을 활용

Transformers: 트랜스포머의 아키텍처를 활용

생성에 중점을 둔 느린 LLM에 비해 빠르게 처리 가능. 자유로운 텍스트 처리보다 대량의 말뭉치를 빠르게 분석하고 작업하는데 적합. 문서 분류나 요약보다는 사전훈련된 모델로 활용함.

GPT-4와 ChatGPT(Generative Pre-trained Transformers)

어텐션 메커니즘을 사용한 자기회귀 모델

텍스트 생성에 활용. 

Generative: 자기 회귀 언어 모델

Pre-trained: 디코더는 거대 말뭉치에서 학습

Transformers: 트랜스포머의 아키텍처를 활용

한번에 하나의 토큰을 생성하는데 뛰어남. 큰 문맥 윈도우를 주었을때 텍스트를 생성하는데 적합. 

T5(Text-to-Text Trsansfer Transformers)

텍스트 분류, 요약 및 생성하는 인코더/디코더 트랜스포머 모델

Text-to-Text: 시퀀스 투 시퀀스 모델

Transfer: 전이학습을 이용

Transformer: 인코더, 디코드를 모두 활용한 순수 트랜스포머

텍스트 처리와 이해하는 능력 그리고 생성까지 모두 필요로한 어플리케이션에 유용하며

GPT-3도 이러한 능력을 보유함. 

1.3 도메인 특화 LLM

domain-specific LLM은 특정 도메인에서 언어와 개념을 이해하기 위해 설계됨. (예시: 생물 의학 무넌에 사전 훈련된 BioGPT) 당연한 얘기지만 특정 도메인을 잘 이해하는거만큼 일반 LLM은 특정 도메인의 언어를 이해하는데 모자람이 있을 것임. 

1.4 LLM을 이용한 어플리케이션

• 사전 훈련된 LLM으로 파인튜닝없이 기본 처리 하기
• 전이학습을 사용해 사전 훈련된 LLM을 파인튜닝 하기
• 사전 훈련된 LLM에 작업 요청하기

https://light-tree.tistory.com/196

https://velog.io/@hwanee/%EB%85%BC%EB%AC%B8-%EB%A6%AC%EB%B7%B0-On-Calibration-of-Modern-Neural-Network

* 위 블로그 내용을 참고하여 정리한 글임.

Calibration이란?

The accuracy of predicted probability of model's ouput

예를 들어, 모델이 50% 정도의 신뢰도를 가지고 output을 줬을때, 그 output이 제대로 classification 된 정도가 실제로 50%가 된다면 모델은 잘 calibrated 되었다고 말함.

이는 모델의 예측값이 reliable and trustworthy 하다는 것을 뜻하기 때문에 매우 중요한 요소로 쓰임.

학습된 모델이 실제 얼마나 신뢰도를 가지는지를 판단하기 위함.

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

요약

• 산포도&상관계수확인: 산포도 확인 후 상관계수 절대값 0.8 이상 다중공선성이 있음으로 간주함
• torelence 확인: 하나의 독립변수를 Y, 나머지 독립변수의 조합을 X로 했을때, R^2를 계산후 torelence가 0에 가까운 값인지 확인함(torelence란 1-R^2, R^2 = 1인 경우, torelence = 0, 0인경우 다중공선성 심각)
• 분산팽창지수(VIF:Variance Inflation Factor, VIF = 1/torelence): 일반적으로 연속형변수에서 10이상이면 다중공선성 있음으로 간주, 더미변수는 3이상이면 다중공선성으로 간주함.
• 상태지수(Condition Index): 100 이상인 경우, 다중공선성 간주하지만 잘 사용되지 않음.

다중공선성 문제 해결하기

• 다중공선성이 큰 변수가 유의미한가? R^2값이 매우 팽창하였음에도 불구하고 유의미하다는 것은 그 자체로 매우 유의미함을 의미함 => 일반적으로 제거하지 않음
• 해당변수를 제거? 데이터입력시 변수를 잘못 구성함. 무작정 제거하지 않음
• 주성분분석으로 변수를 재조합
• 다중공선성이 발생한 변수를 합침:다중공선성이 높은 변수들은 비슷함을 의미하여 평균값으로 대체하기도 함

선형회귀분석 (statsmodels.OLS regression) result로 다중공선성 확인하기

import statsmodels.api as sm

lm = sm.OLS(train_y, train_x)
result = lm.fit()
print(result.summary())

Reference

https://ysyblog.tistory.com/171

https://ysyblog.tistory.com/119

https://bkshin.tistory.com/entry/DATA-20-%EB%8B%A4%EC%A4%91%EA%B3%B5%EC%84%A0%EC%84%B1%EA%B3%BC-VIF

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

• 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

특성 자동 선택

• 유용한 특성만 선택하고 나머지는 줄이는 방향이 좋음
• 특성 선택 방법 : 일변량 통계, 모델 기반 선택, 반복적 선택

1. 일변량 특성선택 

타겟과 변수간의 통계적 의미를 기반으로 유의미한 변수 선택

• chi2: 카이제곱 검정 통계값
• f_classif: 분산분석(ANOVA) F검정 통계값
• mutual_info_classif: 상호정보량(mutual information)

단일 변수 선택법은 각각의 독립변수를 하나만 사용한 예측모형의 성능을 이용하여 가장 분류성능 혹은 상관관계가 높은 변수만 선택하는 방법이다. 사이킷런 패키지의 feature_selection 서브패키지는 다음 성능지표를 제공한다.

하지만 단일 변수의 성능이 높은 특징만 모았을 때 전체 성능이 반드시 향상된다는 보장은 없다.

아래 일변량 변수선택 예제이다. 

from sklearn.feature_selection import SelectPercentile

# SelectPercentile을 사용하여 특성의 50%를 선택하는 모델 생성
select = SelectPercentile(percentile=50)

# 특성 선택
select.fit(X_train, y_train)
X_train_selected = select.transform(X_train)

feature_selection 서브패키지는 성능이 좋은 변수만 사용하는 전처리기인 SelectKBest 클래스도 제공한다. 

from sklearn.feature_selection import chi2, SelectKBest


%%time

selector1 = SelectKBest(chi2, k=14330)
X_train1 = selector1.fit_transform(X_train, y_train)
X_test1 = selector1.transform(X_test)

model = BernoulliNB()
model.fit(X_train1, y_train)
print("train accuracy:{:5.3f}".format(accuracy_score(y_train, model.predict(X_train1))))
print("test accuracy :{:5.3f}".format(accuracy_score(y_test, model.predict(X_test1))))

2. 모델 기반 특성선택

• 지도 학습 머신러닝 모델을 사용하여 특성의 중요도를 평가, 가장 중요한 것만 선택 (최종학습과는 무관함, 모델이 같을 필요 없음)
• 해당 모델은 각 특성의 중요도를 측정하여 순서로 매길 수 있어야 함
• 결정트리 기반의 모델들은 각 특성의 중요도를 featureimportances에 저장하므로 이를 활용할 수 있음

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier

# (지도 학습 모델로 계산된) 중요도가 지정한 임계치보다 큰 모든 특성 선택하는 모델제작
# 절반 가량의 특성이 선택될수 있도록 중간값을 임계치로 사용
select1 = SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=0),
                         threshold='median')

# 특성 선택
select1.fit(X_train, y_train)
X_train_selected1 = select1.transform(X_train)

3. 반복적 특성선택

• 특성을 하나도 선택하지 않은 상태로 시작해 어떤 종료 조건을 도달할 때까지 하나씩 추가하는 방법
• 모든 특성을 가지고 시작해 어떤 종료 조건이 될 때까지 하나씩 제거하는 방법
• 두 가지 방법 중 하나를 활용해 특성을 결정한다.

from sklearn.feature_selection import RFE

# 특성 선택
select2 = RFE(RandomForestClassifier(n_estimators=100, random_state=0),
             n_features_to_select=40)

# 특성 선택
select2.fit(X_train, y_train)
X_train_selected2 = select2.transform(X_train)

reference: https://inuplace.tistory.com/618

https://datascienceschool.net/03%20machine%20learning/14.03%20%ED%8A%B9%EC%A7%95%20%EC%84%A0%ED%83%9D.html

https://dyddl1993.tistory.com/18

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/