NAIAHD

20211002

활성화 함수

activation function:

인공지능 모델의 표현력을 높이기 위해 사용하는 함수인데 

선형 :

비선형 : (데이터의 경계를 곡선으로 분리하는 것)를 할 수 있어 복잡한 데이터들의 관계를 더 잘 띄게 만들 수 있다.

1. 시그모이드 함수 sigmoid function
2. 소프트맥스 함수 softmax function
3. ReLU 함수
4.  

출처 :

텐서플로 첫걸음

인공지능을 위한 수학

출처 : 밑바닥부터 시작하는 딥러닝 

퍼셉트론 관련해서 

좋은 소식: 복잡한 함수도 표현할 수 있다는 것 =>컴퓨터가 수행하는 복잡한 처리도 퍼셉트론으로 (이론상) 표현할 수 있음을 앞 장에서 설명했습니다.

나쁜 소식: 가중치를 설정하는 작업(원하는 결과를 출력하도록 가중치 값을 적절히 정하는 작업)은 여전히 사람이 수동으로 한다는 것입니다. => 신경망이 해결해준다. 

가중치 매개변수 값 

3.1 퍼셉트론에서 신경망으로

3.1.1 신경망의 예

가장 왼쪽 은 입력층 

맨 오른쪽 출력층 

중간 줄은 은닉층(입력층이나 출력층과 달리) 사람 눈에는 보이지 않습니다. 

