73. NIPA AI온라인 교육 AI 실무 응용 과정(4) 딥러닝

AI 실무 응용 과정
[응용교육과정] 딥러닝 시작하기 (4) 딥러닝

 

 

딥러닝개론

인공지능 > 머신러닝 > 딥러닝

 

 

딥러닝이란?

머신러닝의 여러 방법론 중 하나로써 인공신경망에 기반하여 컴퓨터에게 사람의 사고방식을 가르치는 방법

 

 

인공신경망이란?

생물학의 신경망에서 영감을 얻은 학습 알고리즘. 사람의 신경 시스템을 모방함

 

 

신경 시스템?

두뇌의 가장 작은 정보처리 단위

신경세포들이 다발들을 통해 연결되어 있는 구조

자극이 들어오면 신경세포를 통해 다음 신경세포로 전달되고, 내부의 여러가지 처리 과정이 존재한다.

 

사람의 신경 시스템

 

 

딥러닝 역사

First AI winter : 첫번째 딥러닝 빙하기

1986년도 : 기본적인 이론들 등장

Second AI winter : 두번째 딥러닝 빙하기

2012년도 : 이미지넷 (GPU를 사용한 딥러닝 AlexNet으로 이미지를 구분의 정확도를 끌어올림)

 

 

현대의 다양한 딥러닝 기술 적용 사례

1. 얼굴 인식 카메라

2. 기계 번역 모델

3. 알파고 제로 (딥러닝X 강화학습모델+딥러닝O)

 

 

 

 

 

퍼셉트론 (Perceptron)

신경망 이전의 연구

얼굴 인식 : 네모 박스 안의 이목구비를 구별

숫자 및 문자 : 몇 가지 패턴을 통해 구별

-> 사람이 직접 패턴을 파악한 뒤 예측

 

 

1958년도 초기 신경망 퍼셉트론 등장

N개의 신호를 받는 돌기 > 하나로 합쳐지고 > 전달되고 > N개의 다른 신호들로 전달되는 형태 (=인풋 x, 아웃풋 y)

 

 

퍼셉트론의 기본 구조

가중치 : 들어오는 값을 얼마나 증폭하고 감폭해줄지 판단

bias : 입력하는 값에 상관없이 들어오는 값

∑ (summation) : '모두 더해라'

활성화함수 Activation function

 

 

활성화함수

들어오는 x값이 0보다 크면 1로 매핑, 0보다 작으면 0으로 매핑

 

 

퍼셉트론 동작 예

[추가 예시] 1, -2, -0.5가 들어왔다면? y = -0.5 + 2 * 1 + 1 * (-1) = activation 0.5 = 0

입력값에 따라 도출값이 다를 수 있다.

 

 

퍼셉트론 동작 예2

X1 신작 드라마 수 / X2 여가시간 / Y 학습 여부

 

w0 학습 의지 / w1 신작 드라마에 받는 영향 / w2 여가 시간에 따른 학습하고 싶은 정도

-> 입력값(w)에 따라 예측값이 바뀐다.

 

점 : 각각의 데이터

보라색 점 : 학습을 하지 않은 경우

초록색 점 : 학습을 한 경우

* 직선을 얼마나 잘 구하느냐가 퍼셉트론을 얼만큼 잘 구현했는지에 대한 척도다.

 

 

퍼셉트론을 이용한 선형분류기

노란색 : 강아지 / 파란색 : 고양이

퍼셉트론은 선형 분류기로써 데이터 분류가 가능하다 (선을 통해 분류)

 

 

문제점

하나의 선으로 분류할 수 없는 문제가 등장 = 퍼셉트론으로 완벽한 분류 불가능

 

 

[연습문제1] 퍼셉트론 작동 예시 구현하기

perceptron의 예측 결과가 학습한다:1 이 나오도록 x1x_{1}x1​, x2x_{2}x2​에 적절한 값을 입력하세요. 활성화 함수는 ‘신호의 총합이 0 이상이면 학습하고, 0 미만이라면 학습하지 않는다‘는 규칙을 가집니다.

#학습 여부를 예측하는 퍼셉트론 함수
def Perceptron(x_1,x_2):
    
    #설정한 가중치값을 적용
    w_0 = -5 
    w_1 = -1
    w_2 = 5
    
    #활성화 함수에 들어갈 값을 계산
    output = w_0+w_1*x_1+w_2*x_2
    
    #활성화 함수 결과를 계산
    if output < 0:
        y = 0
    else:
        y = 1
    
    return y, output


#1. perceptron의 예측 결과가 학습한다:1 이 나오도록 x_1, x_2에 적절한 값을 입력하세요.
x_1 = 0
x_2 = 2

result, go_out = Perceptron(x_1,x_2)

print("신호의 총합 : %d" % go_out)

if go_out > 0:
    print("학습 여부 : %d\n ==> 학습한다!" % result)
else:
    print("학습 여부 : %d\n ==> 학습하지 않는다!" % result)

신호의 총합 : 5

학습 여부 : 1

==> 학습한다!

 

 

[연습문제2] DIY 퍼셉트론 만들기

1. 신호의 총합 output을 정의하고, output이 0 이상이면 1을, 그렇지 않으면 0인 y를 반환하는 활성화 함수를 작성해 perceptron 함수를 완성합니다.

'''
1. 신호의 총합과 그에 따른 결과 0 또는 1을 반환하는 함수 perceptron을 완성합니다.
   Step01. 입력 받은 값을 이용하여 신호의 총합을 구합니다.
   Step02. 신호의 총합이 0 이상이면 1을, 그렇지 않으면 0을 반환하는 활성화 함수를 작성합니다.
'''
def perceptron(w, x):    
    output = w[0] + w[1]*x[0] + w[2]*x[1] + w[3]*x[2] + w[4]*x[3]    
    y = 1    
    return y, output

#x_1, x_2, x_3, x_4의 값을 순서대로 list 형태로 저장
x = [1,2,3,4]

#w_0, w_1, w_2, w_3, w_4의 값을 순서대로 list 형태로 저장
w = [2, -1, 1, 3, -2]

#퍼셉트론의 결과를 출력
y, output = perceptron(w,x)

print('output: ', output)
print('y: ', y)

 

 

[연습문제3] 퍼셉트론의 알맞은 가중치 찾기

단층 퍼셉트론을 직접 구현해보며 적절한 가중치(Weight)와 Bias 값을 찾아봅시다.

 

1. perceptron 함수의 입력으로 들어갈 가중치 값을 입력해주세요.

