인공재환

3장 신경망을 배우기 전, 

퍼셉트론에 대해 알고 가야할 필요가 있다.

퍼셉트론이란 다수의 신호를 입력으로 받아 하나의 신호를 출력하는 것을 말한다.

또한 이를 통해서 AND,OR,NAND 게이트를 구현해 보았다. 

퍼셉트론은 신경망의 기초가 되는 개념으로, 신경망과 유사한 개념이라고도 볼 수 있다.

신경망

위 그림을 신경망이라고 하고, 왼쪽부터 각각 입력층, 은닉층, 출력층이라고 한다.

'은닉층'이라고 하는 이유는 사람의 눈에는 보이지 않는다. (입력, 출력층과 달리)

 또한 왼쪽부터 책에서는 0층,1층,2층이라고도 말한다.

활성화 함수

활성화 함수란 입력 신호의 총합을 출력 신호로 변환하는 함수를 말한다.

앞에서 배운 시그모이드, 소프트맥스, 렐루 등이 그 예이다.

시그모이드 함수

exp^-x는 e^-x를 뜻하며,  e는 자연상수로 2.7182...의 값을 가지는 실수이다.

계단함수를 이용해서 시그모이드 함수를 더 알아보도록 하자.

계단함수는 입력이 0을 넘으면 1을, 그외에는 0을 출력하는 함수이다.

이를 파이썬으로 구현해보면 다음과 같다.

def step_function(x):
	if x > 0:
    	return 1
    else:
    	return 0

여기서 만약 x인수에 단일 실수값이 아닌, 배열을 넣고 싶다면??

def step_function(x):
	y = x > 0
    return y.astype(np.int)

계단함수의 그래프

import numpy as np
import matplotlib.pyplot as plt
def step_function(x):
    return np.array(x>0, dtype=np.int)

x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x,y)
plt.ylim(-0.1, 1.1)
plt.show()

계단 함수라는 말 그대로 0을 기준으로 출력이 0->1로 바로 바뀌는 것을 볼 수 있다.

이어서 시그모이드 함수를 직접 구현해보자.

def sigmoid(x):
	return 1 / ( 1 + np.exp(-x))

 인수 x가 배열이여도 결과가 정상적으로 출력된다!

x = np.array([-1.0, 1.0, 2.0])
sigmoid(x)

array([0.26894142, 0.73105858, 0.88079708])

배열을 넣어도 올바르게 결과가 나오는 것은 넘파이 라이브러리의 브로드캐스트 기능덕분이다.

브로드캐스트는 넘파이 배열과 스칼라값의 연산을 넘파이 배열의 원소 각각과 스칼라값의 연산으로 바꿔 수행하는 것을 말한다.

예를 들면

t = np.array([1.0, 2.0, 3.0])
1.0 + t

array([2., 3., 4.])

1.0 / t

array([1.        , 0.5       , 0.33333333])

스칼라값 1.0 과 배열 t 사이에서 연산이 각 원소별로 이루어진것을 브로드캐스팅이라고 하는것.!

이제 시그모이드 함수를 그래프로 그려보자.

x = np.arange(-5, 5, 0.1)
y = sigmoid(x)
plt.plot(x,y)
plt.ylim(-0.1, 1.1)
plt.show()

위의 계단함수와 비교해봤을때 차이는 매끄럽냐vs아니다. (연속적)

이 매끈한것이 신경망 학습에서 중요한 역할을 하게된다고 한다.

비선형 함수

계단함수, 시그모이드 함수의 공통점은 모두 비선형 함수라는 것이다. 

시그모이드 = 곡선, 계단 함수 = 구부러진 직선

신경망에서 사용하는 활성화 함수로는 비선형 함수만을 사용해야 한다.  (선형 함수 =>   y= ax+ b인 직선)

(신경망의 층을 깊게 하는 의미가 없어지기 때문에)

선형 함수의 문제는 층을 아무리 깊게 해도 '은닉층이 없는 네트워크'로도 똑같은 기능을 할 수 있다는 데 있다.

ex) h(x) =cx이고 3층 네트워크라고 하면 y(x)=h(h(h(x)))이고, 이는 y(x)=c*c*c , c^3이다.

즉, 은닉층이 필요없는 구조라고 볼 수 있다. 이러면 은닉층이 갖는 benefits을 포기하는 것이기 때문에 

더 구체적이고 예민한 비선형함수를 사용해야 하는것이다.

ReLU 함수

시그모이드 함수는 신경망에서 예전부터 많이 이용해왔는데, 최근에는 ReLU함수를 주로 이용한다고 한다.

ReLU함수는 입력이 0을 넘으면 그 입력을 그대로 출력, 0이하이면 0을 출력하는 함수다.

식으로는

코드로는

def ReLU(x):
	return np.maximum(0, x)

다차원 배열

신경망을 효율적으로 구현하려면 다차원 배열의 개념을 알고 있어야 한다.

다차원 배열의 기본 개념은 "숫자의 집합"이라고 할 수 있다.

숫자가 한 줄로 늘어선 것, 직사각형으로 늘어놓은 것, 3차원으로 늘어놓은 것 등등... 을 모두 다차원 배열이라고 할 수 있다.

A = np.array([1, 2, 3, 4])
print(A)

[1 2 3 4]

np.ndim(A)

1

A.shape

(4,)

배열의 차원수를 알려주는 np.ndim()

배열의 모양 shape (함수아님 인스턴수 변수임)

.shape은 또한 튜플을 반환하는데, 그 이유는 1차원 배열일지라도 다차원 배열일 때와 통일된 형태로 반환하기 위함이다.

ex)2차원 배열일 때는 (4,3) , 3차원 배열일 때는 (4,3,2) 를 반환한다.

이제 2차원 배열을 구현해보자.

B = np.array([1,2], [3,4], [5,6]])
print(B)

[[1 2]
 [3 4]
 [5 6]]

np.ndim(B)
2

B.shape
(3,2)

여기서는 3X2 배열인 B를 작성했다.

3x2 행렬이라고 볼 수 있다.

-----행렬 생략-------

3층 신경망 구현하기

이제 3층 신경망을 구현해보고자 한다. ( 3층 = 0층~3층, 총 4개의 층)