0층, 1층, 2층 (층 번호를 0부터 시작하는 이유는 파이썬 배열의 인덱스도 0부터 시작하여 , 나중에 구현할 때 짝짓기 편하기 때문입니다.

신경망은 모두 3층으로 구성됩니다만, 가중치를 갖는 층은 2개뿐이기 때문에 '2층 신경망'이라고 합니다.

3.1.2 퍼셉트론 복습

b 편향  : 매개변수 , 뉴런이 얼마나 쉽게 활성화되느냐를 제어합니다

w 가중치 : 매개변수, 각 신호의 영향력을 제어합니다 

네트워크에는 b가 보이지 않습니다. 여기에 편향을 명시한다면 아래와 같습니다 

가중치가 b이고 입력이 1인 뉴런이 추가되었습니다 

이 퍼셉트론의 동작은 x1, x2, 1이라는 3개의 신호가 뉴런에 입력되어 , 각 신호에 가중치를 곱한 후 , 다음 뉴런에 전달됩니다.

다음 뉴런에서는 이 신호들의 값을 더하여 , 그 합이 0을 넘으면 1을 출력하고 그렇지 않으면 0을 출력합니다.

y = h( b + w1x1 + w2x2)

3.1.3 활성화 함수의 등장

activation function : 조금전 h(x)라는 함수가 등장했는데 , 이처럼 입력 신호의 총합을 출력 신호로 변환하는 함수를 일반적으로 활성하 함수라 합니다. 

활성화 라는 이름이 말해주듯 활성화함수는 입력 신호의 총합이 활성화를 일으키는지를 정하는 역할을 합니다.

가중치가 곱해진 입력 신호의 총합을 계산하고 , 그 합을 활성화 함수에 입력해 결과를 내는 2단계로 처리됩니다. 

가중치가 달린 입력 신호와 편향의 총합을 계산하고 , 이를 a라 합니다. 

a를 함수 h()에 넣어 y를 출력하는 흐름입니다. 

뉴런 과 노드 

활성화 함수 h()

일반적으로 단순 퍼셉트론은 단층 네트워크에서 계단 함수(임계값을 경계로 출력이 바뀌는 함수)를 활성화 함수로 사용한 모델을 가리키고 

다층 퍼셉트론은 신경망(여러 층으로 구성되고 시그모이드 함수 등의 매끈한 활성화 함수를 사용하는 네트워크)을 가리킵니다.

3.2.2 활성화 함수

3.2.1 시그모이드 함수 sigmoid function

e는 자연 상수로 2.7182.. 의 값을 갖는 실수

h(x) = 1 /( 1+ exp^(-x)) exp^(-x) => e ^(-x)

함수는 입력을 주면 출력을 돌려주는 변환기죠 

신경망에서는 활성화 함수로 시그모이드 함수를 이용하여 신호를 변환하고 , 그 변환된 신호를 다음 뉴런에 전달합니다. 

퍼셉트론과 앞으로 볼 신경망의 주된 차이는 이 활성화 함수 뿐입니다.

3.2.2 계단 함수 구현하기

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

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

x는 실수(부동소수점)만 받아들입니다. 

배열 지원 

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

x라는 넘파이 배열을 준비하고  그 넘파이 배열에 부등호 연산을 수행합니다 

bool 배열 - 각각 원소에 부등호 연산 

astype() 메서드를 배열의 자료형을 변환할 때 

True는 1로 , False는 0으로 변환

3.2.3 계단 함수의 그래프 

matplotlib 라이브러리를 사용 

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.5 에서 5.0 전 까지 0.1 각격의 넘파이 배열을 생성합니다. 

0을 경계로 출력이 0에서 1(또는 1에서 0)로 바뀝니다.

3.2.4 시그모이드 함수 구현하기

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

np.exp(-x) 는 exp(-x)수식에 해당합니다. 

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

이 함수가 넘파이 배열도 훌륭히 처리해줄 수 있는 비밀은 넘파이의 브로드캐스트에 있습니다.

브로드캐스트 기능이란 넘파일 배열과 스칼라값의 연산을 넘파이 배열릐 원소 각각과 스칼라값의 연산으로 바꿔 수행하는 것입니다.

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

3.2.5 시그모이드 함수와 계단 함수 비교

입력이 작을 때의 출력은 0에 가깝고(혹은 0 이고 ). 입력이 커지면 출력이 1에 가까워지는(혹은 1이 되는)구조인 것이다.

계딴 함수와 시그코이드 함수는 입력이 중요하면 큰 값을 출력하고 입력이 중요하지 않으면 작은 값을 출력합니다.

그리고 입력이 아무리 작거나 커도 출력은 0에서 1사이라는 것도 둘의 공통점입니다.

차이점 1

시그모이드 함수는 부드러운 곡선이며 입력에 따라 출력이 연속적으로 변화

계단 함수는 0을 경계로 출력이 갑자기 변화

차이점 2

계단 함수가 0과 1 중 하나의 값 반환

시그모이드는 0과 1 사이의 실수를 반환

공통점

입력이 작을 때 출력은 0 입력이 커지면 출력이 1이 되는 구조

입력이 아무리 작거나 커도 출력은 0에서 1 사이의 값

3.2.6 비선형 함수

시그모이드 함수와 계단 함수는 비선형 함수로 분류됩니다.

비선형 함수는 문자 그래도 '선형이 아닌' 함수 입니다.
신경망에서는 활성화 함수로 비선형 함수를 상용해야 합니다.

3.2.7 ReLU함수 Rectified Linear Unit

0이하이면 0을 출력하는 함수 

0 을 넘으면 그 입력을 그대로 출력 

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

maximum 두 입력 중 큰 값을 선택해 반환하는 함수 입니다. 

3. 다차원 배열의 계산

3.3.1 다차원 배열

import numpy as np
A = np.array([1,2,3,4])
print(A)
print(np.ndim(A))
print(A.shape)
print(A.shape[0])

배열의 차원 수 np.ndim()

배열의 형상은 인스턴스 변수인 shape으로 알 수 있십니다.

import numpy as np
B = np.array([[1,2],[3,4],[5,6]])
print(B)
print(np.ndim(B ))
print(B.shape)
print(B.shape[0])

2차원 배열은 특히 행렬matrix이라고 부르고 , 가로 방향을 행, 세로 방향을 열 이라고 합니다.

3.3.2 행렬의 곱

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

matrixmultiplication.xyz/

3.3.3 신경망에서의 행렬 곱

 Y = np.dot(X,W)

3.4 3층 신경망 구현하기 

3.4.1 표기법 설명

3.4.2 각 층의 신호 전달하기 

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

identity_function() 항등함수 입력을 그대로 출력하는 함수

출력층의 활성화 함수는 σ() 로 표현 (은닉층의 활성화 함수 h())

3.4.3 구현 정리

forward()라는 함수를 정의합니다. 

forward라 한 것은 신호가 순방향(입력에서 출력 방향)으로 전달됨(순전파)을 알리기 위함입니다. 

역방향(backward)

3.5 출력층 설계하기 

신경망은 분류와 회귀 모두에 이용할 수 있습니다. 

회귀에는 항등 함수

분류에는 소프트맥스 함수 

3.5.1 항등함수 와 소프트맥스 함수 구현하기

항등함수는identity function  입력을 그대로 출력합니다.입력과 출력이 항상 같다

소프트맥스 함수  softmax 함수 

지수함수 exponential function 

출력 층의 각 뉴런이 모든 입력 신호에서 영향을 받기 때문입니다

def softmax(a):
	exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
	return y

3.5.2소프트맥스 함수 구현시 주의점

오버플로 문제가 생길 수 있다. 

softmax()

np.exp(a-c) / np.sum(np.exp(a-c))

개선 된 수식 

def softmax(a):
    c = np.max(a)
    exp_a = np.exp(a-c) #오버플로 대책
    sum_exp_a = np.sum(exp_a)
    y = exp_a/ sum_exp_a
    return y

a = np.array([0.3, 2.9, 4.0])
y = softmax(a)
print(y)
print(np.sum(y))

3.5.3 소프트 맥스 함수의 특징

소프트함수의 출력은 0에서 1.0 사이의 실수입니다. 소프트맥스 함수 출력의 총합은 1입니다. 

총합이 1인 것은 중요한 성질입니다. => ' 확률'로 해석할 수있습니다. 

주의점으로 , 소프트맥스 함수를 적용해도 각 원소의 대소 관계는 변하지 않습니다.

결과적으로  신경망으로 분류할 때는 출력층의 소프트맥스 함수를 생략해도 됩니다 .

3.5.4 출력층의 뉴런 수 정하기

출력층의 뉴런 수는 풀려는 문제에 맞게 적절히 정해야 합니다. 

분류에서는 분류하고 싶은 클래스 수로 설정하는 것이 일반입니다. 

3.6 손글씨 숫자 인식

이미 학습된 매개변수를 사용하여 학습 과정은 생략하고 , 추론 과정만 구현할 겁니다.

이 추론 과정을 신경망의 순전파 forward propagation라고도 합니다.

3.6.1 MNIST 데이터 셋 

이미지 인식이나 기계학습 논문들을 읽다 보면 실험용 데이터로 자주 등장하는 것을 확인할 수 있습니다.

import sys, os
sys.path.append(os.pardir) #부모 디렉터리의 파일을 가져올 수 있도록 설정
from dataset.mnist import load_mnist

(x_train, t_train) , (x_test, t_test) = \
    load_mnist(flatten = True, normalize = False)

print(x_train.shape)
print(t_train.shape)
print(x_test.shape)
print(t_test.shape)

normalize는 입력 이미지의 픽셀 값을 0.0 ~ 1.0 사이의 값으로 정규화 할지를 정합니다.

False로 설정하면 입력 이미지의 픽셀 은 원래 값 그대로 0 ~ 255 사이의 값을 유지합니다.

flatten은 입력 이미지를 평탄하게 , 즉 1차원 배열로 만들지를 정합니다. 

False로 설정하면 입력 이미지를 1 * 29 * 28 의 3차원 배열로 ,True로 설정하면 784 개의 원소로 이뤄진 1차원 배열로 저장합니다.

one_hot_label은 레이블을 원-핫 인코딩 형태로 저장할지를 정합니다.

import tensorflow as tf
mnist = tf.keras.datasets.mnist

(x_train, t_train) , (x_test, t_test) = mnist.load_data()
#x_train, x_test = x_train / 255.0, x_test / 255.0

print(x_train.shape)
print(t_train.shape)
print(x_test.shape)
print(t_test.shape)

배치 처리 

PIL python Image Library 모듈을 사용합니다. 이미지 표시에는 

reshape()메서드에 원하는 형상을 인수로 지정하면 넘피이 배열의 형상을 바꿀수 있습니다.

넘파이로 저장된 이미지 데이터를 PIL용 데이터 객체로 변환해야 하며 , 이 변환은 Image.fromarray()가 수행합니다.

3.6.2 신겸앙의 추론 처리

pickle파일 학습된 가중치 매개변수

정확도 

predict()함수는 각 레이블의 확률을 넘파이 배열로 반환합니다.

데이터를 특정 범위로 변환하는 처리를 정규화 normalization라 하고 

신경망의 입력 데이터에 특정 변화을 가하는 것을 전처리 pre-processing라 합니다.

3.6.3 배치 처리

range()함수는 range(start, end)처럼 인수를 2개 지정해 호출하면 start에서 end-1까지의 정수로 이뤄진 리스트를 반환합니다.

argmax()는 최대값의 인덱스를 가져옵니다.

aixs = 1 이라는 인수를 추가한것에 주의합시다. 

y = np.argmax(x, axis = 1)

배치 하나로 묶은 입력 데이터를 배치라고 합니다. 

합성공 신경망 CNN과 순환 신경망 RNN

01. 신경망의 다층화

다층 퍼셉트론

활성화 함수와 기울기 소실 문제

신경망의 활성화 함수는 출력 계층의 값이 커지면 최종 출력이 1로 수렴하는 단위 계단 함수와 로지스틱 함수를 사용했습니다.

쌍곡탄젠트 함수와 소프트 플러스 

선형 유닛Rectified Linear Unit ReLU

시그모이드 함수와 쌍곡 탄젠트 함수는 미분 계산을 기반으로 두는 함수지만 ReLU는 0 또는 입력값을 그대로 내보내므로 계산이 편리합니다.

심층 신경망 Deep Neural Network,DNN은 시그모이드 함수에 전파와 역전파를 여러 번 적용하다 보면 가중치가 발산하거나 곡선의 기울기가 0이 되어 버리는 기울기 소실 문제가vanishing gradient problem 발생하므로 ReLU를 사용합니다.

확률 기반 경사 하강법 sgd stochastic gradient Descent : 신경망 학습에서는 데이터 일부를 뽑은 미니 배치를 이용해 가중치를 반복해서 업데이트 하는 것

훈련 오차와 테스트 오차

학습 과정에서 얼마나 지도 학습 데이터에 오차가 발생하는지 나타내는 값을 훈련 오차라고 합니다.

학습기 구축 과정의 목표는 훈련 오차를 작게 만드는 것입니다.

매개변수 업데이트 횟수를 가로축으로 , 오차를 세로축으로 설정했을 때 만들어지는 곡선을 학습 곡선이라고 합니다.

미지의 데이터를 준비하는 것은 어려우므로 테스트 데이터를 이용해 오차를 확인합니다. 이때 오차를 테스트 오차라고 합니다.

정규화와 드롭아웃

과적합을 억제하는 방법으로 가중치 계수에 제한을 가하는 정규화가 있습니다.

신경먕에서 과적합을 억제하는 또 한가지 방법으로는 드롭아웃이 있습니다.

드롭아웃은 확률 기반으로 다층 네트워크 유닛을 선별한 상태에서 학습을 실행하는 것입니다.

그밖의 신경망 학습

데이터 정규화 

정규화 normalization

표준화 standardization

"평균을 0으로 한다." "분산(표준 편차)을 1로 한다."

"상관관계를 0으로 한다 " 같은 작업을 백색화 whitening라고 합니다.

정규화를 전처리 

데이터 확장

여러가지 네트워크 이용

구조가 다른 여러 개의 신경망을 구축하고 각각 학습한 다음 모델의 평균을 구하면 학습의 일반화 성능을 향상시킬 수 있습니다.

학습률 ε의 결정 방법

학습률을 자동으로 결정하는 알고리즘으로 확률적 경사 하강법의 하나인 에이다그래드 AdaGrad를 많이 사용합니다.

02. 제한 볼츠만 머신

볼츠만 머신과 제한 볼츠만 머신

볼츠만 머신은 노드들이 무향 그래프로 연결된 네트워크입니다.

볼츠만 머신은 퍼셉트론처럼 입력과 출력을 하는 유향 그래프가 아니므로 계산하기 어렵습니다.

제한한 것이 제한 볼츠만 머신Restricted Boltzmann Machine,RBM

제한 볼츠만 머신은 볼츠만 머신의 두 계층 중 같은 계층의 유닛은 서로 연결하지 않도록 구성되어 있습니다.

선행 학습 pre-training 

다층 네트워크를 입력받은 순서대로 제한 볼츠만 머신 같은 두 계층의 네트워크로 분리(오토인코더로 설정)합니다.

다층 네트워크는 기울기 소실 문제가 발생해 학습이 제대로 되지 않을 때가 있습니다. 계층을 깊게 할 수록 그 영향이 더 두드러집니다. 가중치 매개변수의 초깃값을 무작위로 결정하는 것도 원인 중 하나입니다. 이를 해결하는 방법으로 선행 학습이 있습니다.

03. 심층 신경망

지도학습과 자율 학습

심층 신경망: 유닛 수와 계층 수가 3가지 이상이 되도록 다층 구조를 취하는 신경망은 심층 신경망이라고 합니다. 

심층 신경망을 사용하는 학습을 딥러닝이라고 합니다. 

심층 신뢰 신경망 :

이 기술은 가시 계층에서 순서대로 제한 볼츠만 머신의 구조를 꺼내 학습합니다. 

심층 신뢰 신경망은 제한 볼츠만 머신의 축적만으로는 단순한 자율학습입니다.

오토인코더

오토인코더는 전파형 네트워크의 하나입니다.

특징:

1. 입력 데이터 1을 통해 얻은 출력 데이터 1을 다시 입력 데이터 2로 설정합니다.

2. 입력 데이터 2에서 얻은 출력 데이터 2를 입력 데이터 1과 비교합니다.

3. 출력 데이터 2와 입력 데이터 1이 서로 더 가까운 상태가 되는 특징을 얻습니다.

4. 얻은 특정을 통해 더 나은 데이터를 얻습니다.

오토인코더는 지도 데이터가 없는 자율학습입니다.

스파스 코딩

수학에서는 백터나 행렬의 많은 원소가 0일 때 이를 스파스하다고 합니다.

04. 합성공 신경망

합성곱 처리 

합성곱 신경망의 C는 합성공 Convolutional을 의미합니다.

2개의 함수 중 하나를 평행 이동시키면서 합성공을 취한 적분 값을 계산합니다. 

합성공 신경망의 구성

합성공 계층과 풀링 계층을 거쳐 입력 이미지의 특징을 추출해서 출력하는 이미지인 특징 맵을 얻습니다.

합성공 계층과 풀링 계층 사이에 정규화 계층을 포함하기도 합니다.

정규화 계층을 합성곱 계층에서 처리된 이미지에 관해 전체 화소 값의 평균을 0으로 하는 감산 정규화 또는 분산을 정력하는 나누기 정규화 등을 수행합니다.

이처럼 합성곱 계층과 풀링 계층 사이를 반복해서 거친 후 마지막에는 완전 연결 계층 fully connected layer을 구성해서 출력합니다.

출력 내용으로 분류 결과 또는 식별 결과(라벨링한 사물의 이름)을 얻고 싶을 때는 소프트맥스 softmax함수를 이용합니다. 각 라벨을 모두 합한 값이 1이게 변환(정규화)해서 확률 형태로 나타낼 수 있습니다.

풀링 계층에서는 단순히 미이지를 축소합니다.
축소 처리는 필수는 아니지만 후속 네트워크에서의 처리 부담을 가볍게 하는 효과와 축소 처리에 의한 특징량의 압축 효과가 있습니다.

05. 순환 신경망

순환 신경망 : Recurrent Neral Network , RNN은 몇 단계 전으로 거슬러 올라가 데이터를 반영할 수 있는 신경망입니다.

시계열 데이터 등의 맥락을 고려해 학습할 수 있으므로 음성 같은 파형 데이터나 자연어 등의 학습에 이용합니다.

순환 신경망의 학습은 확률적 경사 하강법을 이용하며 실시간 순환 학습 Real-Time Recurrent Learning, RTRL이나 시간 기반 오차역전파BackPropagation Through Time, BPTT로 가중치를 업데이트합니다.

심층 순환 신경망Deep RNN과 양방향 순환 신경망 Bidirectional RNN도 있습니다.

Long Short- Term Memory LSTM

순환 신경망은 거슬러 올라가는 단계 수가 많아지면 기울기 소실 문제 때문에 제대로 학습할 수 없습니다. 이문제를 개선한 것이 Long Short -Term Memory입니다.

LSTM은 신경망의 중간 계층에서의 각 유닛을 LSTM블록이라는 메모리 유닛으로 치환한 구조입니다. 

LSTM블록에는 입력 INPUT게이트, 망각 forget게이트 , 출력 output 게이트 라는 세가지 게이트가 있으며 메모리 셀에 저장된 1단계 이전의 상태를 망각 게이트에서 참조(요소곱)합니다. 그리고 입력 게이트와 망각 게이트를 잘 여닫으면서 출력을 조정합니다.

06. 텐서플로를 이용한 오토인코더 예제

오토인코더 모델 구성

오토인고더는 다음과 같은 조건으로 구성합니다.

1. 입력값으로 이미지만 포함합니다.(라벨 없음).

2. 은닉 계층의 노드 수가 입력 계층의 노드 수보다 적도록 구성합니다.

3. 출력 계층의 노드 수는 입력 계층의 노드 수와 같습니다.

4. 은닉 계층의 노드 수가 적으므로 주요 특징량(feature)위주로 추출합니다. 마치 주성분 분석과 비슷한 효과를 얻을 수 있습니다.

5. 출력 계층에서는 입력 계층의 값을 복원(reconstruction)할 수 있습니다.

필요한 모듈 불러오기

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('./data/mnist/',one_hot = True)

이 경우 다시 수행하기 

하이퍼파라미터 설정하기

#모델 관련 하이퍼파라미터 설정
num_input = 28 * 28
#'입력 계층 노드 수 == 출력 계층 노드 수'이므로 num_output은 따로 정의하지 않습니다.
num_hidden = 256

#학습 관련 하이퍼파라미터 설정
learning_rate = 0.01
training_epoch = 10
batch_size = 100

#평가 관련 하이퍼파라미터 설정
num_output_sample = 10

 모델 만들기

오토인코더에는 라벨이 없습니다.

x_true = tf.placeholder(tf.float32, [None, num_input])

손실 함수의 기준으로 삼기 위해 y_true를 x_true와 같게 설정합니다.

y_true = x_true

인코더: 입력 계층 -> 은닉 계층

디코더: 은닉 계층 -> 출력 계층

인코더

weight_encoder = tf.Variable(tf.truncated_normal([num_input, num_hidden]))
bias_encoder = tf.Variable(tf.truncated_normal([num_hidden]))

디코더 

weight_decoder = tf.Variable(tf.truncated_normal([num_hidden, num_input]))
bias_decoder = tf.Variable(tf.truncated_normal([num_input]))

인코더와 디코더를 설정합니다. 그리고 선형 연산과 비선형 연산을 적용합니다.

encoder = tf.nn.sigmoid(tf.add(tf.matmul(x_true, weight_encoder), bias_encoder))
decoder = tf.nn.sigmoid(tf.add(tf.matmul(encoder, weight_decoder), bias_decoder))

cost optimizer

cost = tf.reduce_mean(tf.square(y_true - decoder))
optimizer = tf.train.AdamOptimizer(learning_rate)
optimizer = optimizer.minimize(cost)

모델의 학습 시작하기

sess = tf.Session()
sess.run(tf.global_variables_initializer())

total_batch = mnist.train.num_examples/batch_size #550

total_batch

for epoch in range(training_epoch):
    total_cost = 0
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        _, cost_value = sess.run([optimizer, cost],{x_true:batch_xs})
        total_cost += cost_value
    print("Epoch : {0}, Cost : {1}.format(epoch+1, total_cost/total_batch))
    
print("최적화를 완료했습니다.")

for epoch in range(training_epoch):
    total_cost = 0
    for i in range(int(total_batch)):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        _, cost_value = sess.run([optimizer, cost],{x_true:batch_xs})
        total_cost += cost_value
    print("Epoch : {0}, Cost : {1}".format(epoch+1, total_cost/total_batch))
    
print("최적화를 완료했습니다.")

평가하기

samples = sess.run(decoder, {x_true : mnist.test.images[:num_output_sample]})
fig, ax = plt.subplots(2, num_output_sample, figsize= (num_output_sample, 2))
for i in range(num_output_sample):
    ax[0][i].set_axis_off
    ax[1][i].set_axis_off
    ax[0][i].imshow(np.reshape(mnist.test.images[i], (28,28)))
    ax[1][i].imshow(np.reshape(samples[i], (28,28)))
plt.show()    

07. 텐서플로를 이용한 합성곱 신경망 예제

여기에서는 합성공 신경망을 구축하고 학습시켜 MNIST데이터를 얼마만큼 정확하게 분석하는지 확인하겠습니다.

필요한 모델 불러오기

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('./data/mnist/',one_hot = True)

합성곱 신경망 모델 만들기

x_true = tf.placeholder(tf.float32, [None, 28,28,1])
y_true = tf.placeholder(tf.float32, [None, 10])

은닉 계층 1을 정의합니다.

(3,3) 크기를 가지는 필터를 설정합니다.

Stride와 padding을 설정해 합성곱을 구합니다.(tf.nn.conv2d()이용)

비선형 ReLU함수(tf.nn.relu()이용)를 적용합니다.

최대 풀링(Max pooling , tf.nn.max_pool()이용)합니다.

0.8의 확률로 드롭아웃(dropout, tf.nn.droupout()이용)합니다.

weight_1 = tf.Variable(tf.truncated_normal([3,3,1,32], stddev = 0.01))
hidden_1 = tf.nn.conv2d(x_true, weight_1, strides= [1,1,1,1] , padding= 'SAME')
hidden_1 = tf.nn.relu(hidden_1)
hidden_1 = tf.nn.max_pool(hidden_1, ksize = [1,2,2,1] , strides = [1,2,2,1] , padding = 'SAME')
hidden_1 = tf.nn.dropout(hidden_1, keep_prob= 0.8)

weight_2 = tf.Variable(tf.truncated_normal([3,3,32,64], stddev = 0.01))
hidden_2 = tf.nn.conv2d(hidden_1, weight_2, strides= [1,1,1,1] , padding= 'SAME')
hidden_2 = tf.nn.relu(hidden_2)
hidden_2 = tf.nn.max_pool(hidden_2, ksize = [1,2,2,1] , strides = [1,2,2,1] , padding = 'SAME')

hidden_2 = tf.reshape(hidden_2, [-1, 7*7*64])
hidden_2 = tf.nn.dropout(hidden_2, keep_prob = 0.8)

weight_3 = tf.Variable(tf.truncated_normal([7*7*64 , 256], stddev = 0.01))
fc_1 = tf.matmul(hidden_2, weight_3)
fc_1 = tf.nn.relu(fc_1)
fc_1 = tf.nn.dropout(fc_1, 0.5)

weight_4 = tf.Variable(tf.truncated_normal([256 , 10], stddev = 0.01))
y_pred = tf.matmul(fc_1, weight_4)

cost = tf.nn.softmax_cross_entropy_with_logits(logits= y_pred, labels= y_true)
cost = tf.reduce_mean(cost)
optimizer = tf.train.AdamOptimizer(learning_rate= 0.01)
optimizer = optimizer.minimize(cost)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

batch_size = 100
num_batch = int(mnist.train.num_examples/batch_size) #550

for epoch in range(10):
    total_cost = 0
    for i in range(num_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        #,합성곱 신경망 모델을 위한 데이터 타입인 [28,28,1]의 형태로 reshaping
        batch_xs = batch_xs.reshape(-1, 28, 28, 1)
        _, cost_value = sess.run([optimizer, cost],{x_true:batch_xs, y_true:batch_ys})
        total_cost += cost_value
    print("Epoch : {0}, Cost : {1}".format(epoch+1, total_cost/num_batch))
    
print("최적화를 완료했습니다.")

평가하기

correct_prediction = tf.equal(tf.argmax(y_pred, 1) , tf.argmax(y_true, 1))
accuracy =  tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("정확도 : {0}".format(sess.run(accuracy, {x_true:mnist.test.images.reshape(-1,28,28,1), y_true:mnist.test.labels})))

출처 : 처음 배우는 인공지능

신경망과 베이즈 네트워크 등을 이용해 데이터를 분석하려면 그래프 네트워크를 알야야 합니다.

01. 그래프 이론

그래프 라고 하면 막대 그래프나  파이 그래프 등 표 형식의 데이터를 그림으로 나타낸 것을 연상한는 분이 많을 겁니다.

그러나 여기에서 말하는 그래프는 점과 선을 연결한 것을 의미합니다.

점을 꼭지점, 정점Vertex, 노드 라고 하며 ,선을 변 또는 간선 Edge이라고 합니다.

모든 정점 사이를 연결한(경로가 존재하는 ) 그래프를 연결 그래프 connected graph그렇지 않은 것을 비연결 그래프라고 합니다. 어떤 정점도 연결되지 않은 정점을 고립 정접Isolated vertex이라고 합니다.

그래프에서 정점 2개가 2개 이상의 변으로 연결되는 변은 "편행 변Parallel edge"이라고 합니다.

1개의 정점에 시작과 끝이 연결된 변이 존재하면 " 양 끝이 같은 변 self-loop'입니다.

무향 그래프와 유향 그래프 

유향 그래프direced graph 그래프의 변에 방향이 존재하면 

특히 어떤 정점에서 출발 한 후 해당 정점에 돌아오는 경로가 하나인 그래프는 유향 빈순회 그래프 Directed acyclic graph, DAT라고 합니다. 

변에 방향이 존재하지 않는 그래프는 무향 그래프 Undirected graph라고 합니다.

가중 그래프 Weighted Graph: 유향 그래프 중 가중치 정보가 추가된 그래프

간선 가중 그래프 Edge-Weighted Graph가중치는 정점에도 적을 수 있으므로 변에 가중치를 나타내며 간선 가중 그래프

정점에 가중치를 나타내면 정점 가중 그래프 Vertex-Weighted Graph라고 합니다.

그래프의 행렬 표현

인접행렬 adjacency matrix: 정점 사이의 관계를 나타내는 행렬입니다.

  정점 수가 n일 때 n*n행렬이며 정점 사이가 변으로 연결되어 있으면 1, 연결되어 있지 않으면 0이 됩니다.

근접행렬 incidence matrix: 정점과 변의 관계를 나타내는 행렬입니다.

  변수가 m일 때 n*m행렬이며 정점과 변이 연결되어 있다면 1, 연결되어 있지 않으면 0이 됩니다.

트리 구조 그래프

그래프에 있는 여러 개 정점에서 출발점이 되는 정점으로 돌아가는 경로가 유일하며 , 출발점이 되는 정점이 막다른 정점(더는 새로운 변을 통해 이동할 수 없는 정점)인 그래프를 트리 구조라고합니다.

출발점이 되는 정점은 루드 Root(뿌리)라고 합니다

의사결정트리는 통계 모델 예측을 위한 조건 분기에 사용되는 규칙으로 사용합니다.

탐색 트리는 상태(조건이 포함된 정보 구조)를 나누는 수단으로 사용합니다.

02. 그래프 탐색과 최적화

탐색 트리 구축

이러한 최적 경로 탐색은 현재 시간 t에 해당하는 상태에 어떤 행동을 했을 때 얻을 수 있는 이익이나 지불 비용을 계산해 다음 시각인 t+1의 상태를 결정하는 것과 같습니다. 이 과정을 반복 실행하면 목적지에 도달했을 때 시간인 T의 이익을 최대화하거나 비용을 최소화하는 계획 문제로 다룰 수 있습니다. 이러한 계획 문제를 단단계(의사)결정 문제라고 합니다.

이진 탐색 트리 binary search tree:  인덱스 정렬된 데이터를 반으로 나눠 저장하는 작업을 반복해 트리구조를 만든 후 원하는 데이터를 빠르고 효율적으로 찾습니다. 

탐색 트리 추적방법

깊이 우선 탐색Depth-first search DFS : 루트 노드에 연결된 경로 중 하나를 선택해 막다른 노드에 도착할 때 까지 일단 탐색한후 , 다시 바로 앞 노드로 이동해 다음 막다른 노드까지 탐색을 반복합니다.

너비 우선 탐색 Breadth-first search , BFS: 루트 노드와 연결된 노드를 모두 탐색한 다음 바로 다음에 깊이의 노드들을 전부 탐색하는 과정을 반복합니다.

노드들 넣는 상자를 스택이라고 합니다.

노드를 넣는 상자를 큐라고 합니다.

효율적인 탐색 방법

비용에 따른 탐색 방법

게임 트리를 전략에 이용하는 방법

동적 계획법

03. 유전 알고리즘

유전 알고리즘구조

생물이 살아가면서 교차 , 돌연변이 도태 등으로 환경에 적합하도록 진화한다는 가설에 기반을 둔 최적화 기법을 유전 알고리즘이라고 합니다.

이 과정에서 교차와 돌연변이 등 진화론 아이디어를 도입한 계산 방법을 진화연산이라고 합니다.

진화연산은 다음 특징이 있습니다.

집단성 : 개체 다수를 집단으로 설정해 동시에 탐색할 때는 병렬 연산합니다.

탐구 가능성 : 탐색 공간(설명 변수와 목적 변수 등이 취할 수 있는 값의 법위)의 자세한 사전 지식을 요구하지 않습니다.

다양성 : 집단에 있는 개체의 다양성으로 노이즈와 동적 변화에 적응성을 갖게 되므로 견고한 답을 얻을 수 있습니다.

유전 알고리즘 용어와 알고리즘 흐름

도태(선택) 개체를 남기는 처리 유전 알고리즘에서 적합도가 높은 개체를 선택해 남기면 다음 세대가 되었을 때 집단 안에서 더 최적 해결책에 가까운 개체가 많아지는 상태를 만들 수 있습니다.

교차 개체 2개에서 자식 둘을 생성하는 처리 부모의 유전자를 재조합해 자식 둘을 생성하는 것

돌연변이 개체 1개의 유전자를 변화시키는 처리 부모의 유전자를 재조합해 자식 한 명을 생성하는 것으로 적합도를 높인다는 기준으로 개체를 다루는 도태나 교차와 달리 무작위 탐색에 가깝습니다.

유전 알고리즘의 사용예:

외판원 문제 Traveling salesman problem TSP

복수 지점을 한번 만 통과하는 최단거리(또는 최단시간)을 이동해 출발점으로 돌아오는 경로를 계산하는 조합 최적화 문제

04. 신경망

헵의 법칙과 형식 뉴런

신경망 : 신경 세포(뉴런_는 다른 신경 세포에게 전기 신호를 받았을 때 전기 신호가 일정 기준을 넘으면 다음 신경 세포로 신호를 전달합니다.

헵의 법칙Hebb : 시냅스의 유연한 연결, 즉 가소성 있는 변화를 의미하며 실제로 일어난다는 사실이 나중에 밝혀졌습니다. 

신경망

계층

입력계층 -> 출력 계층

입력계층 -> 중간계층 -> 출력계층

계층: 신경망에서는 같은 종류의 형식 뉴런을 여러 개 병렬로 배열해 유닛을 형성하는 것

활성화 함수 :

형식 뉴런에서 받은 입력값을 출력할 때 일정 기준에 따라 출력값을 변화시키는 비선형 함수를 활성화 함수라고 합니다.

단위 계단 함수

시그모이드 함수

계단 함수

퍼셉트론

볼츠만 머신 : 각 노드가 양방향으로 연결된 신경망 구조를 제압합니다. 

이웃 노드가 받은 자신의 출력값을 다시 자신이 받는 피드백 메커니즘이 동작한다는 것이 핵심입니다.

요차역전파법backpropagation : 

다층 퍼셉트론: 입력 계층과 출력 계층만 있는 간단한 퍼셉트론의 약점은 선형 분리할 수 있는 데이터에만 적용할 수 있으며 계산 시간이 길다는 것입니다.

다층 퍼셉트론에서는 순방향으로 계층마다 출력을 계산한 후 오차역전파법을 이용해 출력 계층에서 역방향으로 가중치 업데이트를 실행합니다.

자기조직화 self-organization: 신경망의 학습 과정에서 네트워크가 데이터 입력과 출력 후의 가중치를 업데이트해서 스스로 일관성 있게 변화해 나가는 것

05. 텐서플로를 이용한 신경망 만들기 예제 

필요한 모델 이불러오기

import tensorflow as tf
import numpy as np

MNIST 데이터 다운로드하기

학습용 데이터 : 55,000

검증용 데이터 5,000

테스트용 데이터 10,000

이미지와 라벨 쌍으로 구성합니다.

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('./data/mnist/',one_hot = True)

뭔가 이상한것 나왔을 경우 다시 실행하면 된다.

결과

one_hot True로 설정한다.

Mnist 데이터 살펴보기

print(len(mnist.train.labels))
print(len(mnist.train.images))

print(mnist.validation.num_examples)
print(mnist.test.num_examples)

mnist.test.labels.shape

(10000, 10)

mnist.test.labels[0:5,:]

mnist.test.cls = np.argmax(mnist.test.labels, axis = 1)
mnist.test.cls[0:5]

array([7, 2, 1, 0, 4], dtype=int64)

하이퍼파라미터 설정하기

num_epochs = 30
learning_rate = 0.01

num_node_input = 28 * 28 #입력 계층의 노두 개수
num_node_hidden1 = 256 # 은닉 계층 1의 노드 개수
num_node_hidden2 = 256 #은닉 계층 2의 노드 개수
num_node_output = 10 # 출력 계층의 노드 개수

모델 만들기

입력 계층

x_true = tf.placeholder(tf.float32, [None, num_node_input])
y_true = tf.placeholder(tf.float32, [None, num_node_output])

은닉 계층 1

weight_1 = tf.Variable(tf.truncated_normal([num_node_input, num_node_hidden1], stddev = 0.01))
bias_1 = tf.Variable(tf.zeros([num_node_hidden1]))

은닉 계층 2

weight_2 = tf.Variable(tf.truncated_normal([num_node_hidden1, num_node_hidden2], stddev = 0.01))
bias_2 = tf.Variable(tf.zeros([num_node_hidden2]))

출력 계층

weight_3 = tf.Variable(tf.truncated_normal([num_node_hidden2, num_node_output], stddev = 0.01))
bias_3 = tf.Variable(tf.zeros([num_node_output]))

hidden_1 = tf.nn.relu(tf.add(tf.matmul(x_true, weight_1), bias_1))
hidden_2 = tf.nn.relu(tf.add(tf.matmul(hidden_1, weight_2), bias_2))
y_pred = tf.nn.relu(tf.add(tf.matmul(hidden_2, weight_3), bias_3))

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = y_pred, labels = y_true))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits = y_pred, labels = y_true))
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)

학습하기

세션을 실행

sess = tf.Session()
sess.run(tf.global_variables_initializer())

batch_size = 100
total_batch = int(mnist.train.num_examples/batch_size)

for epoch in range(num_epochs):
    total_cost = 0
    
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        sess.run(optimizer, {x_true: batch_xs, y_true: batch_ys})
        total_cost += sess.run(cost, {x_true: batch_xs, y_true: batch_ys})
        
    print("Epoch : {%04d}" % (epoch+1), "Cost : {:.3f}".format(total_cost / total_batch))

print("최적화를 완료했습니다.")

평가하기

correct_prediction = tf.equal(tf.argmax(y_pred,1), tf.argmax(y_true,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction , tf.float32))
print("정확도 : " , sess.run(accuracy, {x_true: mnist.test.images, y_true: mnist.test.labels}))

정확도 : 0.7453

출처 : 처음 배우는 인공지능