w 리스트 안의 값들은 순서대로 w0,w1,w2w_0, w_1, w_2w0​,w1​,w2​에 해당됩니다.

import numpy as np


def perceptron(w, x):    
    output = w[1] * x[0] + w[2] * x[1] + w[0]    
    if output >= 0:
        y = 1
    else:
        y = 0    
    return y



#Input 데이터
X = [[0,0], [0,1], [1,0], [1,1]]

#1. perceptron 함수의 입력으로 들어갈 가중치 값을 입력해주세요. 순서대로 w_0, w_1, w_2에 해당됩니다.
w = [-2, 1, 1]

#AND Gate를 만족하는지 출력하여 확인
print('perceptron 출력')

for x in X:
    print('Input: ',x[0], x[1], ', Output: ',perceptron(w, x))

 

 

 

 

 

다층 퍼셉트론

단층 퍼셉트론	다층 퍼셉트론 (Multi Layer Perceptron)
입력층과 출력층만 존재 퍼셉트론이 1개만 존재하는 경우	단층 퍼셉트론을 여러 개 쌓은 것 단층 퍼셉트론을 많이 쌓을수록 여러가지 결과값을 얻을 수 있다.

* 비 선형적인 문제(=선 하나로 데이터를 분리하지 못하는 문제) 해결

 

 

히든층 (Hidden Layer)

입력층과 출력층 사이의 모든 Layer

 

히든층 개수와 딥러닝

히든층이 많아지면 깊은 신경망이라는 의미의 Deep Learning단어 사용

- 장점 : 분류할 수 있는 방법의 증가 (성능이 좋아질 수 있음)

- 단점 : 가중치 존재. (퍼셉트론 하나에 필요한 가중치는 n+1. 다층 퍼셉트론은 구해야하는 가중치가 굉장히 많아진다.)

 

 

 

 

 

텐서플로우와 신경망

딥러닝 모델의 구성요소

 

 

딥러닝 모델의 학습 방법

예측값과 실제값 간의 오차값을 최소화하기 위해 오차값을 최소화하는 모델의 인자를 찾는 알고리즘을 적용.

Loss Function을 최소화하는 가중치를 찾기 위해 최적화 알고리즘을 적용

 

 

딥러닝 모델에서 예측값 구하는 방법

순전파 (Forward propagation) : 입력 값을 바탕으로 가까운 퍼셉트론부터 점진적으로 출력 값을 계산하는 과정

 

 

순전파 예시

bias는 모두 0이라고 가정

activation function : 다양한 종류의 활성화 함수가 존재하며, 딥러닝 모델에 따라 쓰임이 다르다

 

 

최적화 방식

순전파를 사용하면 예측 값과 실제값 간의 오차값을 구하여 Loss function을 구할 수 있음

그렇다면 최적화를 어떻게 해야할까? -> 경사하강법(Gradient descent)을 사용

 

 

경사 하강법

가중치를 Loss function값이 작아지게 업데이트 하는 방법

가중치는 Gradient값을 사용하여 업데이트를 수행

Gradient값은 각 가중치마다 정해지며, 역전파(Backpropogation)를 통하여 구할 수 있음

 

역전파

 

 

가중치 업데이트 과정

위 과정을 수행하여 가중치들을 업데이트할 수 있으며, 이를 반복하여 Loss function을 제일 작게 만드는 가중치를 구함

 

 

딥러닝 모델의 학습순서

1. 학습용 feature데이터를 입력하여 예측값 구하기 (순전파)

2. 예측값과 실제값 사이의 오차 구하기 (Loss구하기)

3. Loss를 줄일 수 있는 가중치 업데이트하기 (역전파)

4. 1~3번을 반복하며 Loss를 최소로 하는 가중치 얻기

 

 

 

 

 

텐서플로우로 딥러닝 구현하기 - 데이터 전처리

TensorFlow?

유연하고, 효율적이며, 확장성있는 딥러닝 프레임워크

대형 클러스터 컴퓨터부터 스마트폰까지 다양한 디바이스에서 동작 가능

가장 많이 사용되는 프레임워크

 

 

데이터 전처리

Tensorflow 딥러닝 모델은 Tensor형태의 데이터를 입력받는다.

Tensor : 다차원배열로써 Tensorflow에서 사용하는 객체

데이터 > Tensor형태 데이터 변환 > Tensorflow딥러닝 모델

* 다른 정의 : 1차원 vector, 2차원 matrix, 3차원부터 Tensor

 

Dataset API를 사용하여 딥러닝모델용 Dataset 생성

#pandas를 이용해 데이터 불러오기
df = pd.read_csv('data.csv')
feature = df.drop(columns=['label'])
labe = df['label']

#tensor형태로 데이터 변환
dataset = tf.data.Dataset.from_tensor_slices((feature.values, label.values))

 

딥러닝에 사용하는 데이터는 추가적인 전처리 작업이 필요 -> Epoch, Batch

- Epoch : 한 번의 epoch는 전체 데이터 셋에 대해 한 번 학습을 완료한 상태

- Batch : 나눠진 데이터 셋 (보통 mini-batch라고 표현)

iteration은 epoch를 나누어서 실행하는 횟수를 의미

 

* 딥러닝 학습과정에서 데이터 양과 모델이 커지면 w를 계산할 때 굉장히 많은 연산량이 필요하다. 계산량을 줄이기 위해 전체(epoch)의 데이터를 넣는 게 아니라, 그 데이터를 쪼개서 넣어보자!(=1batch, 2batch...) 확률적으로 성능이 떨어질 수는 있으나, 처리 속도는 훨씬 빠르다.

 

ex) 총 데이터가 1000개, Batch size = 100일 때

1iteration = 100개 데이터에 대해서 학습

1epoch = 1000/Batch size = 10iteration 

#tensor형태로 데이터 변환
dataset = tf.data.Dataset.from_tensor_slices((feature.values, label.values))

#dataset의 batch사이즈를 32로 설정
datset = dataset.batch(32)

 

 

 

[연습문제1] 텐서플로우를 활용하여 신경망 구현하기 - 데이터 전처리

텐서플로우를 활용하여 신경망을 구현해보는 과정을 수행해보겠습니다. 텐서플로우 신경망 모델의 학습 데이터는 기존 데이터를 tf.data.Dataset 형식으로 변환하여 사용합니다. pandas의 DataFrame 형태 데이터를 Dataset으로 변환하기 위해서는 from_tensor_slices() 메서드를 사용하여 ds에 저장할 수 있습니다.

 

1. pandas DataFrame df에서 Sales 변수는 label 데이터로 Y에 저장하고 나머진 X에 저장합니다.

