• 인공신경망은 손실 함수를 통해 자신의 파라미터를 검증한다.
• 특정 파라미터를 통해 나온 손실함수 값이 가장 낮은 곳이 최적의 파라미터이다.
• 경사하강법은 비용 함수를 최소화하는 매개변수를 찾기 위해 사용되는 알고리즘이다.
• 한마디로, 주어진 함수에서 극소점을 찾기 위해 기울기(gradient)가 최소가 되는 지점을 찾아가는 방법이다.

✅ gradient descent 비유

gradient descent는 등산을 할 때 정상에서 하산 할때에 많이 비유를 하곤 한다. 특히 우리가 앞이 보이지 않는 안개가 낀 산을 하산을 할때 모든 방향으로 더듬어 보며 비탈길의 경사가 가파른 방향으로 내려갈 것이다.

여기서 산 비탈길의 기울기가 그래프의 기울기로 보면 된다. 이 기울기가 감소하는 즉, gradient 가 descent 하는 방향으로 최적의 값을 찾는 방향으로 학습이 진행된다. 각 지점에서 gradient를 구하기 위해서는 각 점의 순간 변화량을 뜻하는 미분값을 알아야 한다.

📌gradient descent 수식 유도

• 2차 함수 그래프에서 최초 랜덤 위치에서 시작한다고 가정했을 때, 다음 지점은 어디로 가야 하는지에 대한 수식을 유도한다
• 현재 지점에서 기울기를 먼저 구한 뒤
• 기울기가 양수인지 음수인지를 판단하고,
• 둘째로 얼마큼 이동할 것 인가(step size)를 정한 뒤 이동
• 위 그림에서 해당 지점의 기울기가 음수일 때는 양의 방향으로 , 양수일 경우는 음의 방향으로 이동하면 함수의 극소점을 찾을 수 있다.
• 얼마만큼 이동할 것인가에 대한 부분인 step size는 α로 많이 표현을 한다.

  [gradient descent 수식]

  
• xᵢ번째 에서의 기울기에 α 인 step size를 곱하고 기울기의 부호의 반대로 움직임으로써 마이너스 기호를 사용하여 xᵢ 번째에서 xᵢ₊₁번째로 이동을 하는 것

📌 경사하강법 순서

1. 임의의 매개변수_를 정해 비용함수의 시작지점(x축_)으로 지정.
2. 해당 매개변수로** 모델의 오차**_를 구한 후, 비용함수의 시작지점(y축_)으로 지정.
3. 시작 지점에서 다음 지점으로 갈 방향을 정하기 위해, 시작 지점의 기울기를 계산.
4. 기울기(Gradient)와 보폭(Learning rate)을 사용해 다음 지점으로 이동.
5. 위 과정을 _최소값_에 도달할 때까지 반복.

💡경사 하강법의 문제점

1. 적절한 학습률 (Learning Rate)

• 학습률과 기울기 정보를 혼합해 나아갈 방향과 거리를 결정한다.
• 학습률이 높으면 한번에 이동하는 거리가 커지므로 최적값에 빨리 수렴할 수 있다.
• 그러나 너무 크게 설정하면 최적값에 수렴하지 못하고, 다른 곳으로 발산하는 현상이 나타날 수 있다.
• 반대로, 학습률이 낮으면 최적값에 수렴하는 시간이 오래 걸릴 수 있다.
• 적절한 learning rate값을 찾는 것이 중요하다.

2. local minimum

• Global minimum을 목표로 해야하지만 local minimum에 빠지는 경우 탈출하지 못하고 그 점으로 수렴해버릴 수 있다.
• local minima에서 탈출하기 위한 방법으로 momantum이나 stocastic gradient descent와 같은 여러 방법이 존재한다

출처 https://hi-guten-tag.tistory.com/205 https://dotiromoook.tistory.com/25

CNN의 Layer 유형 3가지

• Convolution Layer
• Pooling Layer
• Fully Connected Layer

Stride

• Stride는 입력 이미지에서 필터를 몇 칸 씩 건너 뛰며 적용할지를 의미.
• Stride = 1, 한칸씩 건너뛰며 필터 적용
• (n,n) 이미지에 대해 p만큼 Padding한 후, (f,f) 필터로 s만큼 Stride하며 Convulution한다면,
• 출력 이미지의 크기는 ((n+2p-f)/s+1, (n+2p-f)/s+1)이 된다.

Pooling Layer

• CNN에는 Convolution layer 외 Pooling layer가 존재한다.
• 풀링은 네티워크의 복잡성과 계산 비용을 줄일 수 있다.

  [풀링의 2가지 유형]

1. Max Pooling
2. Average Pooling

1. Max Pooling

• 입력 이미지를 필터 크기만큼의 여러 영역으로 나눈 후,
• 이미지 위에서 필터를 이동하며, 필터 영역 내에서 최대값을 뽑으며 진행된다.
• Max Pooling은 이미지에서 중요한 정보를 잡아놓는데 도움이 된다.
  • 아래 그림) (4,4)이미지에 대해 (2,2) 필터로 2만큼 stride하며 Max Pooling.

2. Average Pooling

• 입력 이미지를 필터 크기만큼의 여러 영역으로 나눈 후,
• 이미지 위에서 필터를 이동하며, 필터 영역 내에서 평균값을 뽑으며 진행된다.
• Average Pooling은 이미지에서 중요한 정보와 덜 중요한 정보를 균형있게 잡아놓는데 도움이 된다.
  • 아래 그림) (4,4)이미지에 대해 (2,2) 필터로 2만큼 stride하며 Average Pooling.

풀링 연산의 장점

• 잡음 처리
• 지나치게 상세한 특징 맵에서 요약 통계 추출
  • 특징 맵 축소됨. ⇒ 속도 up, 메모리 효율

풀링층 특성

• 학습할 매개변수 없음.
  • 단지 최대/평균 연산이기 때문
• 특징 맵의 수가 그대로 유지됨.
  • 특징 맵마다 독립적 연산 적용
• 작은 이동에 둔감하다.
  • 물체 인식, 영상 검색 등에 용이

출처 https://wooono.tistory.com/234

독립 변수 간 상관관계가 매우 높을 때, 하나의 독립변수의 변화가 다른 독립변수에 영향을 미쳐 모델이 불안정해지는 것을 의미한다.

Reference https://velog.io/@jkl133/%EB%8B%A4%EC%A4%91%EA%B3%B5%EC%84%A0%EC%84%B1%EA%B3%BC-MLDL-problems

• 신경망이 훈련 데이터에만 지나치게 적응되어, 그 외 데이터에는 제대로 대응하지 못하는 상태.
• 이는 모델이 훈련 데이터의 노이즈까지 학습하여 발생한다.

과적합을 막는 방법들

1. 데이터 증식 (Data augmentation)

• 모델은 데이터의 양이 적을 경우, 데이터의 특정 패턴, 노이즈까지 쉽게 암기하기 때문에 과적합이 발생할 확률이 높다.
• 데이터의 양을 늘려 학습 데이터의 다양성을 높이는 방법이 있다.
• 하지만 실제 데이터의 양을 늘리는 것엔 한계가 있다.
• 의도적으로 기존의 데이터를 변형,추가 하는 data augmentation 방법을 이용한다.
  • 이미지를 돌리거나, 노이즈 추가, 일부 수정 등

2. 모델 복잡도 줄이기

• 인공 신경망의 복잡도는 은닉층(hidden layer)의 수, 매개변수 수 등으로 결정된다.
• 따라서 네트워크의 층 수, 뉴런 수를 줄여 모델의 복잡도를 낮춘다.

  인공 신경망에서는 모델의 매개변수의 수를 모델의 수용력(capacity)라고도 한다.

3. 가중치 규제 (Regularization)

• 가중치에 규제를 적용하여 네트워크의 복잡도를 줄인다.
  • L1 규제와 L2 규제가 대표적
• L1 규제 : 가중치 w들의 절대값 합계를 cost function에 추가
• L2 규제 : 모든 가중치 w들의 제곱합을 cost function에 추가

4. 드롭아웃 (Dropout)

• 학습 과정에서 일부 뉴런을 무작위로 비활성화하여 네트워크의 복잡도를 줄인다.
• 예를 들어, 드롭아웃 비율을 0.5로 설정하면, 학습마다 랜덤으로 절반의 뉴런을 사용하지 않는다.
• 드롭아웃은 신경망 학습 시에만 사용하고, 예측 시에는 사용하지 않는다.
  • 학습 시에는 인공 신경망이 특정 뉴런, 조합에 너무 의존적이게 되는 것을 방지해줌.
  • 매번 랜덤으로 뉴런을 사용하지 않으므로 -> 서로 다른 신경망들을 앙상블해 사용하는 것과 같은 효과를 내어 과적합을 방지한다.
• 드롭아웃 코드 예제

  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import Dropout, Dense
  

max_words = 10000 num_classes = 46

model = Sequential() model.add(Dense(256, input_shape=(max_words,), activation='relu')) model.add(Dropout(0.5)) # 드롭아웃 추가. 비율은 50% model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) # 드롭아웃 추가. 비율은 50% model.add(Dense(num_classes, activation='softmax'))

