[AI 스터디] Section 7 : 신경망과 딥러닝

Neural Network

전통적인 ML 학습 방법

1. 데이터 구성
   1. 컴퓨터가 이해할 수 있도록 도메인 지식 및 통계학적 지식을 바탕으로 피처를 구성해 데이터를 구성
      ⇒ 도메인 지식을 가진 석 박사급 인재 필요
2. 알고리즘 학습

딥러닝

1. 특징
   • 중요한 Feature 를 스스로 구분하여 weight 를 부여
     ⇒ 사람이 지정한 피처 : over-specified, incomplete 위험성 + 작성에 많은 시간 소요
   • 여러 층에 걸친 내부 parameter 를 스스로 학습 • 적용하기 쉽고 빠르다.
   • Raw data 를 거의 그대로 사용 – computer vision, 언어처리 등 (ex, image, sound, characters, words)
   • Unsupervised, supervised learning 모두 가능
   • 이미지 인식, 대화/언어 문제에 탁월한 성능

Artificial Neural Network

1. Artificial Neuron (perceptron)

   

   
   
   • 모양 : 인간 두뇌의 신경망을 모방 → 실제 적용방식은 두뇌와는 다름
   • 구성 : Pre-Activation 부분(앞) + Activation 부분 (뒤)
   • Pre-Activation : linear regression이 그대로 들어감
     (X : 피처들 각각, output : 예측하고자 하는 것, w : 찾아야하는 것)
     $$a(x) = b+ \sum_i w_ix_i= b + w^TX$$
   • Activation : sigmoid 등의 활성화 함수가 들어감
     ( W : connection weight, b : bias, g : activation function )
     $$h(x) = g(a(x)) = g(b+ \sum_i w_ix_i)$$
2. 활성화 함수 :
   • sigmoid : \(\sigma \left( x\right) =\dfrac{1}{1+e^{-x}}\) 
     →  0~1사이의 값이 나옴
   • Tanh : \( tanh(x) \)   
     → -1~1사이의 값이 나옴
   • ReLU : \( max(0,x) \) 
     → 현대 딥러닝에 대부분 사용
   • Leaky ReLU : \( max(0.1x, x) \) 
     → ReLU에서 음수일때 기울기가 없으므로, 이를 개선하여 조금의 기울기를 부여
   • ELU : \( x \ \ (x≥ 0) \\ \ \ \ \ \ \ \ \ \alpha(e^x -1) \ \ (x <0) \) 
   • Softmax : \( \sigma(z)j = \frac{e^{zj}}{\sum^{K}{k=1}e^{zk}} \)  (for j =1,…, K)
     → 출력값의 다중클래스 분류를 위해 출력값에 대해 정규화하여 (total =1)확률 분포를 출력
     

     

     Linear : pre-Activation, Softmax : Activation

     
     → \( \frac{e^{2.0} }{e^{2.0} + e^{1.0}+e^{0.1}} = 0.7 \ (y가 \ 0일 \ 확률이 \ 0.7 \ (70\%)) \)
     
     
    
3. 작동 원리

• 구성
  • input feature (2 : 체중, 9 : 혈압), output : 당뇨병 진행률 (1개)
  • 히든레이어 1개가 3개의 뉴런으로 구성된 신경망
  • 가중치 : 학습을 통해 스스로 부여됨
• 체중이라고 하는 피처는 히든레이어의 뉴런 3개와 연결됨 → 연결시, 가중치가 부여됨
• pre-activation : 7.6 (2 * 0.2 + 9 * 0.8)
• activation : 0.9994 (활성화 함수에 7.6을 넣어서 나온 값)
• 히든 레이어 → output : 1.79 (0.4 * 0.9994 + 0.5 * 1.000 + 0.9 * 0.9984)
• output 활성화 함수
  • linear regression → 그대로
  • 이진 분류 → sigmoid
  • 다중 분류 → softmaxNeural Network

---

Neural Network 훈련원리

경사하강법 (gradient descent)

1. 목적 : 실제값과 예측값의 차이를 최소화하는 parameter(𝜃) 발견
2. 방법 : 손실함수를 정의하여 손실함수의 값이 0 으로 수렴하도록 parameter(𝜃) 조절
   → 미분을 통해 경사도를 따라 밑으로 내려가는, 최소값을 찾아감