0층 : 입력층 - 2개

1층 : 은닉층 - 3개

2층 : 은닉층 - 2개

3층 : 출력층 - 2개의 뉴런으로 구성되어 있다.

여기서 각 뉴런사이의 화살표에 집중해보자.

입력층의 뉴런에서 은닉층의 뉴런으로 이어져 있는 선이 있다.

더 자세히 말하자면 입력층의 두 번째 뉴런에서 은닉층의 첫 번째 뉴런으로 이어져 있는데,

이를 W1,2라고 표현한다. (앞에가 도착지, 뒤에가 출발지)

이제 절편 (편향)을 추가하여 신호 전달을 구현해보자.

위의 그림에서 a1을 수식으로 나타내보자.

a1 = w11 * x1 + w12 * x2 + b

여기서 행렬곱을 사용하여 1층의 가중치 부분을 간소화 할 수 있다.

A = XW + B

행렬 A, X, B, W는 각각 다음과 같다.

A = (a1 a2 a3) , X = (x1 x2) , B = (b1, b2 , b3)

W = (w11, w21, w31)

        (w12, w22, w32)

이제 식 A = XW +B를 구현해보자.

X = np.array([1.0, 0.5])
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
B1 = np.array([0.1, 0.2, 0.3])

print(W1.shape)
print(X.shape)
print(B1.shape)

(2, 3)
(2,)
(3,)

A1 = np.dot(X, W1) + B1

위 코드를 그림으로 보면 아래처럼 된다.

h(), 즉 은닉층의 노드를 보면 a1이 z1로 변하는데,

a1은 앞의 입력층에서 1 (편향, 절편) + w11 * x1 + w12 * x2의 합이고,

이 a1이 활성화 함수를 지나서 z1로 변환된 것이다.

이제 1층에서 2층으로 가는 과정을 살펴보고 구현해보자.

W2 = np.array([[0.1, 0.4] ,[0.2, 0.5], [0.3, 0.6]])
B2 = np.array([0.1, 0.2])

print(Z1.shape)
print(W2.shape)
print(B2.shape)
(3,)
(3, 2)
(2,)

A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)

1층과 마찬가지로 같다!

이제 마지막으로 2층에서 출력층으로 가는 신호 전달과정을 살펴보자.

 def identity_function(x):
 	 return x
     
W3 = np.array([[0.1, 0.3], [0.2, 0.4]])
B3 = np.array([0.1, 0.2])

A3 = np.dot(Z2, W3) + B3
Y = identity_function(A3)  # 혹은 Y=A3

미리 보기 - 텐서플로를 사용해 순환 신경망을 만들어 영화 리뷰 데이터셋에 적용해서 리뷰를 긍정/부정으로 분류하기

<<<키워드>>>

- 원 핫 인코딩

- 단어 임베딩

IMDB 데이터셋

유명한 영화 데이터베스인 imdb.com에서 수집한 리뷰를 감상평에 따라 긍정 / 부정으로 분류해 놓은 데이터셋이다.

총 50,000개의 샘플로 이루어져 있고 훈련데이터와 테스트 데이터에 각각 25,000개씩 나누어져 있다!

데이터로 텍스트 자체를 신경망에 전달?? X 컴퓨터는 숫자 데이터를 다루기 용이하므로 단어를 숫자 데이터로 바꾸는 작업 필요하다.! like 원-핫 인코딩   --> 토큰으로 변환 !!

하나의 샘플은 여러 개의 토큰으로 이루어져 있고 1개의 토큰이 1개의 타임스텝에 해당한다.

IMDB 데이터셋을 두 가지 방법으로 순환 신경망에 적용시켜보자!

1. 원-핫 인코딩

2. 단어 임베딩

keras 데이터셋 패키지의 imdb 모듈을 import해서 자주 사용하는 단어 500개를 불러오자.

( num_words 매개변수를 500으로 지정 )

from tensorflow.keras.datasets import imdb
(train_input, train_target),(test_input, test_target) = imdb.load_data(num_words=500)

print( train_input.shape, test_input.shape )
(25000,) (25000,)

훈련 세트와 테스트 세트의 크기 25,000씩인것까지 확인!

근데 (25000,) 을 보듯이 배열이 1차원이다.! 

텍스트 데이터 특성상 길이가 제각각이므로 고정 2차원 배열에 담는것보다 메모리 효율적이므로 1차원에 저장하는것이다!

즉, 넘파이 배열안에  정수,숫자가 아닌 개별 리뷰가 담겨있다고 볼 수 있다.

첫 번째 리뷰의 길이를 출력해보자!!

print(len(train_input[0]))

218

218개의 토큰으로 이루어져 있다.!

이제 길이말고 내용을 출력해보고 싶다!

print(train_input[0])

[1, 14, 22, 16, 43, 2, 2, 2, 2, 65, 458, 2, 66, 2, 4, 173,36, 256, 5, 25, 100, 43, 2, 112, 50,
2, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 2, 2, 17, 2, 38, 13
, 447, 4, 192, 50, 16, 6, 147, 2, 19, 14, 22, 4, 2, 2, 469, 4, 22, 71, 87, 12, 16, 43, 2, 38, 
76, 15, 13, 2, 4, 22, 17, 2, 17, 12, 16, 2, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2, 2
, 16, 480, 66, 2, 33, 4, 130, 12, 16, 38, 2, 5, 25, 124, 51, 36, 135, 48, 25, 2, 33, 6, 22, 
12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 2, 15, 256, 4, 2, 7, 2, 5, 2, 36, 
71, 43, 2, 476, 26, 400, 317, 46, 7, 4, 2, 2, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2, 56, 26
, 141, 6, 194, 2, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30,2, 18, 51, 36, 28, 224, 92
, 25, 104, 4, 226, 65, 16, 38, 2, 88, 12, 16, 283, 5, 16, 2, 113, 103, 32, 15, 16, 2, 19, 178,32]

텐서플로에 있는 IMDB 리뷰 데이터는 이미 정수로 변환되어서 개별 토큰으로 출력된다.

참고로 num_words=500으로 지정했기 때문에 어휘 사전에는 500개의 단어만 들어가있다.