```

출처 https://wikidocs.net/61374 책 <밑바닥부터 시작하는 딥러닝>, <딥러닝을 이용한 자연어 처리 입문> https://deep-learning-study.tistory.com/167

Bias-Variance trade-off 란, 모델링 할 때 error 처리를 위해 중요하게 알아야하는 개념이며, 자주 헷갈릴 수 있다.

Bias (편향)

• 편향은 예측값과 실제값의 차이다.
• 편향이 크다는 것은 예측값-실제값 차이가 크다는 것
  • 이는 "과소적합"을 의미한다.

Variance (분산)

• 분산은 입력에 따른 예측값의 변동성을 의미한다.
• 분산이 크다는 것은 입력에 따른 예측값의 변동성이 크다는 것
  • 이는 "과대적합"을 의미한다.

Trade-off

• Trade-off는 시소처럼 한쪽이 올라가면 한쪽이 내려가는 관계를 의미한다.

[예제 1]

• 파란 점 : 예측값 빨간 원 : 실제값
• Bias가 높다는 것
  • 예측값-실제값의 오차가 크다는 것 -> "과소적합"
• Variance가 높다는 것
  • 예측값의 변동성이 크다는 것 -> "과대적합"

[예제 2]

• 왼쪽 그래프 : 큰 bias, 작은 variance
• 오른쪽 그래프 : 작은 bias, 큰 variance

bias 관점

• 왼쪽 그래프의 예측값-실제값 차이는 오른쪽 그래프보다 큼 -> "큰 bias"
• 오른쪽 그래프의 예측값-실제값 차이는 0이다 -> "작은 bias"

  variance 관점

• 왼쪽 그래프는 일반화가 잘 되어 있음 -> 예측값이 일정한 패턴 -> "작은 variance"
• 오른쪽 그래프 : 예측 값이 불규칙 패턴 -> "큰 variance"

[예제 3]

• 모델을 학습 시킬수록 모델의 복잡도는 더 올라간다.
• 그래프의 X축 : 모델 복잡도(model complexity)
• 모델이 단순해질수록, Bias 증가▲, Variance 감소▼
• 모델이 복잡해질수록, Bias 감소▼, Variance 증가▲
• 전체 Error는 Bias와 Variance 간의 Trade-off 관계 때문에, 계속 학습 시킨다고 해도 쉽게 줄어든지 않는다.
• 즉, 무조건 Bias만 줄일 수도, 무조건 Variance만 줄일 수도 없기 때문에, Bias와 Variance의 합이 최소가 되는 적당한 지점을 찾아 최적의 모델을 만들어야한다.

출처 https://wooono.tistory.com/220

• Feature selection은 모델링 시 raw data의 모든 feature를 사용하는 것은 computing power와 memory 측면에서 매우 비효율적이기 때문에
• 일부 필요한 feature만 선택하는 방법ㅣ다.
• 유사하지만 다른 표현의 3가지 feature 처리
  • Feature Engineering : 도메인 지식을 사용하여 데이터에서 피쳐를 변형/생성
    • "feature를 어떻게 유용하게 만들 것인가"
  • Feature Extraction : 차원축소 등 새로운 중요 피쳐를 추출
  • Feature Selection : 기존 피쳐에서 원하는 피쳐만 (변경하지 않고) 선택
    • "유용한 feature를 어떻게 선택할 것인가"
• Feature Selection의 장점
  • 사용자가 해석하기 쉽게 모델을 단순화
  • 훈련 시간의 축소
  • 차원의 저주 방지
  • 일반화

어떤 방법론을 사용할 것인가?

• 시간과 자원이 충분하다면 모든 방법을 테스트하여 구하고자 하는 score가 높은 feature subset을 사용하면 된다.
• 현실적 한계 때문에, 평가 메트릭에 따라 적합한 방법을 사용하는 것이 좋다.

  [Feature Selection의 방법론 3가지]

1. Filter Method : Feature 간 관련성을 측정하는 방법
2. Wrapper Method : Feature Subset의 유용성을 측정하는 방법
3. Embedded Method : Feature Subset의 유용성을 측정하지만, 내장 metric을 사용하는 방법

1. Filter Method : 높은 상관관계 이용

• 통계적 측정 방법으로 피처 간 상관관계를 알아내, 높은 상관계수(영향력)를 가지는 피처를 사용하는 방법
• 하지만 상관계수가 높다고 모델에 적합하다 판단은 금물

  [Filter Method 방법들]

  • information gain
  • chi-square test (카이제곱)
  • fisher score
  • correlation coefficient
    • 흔히 correlation heatmap으로 시각화
  • variance threshold

2. Wrapper Method : 예측 정확도 이용

• 예측 정확도 측면 가장 좋은 성능을 보이는 Feature subset(피처 집합)을 뽑아내는 방법
• 이 경우, 기존 데이터에서 테스트 진행할 hold-out set을 따로 두어야 하며
• 여러번 실험을 통해 시간과 비용이 높게 발생하지만
• 최종적 Best Feature Subset을 찾기 때문에 모델 성능에는 아주 도움이 됨.

  [Wrapper Method 방법들]

• • 1. Forward Selection(전진 선택)
• • • 변수가 없는 상태로 시작
    • 반복 마다 가장 중요한 변수를 추가하여 더이상 성능 향상이 없을 때까지 반복
• • 2. Backward Selection(후방 제거)
• • • 모든 변수를 갖고 시작
    • 가장 덜 중요한 변수를 하나씩 제거하며 더 이상 성능 향상 없을 때까지 반복
• • 3. Stepwise Selection(단계별 선택)
• • • Forward Selection + Backward Selection 결합
    • 모든 변수를 갖고 시작
    • 도움 안되는 변수 삭제 하거나, 모델에서 빠져있는 변수 중 가장 중요한 변수 추가
    • 반대로 변수 없이 시작하여 변수 추가 삭제 반복할 수도 있음.

3. Embedded Method

• Filtering + Wrapper의 장점 결합
• 각각 Feature 직접 학습하며, 모델의 정확도에 기여하는 Feature를 선택
• 계수가 0이 아닌 Feature가 선택되어, 더 낮은 복잡성으로 모델을 훈련하며, 학습 절차 최적화

  [Embedded Method 방법들]

• LASSO : L1-norm을 통해 제약 주는 방법
• Ridge : L2-norm을 통해 제약 주는 방법
• Elastic Net : 위 둘을 선형 결합한 방법
• SelectFromModel
  • decision tree 기반 알고리즘에서 피처를 뽑아오는 방법
  • RandomForest, LightGBM 등

Reference https://wooono.tistory.com/249 https://subinium.github.io/feature-selection/ https://firework-ham.tistory.com/48

밑의 데이터는 외출 활동이 좋은지 아닌지 분류하는 모델을 만들고자 할때, 날씨 데이터의 Feature가 101가지로 들어온 데이터다. 이는 101차원의 데이터와 같은 의미다.

고차원 데이터는 계산과 시각화의 어려움으로 분석이 힘들어진다. 원 데이터의 분포를 가능한 유지하며 데이터의 차원을 줄이는 것이 _차원 축소(dimensionality reduction)_이다.

"다중 공선성 문제"

강한 상관관계를 가지는 몇몇 feature들을 함께 학습 시킬 경우, 모델의 과적합이 발생하여 성능이 저하될 수 있다.

이를 방지하기 위해 feature를 선택/가공하는 과정을 거친다. (3가지)

1) Feature Selection : 필요한 feature만 선택. 2) Feature Extraction : 작은 차원으로 feature를 mapping한다. 차원 축소 기법들 -> PCA, LDA, SVD, NMF 등. 3) Feature Engineering : feature가 부족할때, 모델의 기능 활용 목적에 따라 새로운 feature들을 생성하는 것.

2. 주성분 분석 PCA (Princial Component Analysis)

여러 피쳐들이 갖는 정보들을 하나로 압축한다.

위 그래프 중 (습도,강수량) or (풍속,태풍여부)는 각각 밀접한 연관성이 있다. 이러한 연관성이 높은 피처들을 하나로 합쳐주는 작업을 뜻한다.

Reference (코드) https://huidea.tistory.com/44

Abstract

• 많은 오디오 녹음에는 배경 소음, 매우 짧은 간격 및 클립의 급격한 변화가 있기 때문에,

  짧은 audio clips을 통해 특징을 추출하고 다양한 소리를 분류하는 것은 쉽지 않다.

• possibility of overfitting의 위험을 피하기 위해 training samples 수는 많을 수록 좋다.

• 따라서, data aumentation이 필요 → 더 많은 training samples 제공 + 모델의 정확도와 성능 높일 수 있다.

• 본 연구에서 제안하는 방법론은 학습의 성과를 향상시키기 위한 의미 있는 data aumentation의 아이디어를 포함한다.

• 의미 있는 data augmentation과 함께 CNN을 사용하여 환경 소리 분류를 기반으로 하는 spectral images의 효과적인 접근 방식을 제안한다.

• 접근 방식

  • 스펙트로그램 이미지의 형태로 오디오 클립의 기능을 정의한다.

• 이미지에 사용 가능한 data augmentation을 사용하는 대신, 오디오 클립에 직접 적용되는 variations을 고려하여 의미 있는 data augmentation을 제안한다.

• Result

  • The ResNet-152 model
    • ESC-10 data set : 99.04%
    • Us8k data set : 99.49%
  • DenseNet-161 model
    • ESC-50 data set : 97.57%

        _→ ESC-50 data set에서 이전에 발표된 모든 방법 중 최고의 정확도를 보여주었다._

• 개선 : 의미 있는 data augmentation로 정확도를 향상시켰다.

Intro

• Mel spectrogram 기능을 사용하여, 스펙트로그램 이미지 형태로 오디오 클립의 기능을 정의.
• spectral images는 오디오 신호에 대한 주파수 스펙트럼의 visible representation으로 볼 수 있음.
• spectral images의 장점
  • the audio signals are less periodic
  • weak ambiance
  • short interval
  • the addition of noise on audio signals is much easy as compared with images
• Data set.
  • Environment Sound Classification Data
    • ESC-10
    • ESC-50
    • Urbansound8k (Us8k)

Methodology

• the classification of sounds from the environment after converting the audio clips into spectrogram images.
• Model : DCNN, transfer learning models

2 approaches

1. M1 ) TAA (Traditional Augmentation Approach)

• traditional method available for various image-based training tasks

• used Kera’s package
• respective values
  • Zoom range: 0.25
  • Width shift: 0.20
  • Fill mode: nearest
  • Brightness range: [0.5,1.5]
  • Rotation angle: 30
  • Height shift: 0.20
  • Shear range: 0.30
  • Horizontal flip: True

*1. M2 ) NAA (Novel Augmentation Approarch) *

• classification of different sounds by using spectrogram images

• 학습을 위해 generated audio clips는 Mel-spectrogram images로 변환.
• used Librosa library

[ 5 Transformation ]

1) Pitch shift transformation.

• Positive pitch shift (PPS)

  • 양의 피치 이동 (+2)

• Negative pitch shift (NPS)

  • 음의 피치 이동 (-2)

• code

    import numpy as np
    def manipulate(data, sampling_rate, shift_max, shift_direction):
        shift = np.random.randint(sampling_rate * shift_max)
        if shift_direction == 'right':
            shift = -shift
        elif self.shift_direction == 'both':
            direction = np.random.randint(0, 2)
            if direction == 1:
                shift = -shift
        augmented_data = np.roll(data, shift)
        # Set to silence for heading/ tailing
        if shift > 0:
            augmented_data[:shift] = 0
        else:
            augmented_data[shift:] = 0
        return augmented_data

2) Time stretches transformation.

• Slow time stretches (STS)

  • slow down by the factor of (0.7)

• Fast time stretches (FTS)

  • fast by the value of (1.20)

• code

  import librosa
  
  def manipulate(data, speed_factor):
      return librosa.effects.time_stretch(data, speed_factor)

3) Trim silence.

• Trim silence (TS)

  • trail or trim the silence signal

• code

    from scipy.io.wavfile import read, writedef remove_silence(file,sil,keep_sil,out_path):
        '''
        This function removes silence from the audio.
  
        Input:
        file = Input audio file path
        sil = List of silence time slots that needs to be removed
        keep_sil = Time to keep as allowed silence after removing silence
        out_path = Output path of audio file
  
        returns:
        Non - silent patches and save the new audio in out path
        '''
        rate,aud=read(path)
        a=float(keep_sil)/2
        sil_updated=[(i[0]+a,i[1]-a) for i in sil]
  
        # convert the silence patch to non-sil patches
        non_sil=[]
        tmp=0
        ed=len(aud)/rate
        for i in range(len(sil_updated)):
            non_sil.append((tmp,sil_updated[i][0]))
            tmp=sil_updated[i][1]
        if sil_updated[-1][1]+a/2<ed:
            non_sil.append((sil_updated[-1][1],ed))
        if non_sil[0][0]==non_sil[0][1]:
            del non_sil[0]
  
        # cut the audio
        print('slicing starte')
        ans=[]
        ad=list(aud)
        for i in tqdm.tqdm(non_sil):
            ans=ans+ad[int(i[0]*rate):int(i[1]*rate)]
        #nm=path.split('/')[-1]
        write(out_path,rate,np.array(ans))
        return non_sil

Results

< CNN >

Result 1) 7계층 제안 CNN 아키텍처에 대한 학습 정확도 대 검증 정확도 결과

• Data set.
  • (a), (b) : ESC-10
  • (c), (d) : ESC-50
  • (e), (f) : Us8k

Result 2) 9계층 제안 CNN 아키텍처에 대한 학습 정확도 대 검증 정확도 결과

• Data set.
  • (g),(h) : ESC-10 관련
  • (I),(j) : ESC-50
  • (k),(l) : Us8k

[The performance comparison of NAA with TAA by using 7- & 9-layers CNN]

< Transfer learning models >

[Comparison of the accuracies of Transfer learning models]

• ESC-50 data set에서 이전에 발표된 모든 방법 중 97.57%로 최고의 정확도를 보여주었다.
• (나머지 data도 동일하게 정확도가 훨씬 높다.)

[The performance comparison of NAA with TAA by using Transfer learning models for the ESC-50 dataset.]

• The distinct pre-trained weights : (ResNet, DenseNet, AlexNet, SqueezeNet, VGG)

• DenseNet-161 model의 NAA는 가장 lowest loss value (0.0835)를 달성하였다.

  → 이 또한 ESC-5 data의 모든 방법론 중 가장 높은 정확도를 달성

[기존 연구와 NAA 비교]

• NAA가 압도적으로 높은 정확도를 보이고 있다.

• augmentation techniques를 사용한 다양한 예측 알고리즘, CNN, transfer learning models들은 overfitting 문제를 극복하지 못하고 광범위한 불균형을 초래한다.
• 이 문제를 해결할 수 있는 방법 중 하나는 정규화와 의미 있는 augmentation이다.

Refernce

PDF

Spectral images based environmental sound classification using CNN.pdf

Posters

data augmentation

https://kr.mathworks.com/help/audio/ref/stretchaudio.html

http://kth.diva-portal.org/smash/get/diva2:1381398/FULLTEXT01.pdf

https://medium.com/@makcedward/data-augmentation-for-audio-76912b01fdf6

https://www.semanticscholar.org/paper/Pitch-shifting-algorithm-design-and-applications-in-Royer/e48cb1a41912a3caf7af7f078df17fb6f8884796

https://onkar-patil.medium.com/how-to-remove-silence-from-an-audio-using-python-50fd2c00557d

kaggle : https://www.kaggle.com/code/CVxTz/audio-data-augmentation/notebook

spectrogram

https://towardsdatascience.com/data-augmentation-for-speech-recognition-e7c607482e78

predict() 메소드는 범주를 예측하여 반환하고, predict_praba() 메소드는 확률(probability)을 반환합니다.

## prediction for test set
y_pred = clf.predict(X_test) # class
y_pred_proba = clf.predict_proba(X_test) # probability

1) predict(test) predict의 경우, 각각 모델의 최종 예측값 출력 ex) 회귀 모델 : 0.3456... 특정 값 출력 분류 모델 : 0,1,2,3 등 가장 확률 높은 클래스 출력

2) predict_proba(test) 분류 모델이 각 클래스에 대한 확률을 출력 (회귀에는 사용 불가)

2. Papers You Must Read (PYMR) 고려대학교 DSBA 연구실에서 선정한 데이터를 공부할 때 필독 해야하는 논문 리스트입니다. 딥러닝 뿐만 아니라 데이터마이닝, 앙상블 같은 머신러닝 논문도 포함하고 있습니다. 링크텍스트

본 포스트는 이수안컴퓨터연구소님의 파이토치 한번에 끝내기 PyTorch Full Tutorial Course 강의를 듣고 작성되었습니다.

Autograd(자동미분)

• torch.autograd 패키지는 Tensor의 모든 연산에 대해 자동 미분 제공

• 이는 코드를 어떻게 작성하여 실행하느냐에 따라 역전파가 정의된다는 뜻
• backprop를 위해 미분값을 자동으로 계산

1. 연산 추적(기록) : requires_grad

requires_grad

• 속성을 True로 설정하면, 해당 텐서에서 이루어지는 모든 연산들을 추적 시작

• 기본 텐서의 gradient값은 False

  a = torch.randn(3,3)
  a = a * 3
  print(a)
  print(a.requires_grad)

  tensor([[-3.4160, -4.7597,  1.9489],
        [ 0.4322,  0.9619,  1.0409],
        [ 3.0706, -1.8473,  2.5310]])
  False

requires_grad_(True)

• gradient 값을 True로 변경해야 추적 시작
  • requires_grad_()
  • 기존 텐서의 requires_grad값을 바꿔치기(in-place)하여 변경

    a.requires_grad_(True)

grad_fn

• 미분값을 계산한 함수에 대한 정보 저장
• backpropagation 할 때 어떤 연산을 했는지, 어떤 함수에 대해 진행했는지 기록을 저장

  b = (a * a).sum()   # 결과 : a*a 결과 값 모두 합친 값 한 개
  print(b)
  print(b.grad_fn)

  tensor(59.5639, grad_fn=<SumBackward0>)  # sum 이라는 연산을 했음을 기록
  <SumBackward0 object at 0x7fce31cd6190>

2. 기울기(Gradient)

(1) gradient 추적하는 과정 살펴보기

1. 연산 정보 추적할 수 있도록 requires_grad = True 지정

   x = torch.ones(3,3, requires_grad = True)  # 연산 정보 추적할 수 있게 True로 지정
   print(x)

   tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], requires_grad=True)

2. 연산 추가

• add 연산 추가

  y = x + 5  # grad_fn=<AddBackward0>
  print(y)

  tensor([[6., 6., 6.],
        [6., 6., 6.],
        [6., 6., 6.]], grad_fn=<AddBackward0>)

• Mul, mean 연산 추가

  z = y * y   # grad_fn=<MulBackward0>
  out = z.mean()  # grad_fn=<MeanBackward0>
  print(z, out)

  tensor([[36., 36., 36.],
        [36., 36., 36.],
        [36., 36., 36.]], grad_fn=<MulBackward0>) 
  tensor(36., grad_fn=<MeanBackward0>)

3. 역전파 계산 : .backward()

• .backward() : 역전파 계산

  print(out)
  out.backward()

  tensor(36., grad_fn=<MeanBackward0>)

4. 미분값 저장 : .grad

• data가 거쳐온 layer에 대한 미분값 저장

  print(x) # x의 원래 값
  print(x.grad)  # x의 미분 값 출력

  tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], requires_grad=True)
  tensor([[1.3333, 1.3333, 1.3333],
        [1.3333, 1.3333, 1.3333],
        [1.3333, 1.3333, 1.3333]])

다른 예시

x = torch.randn(3, requires_grad=True)

y = x * 2
while y.data.norm() < 1000:
    y = y * 2

print(y)

tensor([-393.4280, 1086.7229, 68.0228], grad_fn=<MulBackward0>)

v = torch.tensor([0.1, 1.0, 0.0001], dtype = torch.float)
y.backward(v)  # v를 기준으로 backward 

print(x.grad) # v 텐서를 기준으로 변경해줌

tensor([2.0480e+02, 2.0480e+03, 2.0480e-01])

(2) 기울기 업데이트 중지 : with torch.no_grad()

• 기록을 추적하는 것을 방지하기 위해 코드 블럭을 with torch.no_grad()로 감싸면 기울기 계산은 필요없지만
• requires_grad=True로 설정되어 학습 가능한 매개변수를 갖는 모델을 평가(evaluate)할 때 유용

  print(x.requires_grad)       # true/false 출력 (현재는 True 상태)
  print((x**2).requires_grad)  # 제곱에 대해 출력
  

with torch.no_grad(): # with로 감싼 코드에서는 기울기 계산 하지 않음 print((x**2).requires_grad) # Flase가 출력됨

>True
True
False

### (3) 기록을 추적하는 것을 중단 : .detach()
- 연산기록으로부터 분리
- `require_grad`가 다른 새로운 Tensor를 가져올 때

print(x.requires_grad) # True 상태

y = x.detach() # x를 detach한 것을 y로 지정 print(y.requires_grad) # False 출력됨

print(x.eq(y).all()) # x.eq(y) : x=y?

>True
False
tensor(True)

## 3. 자동 미분 흐름 예제
- 계산 흐름
a→b→c→out
![](https://velog.velcdn.com/images/ssom_d/post/8c8e5d0a-1f78-4ffa-8f1f-17d681103452/image.png)
- `backward()`를 통해  a←b←c←out 을 계산하면  ∂out/∂a 값이 `a.grad`에 채워짐

본 포스트는 이수안컴퓨터연구소님의 파이토치 한번에 끝내기 PyTorch Full Tutorial Course 강의를 듣고 작성되었습니다.

파이토치(Pytorch)

• 페이스북이 초기 루아(Lua) 언어로 개발된 토치(Torch)를 파이썬 버전으로 개발하여 2017년도에 공개

• 초기에 토치(Torch)는 넘파이(NumPy) 라이브러리처럼 과학 연산을 위한 라이브러리로 공개
• 이후 GPU를 이용한 텐서 조작 및 동적 신경망 구축이 가능하도록 딥러닝 프레임워크로 발전시킴

파이토치 모듈 구조

파이토치 구성요소

• torch : 메인 네임스페이스, 텐서 등의 다양한 수학 함수가 포함

• torch.autograd : 자동 미분 기능을 제공하는 라이브러리
• torch.nn : 신경망 구축을 위한 데이터 구조나 레이어 등의 라이브러리
• torch.multiprocessing : 병럴처리 기능을 제공하는 라이브러리
• torch.optim : SGD(Stochastic Gradient Descent)를 중심으로 한 파라미터 최적화 알고리즘 제공
• torch.utils : 데이터 조작 등 유틸리티 기능 제공
• torch.onnx : ONNX(Open Neural Network Exchange), 서로 다른 프레임워크 간의 모델을 공유할 때 사용

1. 텐서(Tensors)

• 데이터 표현을 위한 기본 구조로 텐서(tensor)를 사용
• 텐서는 데이터를 담기위한 컨테이너(container)로서 일반적으로 수치형 데이터를 저장
• 넘파이(NumPy)의 ndarray와 유사
• GPU를 사용한 연산 가속 가능

1.1 텐서 초기화와 데이터 타입

[1] 텐서 초기화

(1) 초기화 되지 않은 텐서 : torch.empty()

• 랜덤한 기존 형태 값으로 출력

  x = torch.empty(4,2)

  tensor([[-6.1985e+32, 4.5848e-41],

    [ 1.6558e+01,  0.0000e+00],
    [ 4.4842e-44,  0.0000e+00],
    [ 1.7937e-43,  0.0000e+00]])

(2) 무작위 초기화된 텐서 : torch.rand()

x = torch.rand(4,2)

tensor([[0.1663, 0.9950], [0.8520, 0.5015], [0.7387, 0.0313], [0.8601, 0.9957]])

(3) 데이터 타입이 long(정수)이며 0으로 채워진 텐서 : torch.zeros(4,2, dtype=torch.long)

• 0으로 초기화
• long type : 정수형

  x = torch.zeros(4,2, dtype = long)

  tensor([[0, 0],

    [0, 0],
    [0, 0],
    [0, 0]])

(4) 사용자가 입력한 값으로 텐서 초기화 : torch.tensor([3,2,3])

x = torch.tensor([3,2,3])

tensor([3.0000, 2.3000])

(5) 1로 채워진 텐서 + double 타입 : x.new_ones(2,4, dtype=torch.double)

• new_ones : 1로 채워진 텐서
• double : 실수형

  x = x.new_ones(2,4, dtype = torch.double)

  tensor([[1., 1., 1., 1.],

    [1., 1., 1., 1.]], dtype=torch.float64)

(6) 지정된 범위로 tensor 생성 : torch.arange(start, end, step)

# end만 지정
a = torch.arange(5)

# start, end 지정
a = torch.arange(2, 6)

# start, end, step 모두 지정
a = torch.arange(1, 10, 2)

tensor([0, 1, 2, 3, 4]) tensor([2, 3, 4, 5]) tensor([1, 3, 5, 7, 9])

(7) x와 같은 크기, float 타입, 무작위 텐서 : torch.randn_like()

• randn : 무작위
• like : 기존 텐서 모양과 같게

  x = torch.randn_like(x, dtype = torch.float)

  tensor([[-0.1523, -0.0642, -0.3455, -0.2723],

    [ 1.3314,  1.1569, -0.0211,  0.8774]])

(8) 텐서 크기 확인 : x.size()

print(x.size())

torch.Size([2, 4])

[2] 데이터 타입

# float type
ft = torch.FloatTensor([1,2,3])
print(ft)

# type 변환
print(ft.short())
print(ft.int())     # dtype=torch.int16
print(ft.long())    # dtype=torch.int32

tensor([1., 2., 3.]) tensor([1, 2, 3], dtype=torch.int16) tensor([1, 2, 3], dtype=torch.int32) tensor([1, 2, 3])

# int type
it = torch.IntTensor([1,2,3])
print(it)

# type 변환
print(it.float())
print(it.double())  # dtype=torch.float64
print(it.half())    # dtype=torch.float16

tensor([1, 2, 3], dtype=torch.int32) tensor([1., 2., 3.]) tensor([1., 2., 3.], dtype=torch.float64) tensor([1., 2., 3.], dtype=torch.float16)

1.2 CUDA Tensors : device

• 텐서를 cpu, gpu 장치로 옮기기

x = torch.randn(1)

# cuda가 가능하면(is_available()) gpu, 안되면 cpu로 자동 연결
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)

cuda

• .to 이용해서 device 보냄

  # 기존 x 모양으로 1로 전부 차있는 것에 device 정의 
  y = torch.ones_like(x, device = device)
  print(y)
  

랜덤으로 선언했던 x 텐서를 device로 보냄

x = x.to(device)

z를 cpu로 옮기고 type은 double(float64)로 지정

z = x+y print(z) print(z.to('cpu', dtype = tensor.double))

>tensor([1.], device='cuda:0')
tensor([2.0479], device='cuda:0')
tensor([3.0479], device='cuda:0')
tensor([3.0479], dtype=torch.float64)



# 1.3 다차원 텐서 생성

### (1) 0D Tensor (=Scalar)
- 하나의 숫자를 담고 있는 텐서
- 축과 형상 없음

t0 = torch.tensor(0) print(t0.ndim) # 차원 print(t0.shape) # 크기 print(t0) # 실제값

>0
torch.Size([])
tensor(0)

### (2) 1D Tensor (=Vector)
- 리스트와 유사
- 하나의 축

t1 = torch.tensor([1,2,3]) print(t1.ndim) print(t1.shape) print(t1)

>1
torch.Size([3])
tensor([1, 2, 3])

### (3) 2D Tensor (=Matrix)
- 행렬 모양
- 두개의 축
- 구조 : 특성(feature) + 샘플(smaples)
- ex) 수치, 통계 데이터 셋
![](https://velog.velcdn.com/images/ssom_d/post/2ea14db4-5878-4bd6-8707-3d2aae9b1d3e/image.png)

t2 = torch.tensor([[1,2,3], [4,5,6], [7,8,9]]) print(t2.ndim) print(t2.shape) print(t2)

>2
torch.Size([3, 3])
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])


### (4) 3D Tensor
- 큐브(cube) 모양, 3개의 축
- 구조 : 특성(features) + 샘플(samples) + 타입스텝(timesteps)
- 연속된 시퀀스 데이터, (시간 축이 포함된)시계열 데이터에 해당
- ex) 주식 가격 데이터셋, 시간에 따른 질병 발병 데이터 등
![](https://velog.velcdn.com/images/ssom_d/post/4a21c794-c465-4b88-ba89-e5c0a3e70e06/image.png)

t3 = torch.tensor([[[1,2,3], [4,5,6], [7,8,9]], [[1,2,3], [4,5,6], [7,8,9]], [[1,2,3], [4,5,6], [7,8,9]]]) print(t3.ndim) print(t3.shape) print(t3)

>3
torch.Size([3, 3, 3])
tensor([[[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]],
        [[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]],
        [[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]]])

### (5) 4D Tensor
- 4개의 축
- 컬러 이미지 데이터   (흑백은 3D Tensor로 가능)
- 구조 : 샘플(smaples) + 높이(height) + 너비(width) + 컬러 채널(channel)
![](https://velog.velcdn.com/images/ssom_d/post/1e9804e2-8045-4bb0-be06-3fceaeb85506/image.png)


### (6) 5D Tensor
- 5개의 축
- 비디오 데이터  (이미지가 연달아 있는 데이터)
- 구조 : 샘플(samples) + 프레임(frames) + 높이(height) + 너비(width) + 컬러 채널(channel)



# 1.4 텐서의 연산 (Operations)
- 텐서에 대한 수학 연산, 삼각함수, 비트 연산, 비교 연산, 집계 등 제공
### (1) math

import math

a = torch.rand(1,2) * 2 - 1

- `torch.abs(a)` : 절댓값
- `torch.ceil(a)`  : 반올림
- `torch.floor(a)` : 반내림
- `torch.clamp(a, -0.5,0.5)` : 최대최소를 찝어버린다 (clamp)
    => tensor([[0.5000, 0.5000]])
- `torch.min(a)` : 최소
- `torch.max(a)` : 최대
- `torch.mean(a)` : 평균
- `torch.std(a)` : 분산
- `torch.prod(a)` : 곱
- `torch.unique(torch.tensor([1,2,3,1,2,2]))` : 종류
   => tensor([1, 2, 3])

(1.1) dim 인자(max,min) : argmax,argmin 리턴
- argmax : 최대값을 가진 인덱스
- argmin : 최소값을 가진 인덱스

x = torch.rand(2,2) print(x) print(x.max(dim = 0)) # dim=0 : 열 기준 , max() : 더 큰 인덱스 print(x.min(dim = 1)) # dim=1 : 행 기준 , max() : 더 큰 인덱스

>tensor([[0.7574, 0.0808],
        [0.0846, 0.1804]])

>torch.return_types.max(
values=tensor([0.7574, 0.1804]),
indices=tensor([0, 1]))

>torch.return_types.max(
values=tensor([0.7574, 0.1804]),
indices=tensor([0, 1]))


### (2) torch.연산

x = torch.rand(2,2) y = torch.rand(2,2)

- `torch.add(x,y)` : 덧셈
- `torch.sub(x,y)` : 뺄셈
- `torch.mul(x,y)` : 곱셈
- `torch.div(x,y)` : 나눗셈

- `torch.mm(x,y)` : 내적

내적 예시

print(x) print(y) print(torch.matmul(x,y))

z = torch.mm(x,y) print(z)

print(torch.svd(z)) # U,S,V 로 기존의 행렬 값을 분해

tensor([[0.7431, 0.2229], [0.9548, 0.4806]]) tensor([[0.8347, 0.3137], [1.3998, 0.7706]]) tensor([[0.9323, 0.4049], [1.4698, 0.6699]]) tensor([[0.9323, 0.4049], [1.4698, 0.6699]]) torch.return_types.svd( U=tensor([[-0.5326, -0.8464], [-0.8464, 0.5326]]), S=tensor([1.9084, 0.0154]), V=tensor([[-0.9120, -0.4101], [-0.4101, 0.9120]]))

### (3) 결과 텐서 인자로 제공하는 법

result = torch.empty(2,4) torch.add(x,y, out = result) print(result)

>![](https://velog.velcdn.com/images/ssom_d/post/5329f5cb-666e-4765-82e9-c22a337c801d/image.png)


### (4) in-place : 텐서 값 변경
- 연산 뒤에 "_" 붙이기
- `x.copy_(y)
- `x.t_()`