3. Derivative (도함수, 미분, 접선의 기울기)
   

   

   
   
   • 의미 : x가 얼만큼 증가할때, y가 얼만큼 증가한다
   • J(w) (=L(w)) : W가 파라미터인 손실함수 → ex) MSE
4. Optimization : 손실함수를 최소화하는 w와 b
   • 방향 : Gradient (derivative of Cost Function)
     : 손실이 최소화 되는 w를 찾아야할때, gradient가 +, - 에 따라 방향을 알 수 있음
     • gradient < 0 : 현재의 w값을 키워야겠다
     • gradient > 0 : 현재의 w값을 줄여야겠다
   • 이동 속도 : Learning Rate
     → 최적의 가중치를 지나가지 않도록 작게 해야한다.
   • 가중치 갱신 공식 : New W = old W – (Learning Rate) * (Gradient)
5. 선형 회귀에서의 파라미터 업데이트 → 아래의 과정을 반복하며 최적의 값을 찾아감
   • \( y = 𝜃_0 + 𝜃_1𝑥 \) (= y=b+wx)
     
     
   • Loss Function → (정답- 예측)^2 을 평균 : MSE
     \( 𝐿 (𝜃_0, 𝜃_1) = \frac{1}{m}\sum^{m}_{i=0} (y_i - (𝜃_0 + 𝜃_1x_i))^2 \) ( \( y_i \) : 정답 레이블)
     
     
   • Gradient : 손실함수 편미분
     \( \frac{d𝐿 (𝜃_0, 𝜃_1)}{d𝜃_1} = -2\frac{1}{N}\sum^{m}_{i=0}x_i (y_i - (𝜃_0 + 𝜃_1x_i)) \)
     \( \frac{d𝐿 (𝜃_0, 𝜃_1)}{d𝜃_0} = -2\frac{1}{N}\sum^{m}_{i=0} (y_i - (𝜃_0 + 𝜃_1x_i)) \)
     
     
   • Update : b, w를 업데이트
     \( 𝜃_1 := 𝜃_1 -\alpha \frac{d𝐿 (𝜃_0, 𝜃_1)}{d𝜃_1} \)
     \( 𝜃_0 := 𝜃_0 -\alpha \frac{d𝐿 (𝜃_0, 𝜃_1)}{d𝜃_0} \)

손실함수(= 비용함수, 목적함수)

: 경사하강법, 오차역전파가 작동하도록 대상이 되는 함수 / 미분 가능 함수

→ 만들어서 쓸 수도 있고, 만들어진걸 써도 됨. (거의 만들어진거 씀)

→ 풀려는 문제에 따라 거의 3개로 나뉘어짐

1. Linear Regression (선형회귀) : MSE (Mean Squared Error)
   
   $$MSE = \frac{1}{n} \sum_{i=1}^{n} (\hat Y_i - Y_i)^2$$
   →  Mse를 최소화하는 w와 b를 optimize
   
   
2. Binary Classification (이진분류 / Logistic Regression) : Binary-Cross-Entropy
   $$J(\theta) = -\frac{1}{m} \left[ \sum_{i=1}^{m} \left( (1 - y^{(i)}) \log(1 - h_\theta(x^{(i)})) + y^{(i)} \log(h_\theta(x^{(i)})) \right) \right]$$
   

   

   정답에 따른 손실값 확인 그래프

   1. \( If \ \ 𝑦^{(𝑖)} = 1 : J(𝜃) = −𝑙𝑜𝑔 \ ℎ_𝜃 (𝑥^{(𝑖)})\)
      where ℎ𝜃 (𝑥(𝑖)) should be close to 1
   2. \( If \ \ 𝑦^{(𝑖)} = 1 : J(𝜃) = −𝑙𝑜𝑔 \ (1-ℎ_𝜃 (𝑥^{(𝑖)}))\)
      where ℎ𝜃 (𝑥(𝑖)) should be close to 0
    