2. 학습용 데이터 train_X, train_Y를 tf.data.Dataset 형태로 변환합니다.

- from_tensor_slices 함수를 사용하여 변환합니다.

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

np.random.seed(100)
tf.random.set_seed(100)

#데이터를 DataFrame 형태로 불러 옵니다.
df = pd.read_csv("data/Advertising.csv")

#DataFrame 데이터 샘플 5개를 출력합니다.
print('원본 데이터 샘플 :')
print(df.head(),'\n')

#의미없는 변수는 삭제합니다.
df = df.drop(columns=['Unnamed: 0'])

#1. Sales 변수는 label 데이터로 Y에 저장하고 나머진 X에 저장합니다.
X = df.drop(columns=['Sales'])
Y = df['Sales']

train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.3)

#2. 학습용 데이터를 tf.data.Dataset 형태로 변환합니다. from_tensor_slices 함수를 사용하여 변환하고 batch를 수행하게 합니다.
train_ds = tf.data.Dataset.from_tensor_slices((train_X.values, train_Y.values))
train_ds = train_ds.shuffle(len(train_X)).batch(batch_size=5)

#하나의 batch를 뽑아서 feature와 label로 분리합니다.
[(train_features_batch, label_batch)] = train_ds.take(1)

#batch 데이터를 출력합니다.
print('\nFB, TV, Newspaper batch 데이터:\n',train_features_batch)
print('Sales batch 데이터:',label_batch)

 

 

 

 

 

모델 구현

Keras 패키지

텐서플로우의 패키지로 제공되는 고수준API

딥러닝 모델을 간단하고 빠르게 구현가능

 

 

Keras 메소드 (1)

모델 클래스 객체 생성

tf.keras.models.Sequential()

 

모델의 각 Layer구성

tf.keras.layer.Dense(units, activation)

units : 레이어 안의 Node 수

activation : 적용할 activation함수 설정

 

 

Input Layer의 입력 형태 저장하기

첫 번째(=Input layer)는 입력 형태에 대한 정보를 필요로 한다.

input_shape or input_dim 인자 설정 필요

 

 

모델 구축 코드 예시

model = tf.keras.models.Sequential([	
	tf.keras.layers.Dense(10, input_dim=2, activation='sigmoid'), #2개의 입력변수, 10개 노드
    tf.keras.layers.Dense(10, activation='sigmoid'), #10개의 노드
    tf.keras.layers.Dense(1, activation='sigmoid'), #1개의 노드
])

* 입력이 두 개, 출력이 하나, 세 개의 층 존재

 

 

Keras 메소드 (2)

모델에 Layer추가하기

[model].add(tf.keras.layers.Dense(units, activation))

units : 레이어 안의 Node 수

activation : 적용할 activation함수 설정

 

 

모델 구축 코드 예시(2)

model = tf.keras.models.Sequential()

model.add(tf.keras.layers.Dense(10, input_dim=2, activation='sigmoid'))
model.add(tf.keras.layers.Dense(10, activation='sigmoid'))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))

 

 

Keras 메소드 (3)

딥러닝 모델 학습시키기

 

모델 학습 방식을 설정하기 위한 함수

[model].compile(optimizer, loss)

- optimizer : 모델 학습 최적화 방법 ex) GD, SGD,  Adam...

- loss : 손실 함수 설정 (회귀에서는 MSE, 분류에서는 Cross Entropy...)

 

모델을 학습시키기 위한 함수

[model].fit(x,y)

- x : 학습 데이터

- y : 학습 데이터의 label

* tensor 형태의 dataset을 넣어도 된다

 

 

코드 예시

#MSE를 loss로 설정, 최적화 방식은 SGD사용
model.compile(loss='mean_squared_error', optimizer='SGD') #MSE

#dataset에 저장된 데이터를 입력하고, epochs를 100으로 설정하여 학습
model.fit(dataset, epochs=100)

 

 

Keras 메소드 (4)

평가 및 예측하기

 

모델을 평가하기 위한 메소드

[model].evaluate(x, y)

- x : 테스트 데이터

- y : 테스트 데이터의 label

 

모델로 예측을 수행하기 위한 함수

[model].predict(x)

- x : 예측하고자 하는 데이터

 

 

코드 예시

#MSE를 loss로 설정, 최적화 방식은 SGD사용
model.compile(loss='mean_squared_error', optimizer='SGD') #MSE

#dataset에 저장된 데이터를 입력하고, epochs를 100으로 설정하여 학습
model.fit(dataset, epochs=100)

#모델 평가 및 예측하기
model.evaluate(X_test, Y_test)
predicted_labels_test = model.predict(X_test)

 

 

 

[연습문제2] 텐서플로우를 활용하여 신경망 구현하기 - 모델 구현

[실습1]에 이어서 이번 실습에서는 텐서플로우와 케라스(Keras)를 활용하여 신경망 모델을 구현해보겠습니다.

 

1. tf.keras.models.Sequential()을 활용하여 신경망 모델을 생성합니다.

- 자유롭게 layers를 쌓고 마지막 layers는 노드 수를 1개로 설정합니다.

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

np.random.seed(100)
tf.random.set_seed(100)

#데이터를 DataFrame 형태로 불러 옵니다.
df = pd.read_csv("data/Advertising.csv")

#DataFrame 데이터 샘플 5개를 출력합니다.
print('원본 데이터 샘플 :')
print(df.head(),'\n')

#의미없는 변수는 삭제합니다.
df = df.drop(columns=['Unnamed: 0'])

X = df.drop(columns=['Sales'])
Y = df['Sales']

#학습용 테스트용 데이터로 분리합니다.
train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.3)

#Dataset 형태로 변환합니다.
train_ds = tf.data.Dataset.from_tensor_slices((train_X.values, train_Y))
train_ds = train_ds.shuffle(len(train_X)).batch(batch_size=5)

#1. tf.keras.models.Sequential()를 활용하여 신경망 모델을 생성합니다. 자유롭게 layers를 쌓고 마지막 layers는 노드 수를 1개로 설정합니다.
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, input_shape=(3,)),
    tf.keras.layers.Dense(1)
    ])

print(model.summary())

 

 

[연습문제3] 텐서플로우를 활용하여 신경망 구현하기 - 모델 학습

학습방법 설정 : complie() 메서드는 모델을 어떻게 학습할 지에 대해서 설정합니다. loss는 회귀에서는 일반적으로 MSE인 ‘mean_squared_error’, 분류에서는 ‘sparse_categorical_crossentropy’ 를 주로 사용합니다.