print(x) print(y) y.add_(x) # _ : inplace => 'x 더한 값'을 y로 다시 지정 print(y)

tensor([[0.7431, 0.2229], [0.9548, 0.4806]]) tensor([[0.0917, 0.0908], [0.4450, 0.2899]]) tensor([[0.8347, 0.3137], [1.3998, 0.7706]])

# 1.5 텐서의 조작 (Manipulations)

### (1) 인덱싱(Indexing)
- numpy 형태로 사용 가능

텐서의 특정 위치 값 가져오는 법

x = torch.Tensor([[1,2], [3,4]]) print(x)

행렬 위치로 값 추출

print(x[0,0]) print(x[0,1]) print(x[1,0]) print(x[1,1])

슬라이싱

print(x[:,0]) # 행은 다 선택하면서 0번째 컬럼 선택 print(x[:,1]) print(x[0,:]) # 열을 슬라이싱하고 행을 선정 print(x[1,:])

>tensor([[1., 2.],
        [3., 4.]])
tensor(1.)
tensor(2.)
tensor(3.)
tensor(4.)
tensor([1., 3.])
tensor([2., 4.])
tensor([1., 2.])
tensor([3., 4.])


### (2) 텐서의 크기(size)나 모양(shape) 변경 : view
`view`
- 변경 전,후 텐서 안 원소 개수 유지되어야함
- -1 설정 시, 계산 통해 해당 크기 값 유추