따라서 어휘 사전에 없는 단어는 모두 2로 표시 된다!!!

이제 타겟 데이터를 출력해보자.!

print(train_target[:20])

[1 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 1 1 0 1]

타겟 데이터 => 0: 부정, 1: 긍정

데이터를 더 살펴보기 전 훈련세트에서 검증세트를 떼어 놓자 !

from sklearn.model_selection import train_test_split
train_input, val_input, train_target, val_target = train_test_split(
train_input, train_target, test_size=0.2, random_state= 42)

20%를 검증세트로 떼어 놓았으니 훈련 세트의 크기는 20,000개로 줄어들것.

이제 훈련 세트에 대해 몇 가지를 건드려보자.!

각 리뷰의 길이들을 확인해보고 싶다.!! 

-> 각 리뷰의 길이를 계산해 넘파이 배열에 담고, 리스트 함축 구문을 이용해 train_input의 원소를 순회하면서 길이를 알아보자.

import numpy as np
lengths = np.array([len(x) for x in train_input])

print(np.mean(lengths), np.median(lengths))
239.00925 178.0

평균 = 239     /   중간값 = 178

평균값과 중간값이 차이가 많이 나므로 데이터의 분포가 한쪽에 치우쳐져 있을 것이다.

import matplotlib.pyplot as plt
plt.hist(lengths)
plt.xlabel('length')
plt.ylabel('frequency')
plt.show()

대부분의 리뷰 길이는 300이 안되는것을 확인할 수 있다.!

연습삼아 100개의 단어만 사용해보자!

하지만 100개의 단어도 안되는 리뷰가 굉장히 많으므로 앞서 배운 패딩을 적용시켜야 한다.

보통 업계에서 패딩을 나타내는 토큰으로는 0을 사용한다고 한다.

케라스의 시퀀스 데이터의 길이는 맞추는 메소드를 이용해보자 (pad_sequences()).

이 메소드를 이용해서 train_input의 길이를 100으로 간편하게 맞춰보자.

from tensorflow.keras.preprocessing.sequence import pad_sequences
train_seq = pad_sequences(train_input, maxlen=100) # 패딩으로 train_input길이를 100으로 맞춤

# 100보다 길면 잘라내고 짧으면 0으로 패딩 ->

100으로 패딩한 train_seq을 출력해보자.

print(train_seq.shape)

(20000, 100)

아무래도 2차원 배열이 데이터를 다루기에 효율적이므로,

패딩을 이용해 길이를 같게 해줌으로써 2차원 배열로 만든것 같다!

샘플 개수 = 25,000개에서 20%떼어냈으므로 20,000개,

토큰 개수 = 100으로 패딩했으므로 100개로  이루어진 2차원배열이다!!

train_seq에 있는 첫 번째 샘플을 출력해보자.

print(train_seq[0])

[ 10   4  20   9   2 364 352   5  45   6   2   2  33 269   8   2 142   2
   5   2  17  73  17 204   5   2  19  55   2   2  92  66 104  14  20  93
  76   2 151  33   4  58  12 188   2 151  12 215  69 224 142  73 237   6
   2   7   2   2 188   2 103  14  31  10  10 451   7   2   5   2  80  91
   2  30   2  34  14  20 151  50  26 131  49   2  84  46  50  37  80  79
   6   2  46   7  14  20  10  10 470 158]

이 샘플의 앞뒤에 패딩값 0이 없는것으로 보아 100보다는 긴 리뷰라고 볼 수 있다.!

원래 샘플의 앞vs뒤 부분중 어디가 잘렸을지 확인해보기 위해 train_input에 있는 원본 샘플의 끝을 먼저 보자.

print(train_input[0][-10:])

[6, 2, 46, 7, 14, 20, 10, 10, 470, 158]

음수 인덱스와 슬라이싱을 사용해 train_input[0]에 있는 마지막 10개의 토큰을 출력했다

train_seq[0]의 출력값과 정확히 일치하는것 또한 확인할 수 있다.

그러면????

샘플 앞부분이 잘렸다는 것!!

참고)  pad_sequences 메소드는 기본적으로 maxlen보다 긴 시퀀스의 앞부분을 자른다고 한다!!!

이유-> 일반적으로 텍스트 中 중요한 정보는 뒷부분(어미)에 나올 확률이 높기 때문..

하지만!! 

그럼에도 불구하고 앞부분을 자르고 싶다면 

pad_sequences( truncating = 'post') 로 설정해주면 된다. truncating = 'pre'가 default값

print(train_seq[5])

[  0   0   0   0   1   2 195  19  49   2   2 190   4   2 352   2 183  10
  10  13  82  79   4   2  36  71 269   8   2  25  19  49   7   4   2   2
   2   2   2  10  10  48  25  40   2  11   2   2  40   2   2   5   4   2
   2  95  14 238  56 129   2  10  10  21   2  94 364 352   2   2  11 190
  24 484   2   7  94 205 405  10  10  87   2  34  49   2   7   2   2   2
   2   2 290   2  46  48  64  18   4   2]

이 6번째 샘플을 보면 앞 부분이 0으로 채워져 있는것으로 보아 리뷰 길이가 100이 안되는것을 확인할 수 있다.

또한, 앞 부분이 0으로 채워져 있는것으로 보아 위와 같은 이유(중요한 부분 -> 뒤에 있다.)로 인해

패딩토큰은 시퀀스의 뒷부분이 아닌 앞부분에 추가된다는것을 엿볼 수 있다.

하지만!!!!!

또 뒷부분을 0으로 채우고싶다면

pad_sequences( padding = 'post')로 바꿔주면 된다.!

이제 검증 세트의 길이도 100으로 맞춰보고 본격적으로 해보자.

val_seq = pad_sequences(val_input, maxlen=100)

훈련 세트, 검증 세트 모두 100으로 패딩완료.

순환 신경망 만들기

가장 간단한 클래스인 SimpleRNN클래스를 이용

IMDB 리뷰 긍정/부정 분류 모델이므로 이진분류---> 따라서 활성화 함수는 시그모이드로 선택

from tensorflow import keras

model = keras.Sequential()
model.add(keras.layers.SimpleRNN(8, input_shape=(100, 500)))
model.add(keras.layers.Dense(1, activation = 'sigmoid'))