학습 수행 : X 데이터를 에포크를 100번으로 하여 학습합니다. verbose 인자는 학습 시, 화면에 출력되는 형태를 설정합니다. (0: 표기 없음, 1: 진행 바, 2: 에포크당 한 줄 출력)

 

1. Dataset으로 변환된 학습용 데이터를 바탕으로 모델의 학습을 수행합니다.

- compile 메서드를 사용하여 최적화 모델을 설정합니다. loss는 ‘mean_squared_error’, optimizer는 ‘adam’으로 설정합니다.

- fit 메서드를 사용하여 학습용 데이터를 학습합니다. epochs는 100으로 설정합니다.

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

np.random.seed(100)
tf.random.set_seed(100)

#데이터를 DataFrame 형태로 불러 옵니다.
df = pd.read_csv("data/Advertising.csv")

#DataFrame 데이터 샘플 5개를 출력합니다.
print('원본 데이터 샘플 :')
print(df.head(),'\n')

#의미없는 변수는 삭제합니다.
df = df.drop(columns=['Unnamed: 0'])

X = df.drop(columns=['Sales'])
Y = df['Sales']

#학습용 테스트용 데이터로 분리합니다.
train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.3)

#Dataset 형태로 변환합니다.
train_ds = tf.data.Dataset.from_tensor_slices((train_X.values, train_Y))
train_ds = train_ds.shuffle(len(train_X)).batch(batch_size=5)


#keras를 활용하여 신경망 모델을 생성합니다.
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, input_shape=(3,)),
    tf.keras.layers.Dense(1)
    ])


"""
1. 학습용 데이터를 바탕으로 모델의 학습을 수행합니다.
step1. compile 메서드를 사용하여 최적화 모델 설정합니다. loss는 mean_squared_error, optimizer는 adam으로 설정합니다.
step2. fit 메서드를 사용하여 Dataset으로 변환된 학습용 데이터를 학습합니다. epochs는 100으로 설정합니다.
"""
model.compile(loss='mean_squared_error', optimizer='adam')
history = model.fit(train_ds, epochs=100, verbose=2)

 

 

[연습문제4] 텐서플로우를 활용하여 신경망 구현하기 - 모델 평가 및 예측

평가 방법 : evaluate() 메서드는 학습된 모델을 바탕으로 입력한 feature 데이터 X와 label Y의 loss 값과 metrics 값을 출력합니다. 이번 실습에서는 metrics 를 compile에서 설정하지 않았지만, 분류에서는 일반적으로 accuracy를 사용하여 evaluate 사용 시, 2개의 아웃풋을 리턴합니다.

예측 방법 : X 데이터의 예측 label 값을 출력합니다.

 

1. evaluate 메서드를 사용하여 테스트용 데이터의 loss 값을 계산하고 loss에 저장합니다.

2. predict 메서드를 사용하여 테스트용 데이터의 예측값을 계산하고 predictions에 저장합니다.

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

np.random.seed(100)
tf.random.set_seed(100)

#데이터를 DataFrame 형태로 불러 옵니다.
df = pd.read_csv("data/Advertising.csv")

#DataFrame 데이터 샘플 5개를 출력합니다.
print('원본 데이터 샘플 :')
print(df.head(),'\n')

#의미없는 변수는 삭제합니다.
df = df.drop(columns=['Unnamed: 0'])

X = df.drop(columns=['Sales'])
Y = df['Sales']

#학습용 테스트용 데이터로 분리합니다.
train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.3)

#Dataset 형태로 변환합니다.
train_ds = tf.data.Dataset.from_tensor_slices((train_X.values, train_Y))
train_ds = train_ds.shuffle(len(train_X)).batch(batch_size=5)

#keras를 활용하여 신경망 모델을 생성합니다.
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, input_shape=(3,)),
    tf.keras.layers.Dense(1)
    ])

#학습용 데이터를 바탕으로 모델의 학습을 수행합니다.
model.compile(loss='mean_squared_error', optimizer='adam')
history = model.fit(train_ds, epochs=100, verbose=2)

#1. evaluate 메서드를 사용하여 테스트용 데이터의 loss 값을 계산합니다.
loss = model.evaluate(test_X, test_Y, verbose=0)

#2. predict 메서드를 사용하여 테스트용 데이터의 예측값을 계산합니다.
predictions = model.predict(test_X)

#결과를 출력합니다.
print("테스트 데이터의 Loss 값: ", loss)
for i in range(5):
    print("%d 번째 테스트 데이터의 실제값: %f" % (i, test_Y.iloc[i]))
    print("%d 번째 테스트 데이터의 예측값: %f" % (i, predictions[i][0]))

 

 

 

[연습문제5] 신경망 모델로 분류하기

Iris 데이터가 주어졌을 때 붓꽃의 종류를 분류하는 신경망 모델을 구현합니다. Iris 데이터는 아래와 같이 꽃받침 길이, 꽃받침 넓이, 꽃잎 길이, 꽃잎 넓이 네 가지 변수와 세 종류의 붓꽃 클래스로 구성되어 있습니다.

모델 구현 (5개의 범주를 갖는 label 예시) : 분류 모델에서는 마지막 레이어에 분류 데이터의 label 범주의 개수만큼 노드를 설정합니다. 추가로 activation 인자로 ‘softmax’ 를 설정합니다.

학습 방법 : 분류에서는 일반적으로 loss를 ‘sparse_categorical_crossentropy’으로 사용합니다. metrics 인자는 에포크마다 계산되는 평가 지표를 의미합니다. 정확도를 의미하는 ‘accuracy’ 를 입력하면 에포크마다 accuracy를 계산하여 출력합니다.

 

1. keras를 활용하여 신경망 모델을 생성합니다. 3가지 범주를 갖는 label 데이터를 분류하기 위해서 마지막 레이어 노드를 아래와 같이 설정합니다.

- 노드의 수는 3개

- activation은 ‘softmax’로 설정합니다.

import tensorflow as tf
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

np.random.seed(100)
tf.random.set_seed(100)

#sklearn에 저장된 데이터를 불러 옵니다.
X, Y = load_iris(return_X_y = True)

#DataFrame으로 변환
df = pd.DataFrame(X, columns=['꽃받침 길이','꽃받침 넓이', '꽃잎 길이', '꽃잎 넓이'])
df['클래스'] = Y

X = df.drop(columns=['클래스'])
Y = df['클래스']

#학습용 평가용 데이터로 분리합니다
train_X, test_X, train_Y, test_Y = train_test_split(X, Y, test_size=0.2, random_state = 42)