x = torch.randn(4,5)

y = x.view(20) # 20개가 나열된 형태로 변경되어 출력

z = x.view(5,-1) # 행 5개, -1 : 나머지는 알아서 계산해서 넣어 # 5,4로 출력됨

tensor([[ 0.1870, 0.6372, 0.2561, -1.3911, 0.8974], [ 0.8734, 0.5315, -0.4903, -0.4616, -0.3950], [ 0.4581, -0.1911, -1.6286, 0.5659, -1.8072], [-1.9535, 0.2897, -0.4601, 0.5018, 1.1456]]) tensor([ 0.1870, 0.6372, 0.2561, -1.3911, 0.8974, 0.8734, 0.5315, -0.4903, -0.4616, -0.3950, 0.4581, -0.1911, -1.6286, 0.5659, -1.8072, -1.9535, 0.2897, -0.4601, 0.5018, 1.1456]) tensor([[ 0.1870, 0.6372, 0.2561, -1.3911], [ 0.8974, 0.8734, 0.5315, -0.4903], [-0.4616, -0.3950, 0.4581, -0.1911], [-1.6286, 0.5659, -1.8072, -1.9535], [ 0.2897, -0.4601, 0.5018, 1.1456]])

### (3) 실제값 출력 : item
- 단, 스칼라 값이 하나만 존재해야 사용 가능 (2개 이상부터 에러)
`item`