<<SimpleRNN의 첫 번째 매개변수 X = 사용할 뉴런의 개수>> -> CNN과 동일

input_shape = (100,500)으로 했는데, 첫 번째 차원이 100인 것은 앞에서 샘플의 길이를 100으로 지정했기 때문이다.!

두 번째 차원이 500인 것은, 원-핫 인코딩을 위해 배열의 길이를 설정해준것!

(기존의 정수는 크기가 제각각이지만, 그 크기에는 순서와 의미가 없다. 따라서 그것을 제거해주는 원핫인코딩이 필요)

새로 등장한 개념인 순환층또한 활성화 함수가 필요하다! SimpleRNN의 기본 활성화 함수는 

하이퍼볼릭 탄젠트 함수인 tanh라는 매우 강력해보이는 함수를 사용한다. tanh => -1~1출력하는 시그모이드

우리는 원-핫 인코딩을 제공하는 모듈을 사용하도록 하자!

train_oh라는 매개변수 : train_seq을 원핫인코딩으로 변환한 배열

train_oh = keras.utils.to_categorical(train_seq)

print(train_oh.shape)
(20000, 100, 500)

배열 크기 20,000개인 이유 => 정수 하나하나 모두 500차원의 배열로 변경되었음 (20000, 100)크기의 train_seq이 

(20000,100,500으로 변한것)

이렇게 샘플 데이터의 크기가 1차원 정수배열(100,)에서 2차원 배열 (100, 500)로 바꿔야하므 SimpleRNN 클래스의 input_shape매개변수의 값을 (100,500)으로 지정한 것이다.

이제 인코딩이 잘 되었는지 확인해보자.

print(train_oh[0][0][:12])


[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]

< train의 첫 번째 샘플의 첫 번째 토큰 中 12개 원소 > -> 인코딩이 잘 되었음을 확인

이제 val도 인코딩

val_oh = keras.utils.to_categorical(val_seq)

모델 요약 !

model.summary()

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 simple_rnn (SimpleRNN)      (None, 8)                 4072      
                                                                 
 dense (Dense)               (None, 1)                 9         
                                                                 
=================================================================
Total params: 4,081
Trainable params: 4,081
Non-trainable params: 0
_________________________________________________________________

rmsprop = keras.optimizers.RMSprop(learning_rate=0.4)

model.compile(optimizer = rmsprop, loss = 'binary_crossentropy',
				metrics=['accuracy'])
                
check_point_cb = keras.callbacks.ModelCheckpoint('best-simplernn-model.h5',
						save_best_only = True)
earlystopping_cb= kerars.callbacks.EarlyStopping(patience=3, restore_best_weights=True)

history=model.fit(train_oh,train_target, epochs=100, batch_size=64,
				validation_data = (val_oh, val_target),
				callbacks = [check_point_cb, earlystopping_cb])

Epoch 1/100
313/313 [==============================] - 7s 19ms/step - loss: 0.7534 - accuracy: 0.4992 - val_loss: 0.7433 - val_accuracy: 0.5002
Epoch 2/100
313/313 [==============================] - 6s 18ms/step - loss: 0.7456 - accuracy: 0.4998 - val_loss: 0.7360 - val_accuracy: 0.4996
Epoch 3/100
313/313 [==============================] - 6s 18ms/step - loss: 0.7392 - accuracy: 0.4992 - val_loss: 0.7300 - val_accuracy: 0.5032
Epoch 4/100
313/313 [==============================] - 6s 18ms/step - loss: 0.7332 - accuracy: 0.4992 - val_loss: 0.7240 - val_accuracy: 0.5048
Epoch 5/100
...............................................................................................
313/313 [==============================] - 6s 18ms/step - loss: 0.6931 - accuracy: 0.5112 - val_loss: 0.6934 - val_accuracy: 0.5028
Epoch 33/100
313/313 [==============================] - 6s 18ms/step - loss: 0.6931 - accuracy: 0.5127 - val_loss: 0.6933 - val_accuracy: 0.5028

조기 종료(33회) 시의 에포크를 확인해보자! 정확도도 약 80%로 뛰어난 편이라고 할 수 있다.

이제 훈련 손실과 검증 손실을 이용해 그래프를 그려보자.

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend(['train','val'])
plt.show()

단어 임베딩

순환 신경망에서 텍스트 처리 방법의 일종으로,

각 단어를 고정된 크기의 실수 벡터로 만들어 주는 것.!

보통 NLP에서는 원-핫 인코딩 보다 단어 임베딩이 더 좋다고한다..!

(원핫 인코딩된 숫자보다 의미 있는 값으로 채워줄 수 있다고해서)

또한 단어 임베딩의 장점 : 입력으로 정수를 받을 수 있다..!

<<즉, 원-핫 인코딩으로 변경된 train_oh 배열이 아니 train_seq를 사용할 수 있다. -> 메모리 효율적>>

이 또한 케라스 라이브러리에 있는 모듈을 사용해보자.

model2 = keras.Sequential()
model2.add(keras.layers.Embedding(500, 16, input_length = 100))
model2.add(keras.layers.SimpleRNN(8))
model2.add(keras.layers.Dense(1, activation = 'sigmoid'))

Embedding에 있는 500은 어휘 사전의 크기이다. (앞서서 설정한 500)

              ""               16은  임베딩 벡터의 크기이다.

모델 요약!

model2.summary()

Model2: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding_1 (Embedding)     (None, 100, 16)           8000      
                                                                 
 simple_rnn_2 (SimpleRNN)    (None, 8)                 200       
                                                                 
 dense_2 (Dense)             (None, 1)                 9         
                                                                 
=================================================================
Total params: 8,209
Trainable params: 8,209
Non-trainable params: 0
_________________________________________________________________

키워드 :  순차 데이터

               피드포워드 신경망

               타임스텝

               은닉 상태

댓글 등 텍스트를 인식하여 어떠한 평가, 의견등을 분석해 볼 수 있을까??

ex) 상품 판매 홈페이지에서 댓글을 통해 상품에 대한 긍정 / 부정적인 의견 구분하기

순차 데이터