#Dataset 형태로 변환합니다.
train_ds = tf.data.Dataset.from_tensor_slices((train_X.values, train_Y))
train_ds = train_ds.shuffle(len(train_X)).batch(batch_size=5)

# 1. keras를 활용하여 신경망 모델을 생성합니다. 3가지 범주를 갖는 label 데이터를 분류하기 위해서 마지막 레이어 노드를 아래와 같이 설정합니다.
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, input_dim=4),
    tf.keras.layers.Dense(3, activation='softmax')
    ])

#학습용 데이터를 바탕으로 모델의 학습을 수행합니다.
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
history = model.fit(train_ds, epochs=100, verbose=2)

#테스트용 데이터를 바탕으로 학습된 모델을 평가합니다.
loss, acc = model.evaluate(test_X, test_Y)

#테스트용 데이터의 예측값을 구합니다.
predictions = model.predict(test_X)

#결과를 출력합니다.
print("테스트 데이터의 Accuracy 값: ", acc)
for i in range(5):
    print("%d 번째 테스트 데이터의 실제값: %d" % (i, test_Y.iloc[i]))
    print("%d 번째 테스트 데이터의 예측값: %d" % (i, np.argmax(predictions[i])))

 

 

 

 

 

 

다양한 신경망

우리 주변의 이미지 처리 기술 ex) 얼굴 인식 카메라, 화질 개선, 이미지 자동 태깅

다음과 같은 이미지가 있다고 할 때, 어떤 동물인지 분류하고자 한다면?

-> 컴퓨터에게 이미지는 각 픽셀 값을 가진 숫자 배열로 인식

* 픽셀 : 정사각형 형태의 이미지의 작은 단위

 

 

이미지 전처리하기

모두 같은 크기를 같는 이미지로 통일

1) 가로, 세로 픽셀 사이즈를 표현하는 해상도를 통일

2) 색을 표현하는 방식 통일 (RGG, HSV, Gray-scale, Binary, ...)

28X28의 해상도, Gray-scale로 통일된 상태

 

 

 

[연습문제6] MNIST 분류 CNN 모델 - 데이터 전 처리

신경망을 이용한 학습을 시작할 때 대부분 MNIST를 접하게 됩니다. MNIST는 손글씨로 된 사진을 모아 둔 데이터입니다. 손으로 쓴 0부터 9까지의 글자들이 있고, 이 데이터를 사용해서 신경망을 학습시키고, 학습 결과가 손글씨를 인식할 수 있는지 검증합니다. 이미지 데이터를 출력하고 그 형태를 확인하여 CNN 모델에 적용할 수 있도록 데이터 전 처리를 수행합니다.

MNIST 데이터는 이미지 데이터이지만 가로 길이와 세로 길이만 존재하는 2차원 데이터입니다. CNN 모델은 채널(RGB 혹은 흑백)까지 고려한 3차원 데이터를 입력으로 받기에 채널 차원을 추가해 데이터의 모양(shape)을 바꿔줍니다. 결과는 아래와 같습니다.

[데이터 수, 가로 길이, 세로 길이]
-> [데이터 수, 가로 길이, 세로 길이, 채널 수]

 

차원 추가 함수 : tf.expand_dims(data, axis)

Tensor 배열 데이터에서 마지막 축(axis)에 해당하는 곳에 차원 하나를 추가할 수 있는 코드입니다. ( axis에 -1을 넣으면 어떤 data가 들어오던 마지막 축의 index를 의미합니다.)

1. 학습용 및 평가용 데이터를 CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다.

- tf.expand_dims 함수를 활용하여 train_images, test_images 데이터의 형태를 변환하고 각각 train_images, test_images에 저장합니다.

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from elice_utils import EliceUtils

elice_utils = EliceUtils()

import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

#동일한 실행 결과 확인을 위한 코드입니다.
np.random.seed(123)
tf.random.set_seed(123)


#MNIST 데이터 세트를 불러옵니다.
mnist = tf.keras.datasets.mnist

#MNIST 데이터 세트를 Train set과 Test set으로 나누어 줍니다.
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()    

#Train 데이터 5000개와 Test 데이터 1000개를 사용합니다.
train_images, train_labels = train_images[:5000], train_labels[:5000]
test_images, test_labels = test_images[:1000], test_labels[:1000]


print("원본 학습용 이미지 데이터 형태: ",train_images.shape)
print("원본 평가용 이미지 데이터 형태: ",test_images.shape)
print("원본 학습용 label 데이터: ",train_labels)

#첫 번째 샘플 데이터를 출력합니다.
plt.figure(figsize=(10, 10))
plt.imshow(train_images[0], cmap=plt.cm.binary)
plt.colorbar()
plt.title("Training Data Sample")
plt.savefig("sample1.png")
elice_utils.send_image("sample1.png")

#9개의 학습용 샘플 데이터를 출력합니다.
class_names = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']
for i in range(9):
    plt.subplot(3,3,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.savefig("sample2.png")
elice_utils.send_image("sample2.png")

#1. CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다.
train_images = tf.expand_dims(train_images, -1)
test_images = tf.expand_dims(test_images, -1)

print("변환한 학습용 이미지 데이터 형태: ",train_images.shape)
print("변환한 평가용 이미지 데이터 형태: ",test_images.shape)

 

 

 

 

 

기존 다층 퍼셉트론 기반 신경망의 이미지 처리 방식

극도로 많은 수의 파라미터가 필요하다. 

만약 이미지에 변화가 있다면? -> 데이터 관점에서 보면 새로운 이미지이므로 분류 성능이 떨어질 수 있다.

 

 

합성곱 신경망(Convolution Neural Network)

작은 필터를 순환시키는 방식.

이미지의 패턴이 아닌 특징을 중점으로 인식한다. -> 성능 향상

 

 

합성곱 신경망의 구조

CNN이 입력 이미지의 특징을 추출, Fully-Connected Layer가 분류하는 과정으로 동작한다

- CNN : Convolution Layer + Pooling Layer

- Fully-Connected Layer : 여태까지 공부했던 딥러닝 모델 (=Dense Layer)

 

 

이미지에서 어떠한 특징이 있는 지를 구하는 과정

필터가 이미지를 이동하며 새로운 이미지(피쳐맵)를 생성 (귀, 수염, 입, 색깔 필터 등등을 이동하며 해당 이미지가 있는지 없는지를 판단하고, 이미지가 매치되면 그 값을 가장 크게끔 만든다)

 

 

피쳐맵의 크기 변형

Padding : 원본과 다른 사이즈의 필터 생성되는 것을 방지하고자 만든 방식

Striding : 설정값에 따라 검사 구역을 지정할 수 있다

 

 

Pooling Layer

이미지의 왜곡이 영향(노이즈)를 축소하는 과정.

정보 또한 압축된다.

ex) 필터를 거쳐 생성된 피쳐맵에 Max Pooling을 사용하면 높은 값을 대표값으로, 작은 값은 0으로 통일시킨다

