[DL] basic _딥러닝 기본

## 딥러닝(Deep Learning)
* 머신러닝의 일종
* 머신러닝과 달리 다양한 모델(알고리즘)에 대한 학습을 스스로 결정하고 학습해 나가서
좀 더 정확한 결과를 예측하는 학문/기술 분야
* 딥러닝의 예
    - 알파고 (기존의 바둑 기보 데이터들을 모두 학습하고 학습 결과를 통해서 스스로 알고리즘들을 도출해냄)


#딥러닝 기법
1. 앙상블 기법
    - 여러개의 기본 모델을 활용해서 하나의 새로운 모델을 생성해 내는 기법
    - 모델의 예측성능을 향상시키기 위해서 사용

    1) 보팅(Voting)
    - 서로 다른 알고리즘을 가진 분류기를 결합하는 방식
    - 하드보팅(Hard Voting)
       다수결의 원칙 기반, 예측 결과값을 다수 분류기가 결정한 예측값을 최종 보팅 결과값으로 선택함
    - 소프트보팅(SOFT VOTING)
    레이블값 결정 확률을 모두 더하고 평균을 내서 확률이 가장 높은 레이블값을 최종 결과값으로 선택함
    (각 분류기의 예측 결과에 대한 확률을 평균하여 가장 높은 확률을 가진 클래스를 선택)



    2) 배깅(Bagging:Bootstrap Aggregating)
    - 데이터를 재구성하여 다양한 모델을 만들어내는 앙상블 기법 중 하나
    - 의사결정트리처럼 과적합이 발생하기 쉬운 모델에서 사용(과적합 방지)
    - 랜덤포레스트는 배깅을 기반으로 한 모델로 여러개의 의사결정트리를 생성하고 그 결과를 조합하여 다양한 예측을 수행

    3) 부스팅(Boosting)
    - 이전 모델들이 잘못 예측한 데이터에 높은 가중치를 부여해서 학습하는 방법
    - Adaptive Boosting
        오분류된 데이터에 가중치를 부여하면서 부스팅을 수행
        이전 분류기의 오류를 보완하는 방식으로 새로운 분류기를 학습

    - Gradient Boosting (점진형 부스팅)
        이전 라운드에서 합성분류기 별 오류를 새로운 분류기로 학습
        경사하강법을 통해 오류를 최소화 하는 방법으로 모델 향상


## 딥러닝

1) 신경망(Neural Network)
    - 머신러닝 알고리즘 중 하나
    - 인간의 뇌 기능을 흉내내서 만들어짐
    - 입력층, 은닉층, 출력층으로 구분
    - 층을 점점 늘려서 깊게 만든 신경망을 심층신경망(Deep Neural Network)
    - 깊은  층을 가진 신경망의 가중치를 학습시키는 것을 딥러닝 또는 심층학습이라 함
    - AI > 머신러닝 > 딥러닝

2) 신경망으로 할 수 있는 것들
    - 분류
    - 회귀
    - 클러스터링
    - 이미지생성
    - 자연어처리
    - .....무한

3) 관련용어
    -GPU
    :그래픽 처리장치, 고성능 병렬처리를 위한 범용 연산장치
    - 셀프 수퍼바이즈러닝
    기계학습의 한 방법, 레이블이 없는 대규모 데이터셋을 사용해서 모델을 학습시키는 방법
    -BERT
    구글에서 개발한 자연어 처리 모델
    딥러닝의 자연어 처리뷴야에서 매우 중요한, 시초가 되는 모델
    이전의 모델은 텍스트를 단방향 방식으로 이용해서 처리했으나
    BERT는 양방향 방식을 도입한 첫번째 모델

    -인코더(Encoder)
    자연어 처리에서 주로 사용하는 구성요소 중 하나

    -퍼셉트론(perceptron)
    인공 신경망 모형의 하나
    프랑크 로젠크라트가 1957년 제안한 초기 형태의 인공 신경망
    다수의 신호를 받아서(input) 하나의 신호(output)을 출력
    뉴런의 수상돌기 축색돌기처럼 신호를 전달하는 역할을 퍼셉트론 가중치(weight)가 함
    가중치 :  각각의 입력 신호에 부여되어 입력신호와의 계산을 한 신호의 총합으로 정해진 임계값
            을 넘었을 때 1을 출력
    출력 = 활성화함수((입력1*가중치1)+(입력2*가중치2)+...(입력n*가중치n) + 편향)

4) 딥러닝 학습 포인트
    - 데이터 : 양질의 많은 데이터
    - 모델 : CNN, RNN, FNN, Transformer ...
    - 알고리즘: Gradient Descent(경사하강법)을 기초로 한 많은 알고리즘들...
    - 손실함수(Loss Function) : 모델의 성능에 대한 척도