순차 데이터는 텍스트, 리스트와 같이 순서에 의미가 있는 데이터를 말한다. ( 시계열 데이터 )

우리가 여태까지 사용했던 feature 데이터 등은 순서가 중요하지 않았다.

( 사용자 A : "별로지만 추천해요." ==> 긍정 부정 판단시 애매함, 순서 고려해야함 !! )

앞서 우리가 머신러닝 말고도 딥러닝의 완전 연결 신경망이나 CNN에서는 하나의 샘플에 대해 정방향 계산을 수행하고 

나면, 그 샘플은 버려지고 다시 사용하지 않았다.!!

이렇게 입력데이터의 흐름이 앞으로만 전달되는 신경망을 피드포워드 신경망이라고 한다.!!

신경망이 이전에 처리했던 샘플을 처리하는데 재사용하기 위해 이렇게 데이터의 흐름 앞으로 전해져선 안된다고 한다.

다음 샘플을 위해선 이전 데이터가 신경망 층에 순환될 필요가 있다. 이러한 신경망을 순환 신경망이라고 한다.

순환 신경망

순환 신경망은 일반적인 완전 연결 신경망과 거의 비슷하다.

완전 연결 신경망에서 이전 데이터의 처리 흐름을 순환하는 고리 하나만 추가하면 된다!!!

( 아래 그림에서 은닉층에 있는 붉은 고리처럼 )

그림을 보면 뉴런의 출력이 다시 자기 자신으로 되돌아온다. (재사용)

예를 들어 A,B,C 3개의 샘플을 처리하는 순환 신경망의 뉴런을 가정해보자. 첫 번째 A를 처리하고 난 뒤는 어떻게 될까?

첫 번째 샘플인 A를 처리하고, 다시 뉴런으로 들어간다. 그다음 B를 처리할 때 앞에서 A를 사용해 만든 출력 OA를 함께 사용한다.

따라서 OB에는 A에 대한 정보도 어느정도 포함되어 있을 것이다. 그다음 C도 마찬가지로 Ob를 함꼐 사용한다. (누적되겠지?)

이렇게 샘플을 처리하는 한 단계를 타임스텝이라고 말한다.

※OC에는 A보다 B에 대한 정보가 더 많다!!※--> 최신화 가중치?

순환 신경망에서는 층을 셀이라고 말한다.

하나의 셀에는 여러 개의 뉴런이 있지만 완전 연결 신경망과 달리 뉴런을 모두 표시하지 않고 하나의 셀로 층을 표현한다. 

또 셀의 출력을 은닉 상태라고 말한다.!!

--> summary : 기존의 연결 신경망 : 입력에 어떤 가중치를 곱하고 활성화 함수를 통과시                             켜 다음층으로 보내는것. 

                            + 층의 출력을 다음 스텝에서 재사용하면 순환 신경망

일반적으로 은닉층의 활성화 함수는 하이퍼볼릭 탄젠트 함수를 사용한다. tanh 

모양은 시그모이드함수와 비슷하게 생겼다.

차이점은 시그모이드와 달리 -1 ~ 1의 범위를 가진다.

아까 순환신경망은 재사용 빼고 다 같다고 했는데, 그렇다면 가중치는 어떻게 될까??

순환 신경망에서의 뉴런은 가중치가 하나 더 있다. 

이전 타임스텝의 은닉 상태에 곱해지는 가중치

Wx : 입력에 곱해지는 가중치

Wh : 이전 타임스텝의 은닉 상태에 곱해지는 가중치

셀의 은닉 상태 ( = 출력 )가 다음 타임스텝에서 재사용되기 때문에 타임스텝으로 셀을 나눠서 다시 그림을 보자.

셀의 가중치와 입출력

순환 신경망의 셀에서 필요한 가중치의 크기를 계산 해보자.

입력층 4개, 순환층 3개

Wx :  4 x 3 = 12

Wh :  3 x 3 = 9개

Wh의 크기는 n^2이다.

이제 모델 파라미터 개수 = 가중치 + 절편

12 + 9 + 3 이므로 24가지의 파라미터가 있음을 확인할 수 있다.!!

순환층의 입력 / 출력

CNN을 생각해 보면 합성곱 층의 입력은 전형적으로 하나의 샘플이 3개의 차원을 가집니다.

너비, 높이, 채널이다. 입력이 합성곱 층과 풀링 층을 통과하면 너비, 높이, 채널의 크기가 달라지지만 차원의 개수는 그대로 유지된다 !!!

순환층은 일반적으로 샘플마다 2개의 차원을 가진다. 

보통 하나의 샘플을 하나의 시퀀스라고 말한다고 한다고 한다.

시퀀스 안에는 여러 개의 아이템이 들어 있는데, 여기에서 시퀀스의 길이가 타임스텝의 길이가 된다!!!

ex) " I am a boy. "

이 샘플은 4개의 단어로 이루어져 있는데, 각 단어를 3개의 어떤 숫자로 표현한다고 가정해보자.

이런 입력이 순환층을 통과하면 두 번째, 세 번째 차원이 사라지고 순환층의 뉴런 개수만큼 출력된다.

이를 차근차근 설명해 보겠다. 

가중치 시각화

CNN은 여러 개의 필터를 사용해 이미지에서 특징을 학습한다.

각 필터는 커널이라 부르는 가중치와 절편을 가지고 있다.

가중치의 경우 입력 이미지를 2차원으로 적용하면 어떤 특징을 크게 두드러지게하는데, 그림으로 보면

색이 있는 공간은 값이 높고, 아니면 낮을 것이다.

이전에 학습했던 데이터를 불러오자 checkpoint 파일 불러오기

from tensorflow import keras
model = keras.models.load_model('best-cnn-model.h5')

model.layers

[<keras.layers.convolutional.conv2d.Conv2D at 0x24c86ab22b0>,
 <keras.layers.pooling.max_pooling2d.MaxPooling2D at 0x24c86a9c220>,
 <keras.layers.convolutional.conv2d.Conv2D at 0x24cfacd7580>,
 <keras.layers.pooling.max_pooling2d.MaxPooling2D at 0x24cfacd4be0>,
 <keras.layers.reshaping.flatten.Flatten at 0x24cfabec670>,
 <keras.layers.core.dense.Dense at 0x24cfabe01c0>,
 <keras.layers.regularization.dropout.Dropout at 0x24cfb2fe400>,
 <keras.layers.core.dense.Dense at 0x24cfabfe760>]