Average Pooling은 평균값으로 대체하는 기법 (거의 사용하지 않음)

 

 

Fully Connected Layer

추출된 특징을 사용하여 이미지를 분류

 

 

분류를 위한 Softmax활성화 함수

마지막 계층에 Softmax활성화 함수 사용

a + b + c + d + e + f = 1 (각각의 값은 확률값)

a, b, c, d, e >= 0

 

Q. 고양이가 맞냐(1) 틀리냐(0)라는 문제를 풀 때 -> 마지막 값에서 step function을 넣으면 답을 구할 수 있었음

Q. 고양이, 강아지, 토끼 같은 다양한 label을 예측해야 할 때 -> 활성화함수 Softmax 사용, 마지막 layer의 unit의 개수는 예측해야하는 label의 범주의 개수만큼으로 설정해야 한다

 

 

정리

1. 합성곱 : 특징 추출

2. 풀링 : 사이즈 조절, 노이즈 처리

* 이 과정을 N번 반복 -> 특징 별 필터를 많이 생성 (풀링 덕분에 데이터 사이즈가 작기때문에 전체적인 양이 늘지 않는다) = 반복할때마다 줄어든 영역에서의 특징을 찾게 되고, 영역의 크기가 작아졌기 때문에 빠른 학습이 가능해진다.

3. 활성함수 : 분류

 

 

합성곱 신경망 기반 다양한 이미지 처리 기술

Object detection & segmentation : 각각의 이미지를 구분할 수 있음

Super resolution (SR) : 해상도가 낮은 이미지의 해상도를 높일 수 있다

 

 

 

[연습문제7] MNIST 분류 CNN 모델 - 모델 구현

Keras에서 CNN 모델을 만들기 위해 필요한 함수/메서드

1. CNN 레이어 tf.keras.layers.Conv2D(filters, kernel_size, activation, padding) : 입력 이미지의 특징, 즉 처리할 특징 맵(map)을 추출하는 레이어입니다.

• filters : 필터(커널) 개수
• kernel_size : 필터(커널)의 크기
• activation : 활성화 함수
• padding : 이미지가 필터를 거칠 때 그 크기가 줄어드는 것을 방지하기 위해서 가장자리에 0의 값을 가지는 픽셀을 넣을 것인지 말 것인지를 결정하는 변수. ‘SAME’ 또는 ‘VALID’

2. Maxpool 레이어 tf.keras.layers.MaxPool2D(padding) : 처리할 특징 맵(map)의 크기를 줄여주는 레이어입니다.

• padding : ‘SAME’ 또는 ‘VALID’

3. Flatten 레이어 tf.keras.layers.Flatten() : Convolution layer 또는 MaxPooling layer의 결과는 N차원의 텐서 형태입니다. 이를 1차원으로 평평하게 만들어줍니다.

 

4. Dense 레이어 tf.keras.layers.Dense(node, activation)

• node : 노드(뉴런) 개수
• activation : 활성화 함수

 

1. keras를 활용하여 CNN 모델을 설정합니다.

- 분류 모델에 맞게 마지막 레이어의 노드 수는 10개, activation 함수는 ‘softmax’로 설정합니다.

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from visual import *
from elice_utils import EliceUtils

elice_utils = EliceUtils()

import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

#동일한 실행 결과 확인을 위한 코드입니다.
np.random.seed(123)
tf.random.set_seed(123)


# MNIST 데이터 세트를 불러옵니다.
mnist = tf.keras.datasets.mnist

#MNIST 데이터 세트를 Train set과 Test set으로 나누어 줍니다.
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()    

#Train 데이터 5000개와 Test 데이터 1000개를 사용합니다.
train_images, train_labels = train_images[:5000], train_labels[:5000]
test_images, test_labels = test_images[:1000], test_labels[:1000]

#CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다.
train_images = tf.expand_dims(train_images, -1)
test_images = tf.expand_dims(test_images, -1)


#1. CNN 모델을 설정합니다. 분류 모델에 맞게 마지막 레이어의 노드 수는 10개, activation 함수는 'softmax'로 설정합니다.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = 'relu', padding = 'SAME', input_shape = (28,28,1)),
    tf.keras.layers.MaxPool2D(padding = 'SAME'),
    tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = 'relu', padding = 'SAME'),
    tf.keras.layers.MaxPool2D(padding = 'SAME'),
    tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = 'relu', padding = 'SAME'),
    tf.keras.layers.MaxPool2D(padding = 'SAME'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation = 'relu'),
    tf.keras.layers.Dense(10, activation = 'softmax')
])

#CNN 모델 구조를 출력합니다.
print(model.summary())

#CNN 모델의 학습 방법을 설정합니다.
model.compile(loss = 'sparse_categorical_crossentropy',
              optimizer = 'adam',
              metrics = ['accuracy'])
              
#학습을 수행합니다. 
history = model.fit(train_images, train_labels, epochs = 20, batch_size = 512)

#학습 결과를 출력합니다.
Visulaize([('CNN', history)], 'loss')

 

 

 

[연습문제8] MNIST 분류 CNN 모델 - 평가 및 예측

Keras에서 CNN 모델의 평가 및 예측을 위해 필요한 함수/메서드

평가 방법 model.evaluate(X, Y) : evaluate() 메서드는 학습된 모델을 바탕으로 입력한 feature 데이터 X와 label Y의 loss 값과 metrics 값을 출력합니다.

예측 방법 model.predict_classes(X) : X 데이터의 예측 label 값을 출력합니다.

 

1. evaluate 메서드와 평가용 데이터를 사용하여 모델을 평가합니다.

- loss와 accuracy를 계산하고 loss, test_acc에 저장합니다.

2. predict_classes 메서드를 사용하여 평가용 데이터에 대한 예측 결과를 predictions에 저장합니다.

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from visual import *
from plotter import *
from elice_utils import EliceUtils

elice_utils = EliceUtils()

import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

# 동일한 실행 결과 확인을 위한 코드입니다.
np.random.seed(123)
tf.random.set_seed(123)


# MNIST 데이터 세트를 불러옵니다.
mnist = tf.keras.datasets.mnist