3. Multi-Class Classification (다중분류) : Categorical-Cross-Entropy
   

   

   (\(t_i\) : 0이 아닌 타겟 C : multi-classes)

   • softmax : 활성화함수 f
   • CE = softmax 함수의 출력값인 확률분포에 log를 취한 것 * t 의 sum
   • 예시
     

     

     
     - True value : 하나만 1이고 나머진 0
     - prediction : 모델이 예측한 값
     - 현재 : 7일 확률이 60% → 나중 최종 목표 : 7일 확률이 100% 에 가깝게되도록
     - LCE = -log 0.6
     

     

     - true value가 아닌 값은 0이 곱해짐
     - 현재 우리모델이 예측한 값과 실제값의 차이를 계산한 손실값

---

Backpropagation (오차역전파)

: 손실함수를 최소화하는 방향으로 신경망 전체의 파라미터가 업데이트 되도록 하는 기법

→ 뉴럴 네트워크를 훈련시키는 방법

→ 여러 은닉층의 가중치 값을 최종 예측 값이 레이블값과 근사한 값을 가지도록 조정해야함

Forward Propagation : 순전파

: 뉴럴네트워크의 작동방식과 동일

 

Backward Propagation : 역전파

1. 아이디어 : 복합함수 이므로 미분에 chain rule (연쇄 법칙)을 적용 가능하다.
2. chain rule

   

   
     - w1을 얼만큼 바꿨을 때, p가 얼마나 바뀌었을지 계산할 수 있음 ⇒ P에 대한 w1의 변화율 계산 ⇒ 기울기를 구한 것    - 한번만 계산하면 여러번 재사용할 수 있는 경우가 많음 (계산량을 획기적으로 줄일 수 있음)
     - 이를 통해 경사하강법을 할 수 있는 것
3. EXAMPLE) 2개의 피처 / 히든 레이어 1개 / 시그모이드 함수

  <순방향>