conv = 모델의 첫 번째 층 : 첫 번째 CNN ( 필터 32개, 커널 사이즈 3x3 )

conv의 가중치의 첫 번째 원소와 두번 째 원소의 크기를 출력해보자.

첫 번째 원소 = 가중치

두 번째 원소 = 절편

conv = model.layers[0]
print(conv.weights[0].shape, conv.weights[1].shape)

(3, 3, 1, 32) (32,)

커널의 크기 3x3이므로 3,3,1이 커널의 크기로 출력되었고, 필터 개수 32개 임을 확인할 수 있다.

절편은 (32,) ==> 필터마다 1개의 절편 존재하므로 32개의 상수가 있음을 확인할 수 있다.

conv_weights = conv.weights[0].numpy()
print(conv_weights.mean(), conv_weights.std())

-0.025013467 0.2464292

가중치 배열의 평균 / 표준편차를 계산

0에 가깝고 표준편차는 0.27이다.

import matplotlib.pyplot as plt
plt.hist(conv_weights.reshape(-1,1))
plt.xlabel('weight')
plt.ylabel('count')
plt.show()

균일해보이지 않다!!!

이제 훈련 전의 데이터의 가중치를 살펴보자.

not_training = keras.Sequential()
not_training.add(keras.layers.Conv2D(32,kernel_size=3, activation = 'relu', 
                                    padding='same', input_shape=(28,28,1)))

not_training_conv = not_training.layers[0]
print(not_training_conv.weights[0].shape)

(3, 3, 1, 32)

평균 / 표준편차를 출력해보자.

not_training_weights = not_training_conv.weights[0].numpy()

print(not_training_weights.mean(),not_training_weights.std())

-0.003274826 0.08374746

아까처럼 가중치의 배열을 그림으로 표현해보자.

plt.hist(not_training_weights.reshape(-1,1))
plt.xlabel('weight')
plt.ylabel('count')
plt.show()

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import warnings
from sklearn.model_selection import GridSearchCV
from xgboost import XGBClassifier
import warnings
warnings.simplefilter(action= 'ignore', category=FutureWarning)

오늘은 부스팅이 해보고 싶어서 XGB Classifier를 이용하여 분류해보고자 한다.

하이퍼파라미터탐색은 GridSearch를 이용하겠다.

전처리된 데이터를 준비하고,

train = pd.read_csv('1차 최종 train.csv')
test = pd.read_csv('test.csv')

혹시 모르니 info()를 통해 타입을 살펴보자.

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8125 entries, 0 to 8124
Data columns (total 13 columns):
 #   Column        Non-Null Count  Dtype
---  ------        --------------  -----
 0   Unnamed: 0    8125 non-null   int64
 1   HomePlanet    8125 non-null   int64
 2   CryoSleep     8125 non-null   int64
 3   Cabin         8125 non-null   int64
 4   Destination   8125 non-null   int64
 5   Age           8125 non-null   int64
 6   VIP           8125 non-null   int64
 7   RoomService   8125 non-null   int64
 8   FoodCourt     8125 non-null   int64
 9   ShoppingMall  8125 non-null   int64
 10  Spa           8125 non-null   int64
 11  VRDeck        8125 non-null   int64
 12  Transported   8125 non-null   int64
dtypes: int64(13)

이제 input과 target 데이터로 나누자.

train_input = train.drop('Transported',axis=1)
train_target = train['Transported']
train_input.info()

[ 하이퍼 파라미터 탐색 / 튜닝]

params = {'learning_rate':(0.01,1),
          'gamma':(0,1),
          'max_depth':(3,10),
          'sub_sample':(0.5,1),
          'min_child_weight': (1, 5),
          'colsample_bytree':(0.1,1),
          'n_estimators' : (50,200)}

gs = GridSearchCV(XGBClassifier(random_state = 42), param_grid=params ,n_jobs=-1)

gs.fit(train_input, train_target)

[15:35:27] WARNING: C:/buildkite-agent/builds/buildkite-windows-cpu-autoscaling-group-i-0fc7796c793e6356f-1/xgboost/xgboost-ci-windows/src/learner.cc:767: 
Parameters: { "sub_sample" } are not used.

GridSearchCV(estimator=XGBClassifier(base_score=None, booster=None,
                                     callbacks=None, colsample_bylevel=None,
                                     colsample_bynode=None,
                                     colsample_bytree=None,
                                     early_stopping_rounds=None,
                                     enable_categorical=False, eval_metric=None,
                                     feature_types=None, gamma=None,
                                     gpu_id=None, grow_policy=None,
                                     importance_type=None,
                                     interaction_constraints=None,
                                     learning_rate=None, max_b...
                                     max_delta_step=None, max_depth=None,
                                     max_leaves=None, min_child_weight=None,
                                     missing=nan, monotone_constraints=None,
                                     n_estimators=100, n_jobs=None,
                                     num_parallel_tree=None, predictor=None,
                                     random_state=42, ...),
             n_jobs=-1,
             param_grid={'colsample_bytree': (0.1, 1), 'gamma': (0, 1),
                         'learning_rate': (0.01, 1), 'max_depth': (3, 10),
                         'min_child_weight': (1, 5), 'n_estimators': (50, 200),
                         'sub_sample': (0.5, 1)})

gs.best_params_

{'colsample_bytree': 1,
 'gamma': 1,
 'learning_rate': 0.01,
 'max_depth': 10,
 'min_child_weight': 5,
 'n_estimators': 50,
 'sub_sample': 0.5}

params = gs.best_params_
xgb = XGBClassifier(random_state=42, **params)
xgb.fit(train_input,train_target)
xgb.score(train_input,train_target)

[15:47:29] WARNING: C:/buildkite-agent/builds/buildkite-windows-cpu-autoscaling-group-i-0fc7796c793e6356f-1/xgboost/xgboost-ci-windows/src/learner.cc:767: 
Parameters: { "sub_sample" } are not used.

0.8016