x = torch.randn(1) print(x) print(x.item()) print(x.dtype)

>tensor([-1.7272])
-1.7272114753723145
torch.float32

### (4) 차원 축소(제거) : squeeze

tensor = torch.rand(1,3,3) print(tensor.shape)

t = tensor.squeeze()
print(t.shape)

>torch.Size([1, 3, 3])
torch.Size([3, 3])   ## 차원이 축소됨


### (5) 차원 증가(생성) : unsqueeze
- dim 인자
   - unsqueeze(dim=0) : 첫번째 차원을 기준으로 차원 증가
   - unsqueeze(dim=1) : 뒤에 추가해서 차원 증가

tensor = torch.rand(3,3) print(tensor.shape)

t = tensor.unsqueeze(dim=0) print(t.shape)

>torch.Size([3, 3])
torch.Size([1, 3, 3])  #첫번째 차원을 기준으로 차원이 증가됨


### (6) 텐서 결합 : stack, cat
1. `stack`

x = torch.FloatTensor([1,4]) y = torch.FloatTensor([2,5]) z = torch.FloatTensor([3,6])

텐서 결합

print(torch.stack([x,y,z]))

>tensor([[1., 4.],
        [2., 5.],
        [3., 6.]])

2. `cat`
- 텐서를 결합하는 메소드(concat)
- 넘파이의 `stack`과 유사하지만 쌓을 `dim` 존재
- 해당 차원을 늘려준 후 결합



- 차원 기준 텐서 결합 (첫번째 차원)

a = torch.randn([1,3,3]) b = torch.randn([1,3,3])

차원 기준 텐서 결합 (첫번째 차원)

c = torch.cat((a,b), dim = 0) # dim=0 : 첫번째 차원을 기준으로 결합 print(c) print(c.size()) # 결과 : torch.Size([2, 3, 3])

tensor([[[ 1.7086, 1.7309, 1.4096], [ 0.0378, -0.8366, 1.3575], [ 0.7722, -0.5331, -0.2113]], [[-0.3134, 1.9430, 1.1301], [ 0.3056, 1.4749, 1.5296], [ 0.7489, 0.9423, 0.2366]]]) torch.Size([2, 3, 3])

- 차원 기준 텐서 결합 (두번째 차원)

c = torch.cat((a,b), dim=1) # dim=1 : 두번째 차원을 기준으로 결합 print(c) print(c.size()) # 결과 : torch.Size([1, 6, 3])

tensor([[[ 1.7086, 1.7309, 1.4096], [ 0.0378, -0.8366, 1.3575], [ 0.7722, -0.5331, -0.2113], [-0.3134, 1.9430, 1.1301], [ 0.3056, 1.4749, 1.5296], [ 0.7489, 0.9423, 0.2366]]]) torch.Size([1, 6, 3])

- 차원 기준 텐서 결합 (세번째 차원)

c = torch.cat((a,b), dim=2) # dim=2 : 세번째 차원을 기준으로 결합 print(c) print(c.size()) # 결과 : torch.Size([1, 3, 6])

tensor([[[ 1.7086, 1.7309, 1.4096, -0.3134, 1.9430, 1.1301], [ 0.0378, -0.8366, 1.3575, 0.3056, 1.4749, 1.5296], [ 0.7722, -0.5331, -0.2113, 0.7489, 0.9423, 0.2366]]]) torch.Size([1, 3, 6])

### (7) 텐서를 여러 개로 나누기 : chunk, split

1. `chunk`
- 몇개로 나눌 것인가? 정의

tensor = torch.rand(3,6) print(tensor)

t1,t2,t3 = torch.chunk(tensor, 3, dim=1)

첫번쨰 차원을 기준으로 3개로 나눔

print(t1) print(t2) print(t3)

tensor([[0.5286, 0.2108, 0.0335, 0.2943, 0.8410, 0.4693], [0.3923, 0.1196, 0.1436, 0.3561, 0.2415, 0.0414], [0.9088, 0.4601, 0.1271, 0.7551, 0.6036, 0.3934]]) tensor([[0.5286, 0.2108], [0.3923, 0.1196], [0.9088, 0.4601]]) tensor([[0.0335, 0.2943], [0.1436, 0.3561], [0.1271, 0.7551]]) tensor([[0.8410, 0.4693], [0.2415, 0.0414], [0.6036, 0.3934]])

2. `split`
- 텐서의 크기는 몇인지 물어본 후, 그에 맞춰 나눔

tensor = torch.rand(3,6) t1, t2 = torch.split(tensor, 3, dim=1)

print(tensor) print(t1) print(t2)