• w1, x1을 이용해 pre-activation값인 z값을 계산
• z값을 활성화함수인 시그모이드 함수에 넣음
• 위의 결과로 output이 나옴 → 예측치라고 가정
• 손실 계산 : loss function인 cross entropy 함수에 a, y(정답)을 넣음

  <역방향>
  : 손실을 줄이기 위한 w 조정 (기울기 <0 ⇒ 학습률만큼 더함 / 기울기 > 0 ⇒ 뺌

1. binary cross-entropy 함수 미분
   $$(\frac{dL}{da} ) : -[y\frac{1}{a} - (1-y)\frac{1}{1-a}] $$
2. sigmoid 함수 미분
   $$ (\frac{da}{dz}) : \sigma(z)(1-\sigma(z)) $$
   ⇒ a, b로 (\ \frac{dL}{dz}\) 계산 가능
   
   
3. \(  \frac{dz}{dw_1} \) 계산 : ax2+bx+c=0
   \(  z=w_1x_1+ w_2x_2 + b \) 식 w1으로 편미분 ⇒ x1
   
   $$ \frac{dL}{dW_1} = \frac{dL}{dz} \ \frac{dz}{dW_1} = -[y\frac{1}{a} - (1-y)\frac{1}{1-a}] * \sigma(z)(1-\sigma(z)) * x_1 $$
4. 방법
   • 각각의 input data 에 대하여, 여러개의 히든레이어가 있을 때, 각 layer 별로 forward pass output 값을 계산
     - 방법 : 각 뉴런의 pre-activation에서 wx+b를 구함 ⇒ activation 에서 활성화 함수를 통과 ⇒ 출력값 나옴
   • Output layer에 도달시, 예측 수행
   • 예측값과 실제값의 차이를 측정한 cost function 계산
   • Backpropagation 을 통해 손실함수의 손실값을 전단계의 layer 로 전달하여 기울기를 구함
   • Error term 의 값에 따라 각 layer 의 weight 를 update
     ⇒ 기울기 <0 또는 기울기 >0 에 따라서 업데이트

---

Global minimum, Learning rate, optimizer

다차원 공간에서의 데이터 분포

-  local minimum의 위치에서 제일 작은 값을 가지는 것 같지만, global minimum 값이 존재한다.
    ⇒ local minimum에 빠지면, 이상적인 가중치를 찾을 수 없음

- optimizer : global minimum에 가도록 하는 역할

 

[ Learning rate ]

: step size를 얼마만큼씩 가중치를 조정할 것인지

1. defalut : 0.01
2. 학습률이 너무 높은 경우 : 학습은 빨리됨 → 문제점 : global minimum에 도달할 수 없고, 왔다갔다함
   학습률이 너무 적은 경우 : 너무 천천히 내려감
3. 해결법 : Adaptive Learning rate 기법 → 처음엔 크게, 갈수록 조금씩 줄여준다

[optimization 방법 : SGD (stochastic Gradient Descent, 확률적 경사하강법)]

1. 방법
   • 데이터를 한 건씩 손실을 계산
   • 기울기가 +, -를 반복하며 전체 데이터가 최소점을 향해 진행됨
2. 문제점
   • 다량의 데이터이기 때문에 한 건씩 처리하는 방식은 너무 오래걸림
   • 진폭이 큰 업데이트 궤적
3. 해결법 1 : batch gradient descent
   • 전체 데이터의 기울기를 한번에 계산 → 기울기의 평균 계산
     → 평균되는 방향으로 진행시, global minimum인 값으로 가중치 업데이트 가능
   • 문제점 : 전체 데이터가 메모리에 올라가야함 (한정된 메모리 부족 이슈)
   • 장점 : 스무스한 업데이트 궤젹
4. 해결 : mini batch gradient descent
   • 파라미터의 배치 사이즈를 정함 → 작은 샘플들을 모아 경사하강법 적용 → global minimum인 값으로 이동
   • 중간 정도의 업데이트 궤적

Momentum

: 방향성을 유지하며 가속 → Global minimum 에 빨리 도달하기 위해서 !

• vertically 는 변화가 적고, horizontally 는 변화가 크도록 parameter 조절
• 경사하강법을 적용할 때, 업데이트 되던 방향을 어느정도 유지하며 진행 시, 진폭이 커지는것을 막아 빠르게 도달

1.  
2. 다차원 공간에서의 Local minumum 탈출 가능해짐
   
   • local minium 발생 원인
     : 기울기 = 0인 값만을 이용해, 그동안 움직이던 global minimum 방향을 무시하여
       local minimum 주변만 왔다갔다 움직이게되는 것
   • momentum의 탈출 방법
     : 움직이던 방향성을 수학적으로 남겨놓고 공식을 구현
3. saddle point에서 탈출 가능  
   • 기존 : 기울기 소실 현상 발생 → 기울기가 0이 되어 해당 포인트에서 멈춤
   • momentum 추가 : 관성을 유지하므로 방향을 따라서 내려갈 수 있음
4. 사람이 설정하는 파라미터임!! → 스스로 찾아주지 않음

Optimizers : 최소, 최대 값 찾기

→ 현재는 최솟값 찾는 optimizer를 공부함

→ 알고리즘에 따라 global minimum을 찾아가는 궤적이 다름

→ optimizer별로 saddle point에서 벗어나는 알고리즘이 구현되어있음

→ 어떤 데이터가 어떤 다차원 공간을 구성하냐에 따라 optimizer 성능이 달라짐

 

1. 종류
   • Stochastic Gradient Descent Optimizer
   • RMSProp Optimzer
   • Adagrad Optimizer
   • Adam Optimizer, etc

---

하이퍼파라미터와 과적합 방지 기법

Epoch

: 전체 dataset 이 neural network 을 통해 한번 처리된 것

1. 특징
   • Epoch 은 model 의 training 시에 hyper parameter 로 횟수 지정
   • 하나의 epoch 은 한번에 처리하기 어려운 size 이므로 여러 개의 batch 로 나누어 처리 (메모리 이슈)
     ⇒ 전체 데이터 (1 에폭)를 배치 사이즈로 나누어 사용 (미니배치)
   • Parameter training 을 위해서는 여러 번 epoch 을 반복해야 한다.
     ⇒ 파라미터를 반복하여 업데이트를 함
   • One epoch 내에서의 iteration 횟수 : total sample size / batch size
     ⇒ Ex) 1 epoch = 2000 training example / 500 batches = 4 iterations

Hyper-parameter