그리드 서치를 통해 params의 범위를 지정 후 탐색 한 후 가장 높은 점수를 얻은 최적의

하이퍼 파라미터 조합을 사용해 XGB Classifier을 사용했다

예측 성공률은 80%가 나왔다.

처음 돌린것 치고 괜찮은것 같다.

XGB를 다시 사용하고,

 그리드서치를 베이지안 옵티마이저로 변경하여 하이퍼 파라미터만 바꿔서 다시 돌려보자.

from sklearn.model_selection import cross_val_score
# Define the hyperparameters and their ranges to be optimized
params = {'max_depth': (3, 10),
          'learning_rate': (0.01, 1),
          'n_estimators': (50, 200),
          'min_child_weight': (1, 5),
          'subsample': (0.5, 1),
          'gamma': (0, 1),
          'colsample_bytree': (0.1, 1)}

# Define the objective function to be optimized by Bayesian Optimization
def xgb_cv(max_depth, learning_rate, n_estimators, min_child_weight, subsample, gamma, colsample_bytree):
    xgb.set_params(max_depth=int(max_depth),
                   learning_rate=learning_rate,
                   n_estimators=int(n_estimators),
                   min_child_weight=int(min_child_weight),
                   subsample=subsample,
                   gamma=gamma,
                   colsample_bytree=colsample_bytree)
    return cross_val_score(xgb, train_input, train_target, cv=5, scoring='accuracy').mean()

# Define the Bayesian Optimization object
xgbBO = BayesianOptimization(xgb_cv, params)

# Optimize the hyperparameters using Bayesian Optimization
xgbBO.maximize(n_iter=50, init_points=5)

# Print the best hyperparameters and their corresponding score
print(xgbBO.max)

베이지안 옵티마이저 ( 하이퍼 파라미터 탐색 (서치)) 는 그리드와 다르게

함수를 따로 설정해줘야 하는것 같다. def xgb_cv :

하이퍼 파라미터를 입력으로 가져가서 XGB 분류기의 교차 검증된 정확도 점수를 반환하는

"xgb_cv"라는 목적 함수를 정의한다.

목적 함수는 sikit-learn의 "cross_val_score" 함수를 사용하여 5배 교차 검증을 수행한다.

그런 다음 "xgbB"라는 베이지안 최적화 개체를 만든다."  목적 함수와 하이퍼 파라미터를 인수로 전달한다.

우리는 베이지안 최적화를 사용하여 하이퍼 파라미터를 최적화하기 위해

베이지안 최적화 객체의 "최대화" 방법을 부른다.

마지막으로 베이지안 최적화 개체의 "max" 속성을 사용하여 최상의 하이퍼 파라미터와 해당 점수를 print한다.

 탐색 과정 보기