# MNIST 데이터 세트를 Train set과 Test set으로 나누어 줍니다.
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()    

# Train 데이터 5000개와 Test 데이터 1000개를 사용합니다.
train_images, train_labels = train_images[:5000], train_labels[:5000]
test_images, test_labels = test_images[:1000], test_labels[:1000]

# CNN 모델의 입력으로 사용할 수 있도록 (샘플개수, 가로픽셀, 세로픽셀, 1) 형태로 변환합니다.
train_images = tf.expand_dims(train_images, -1)
test_images = tf.expand_dims(test_images, -1)


# CNN 모델을 설정합니다.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = 'relu', padding = 'SAME', input_shape = (28,28,1)),
    tf.keras.layers.MaxPool2D(padding = 'SAME'),
    tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = 'relu', padding = 'SAME'),
    tf.keras.layers.MaxPool2D(padding = 'SAME'),
    tf.keras.layers.Conv2D(filters = 32, kernel_size = (3,3), activation = 'relu', padding = 'SAME'),
    tf.keras.layers.MaxPool2D(padding = 'SAME'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation = 'relu'),
    tf.keras.layers.Dense(10, activation = 'softmax')
])

# CNN 모델 구조를 출력합니다.
print(model.summary())

# CNN 모델의 학습 방법을 설정합니다.
model.compile(loss = 'sparse_categorical_crossentropy',
              optimizer = 'adam',
              metrics = ['accuracy'])
              
# 학습을 수행합니다. 
history = model.fit(train_images, train_labels, epochs = 10, batch_size = 128, verbose = 2)

Visulaize([('CNN', history)], 'loss')

"""
1. 평가용 데이터를 활용하여 모델을 평가합니다.
   loss와 accuracy를 계산하고 loss, test_acc에 저장합니다.
"""
loss, test_acc = model.evaluate(test_images, test_labels, verbose = 0)

"""
2. 평가용 데이터에 대한 예측 결과를 predictions에 저장합니다.
"""
predictions = model.predict_classes(test_images)

# 모델 평가 및 예측 결과를 출력합니다.
print('\nTest Loss : {:.4f} | Test Accuracy : {}'.format(loss, test_acc))
print('예측한 Test Data 클래스 : ',predictions[:10])

# 평가용 데이터에 대한 레이어 결과를 시각화합니다.
Plotter(test_images, model)

Test Loss : 0.1703 | Test Accuracy : 0.9490000009536743 예측한 Test Data 클래스 : [7 2 1 0 4 1 4 9 6 9] 레이어 이름: conv2d

레이어 이름: max_pooling2d

레이어 이름: conv2d_1

레이어 이름: max_pooling2d_1

레이어 이름: conv2d_2

레이어 이름: max_pooling2d_2

 

 

 

 

 

 

자연어 처리를 위한 데이터 전처리

주변의 자연어 처리 ex) 기계 번역 모델, 음성인식

 

처리 과정

1. 자연어 전처리 (Preprocessing)

2. 단어 표현 (Word Embedding)

3. 모델 적용 (Modeling)

 

 

오류 교정 (Noise canceling)

"안녕하 세요. 반갑 스니다." 
↓
"안녕하세요. 반갑습니다." 

-> 자연어 문장의 스펠링 체크 및 띄어쓰기 오류 교정

 

 

토큰화 (Tokenizing)

"딥러닝 기초 과목을 수강하고 있습니다."
↓
"['딥', '러닝', '기초', '과목', '을', '수강', '하고', '있습니다'. '.']

-> 문장을 토큰으로 나눈다. * 토큰 : 어절, 단어 등으로 목적에 따라 다르게 정의

 

 

불용어 제거(StopWord removal)

한국어에서 ex) 아, 휴, 아이구, 아이쿠, 아이고, 쉿, 그럿지 않으면, 그러나, 그런데, 하지만, ...

-> 불필요한 단어 제거

 

 

Bag of Words

자연어 도큰을 하나씩 뽑아 index를 부여하는 작업

 

자연어 데이터

['안녕', '만나서', '반가워']

['안녕', '나도', '반가워']

↓ 수치형 변환

Bag of Words 

['안녕' : 0, '만나서' : 1, '반가워' : 2, '나도' : 3]

 

 

토큰 시퀀스

Bag of Words에서 단어에 해당되는 인덱스로 변환.

모든 문장의 길이를 맞추기 위해 기준보다 짧은 문장에는 패딩을 수행한다.

* 긴 문장을 기준으로 길이를 통일하나, 유난히 긴 문장은 제외하고 작업 수행.

 

 

 

[연습문제9] 영화 리뷰 긍정/부정 분류 RNN 모델 - 데이터 전 처리

영화 리뷰와 같은 자연어 자료는 곧 단어의 연속적인 배열로써, 시계열 자료라고 볼 수 있습니다. 즉, 시계열 자료(연속된 단어)를 이용해 리뷰에 내포된 감정(긍정, 부정)을 예측하는 분류기를 만들어 보겠습니다.

 

1. 인덱스로 변환된 X_train, X_test 시퀀스에 패딩을 수행하고 각각 X_train, X_test에 저장합니다.

- 시퀀스 최대 길이는 300으로 설정합니다.

import json
import numpy as np
import tensorflow as tf
import data_process
from keras.datasets import imdb
from keras.preprocessing import sequence

import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

#학습용 및 평가용 데이터를 불러오고 샘플 문장을 출력합니다.
X_train, y_train, X_test, y_test = data_process.imdb_data_load()

#1. 인덱스로 변환된 X_train, X_test 시퀀스에 패딩을 수행하고 각각 X_train, X_test에 저장합니다. 시퀀스 최대 길이는 300으로 설정합니다.
X_train = sequence.pad_sequences(X_train, maxlen=300, padding='post')
X_test = sequence.pad_sequences(X_test, maxlen=300, padding='post')

print("\n패딩을 추가한 첫 번째 X_train 데이터 샘플 토큰 인덱스 sequence: \n",X_train[0])

 

 

 

 

 

 

워드 임베딩 Word Embedding

Bag of Words는 의미 없이 단순하게 순서를 부여한다. Word Embedding을 통해 Bag of Words의 인덱스로 정의된 토큰들에게 의미를 부여한다.

 

이유

벡터를 사용하여 토큰의 특징을 설명 (유사도 구하기, 연산 가능)

- 유사도 : 어머니와 아버지의 임베딩[]을 살펴보면 0의 부분이 대략적으로 겹치는 것을 볼 수 있다. (유사관계를 가진 벡터들끼리는 유사하게 형태를 만든다 -> 단어들의 연관성을 알 수 있다.)

 

 