tensor([[0.0883, 0.4678, 0.1435, 0.6052, 0.9097, 0.4505], [0.3931, 0.1826, 0.0384, 0.2358, 0.7419, 0.0266], [0.3956, 0.3721, 0.3204, 0.4135, 0.3338, 0.3091]]) tensor([[0.0883, 0.4678, 0.1435], [0.3931, 0.1826, 0.0384], [0.3956, 0.3721, 0.3204]]) tensor([[0.6052, 0.9097, 0.4505], [0.2358, 0.7419, 0.0266], [0.4135, 0.3338, 0.3091]])

이 글은 딥러닝 호형님의 딥러닝 전체 흐름보기 강의를 바탕으로 작성되었습니다.

1. 머신러닝 학습 방법

1. 지도 학습 (supervised learning)
2. 비지도 학습 (Unsupervised learning)
3. 강화학습 (Reinforcement learning)

2. 딥러닝

[ 딥러닝 전체 흐름 ]

1. 문제 이해/Data 처리
2. 학습 데이터 생성
3. 모델 결정
4. 모델 구축
5. 예측값 산출
6. Loss 계산
7. parameter 업데이트
8. 최적화

1. 문제 이해 : 무엇을 생각해야 하나?

1. 원하는 타겟이 무엇인가?
   • ex) 주가 예측, 불량 검출, 패션 디자인 등
2. 데이터는 어떻게 생겼는가?
   • ex) 데이터 구조, 타입, 실시간, 크기 등
3. 딥러닝이 꼭 필요한가?
   • 딥러닝은 만능이 아니다.
   • 왜 예측이 잘되는지 설명이 어려움
   • 성능 위주로 정확도로만은 받아들일 수 없음
   • 오버헤드가 아닌지?

1.2 데이터 처리 : 어떻게 가공?(Feature Engineering)

1. 예측 방해 요소 확인
   • 결측값, 중복값, 오류, 오차, 다변수 등
   • background knowledge가 필요 (+ 도메인 지식)
2. 데이터 구조 및 분포 분석
   • ex) 통계분석 - 상관관계, 히스토그램, 가설검증 등
3. 데이터 가공
   • ex) Outlier 제거
   • feature selection, 변수 생성
   • scaling(Nomalization, minmax scaler, low sclaing...) 등
4. 데이터 형태 변환
   • ex) labeling, one-hot-encoding(0,1로만 이루어짐) 등
   • ex) 년도,나이대를 0,1,2 등 그룹으로 묶기
   • 특정 class 잡아주기

2. 학습 데이터 생성 : 샘플링

1. 편향 방지
   • 특정 데이터로 편중되어선 안됌.
2. Cheating 금지
   • test 데이터와 중복 금지
3. 충분한 데이터 양
4. 샘플링 종류 선택
   • ex) 기본 random / under / stratified sampling 등
   • under sampling : calss 중 가장 적은 데이터를 기준으로 똑같은 개수로 뽑아 학습 데이터로 만듬
   • stratified sampling(추가 추출법) : 가지고 있는 데이터가 모집단이라 할때, 모집단의 class 비율과 똑같이 학습 데이터 만듬
5. 데이터 분할
   • Train vs Test
   • Train. vs Validation. vs Test
   • Cross Validation

3. 모델 결정 : (NN, CNN, RNN, GAN...)

1. 어떤 종류의 문제인가?

   • regression, Classification, Clustering(비지도) 등...

2. 무엇을 최적화 할 것인가?

   • ex) 예측 시간 단축, 정확도 등 최적화의 목적 확인

3. 데이터가 얼마나 큰가?

   • GPU 연산 유무, 하드웨어 성능 확인

4. 모델 종류

   • CNN

   • 이미지, 자연어 처리 등

   • RNN

   • 시계열 데이터

   • GAN

   • latent space로 가짜 데이터를 만들어 가짜/진짜 구별 안되게 학습

   • AutoEncoder

   • 비지도 학습
   • 레이블링이 없고 데이터를 넣으면 레이어를 거쳐 원본과 유사하게 데이터를 생성하는 모델

4. 모델 구축

1. epoch, mini batch
   • batch : data 1조각, train 데이터를 n 조각으로 쪼개 한조각씩 넣어줌.
   • epoch : 학습 횟수
2. layer, Node, filter 등 (수,크기 지정)
   • input layer, hidden later, output layer
   • filter : layer 연결 선들이 metric 형태로 들어가 있는 것. filter의 크기,값 지정해야함, 초기값은 random
3. loss function
   • output 결과가 잘 되었는지 확인
4. optimizer
   • loss funnction을 계산하여 얼만큼 예측? 어떻게 업데이트? 하며 최적화 과정

5. 예측 : output

• 모델 구축해놓고 input만 넣으면 예측
• 중요한건 예측을 잘 했는가

6. Loss 계산

• y 실제값, ŷ 예측값
• ŷ 이 얼마나 예측을 잘했는가의 기준이 loss function
• 예측값이 어떠한 기준에 의해 loss를 계산
• loss값이 작아지게 하는 것이 목표
• 학습 흐름 (loss 작아지게 하는게 목표) => input 값을 넣어 아웃풋 나오면 실제 값과 비교(loss(오차) 계산)해서 => loss(오차)가 작아지게 하는 가중치값을 업데이트하여 => 다시 input 넣고 다시 loss 계산해서 가중치 업데이트...반복

7. Parameter Weight Update

• 업데이트 할 parameter weight 값을 구하는 것이 목표
• 역전파 (Backpropagation)
  • loss function의 예시 그림
  • loss function이 가장 작은 지점의 (θ0 , θ1) 값을 구하고자 함.
  • 역전파를 통해 loss가 작아지는 weight값을 찾아가게 하는 것이 역전파 알고리즘.
    • 모델을 backward pass 거꾸로 올라가며 node의 기여도를 확인하여 더 나은 weight 값 찾기
  • W 값들을 전부 역전파를 통해 업데이트 해줌

8. Optimizer

[파라미터를 업데이트 하는 방법]

• 경사하강법 (gradient descent)
  • 기본적인 형태
  • (미분) 기울기 값을 통해 작아지는 방향으로 찾아가게끔 만들어주는 것.
  • α : learning rate, 기울기 방향으로 갈때 걸음 수 (좁게,넓게)

• 기본 형태를 기준으로 다양한 optimizer가 나옴

9. 최적화 (진단) : 모델 튜닝

1. loss/정확도 안좋을 경우 조절
   • learning rate : 너무 작은 경우 조금씩 가다가 글로벌 미니멈까지 가기 전에 끝날 수도 : 너무 큰 경우 큼직큼직 걷다가 글로벌 미니멈을 지나쳐버릴 수도..
   • optimizer : 다양한 optimizer 방법 사용
   • batch : 몇개씩 data 넣을지
   • filter : 크기,수
   • layer : 수
   • node : 얼마나 가져갈지
   • activation function : 한 라인이 1차 결합(W*X+bias등)으로 들어감. : 실제 데이터가 전부 linear 한 관계가 아니기 때문에 : layer에서 layer로 넘어갈때 linear함을 non linear함으로 바꿔줌
   • etc..
2. overfitting 방지
   • early stopping
   • regularization : loss function이 완전히 작아지지 않게끔
   • dropout : node의 일부를 죽여서 과적합 방지
   • etc..

이 글은 데이터 스테이션님의 딥러닝 신경망 알고리즘 이해하기 ! 강의를 듣고 작성되었습니다.

1. 신경망 알고리즘

1. layer (층) : 노드 한줄
2. Node (노드)
3. Weight (가중치)

• 비정형(저차원) 데이터를 처리할때 쓰임

2. 신경망 알고리즘 기본 작동 원리

1) 네트워크 (Layer)의 기능 및 역할

• 데이터 연산이 처리되는 각 층을 연결

• 층간 활성함수에 의한 연산으로 다양하고 복잡한 형태의 계산이 가능

• 점진적(Foward pass)으로 데이터가 정제되어 처리될 수 있는 구조 형성

• 층(layer)에서 입력 데이터(input data)가 처리되는 정보는 Weight(해당 layer의 parameter)라는 Vector에 저장되어 있음

  딥러닝의 목표 : 예측을 정확하게 하기 위한 Weight를 찾는 것

  정답지가 연속형,이산형,카테고리형 등에 따라 어떤 방식으로 weight를 찾을지 결정.

• Backpropagation(역전파) 알고리즘을 구현한 Optimizer를 이용해 Update

• Training Loop를 통해, 최초의 부여받은 Random Weight에서 Cost Function이 가장 낮아지는 Weight를 도출

손실함수 (Cost Function or Objective Function)

• 예측값과 실제 값의 차이(오차)를 계산한 함수.
• 신경망 출력 제어의 지표가 됨.
• 신경망이 얼마나 잘 만들어졌는가, 잘만들어 지고 있는가를 파악할 수 있음
• 손실함수가 최소가 되는 방향으로 weight를 Update

< 우리가 딥러닝(NN) 사용할 때 집중해야할 부분 >

1. 중간에 update될 weight
2. weight에 의해서 계산될 손실함수가 어떤 식으로 바뀌는지
3. 정했던 데이터가 이산형,연속형,카테고리형이냐에 따라 손실 함수를 어떻게 정희해야 하는가

처리 순서

1. 여러개의 Batch를 나눠 학습 (몇 번 반복할 것인가 결정 : Epoch)
2. 데이터가 각 층을 통과하며, Node에 있는 함수에 의해 처리 (Forward Pass)
3. 실측값과 신경망에 의한 예측값을 비교해 오차 계산
4. chain Rule을 통해 오차에 대한 각 Node에 있는 기여도를 계산 (Backward Pass)
5. 오차가 감소하도록 Weight를 계산

3. 데이터와 알고리즘

• Perceptron Model

  • 초기 신경망 모델
  • input layer과 하나의 Hidden Layer와 Output Layer로 구성되어 있으며, 초기 Perceptron Model은 층이 하나 뿐인 Threshold Logic Unit으로 구성