5) 딥러닝 모델
    -CNN (Convloutional Neural Network)
    주로 이미지처리에 사용되는 딥러닝모델
    지역적인 패턴 및 공간적인 구조를 인식하기 위해서 컨볼루레이어를 사용
    이미지의 특징을 추출하기 위해 입력데이터에 여러 필터를 적용하고 이미지를 잘 이해할 수 있도록 설계되어 있음
    -RNN (Recurrent Neural Network)
    순차적인 데이터 처리에 사용되는 딥러닝 모델
    순환구조를 가지며, 이전 시간 단계의 출력을 현재시간 단계의 입력으로 사용
    시계열데이터, 자연어처리에 주요 사용
    -GAN(Generative Adversarial Network)
    생성모델 중 하나
    두 개의 신경망인 생성자(Generator)와 판별자(Discriminator)가 서로 대립하며 경쟁하는 구조를 따름
    생성자는 진짜와 구별할 수 없는 가짜 데이터를 만들려고 노력하고 판별자는 진짜 와 가짜를 더 정확하게 구별하게 된다.
    주로 이미지생성, 이미지감별, 이미지변환, 이미지편집에 사용

## 텐서플로우(Tensor Flow)
    구글에서 개발한 오픈소스 머신러닝 프레임워크
    그래프기반 계산, 다양한 플랫폼 지원, 높은 수준의 API를 제공(케라스API를 내장)

1) 텐서(Tensor)
    - Tensor multi dimentional array의 줄임말(다차원 배열)
    - 텐서플로우에서 사용하는 기본 데이터타입

2) 변수텐서(Variable Tensor)
    -가변성(Mutable)텐서
    -생성 후 내부 값 수정이 가능하고 모델의 가중치처럼
    훈련중에 업데이트 되어야 하는 값들을 나타내기 위해 사용
    - tf.Variable() 클래스를 사용하여 생성
    - 초기값과 데이터 타입을 지정할 수 있음
    - 변수텐서는 assign()메소드를 사용해 값을 변경할 수 있음

3) 상수텐서(Constant Tensor)
    - 불변성(Immutable Tensor)
    - 한 번 생성되면 내부값을 변경할 수 없음
    - 모델의 하이퍼파라미터나 고정된 상수 값을 나타내기 위해 사용함
    - 하이퍼파라미터(Hyper Parameter)
        : 원래 데이터에 있는 파라미터가 아닌 연산을 위해서 새로 생성된 파라미터

    - tf.constant()함수를 사용해서 생성

4) 넘파이 배열을 텐서 변환
    - 변수 = tf.convert_to_tensor(넘파이배열)

5) 리스트를 텐서 변환
    - 변수 = tf.convert_to_tensor(리스트)

6) 텐서를 넘파이 배열로 변환
    - 변수.numpy()

7) 텐서플로우 함수
    - tf.constant() : 상수 텐서를 생성하는 함수
    - tf.Variable() : 변수 텐서를 생성하는 함수
    - tf.add(): 두 텐서를 더함
    - tf.matmul(): 두 텐서의 행렬곱셈을 하는 함수
    - tf.zeros((행, 열)) : 모든 요소가 0인 텐서를 생성하는 함수
    - tf.ones((행, 열)): 모든 요소가 1인 텐서를 생성하는 함수
    - tf.fill((행, 열), 값) :  주어진 모든 요소를 값으로 채운 텐서를 생성하는 함수

8) 텐서의 속성
    - 차원(Dimension) : 배열의 축의 개수
                        스칼라(차원0), 1차원배열(차원1), 2차원배열(차원2), ....

    - 크기(shape): 각 차원의 요소 수
    - 데이터타입(data type): 요소들의 데이터 타입
    - 디바이스(Device): 텐서가 어떤 장치에서 저장되는지 (cpu, gpu...)
    - 텐서연산(operation) : 텐서 덧셈, 곱셈, 활성화함수적용...
    -

# 부스팅 기법
# boosting.py

def p(str):
    print(str, '\n')

# 라이브러리 로딩
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
from sklearn.metrics import accuracy_score

# iris데이터 로딩
iris = load_iris()
X = iris.data
y = iris.target

# 트레인, 테스트 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

## Adaptive Boosting

# estimator : 기본 분류기 지정 (기본값이 의사결정트리)
#                  max_depth : 트리 깊이
# n_estimators : 부스팅을 수행할 기본 분류기의 개수 (기본값 50)
ada = AdaBoostClassifier(
     estimator=DecisionTreeClassifier(max_depth=1), n_estimators=50
)
#p(ada)

# 모델 학습
ada.fit(X_train, y_train)

# 예측값
ada_pred = ada.predict(X_test)

# 정확도
ada_acc = accuracy_score(y_test, ada_pred)
p(ada_acc)


## Gradient Boosting

# n_estimators : 부스팅을 수행할 기본 분류기의 개수, 기본값 100
# learning_rate :
# 학습률, 기본값 0.1, 학습률이 작을수록 모델을 안정적으로 만들고 과적합을 줄일 수 있음
# max_depth : 트리의 최대 깊이, 기본값 3
gb = GradientBoostingClassifier(
    n_estimators = 365,
    learning_rate = 0.1,
    max_depth = 1
)
#p(gb)