기존 다층 퍼셉트론 신경망의 자연어 분류 방식

대괄호를 없애고 MLP모델에 넣어줘야 하는데, 이 경계를 허물면 특징들이 사라지게 된다. 임베딩의 효과가 사라지고, 문장들 간의 관계 또한 무너진다.

-> 자연어 문장을 기존 MLP모델에 적용시키기에는 한계가 있다. 토큰 간 순서와 관계를 적용할 수 있는 모델은 없을까?

 

 

RNN model (Recurrent Neural Network)

X → RNN → Y

기존 퍼셉트론 계산과 비슷하게 X입력 데이터를 받아 Y를 출력한다

 

 

순환 신경망의 입출력 구조

출력 값을 두 갈래로 나뉘어 신경망에게 기억하는 기능 부여

이전에 사용했던 토큰에 대한 기억을 받아와서, 다음 토큰의 계산에 사용한다.

 

 

순환 신경망 기반 자연어 분류 예시

[수업이], [이], [너무], [재밌어]를 계속 RNN분류처리한다.

마지막에 나온 결과물 Y만 Fully connected Layer에 넣어 0인지 1인지를 판단한다. (이전 output Y는 신경쓰지 않는다)

 

 

정리

1) 임베딩 : 전처리 된 데이터의 특징 추출 

2) RNN : 기억하는 딥러닝 모델. 앞서 사용된 토큰들이 함께 학습되므로 서로간의 순서 관계도 포함되어 학습

3) 활성함수 : 분류작업 진행 ex) sigmoid, softmax

 

 

 

 

 

[연습문제10] 영화 리뷰 긍정/부정 분류 RNN 모델 - 모델 학습

Keras에서 RNN 모델을 만들기 위해 필요한 함수/라이브러리

일반적으로 RNN 모델은 입력층으로 Embedding 레이어를 먼저 쌓고, RNN 레이어를 몇 개 쌓은 다음, 이후 Dense 레이어를 더 쌓아 완성합니다.

 

임베딩 레이어 tf.keras.layers.Embedding(input_dim, output_dim, input_length) : 들어온 문장을 단어 임베딩(embedding)하는 레이어

• input_dim: 들어올 단어의 개수
• output_dim: 결과로 나올 임베딩 벡터의 크기(차원)
• input_length: 들어오는 단어 벡터의 크기
• RNN 레이어

단순 RNN 레이어 : tf.keras.layers.SimpleRNN(units)

• units: 레이어의 노드 수

 

1. RNN 모델을 구현합니다.

- 임베딩 레이어 다음으로 SimpleRNN을 사용하여 RNN 레이어를 쌓고 노드의 개수는 5개로 설정합니다.

import json
import numpy as np
import tensorflow as tf
import data_process
from keras.datasets import imdb
from keras.preprocessing import sequence

import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

#동일한 실행 결과 확인을 위한 코드입니다.
np.random.seed(123)
tf.random.set_seed(123)

#학습용 및 평가용 데이터를 불러오고 샘플 문장을 출력합니다.
X_train, y_train, X_test, y_test = data_process.imdb_data_load()

max_review_length = 300

#패딩을 수행합니다.
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length, padding='post')
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length, padding='post')


embedding_vector_length = 32

"""
1. 모델을 구현합니다.
임베딩 레이어 다음으로 `SimpleRNN`을 사용하여 RNN 레이어를 쌓고 노드의 개수는 5개로 설정합니다. 
Dense 레이어는 0, 1 분류이기에 노드를 1개로 하고 activation을 'sigmoid'로 설정되어 있습니다.
"""
model = tf.keras.models.Sequential([
    tf.keras.layers.Embedding(1000, embedding_vector_length, input_length = max_review_length),
    tf.keras.layers.SimpleRNN(5),
    tf.keras.layers.Dense(1, activation='sigmoid')
    ])

#모델을 확인합니다.
print(model.summary())

#학습 방법을 설정합니다.
model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

#학습을 수행합니다.
model_history = model.fit(X_train, y_train, epochs = 3, verbose = 2)

 

 

 

[연습문제11] 영화 리뷰 긍정/부정 분류 RNN 모델 - 평가 및 예측

Keras에서 RNN 모델의 평가 및 예측을 위해 필요한 함수/메서드

평가 방법 model.evaluate(X, Y) : evaluate() 메서드는 학습된 모델을 바탕으로 입력한 feature 데이터 X와 label Y의 loss 값과 metrics 값을 출력합니다.

예측 방법 model.predict(X) : X 데이터의 예측 label 값을 출력합니다.

 

1. evaluate 메서드를 사용하여 평가용 데이터를 활용하여 모델을 평가합니다.

- loss와 accuracy를 계산하고 loss, test_acc에 저장합니다.

2. predict 메서드를 사용하여 평가용 데이터에 대한 예측 결과를 predictions에 저장합니다.

import json
import numpy as np
import tensorflow as tf
import data_process
from keras.datasets import imdb
from keras.preprocessing import sequence

import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

#동일한 실행 결과 확인을 위한 코드입니다.
np.random.seed(123)
tf.random.set_seed(123)

#학습용 및 평가용 데이터를 불러오고 샘플 문장을 출력합니다.
X_train, y_train, X_test, y_test = data_process.imdb_data_load()

max_review_length = 300

#패딩을 수행합니다.
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length, padding='post')
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length, padding='post')


embedding_vector_length = 32


#모델을 구현합니다.
model = tf.keras.models.Sequential([
    tf.keras.layers.Embedding(1000, embedding_vector_length, input_length = max_review_length),
    tf.keras.layers.SimpleRNN(5),
    tf.keras.layers.Dense(1, activation='sigmoid')
    ])

#모델을 확인합니다.
print(model.summary())

#학습 방법을 설정합니다.
model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

#학습을 수행합니다.
model_history = model.fit(X_train, y_train, epochs = 5, verbose = 2)

#1. 평가용 데이터를 활용하여 모델을 평가합니다. loss와 accuracy를 계산하고 loss, test_acc에 저장합니다.
loss, test_acc = model.evaluate(X_test, y_test, verbose = 0)

#2. 평가용 데이터에 대한 예측 결과를 predictions에 저장합니다.
predictions = model.predict(X_test)

#모델 평가 및 예측 결과를 출력합니다.
print('\nTest Loss : {:.4f} | Test Accuracy : {}'.format(loss, test_acc))
print('예측한 Test Data 클래스 : ',1 if predictions[0]>=0.5 else 0)