1. parameter : w, b → 스스로 학습하는 것
2. 하이퍼 파라미터 : 파라미터 제외 나머지 전부 → 사람이 지정해주는 것
   • 학습률  : \( \alpha \)
   • momentum
   • number of layers : 히든 레이어 개수
     ⇒ 적으면, 데이터의 충분한 디테일을 모델이 학습할 수 없음
     ⇒ 많다고 좋은게 아님 / 가중치 개수가 엄청나게 늘어나고, 엄청 큰 데이터의 양이 필요로 해짐
     
     
   • Dropout rate : 과적합 방지를 위해 뉴런을 죽였다가 살렸다가 하는 비율
     ⇒ 특정 뉴런이 강하게 의존되는 현상이 발생하는 것을 방지하는 것
     ⇒ 일반화 능력이 떨어지는 것 / 과적합 되는 것 / 특정 피처에 의존하는 것 을 방지
     ⇒ Dropout Regularization : 랜덤한 뉴런 선택을 진행하는 드롭아웃을 통한 과적합 방지
   • number of epochs
   • batch size
3. 하이퍼파라미터 값 결정하는 방법 : 정해진 룰이 없음
   • 유사한 모델 참조
   • 경험에 의한 추측
   • 그리드 서치 : 종류별로 다 해봐라

---

 

tensorflow 소개 및 neural network를 이용한 회귀 원리

Tensorflow란 ?

: 구글에서 사용하던 딥러닝 프레임워크를 오픈 소스로 공개한것

1. Tensorflow 설치

# GPU가 장착되어있지 않은 컴퓨터일 떄
# ANACONDA Prompt에서 실행
pip install --upgrade tensorflow

# python 을 입력하여 파이썬 인터프리터에 접
import tensorflow as tf
tf._version_ # 현재 사용 중인 버전을 확인 할 수 있음

# GPU가 지원되는 컴퓨터일때,
GPU 지원에서 CUDA 라이브러리 설치후 사용하는 방법 확인 가능

 

  2. Keras

 

# 초보자용 : Sequential API를 사용해 모델 구성
# 대부분의 모델이 가능
model = tf.keras.models.Sequentioal([
	tf.keras.layers.Flatten()
])

# 전문가용 : Subclassing API -> pandas의 class 문법을 사용
# tf.keras.Model을 상속받아 사용
class MyModel(tf.keras.Model):
	def __init__(self):
		super(MyModel, self).__init__()
		self.conv1 = Conv2D(32,3,activation='relu')
		등등
	# 순전파
	def call(self, x):
		x = self.conv1(x)
		등등
model = MyModel()
# 역전파
with tf.GradientTape() as tape :
	logits = model(images)
	loss_value = loss(logits, labels)
grads = tape.gradient(loss_value, model.trainalble_variable)

 

[ 전통적인 linear Regression vs 뉴럴네트워크로 구현한 linear Regression ]

1. 전통적인 linear Regression
   1. one layer
      : 히든레이어 없이 입력, 출력층을 바로 연결된 형태의 단일 레이어 뉴럴 네트워크
      ⇒ 전통적인 선형회귀는 one layer일 때, 동일한 모양 (수학적으로 동일)
      ⇒ 선형적인 특성만 파악
2. 뉴럴네트워크
   1. multiple-layers인 히든레이어
      • 히든레이어의 노드 : 각 뉴런에 선형적인 pre-activation, 비선형적인 activation 부분으로 나뉨
        ⇒ 히든레이어 내에서 선형성, 비선형적인 패턴을 파악해 두 특성을 함께 파악할 수 있음

실습 : neural network를 이용한 linear regression

Boston 주택 가격 예측

• 구성 : 13개의 종속변수 + 1개의 독립변수(주택가격 중앙값)

데이터 불러오기 + 정제

# 데이터 불러오기
df_boston = pd.read_csv("boston_house.csv", index_col=0)
boston = df_boston.drop('MEDV', axis=1)
target = df_boston.pop('MEDV')

X = boston.values
y = target.values

print(X.shape) (506, 13) print(y.shape) (506,)

# train, test 분리
X_train, X_test, y_train, y_test = train_test_split(X, y)

# feature scailing
sc = MinMaxScaler()
X_train = sc.fit_transform(X_train)
X_test  = sc.transform(X_test)

모델 설계, 모델 compile, 훈련 → 이게 차이점

모델 설계