|   iter    |  target   | colsam... |   gamma   | learni... | max_depth | min_ch... | n_esti... | subsample |
-------------------------------------------------------------------------------------------------------------
| 1         | 0.6103    | 0.6987    | 0.1225    | 0.1515    | 8.224     | 2.78      | 88.54     | 0.8106    |
| 2         | 0.5686    | 0.6152    | 0.4665    | 0.6057    | 4.602     | 4.858     | 83.59     | 0.7877    |
| 3         | 0.5669    | 0.6712    | 0.5453    | 0.9401    | 7.787     | 1.631     | 84.9      | 0.7387    |
| 4         | 0.5202    | 0.2059    | 0.7044    | 0.0881    | 7.868     | 2.342     | 148.1     | 0.916     |
| 5         | 0.5641    | 0.518     | 0.08341   | 0.9347    | 6.403     | 2.885     | 142.2     | 0.9287    |
| 6         | 0.7503    | 0.7642    | 0.2208    | 0.01476   | 7.224     | 2.787     | 89.72     | 0.7512    |
| 7         | 0.6741    | 0.6956    | 0.2691    | 0.04304   | 7.473     | 2.803     | 90.27     | 0.7354    |
| 8         | 0.6111    | 0.3772    | 0.1156    | 0.1722    | 6.862     | 2.909     | 89.46     | 0.5736    |
| 9         | 0.5589    | 0.996     | 0.3121    | 0.7178    | 6.272     | 1.441     | 197.7     | 0.9347    |
| 10        | 0.7438    | 1.0       | 0.2819    | 0.01      | 7.435     | 2.692     | 89.73     | 0.888     |
| 11        | 0.6028    | 0.935     | 0.7813    | 0.3266    | 7.275     | 2.008     | 89.35     | 0.9696    |
| 12        | 0.5586    | 0.8707    | 0.4239    | 0.9497    | 7.755     | 2.939     | 90.22     | 0.8634    |
| 13        | 0.7199    | 0.9006    | 0.3698    | 0.03016   | 7.438     | 2.105     | 90.24     | 0.5563    |
| 14        | 0.5978    | 0.6174    | 0.7405    | 0.2071    | 7.302     | 2.448     | 89.83     | 0.9597    |
| 15        | 0.6238    | 0.5315    | 0.3929    | 0.05831   | 5.405     | 1.407     | 139.3     | 0.9426    |
| 16        | 0.5623    | 0.9584    | 0.5933    | 0.7928    | 5.375     | 2.849     | 173.5     | 0.8334    |
| 17        | 0.5706    | 0.5806    | 0.2061    | 0.8379    | 8.009     | 3.695     | 96.87     | 0.5719    |
| 18        | 0.6091    | 0.969     | 0.6108    | 0.5672    | 8.644     | 4.891     | 123.8     | 0.7119    |
| 19        | 0.5499    | 0.4206    | 0.9338    | 0.9778    | 4.152     | 2.256     | 142.6     | 0.8824    |
| 20        | 0.6901    | 0.685     | 0.01052   | 0.03924   | 7.289     | 2.735     | 90.7      | 0.5096    |
| 21        | 0.6047    | 0.6388    | 0.07058   | 0.1224    | 6.596     | 2.135     | 90.52     | 0.6906    |
| 22        | 0.7596    | 1.0       | 0.05041   | 0.01      | 7.305     | 2.524     | 89.87     | 0.5584    |
| 23        | 0.5822    | 0.8653    | 0.4866    | 0.3237    | 7.976     | 1.363     | 90.84     | 0.9786    |
| 24        | 0.5978    | 0.9655    | 0.1968    | 0.2951    | 7.567     | 2.518     | 89.95     | 0.505     |
| 25        | 0.6135    | 0.7961    | 0.8492    | 0.1947    | 7.032     | 1.907     | 90.26     | 0.5117    |
| 26        | 0.5785    | 0.2114    | 0.9544    | 0.9256    | 6.561     | 4.046     | 93.02     | 0.9875    |
| 27        | 0.5724    | 0.3869    | 0.213     | 0.126     | 8.753     | 1.661     | 195.6     | 0.9378    |
| 28        | 0.6228    | 0.7242    | 0.4029    | 0.1495    | 6.745     | 3.011     | 90.32     | 0.6581    |
| 29        | 0.6012    | 0.6911    | 0.2479    | 0.5442    | 7.269     | 2.962     | 89.39     | 0.6084    |
| 30        | 0.5546    | 0.2324    | 0.2779    | 0.3053    | 7.547     | 2.212     | 90.49     | 0.5984    |
| 31        | 0.5579    | 0.8693    | 0.7293    | 0.5319    | 7.034     | 2.044     | 90.46     | 0.6849    |
| 32        | 0.7332    | 0.7667    | 0.3579    | 0.02248   | 7.386     | 1.447     | 89.73     | 0.8661    |
| 33        | 0.5915    | 0.9329    | 0.4795    | 0.7687    | 7.461     | 1.033     | 89.7      | 0.9438    |
| 34        | 0.5662    | 0.2785    | 0.8665    | 0.6453    | 8.654     | 2.789     | 160.3     | 0.7509    |
| 35        | 0.6073    | 0.7983    | 0.1568    | 0.4487    | 6.283     | 3.771     | 160.9     | 0.886     |
| 36        | 0.521     | 0.1814    | 0.7958    | 0.09026   | 9.277     | 4.778     | 134.8     | 0.8938    |
| 37        | 0.6261    | 0.4929    | 0.6858    | 0.05002   | 7.517     | 1.226     | 89.75     | 0.9839    |
| 38        | 0.5979    | 0.6657    | 0.7642    | 0.2697    | 6.881     | 1.312     | 89.71     | 0.6174    |
| 39        | 0.7503    | 0.9457    | 0.07201   | 0.01      | 7.16      | 2.515     | 89.88     | 0.8681    |
| 40        | 0.7575    | 1.0       | 0.0       | 0.01      | 7.228     | 2.885     | 89.85     | 0.7391    |
| 41        | 0.6132    | 0.7363    | 0.1436    | 0.3085    | 7.023     | 2.021     | 89.61     | 0.5638    |
| 42        | 0.624     | 0.891     | 0.06212   | 0.1219    | 7.22      | 3.854     | 90.19     | 0.883     |
| 43        | 0.5767    | 0.7601    | 0.25      | 0.2714    | 7.582     | 1.709     | 89.91     | 0.9229    |
| 44        | 0.614     | 0.3562    | 0.5391    | 0.214     | 7.684     | 3.257     | 91.44     | 0.5431    |
| 45        | 0.6106    | 0.6325    | 0.3444    | 0.1795    | 7.056     | 2.479     | 91.33     | 0.6597    |
| 46        | 0.7557    | 0.8779    | 0.2409    | 0.0188    | 5.539     | 4.755     | 93.72     | 0.755     |
| 47        | 0.6015    | 0.5372    | 0.0837    | 0.1466    | 7.103     | 2.961     | 89.7      | 0.9337    |
| 48        | 0.581     | 0.9351    | 0.1166    | 0.4818    | 9.327     | 1.28      | 78.47     | 0.5416    |
| 49        | 0.5762    | 0.599     | 0.5343    | 0.6791    | 4.135     | 4.219     | 50.72     | 0.7866    |
| 50        | 0.609     | 0.3763    | 0.9039    | 0.2149    | 5.726     | 4.672     | 79.75     | 0.7045    |
| 51        | 0.5929    | 0.37      | 0.6496    | 0.7564    | 4.512     | 3.833     | 190.0     | 0.6005    |
| 52        | 0.6017    | 0.9499    | 0.5243    | 0.5982    | 5.635     | 4.218     | 94.03     | 0.5944    |
| 53        | 0.6108    | 0.8254    | 0.2186    | 0.1845    | 6.988     | 2.436     | 90.58     | 0.6205    |
| 54        | 0.5652    | 0.5436    | 0.9611    | 0.901     | 8.289     | 3.423     | 79.72     | 0.751     |
| 55        | 0.5876    | 0.7708    | 0.5102    | 0.7385    | 5.594     | 3.223     | 153.1     | 0.5488    |
=============================================================================================================
{'target': 0.7596307692307692, 'params': {'colsample_bytree': 1.0, 'gamma': 0.050406580268173413, 'learning_rate': 0.01, 'max_depth': 7.305157214715147, 'min_child_weight': 2.5238667272883433, 'n_estimators': 89.87424334757735, 'subsample': 0.5583965007292178}}

params = xgbBO.max['params']
params['max_depth'] = int(round(params['max_depth']))
params['n_estimators'] = int(round(params['n_estimators']))
params['gamma'] = int(round(params['gamma']))
params['min_child_weight'] = int(round(params['min_child_weight']))
xgb = XGBClassifier(random_state = 42, **params)
xgb.fit(train_input, train_target)



XGBClassifier(base_score=None, booster=None, callbacks=None,
              colsample_bylevel=None, colsample_bynode=None,
              colsample_bytree=1.0, early_stopping_rounds=None,
              enable_categorical=False, eval_metric=None, feature_types=None,
              gamma=0, gpu_id=None, grow_policy=None, importance_type=None,
              interaction_constraints=None, learning_rate=0.01, max_bin=None,
              max_cat_threshold=None, max_cat_to_onehot=None,
              max_delta_step=None, max_depth=7, max_leaves=None,
              min_child_weight=3, missing=nan, monotone_constraints=None,
              n_estimators=90, n_jobs=None, num_parallel_tree=None,
              predictor=None, random_state=42, ...)

score를 출력해보자.

xgb.score(train_input, train_target)	

0.8045538461538462