# 모델 학습
gb.fit(X_train, y_train)

# 예측값
gb_pred = gb.predict(X_test)

# 정확도
gb_acc = accuracy_score(y_test, gb_pred)
p(gb_acc)


## 트리 시각화

# 라이브러리 로딩
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
import pandas as pd

# 데이터 로딩
iris = load_iris()

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 데이터프레임
df = pd.DataFrame(iris.data, columns=iris.feature_names)
#p(df)

# label 생성
df['label'] = [iris.target_names[x] for x in iris.target]

# 독립변수 / 종속변수
X = df.drop('label', axis=1)
y = df['label']

# 모델 생성
clf = DecisionTreeClassifier(
    criterion = 'entropy',
    splitter = 'best',
    max_depth = 3,
    min_samples_leaf = 5
)

# 모델 학습
clf.fit(X, y)

# 예측값 출력
p(clf.predict(X)[:3])

# 변수 중요도
for i, column in enumerate(X.columns):
    p(f'{column} 중요도 : {clf.feature_importances_[i]}')

# 정확도
p(f'정확도 : {clf.score(X, y)}')

# 시각화
plt.figure(figsize=(12, 8))
plot_tree(clf, feature_names=X.columns, class_names=clf.classes_)
plt.show()

# clf 정보 확인 함수
import numpy as np
def get_info(dt_model, tree_type='clf'):
    tree = dt_model.tree_
    # 분할에 사용된 기준
    criterion = dt_model.get_params()['criterion']
    # 트리 유형이 유효한지 확인
    # assert : 주어진 조건이 참이 아니면 AssertionError를 발생시킨(디버깅용으로 사용)
    assert tree_type in ['clf', 'reg']
    # 트리의 노드 수
    num_node = tree.node_count
    # 노드 정보를 저장할 리스트
    info = []
    # 트리의 각 노드 반복
    for i in range(num_node):
        # 각 노드의 정보를 저장할 딕셔너리
        temp_di = dict()
        # 현재 노드가 분할을 나타내는지 확인
        if tree.threshold[i] != -2: # -2:leaf node
            # 분할에 사용된 특징과 임계값 저장
            split_feature = tree.feature[i]
            split_thres = tree.threshold[i]
            # 분할 질문
            temp_di['question'] = f'{split_feature} <= {split_thres:.3f}'
            # 불순도와 노드에 포함된 샘플 수
            impurity = tree.impurity[i]
            sample = tree.n_node_samples[i]
            # 불순도와 샘플 수 저장
            temp_di['impurity'] = f'{criterion} = {impurity:.3f}'
            temp_di['sample'] = sample
            # 예측된 값(회귀), 클래스 확률(분류)
            value = tree.value[i]
            temp_di['value'] = value
            # 분류 트리의 경우 예측된 클래스 레이블 저장
            if tree_type == 'clf':
                classes = dt_model.classes_
                idx = np.argmax(value)
                temp_di['class'] = classes[idx]
        # 노드 정보를 리스트에 추가
        info.append(temp_di)
    return info

# 함수 실행
p(get_info(clf))

 

---

여기까지해서 의사결정 트리를 구분해보았습니다.

 

결과값

 

나중에 트리에 있는 값을을 꺼내고싶을떄 위 함수를 그대로 가지고 와서 써도 됩니다.

 

---

#GradientBoosting
gb = GradientBoostingClassifier(
    n_estimators=120,
    learning_rate=0.1,
    max_depth=1
)

#학습
gb.fit(X_train, y_train)

first = gb.estimators_[0][0]

plt.figure(figsize=(8,5))
plot_tree(first, filled=True, feature_names=iris.feature_names)
plt.show()

 

---

## 회귀나무

##회귀나무

# datasets 모듈을 사용해서 보스턴 주택가격 데이터 로딩
from sklearn import datasets

X, y = datasets.fetch_openml('boston', return_X_y=True)

#보스턴 주택가격 데이터
df = pd.DataFrame(X)
df['MEDV'] = y
p(df)

#독립변수, 종속변수 분리
X = df.drop('MEDV', axis=1)
y = df['MEDV']

# DecisionTreeRegressor
from sklearn.tree import DecisionTreeRegressor
reg = DecisionTreeRegressor(
    criterion = 'squared_error',
    splitter = 'best',
    max_depth= 3,
    min_samples_leaf= 10,
    random_state= 100
)

#학습
reg.fit(X, y)

#예측값
p(reg.predict(X)[:3])

#변수 중요도
for i, column in enumerate(X.columns):
    p(f'{column} 중요도: {reg.feature_importances_[i]}')

# 트리 시각화
plt.figure(figsize=(15, 12))
plot_tree(reg, feature_names=X.columns)
plt.show()

 

---

tensor basic