# sequntial 모델 사용 : 계속 add해가면서 몯모델을 만들면 
model = Sequential()
# 히든 레이어 개수 : 64 / input shape : tuple 형태로 해야함 -> (13, ) / 활성화함수 = ReLU
model.add(Dense(64, input_shape=(13,), activation='relu'))
# 인풋을 지정안해도 됨 (첫번째 레이어의 출력이 인풋이 될 것이기 때문에) / 활성화함수 = ReLU
model.add(Dense(32, activation='relu'))
# 1개로 연결 / 활성화함수 = 없음 (이유 : linear regression 모델을 만들 것이기 때문)
model.add(Dense(1))

model.summary()
# Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 64)                896  (13 * 64+1)     
                                                                 
 dense_1 (Dense)             (None, 32)                2080 (64 * 32+1)    
                                                                 
 dense_2 (Dense)             (None, 1)                 33   (32 * 1 + 1)     
                                                                 
=================================================================
Total params: 3,009
Trainable params: 3,009
Non-trainable params: 0
_________________________________________________________________

# 모델 컴파일 
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['mae', 'mse'])

모델 훈련 및 예측

# 훈련 : loss, metrics 값이 저장
# batch_size : 클수록 좋으나, 메모리 차지가 늘어남 (하이퍼 파라미터)
# epoch : 데이터를 몇번 보여줄 것인가
# validation 데이터 지정 : X_test, y_test로
# verbose : 훈련 시, 출력 정도 (보통 1, 2 사)
history = model.fit(X_train, y_train, batch_size=32, 
                    epochs=500, validation_data=(X_test, y_test), verbose=1)

# 모델 평가 : 마지막에 찍힌 것을 한번 더 반복                   
model.evaluate(X_test, y_test, verbose=0)

# 모델 예측
y_pred = model.predict(X_test)

# 예측 평가
# MSE(mean squared error) 계산 : Mean squared error: 7.38
print("Mean squared error: {:.2f}".format(mean_squared_error(y_test, y_pred)))

# R2 계산 : R2 score: 0.91 (1에 가까울 수록 음)
print("R2 score: {:.2f}".format(r2_score(y_test, y_pred)))

# 결과 시각화
plt.scatter(y_test, y_test, label='true')
plt.scatter(y_test, y_pred, label='predict')
plt.xlabel('y_test')
plt.ylabel('y')
plt.legend()
plt.title('Boston House Price Prediction ($1,000)')

# 모델 훈련 과정 시각화
plt.plot(history.history['mse'], label='Train error')
plt.plot(history.history['val_mse'], label='Test error')
plt.ylim([0, 50])
plt.legend()

 

파랑 : 실제값, 주황 : 예측 값 → 비슷하게 다 잘 맞췄음

sklearn LinearRegression 비교

from sklearn.linear_model import LinearRegression

# 모델 설계
regr = LinearRegression()
# 모델 훈련
regr.fit(X_train, y_train)
# 예측
y_pred = regr.predict(X_test)

# The coefficients : 
print('Coefficients: \\n', regr.coef_)
print('Intercept: \\n', regr.intercept_)

# MSE(mean squared error) 계산
print("Mean squared error: {:.2f}".format(mean_squared_error(y_test, y_pred)))

# R2 계산 
print("R2 score: {:.2f}".format(r2_score(y_test, y_pred)))

plt.scatter(y_test, y_pred)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], '--', c='r')
plt.xlabel('y_test')
plt.ylabel('y_pred')
plt.title('Boston House Price Prediction ($1,000)')

---

자동차 연비 계산

데이터 불러오기 + 정제

# 링크로 불러와서 데이터를 다운로드 받기
data_path = tf.keras.utils.get_file("auto-mpg.data", 
        "<https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data>")
column_names = ['mpg', 'cylinders', 'displacement', 'horsepower', 'weight', 'acceleration', 'model year', 'origin']
rawdata = pd.read_csv(data_path, names=column_names, na_values="?", comment="\\t", sep=" ", skipinitialspace=True)

# null 데이터 삭제
rawdata.dropna(inplace=True)
data = rawdata.copy()
# 원핫 인코딩
data = pd.get_dummies(data, columns=['cylinders', 'origin'])
# 레이블 지정
label = data.pop('mpg')
# train / test split
X_train, X_test, y_train, y_test = train_test_split(data.values, label.values)
# 피처 스케일링
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

Regression Model Build