• Multi Layer Perceptron

  • perceptron 구조를 여러층으로 쌓아올린 신경망 알고리즘
  • 하나 이상의 Hidden Layer로 구성
  • 기존의 perceptron이 가지고 있는 한계를 개선 (단순한 문제에서 발생하는 오류)

• Deep Neural Network, DNN

  • Hidden Layer를 여러 겹 쌓아올린 신경망
  • 역전파(BackPropagation)알고리즘을 통해 훈련 방법을 개선
  • 네트워크를 데이터가 통과하면서, 각 층에 있는 HyperParameter를 계산
  • 손실함수에 의한 오차를 다시 노드의 기여도로 거꾸로 계산해 나가며(역전파,BackPropagaion) Hidden Layer를 새로 Update 시켜주는 알고리즘
  • 일반적으로 우리가 알고있는 형태

DNN의 2가지 종류

1. Convolutional Neural Network, CNN

• 합성곱신경망
• 사람의 시신경 구조를 모방한 알고리즘
• 데이터를 특정 차원으로 추출하여, 해당 차원의 패턴을 파악하는 구조
• 데이터 펼쳐져 있을때 특정 특징들을 추출해 모아 하나의 Convilution Layer를 만들고 그 안에서 데이터를 줄이며 학습하는 형태
• Convolution과정과 Pooling과정을 통해 진행
• 이미지 처리에 주로 사용되다가 자연어 처리에도 사용하기도 함

  2. Recurrent Neural Network, RNN

• 순환신경망 알고리즘
• 반복적이고 순차적인 데이터를 순서대로 처리하는 형태의 알고리즘
• 알고리즘 내부의 순환구조가 존재하여, 과거의 학습을 Weight를 활용해 현재의 Node에 Weight를 반영하는 알고리즘
• 시계열 데이터 처리할 때 사용

• 고유값(eigen value)와 고유벡터(eigen vector)에 대해 설명해주세요. 그리고 왜 중요할까요?
• 샘플링(Sampling)과 리샘플링(Resampling)에 대해 설명해주세요. 리샘플링은 무슨 장점이 있을까요?
• 확률 모형과 확률 변수는 무엇일까요?
• 누적 분포 함수와 확률 밀도 함수는 무엇일까요? 수식과 함께 표현해주세요.
• 조건부 확률은 무엇일까요?
• 공분산과 상관계수는 무엇일까요? 수식과 함께 표현해주세요.
• 신뢰 구간의 정의는 무엇인가요?
• p-value를 모르는 사람에게 설명한다면 어떻게 설명하실 건가요?
• R square의 의미는 무엇인가요?
• 평균(mean)과 중앙값(median)중에 어떤 케이스에서 뭐를 써야할까요?
• 중심극한정리는 왜 유용한걸까요?
• 엔트로피(entropy)에 대해 설명해주세요. 가능하면 Information Gain도요.
• 어떨 때 모수적 방법론을 쓸 수 있고, 어떨 때 비모수적 방법론을 쓸 수 있나요?
• “likelihood”와 “probability”의 차이는 무엇일까요?
• 통계에서 사용되는 bootstrap의 의미는 무엇인가요.
• 모수가 매우 적은 (수십개 이하) 케이스의 경우 어떤 방식으로 예측 모델을 수립할 수 있을까요?
• 베이지안과 프리퀀티스트 간의 입장차이를 설명해주실 수 있나요?
• 검정력(statistical power)은 무엇일까요?
• missing value가 있을 경우 채워야 할까요? 그 이유는 무엇인가요?
• 아웃라이어의 판단하는 기준은 무엇인가요?
• 필요한 표본의 크기를 어떻게 계산합니까?
• Bias를 통제하는 방법은 무엇입니까?
• 로그 함수는 어떤 경우 유용합니까? 사례를 들어 설명해주세요.
• 베르누이 분포 / 이항 분포 / 카테고리 분포 / 다항 분포 / 가우시안 정규 분포 / t 분포 / 카이제곱 분포 / F 분포 / 베타 분포 / 감마 분포에 대해 설명해주세요. 그리고 분포 간의 연관성도 설명해주세요.
• 출장을 위해 비행기를 타려고 합니다. 당신은 우산을 가져가야 하는지 알고 싶어 출장지에 사는 친구 3명에게 무작위로 전화를 하고 비가 오는 경우를 독립적으로 질문해주세요. 각 친구는 2/3로 진실을 말하고 1/3으로 거짓을 말합니다. 3명의 친구가 모두 “그렇습니다. 비가 내리고 있습니다”라고 말했습니다. 실제로 비가 내릴 확률은 얼마입니까?
• 필요한 표본의 크기를 어떻게 계산합니까?
• Bias를 통제하는 방법은 무엇입니까?
• 로그 함수는 어떤 경우 유용합니까? 사례를 들어 설명해주세요

Contents

Image Classification 이란?

1. 데이터 중심 접근 방법 (Data-Driven Approach)
2. Nearest Neighbor (NN)
3. K-Nearest Neighbors
4. Linear Classification (선형 분류)

Image Classification 이란?

• 이미지를 분류하는 것
• 이미지가 입력되면 시스템에서 미리 label해놓은 분류된 이미지 집합 중, 어디에 속할지 컴퓨터가 판단하는 것.
• 하지만 기계는 사람과 달리 정밀 분류가 힘들다.

• 위 사진과 같이 기계는 고양이 사진을 입력 받으면
• RGB(Red, Blue, Green)값을 기준으로 격자 모양의 숫자들을 나열하여 인식한다.
• 하지만 기계는 카메라 각도나 밝기, 객채의 행동 혹은 가려짐 등 여러차이로 인해 이미지의 픽셀 값이 달리 읽어 사물을 다르게 인식.

=> 따라서, 이 문제를 해결하기 위해 새롭게 등장한 방법이 데이터 중심 접근 방법 (Data-Driven Approach) 이다.

1. 데이터 중심 접근 방법 (Data-Driven Approach)

1. 객체의 특징을 규정하지 않음.
2. 다양한 사진들과 label을 수집.
3. 이를 이용해 모델을 학습해 사진을 새롭게 분류하는 방식.

2. Nearest Neighbor (NN)

• 입력받은 데이터를 저장한 후 -> 새로운 데이터 들어오면 -> 기존 데이터에서 비교해 -> 가장 유사한 데이터를 찾아내는 방식.
• 강의에서는 CIFAR-10 (10가지 종류의 물체와 동물을 모은 사진 데이터 셋)데이터를 사용

• 기계가 어떻게 이미지를 비교하고 입력과 비슷한 이미지를 찾아낼까? => Distance Metric 공식을 통사용.

• 이 방법은 이미지는 pixel-wise로 비교하는데

• test 이미지의 픽셀값에서 train 이미지의 픽셀값의 차를 구하고 절대값을 취함.

• 다음 각 픽셀 값을 모두 더해 하나의 출력값으로 만든다.

[단점]

• 모든 사진의 픽셀값을 계산하기 때문에
• 예측 과정 시간 소요가 큼
• 이를 보완하기 위해 K-Nearest Neigbor 나옴

3. K-Nearest Neighbors

• distance mertic를 이용해서 가까운 이웃을 k개 만큼 찾고

• 이웃 간 투표해 득표 많이 얻은 label로 예측하는 방법.

• 가까운 이웃이 존재하지 않으면 흰색으로 표기

• KNN을 사용하려면 학습 전 사전에 K와 거리 척도인 하이퍼 파라미터를 설정해야함.

• 하이퍼 파라미터 선택법은 preoblem-dependant(문제 의존적) 이므로, 여러 시도 후 성능 좋은 것을 선택한다.

• 일반적으로 데이터를 train,validation,test로 나누어 학습하고 예측하는 방법과, Cross vaildation(교차검증)이 있다.

• 교차 검증은 작은 데이터에 사용하며 딥러닝에는 많이 사용하지 않는다.

3.1) Distance Metric

1. 맨해튼 거리 (Manhattan distance) : L1 distance

• 좌표계 회전 시 거리 값이 달라짐

2. 유클리디안 거리 (Euclidean distance) : L2 distance

• 좌표계 회전 시 영향 받지 않음

4. Linear Classification (선형 분류)

• Neral Network(NN)과 Convolution Neral Network(CNN) 기반 알고리즘
• NN을 구축할 때 다양한 컴포넌트를 사용할 수 있는데
• 이 컴포넌트를 한 데 모아 CNN을 이루게 된다.
• 이 방법은 Nearest Neighbor보다 효율적이고 빠름

ex) 고양이 사진 (32x32x3)을 예시로 입력(X) 받음 -> 가중치 파라미터 (W)와 곱하여 -> 카테고리 score 값 (f(x,w))인 10을 만듦.

• score 값이 높을 수록 고양이일 확률이 높음.

bias(편향값)

• W * x 에 bias(편향값)을 더하는데,
• bias는 입력과는 직접적 관계를 가지지 않으나
• 이미지 라벨의 불균형한 상태 보완 위해 사용된다.

• 입력으로 2*2 형태 고양이 사진을 받으면, linear classifier는 4-dim 열 형태로 퍼지게 됨.
• 그리고 각각의 가중치(W)와 입력 이미지의 값(X)들의 내적한 값(클래스 간 템플릿 유사도를 측정한 값)에 bias를 더하면 score 값이 구해짐.

Multimodal problem (가중치 설정의 필요성)

• 이미지를 고차원 공간으로 보게 되면, Linear Classifier는 각 클래스를 구분해주는 선형 경계 역할을 하지만,
• 일차 함수 직선으로 분류되지 않은, 즉 데이터의 분포에 따른 선형으로 분류할 수 없는 데이터가 대부분이다 (Multimodal problem)
• 이러한 단점 보완을 위해 W 가중치 설정이 중요하며, 다음 강의부터 W를 설정할 방법을 알아볼 것이다.

Reference

• https://docs.sangyunlee.com/deep-learning/cs231n-1/cs231n

• K-최근접 이웃 (K-NN, K-Nearest Neighbot) 알고리즘