# sequntial 모델
model = Sequential()
model.add(Dense(64, input_shape=(13,), activation='relu')
model.add(Dense(32, activation='relu'))
model.add(Dense(1))
model.summary()

# 모델 컴파일 
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['mae', 'mse'])

train / predict

# 훈련
history = model.fit(X_train, y_train, batch_size=32, 
                    epochs=500, validation_data=(X_test, y_test), verbose=1)
# 모델 평가 : 마지막에 찍힌 것을 한번 더 반복                   
model.evaluate(X_test, y_test, verbose=0)
# 모델 예측
y_pred = model.predict(X_test)

r2 계산

# R2 계산 : R2 score: 0.91 (1에 가까울 수록 음)
print("R2 score: {:.2f}".format(r2_score(y_test, y_pred)))

시각화

# 결과 시각화
plt.scatter(y_test, y_test, label='true')
plt.scatter(y_test, y_pred, label='predict')
plt.xlabel('y_test')
plt.ylabel('y')
plt.legend()
plt.title('Boston House Price Prediction ($1,000)')

# displacement가 얼마일때, 연비가 얼마인지 확인
plt.scatter(X_test[:, 0], y_test, label='true value')
plt.scatter(X_test[:, 0], y_pre, label='predicted value')
plt.xlabel('displacement')
plt.ylabel('mpg')
plt.legend()

 

비슷하게 맞췄다.

---

Neural network를 이용한 이진분류

(Logistic Regression, binary classification)

Sigmoid 함수

$$ f(z) = \frac{1}{1+e^{-z}} \ \ \ (z = \theta X) $$

1. 함수 소개
   • z : logit (logit 안에 linear regression의 wx+b의 공식이 들어간다)
   • S curve 형성 : 0.5 부근에서 급격히 변화하는 함
   • [0, 1] 로 바운드 ⇒ 확률로 생각가능
   • 미분이 쉬움 (이유 : e )
2. linear regression과 비교
   • 공동점 : 로짓을 구하는 부분이 동일
   • 차이점 : 이진분류의 경우, sigmoid를 적용한다

neural net을 적용한 logistic regression

neural network regression 모델의 output layer에 activation 함수만 지정한 형태

1. output
   1. 활성화 함수 $\sigma (z)$ : sigmoid 함수
   2. 뉴런 : 1개 (시그모이드 함수로 나온 확률값 >0.5 ⇒ 1 / < 0.5 ⇒ 0)
      
      

실습 : Malware Detection

데이터 불러오기 및 정제

df = pd.read_csv('datasets/malware.csv', index_col=0)
# X, y로 지정
X = df.values
y = df.pop('legitimate').values

X.shape, y.shape #((10000, 54), (10000,))

# train, test 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# 피처 스케일링
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test  = sc.transform(X_test)

모델 설계

# 모델 구성
model = tf.keras.Sequential()
model.add(Dense(32, input_shape=(54,), activation="relu"))
model.add(Dense(16, activation="relu"))
model.add(Dense(1, **activation="sigmoid"**))

model.summary()
# Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 32)                1760  (32 * 54+1)    
                                                                 
 dense_1 (Dense)             (None, 16)                528        
                                                                 
 dense_2 (Dense)             (None, 1)                 17        
                                                                 
=================================================================
Total params: 2,305
Trainable params: 2,305
Non-trainable params: 0

# 모델 컴파일 : 이진분류 이므로 손실은 binary_crossentropy
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=["accuracy"])

모델 훈련 + 평가

# 모델 훈련 
history = model.fit(X_train, y_train, epochs=20, batch_size=32,
                    validation_data=(X_test, y_test))

score = model.evaluate(X_test, y_test, verbose=0)

print(model.metrics_names)
print("Test score : {:.2f}".format(score[0]))
print("Test accuracy : {:.2f}".format(score[1]))

결과 시각화

# 모델 결과 정확도 시화
plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend(['train', 'test'])
# 모델 결과 손실 : 살짝 과적합됨 -> 갈수록 점점 손실이 오르는 중
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'test'])

예측

# y_pred가 1일 확률이므로 0.5와 비교하여 T/F로 바꾸는 작업이 필요
y_pred = model.predict(X_test) > 0.5
accuracy_score(y_test, y_pred) # 0.9905