• 분류 (Classification)

• 지도학습

• 비슷한 특성을 가진 데이터는 비슷한 범주에 속하는 경향이 있다는 가정

• 주변의 가장 가까운 K개의 데이터를 보고 데이터가 속할 그룹을 판단하는 알고리즘

• 가장 가까운 속성에 따라 분류하여 레이블링을 하는 알고리즘

[장점]

• 단순, 구현 쉬움, 빠름

[단점]

• 모델을 생성하지 않기 때문에
• 특징과 클래스 간 관계 이해에 제한적
• 모델 결과로 해석하는게 아닌, 미리 변수와 클래스 간 관계 파악해 알고리즘에 적용해야 원하는 경과 얻으 수 있음
• 적절한 k의 선택이 필요
• 데이터가 많아지면 분류 단계가 느림

2. 거리 기반 분류분석 모델

• K-NN 알고리즘은 새로운 데이터로부터 거리가 가까운 K개의 다른 데이터의 레이블(속성)을 참고하여 K개의 데이터 중 가장 빈도 수가 높게 나온 데이터의 레이블로 분류

거리 측정 방법

1) 유클리드 거리 (Euclidean Distance) : L2 Distance

• 2차원 평면에 서로 다른 두 점 A(x1, y1)와 B(x2, y2)가 있을 때
• 이 둘의 거리 d는 유클리드 거리 계산법에 의해 다음과 같이 나온다.

2) 맨해튼 거리 (Mangattan Distance) : L1 Distance

• 유클리드 공식처럼 직선으로 이동할 수 없는 건물들이 많은 지역의 거리 재기 위해 탄생한 공식

• 초록색 직선 : 유클리드 거리
• 나머지 색 선 : 맨해튼 거리 => 모두 총 거리가 동일

3. K-NN 알고리즘 원리

• K 값에 따라 분류가 달라짐
• K는 홀수 설정이 좋으며, 최선의 K 선택하는데 일반적으로 총 데이터 수의 제곱근 값 사용

Computer Vision 이란?

• 컴퓨터 과학의 연구 분야 중 인간이 시각적으로 하는 일들을 대행하도록 시스템을 만드는 것.

2015년부터 2017년까지 CSICO에서 발표한 통계자료에 따르면 인터넷 트래픽 중 80%는 인터넷 비디오데이터였다. 인터넷의 데이터 대부분이 시각적인 자료였다. 이러한 시각적 자료 혹은 데이터를 암흑 물질(Dark Physics)라고 표현했는데, 시각 데이터를 이해하고 해석하기 어려우며 이를 해결할 수 있는 알고리즘이 개발의 필요성을 강조했다.

computer vision의 역사

고양이의 뇌에 전기적 신호를 보내 1차 시각 피질에서 다양한 종류의 세포가 있음을 알아내는데, 세포가 Edge에 반응하는 세포로 시각 처리가 단순한 구조로 시작하여 점점 복잡해지는 것을 발견했다.

ImageNet 프로젝트 소개와 다음 2가지의 목표를 둔다.

1. 세상 모든 이미지 분류
2. 기계학습의 Overfiting 문제 극복

그리고 2012년 ImageNet 국제대회 ILSVRC 개최에서 CNN(Convolutional Neural Network) 도입으로 기존 28.2%, 25%의 오류율을 16.4%로 오차율이 급격히 감소되었다. 따라서 C2S231n 수업에서는 CNN을 배우게 된다.

-모델이 train 데이터에 지나치게 적응되어 그 외 데이터에는 대응하지 못하는 상태.

EX) 아래와 같은 회귀 문제에서, 두번째 모델이 최적의 모델이다

1. 첫번쨰 모델 : 과소적합(Underfitting), 주어진 데이터를 아직 제대로 반영하지 못함.
2. 두번쨰 모델 : 우리가 원하는 모델!
3. 세번째 모델 : 과대적합(Overfitting), 새로운 데이터에는 적용할 수 없는 일반화하기 어려운 경우.

• 여기서 빨간 점(data)과 점선(모델이 예측한 결과)의 거리가 가장 가까운 모델은 두번째 모델이다.

  • 모든 input 데이터에 대해 오차가 존재하지만, 두번째가 가장 데이터 분포와 경향 잘 나타내고 있음.
  • 과적합된 세번째 모델은, 기존 데이터들은 오차 없이 잘 표현했지만, 새로운 데이터(빨간점)가 주어지자 오히려 예측한 값의 오차가 더 크게 나타남.

• 모델의 성능은 곧 일반화 성능을 말한다고도 볼 수 있음.

2. 과적합이 일어나는 이유

아주 다양하지만, 주로 두가지 경우에 발생한다.

1. 상대적으로 데이터 수가 적은데 비해 feature(-> parameter)가 많고 표현력이 높은 모델의 경우
2. train 데이터가 적은 경우 (상대적으로 feature -> parameter가 많은 데 비해)

• train에 과적합된 eccuracy 그래프
• train에 비해 test 성능이 낮고 그 차이가 크면 과적합 발생한 것.

3. 과적합을 방지하는 법

Overfitting 해결법

1. input 데이터 늘리기
2. feature의 개수를 줄이기
   • 주요 feature를 직접 선택하고 버림
   • model selection algorithm을 사용
3. 규제(Regularization)
   • 각 feature마다 페널티(규제)를 부여해 그 영향력을 조정하는 것
   • 모든 feature를 사용하되, parameter(θ)의 값을 줄인다.

정규화, 표준화, 정칙화(규제) 차이

1. 정규화(Nomalization) : 데이터의 분포가 정규분포에 가깝게 만드는 것. : 범위(scale)를 0~1 사이 값으로 바꿈
2. 표준화(Standardization) : 데이터가 표준 정규분포에 가깝게 만드는 것. : 평균이 0, 분산이 1 되도록 scaling
3. 정칙화/규제 (Regularization) : 오버피팅 방지를 위해 weight에 penalty 부여하는것.

4. 규제 (Regularization)

: 모델이 가질 수 있는 파라미터 값에 제약을 부여해 과적합을 방지하는 방법론

1. 가중치 감소

• 모델의 학습 과정에서 가중치에 페널티(규제) 부여함으로써 과적합 방지하는 방법
• 가중치 W가 클수록 더 큰 페널티를 부과 -> 해당 input x에 대해 지나치게 fit하지 않도록 조절
• 이때 페널티를 얼마나 부과할 것인지 계산 하는 방법 L1 or L2 규제

1. L1 규제 (Lasso) : 가중치의 절댓값에 비례하는 비용 추가

2. L2 규제 (Ridge) : 가중치 제곱에 비례하는 비용 추가

• L : 손실함수(loss function), ㅅ는 규제 강도(Regularization Strength)
• 즉, 규제 정도를 결정하는 하이퍼파라미터 의미

2. 드롭아웃 (Dropout)

• 뉴런을 임의로 삭제하며 학습하는 방법
• train 하면서 무작위로 은닉층(Hidden layer)의 뉴런을 골라 배제하고, 다음 layer로 신호를 전달하지 못하도록 하는 것.

Reference

• https://nanunzoey.tistory.com/entry/%EA%B3%BC%EC%A0%81%ED%95%A9Overfitting%EA%B3%BC-%EA%B7%9C%EC%A0%9CRegularization

• 입력,은닉,출력층으로 구성된 모형
• 각 층을 연결하는 노드의 가중치를 업데이터하며 학습
• overfitting이 심하게 일어나고, 학습 시간이 매우 오래 걸림

Deep Learning

• 다층의 layer 통해 복잡한 데이터 학습이 가능토록 함
• 알고리즘 및 GPU의 발전이 deep learning의 부흥을 이끔
• 다양한 형태로 발전 (CNN,RNN,AutoEncoder 등)
• AutoEncoder : x를 갖고 x를 예측해서 새로운 변수(특징) 추출 (unsupervised learning)
• 다양한 분야로 발전
  • image Resolution(해상도 복원)
  • style transfer (스타일 전환)
  • colorization (색 변환) 등)
  • object detection(객체 판별)
• 네트워크 구조의 발전
  • ResNET
  • DenseNET
• 네트워크 초기화 기법
  • Xavier
  • he initialization
• 다양한 activaion function (ReLu, ELU, SeLU, Leaky ReLU 등)
• Generalization, overfitting 문제
• Semi-supervised learning, Unsupervised learning

GAN (Generative Adversarial Network)

• Data를 만들어내는 Generator와 만들어진 data를 평가하는 Discriminator가 서로 대립(Adversarial)적으로 학습해가며 성능을 점차 개선해 나가자는 개념

• 생성 모델

• Discriminator를 학습시킬 때에는 D(x):진짜데이터 가 1이 되고 D(G(z)):가짜데이터 가 0이 되도록 학습시킴 (진짜 데이터를 진짜로 판별하고, 가짜 데이터를 가짜로 판별할 수 있도록)

• Generator를 학습시킬때에는 D(G(z))가 1이 되도록 학습시킴 (가짜 데이터를 discriminator가 구분 못하도록 학습, discriminator를 헷갈리게 하도록)

=> 서로 대립적으로 학습하며 성능이 개선되며, Generator는 결국 진짜 같은 가짜 데이터를 만들어 discriminator가 분류할 수 없도록 만듬

강화학습 (Reinforcement Learning)

• 현재 상태에서 먼 미래까지 어떤 액션을 취해야 큰 보상을 받을 수 있을까

• Q-learning : 현재 상태에서부터 먼 미래까지 가장 큰 보상을 얻을 수 있는 행동을 학습하게 하는 것.

• Q-learning + Deep learning : DQN (Deep Reinforcement Learning) : 잘안씀

• 더 효율적으로 빠르게 학습 할 수 있는 강화학습 모델 연구 ing

• Action이 continuous한 경우 (실수값) 어떻게 해야 학습이 잘되는가?

• Reward가 매우 sparse(희박)한 경우

• Multi agent 강화학습 모델의 경우