[Tensorflow] 1. 논리연산을 위한 신경망 네트워크 생성

흔히 C나 Python와 같은 프로그래밍을 배우다 보면 자연스럽게 논리 연산을 접하게 되는데요.

생각해보면 저 역시 대학교 첫 컴퓨터 프로그래밍 시간에 배웠더라고요!

 

각설하고 논리연산은 비트연산이라고도 불리며 컴퓨터는 0과 1로 정보를 처리하므로 논리 연산은 굉장히 중요한 연산이에요.

전자공학에서도 논리 연산을 물리적 장치로 구현한 전자 회로를 의미 논리 회로(logic gate)에서도 사용되며

데이터베이스의 인덱스 중에 비트맵 인덱스(Bitmap Index), 데이터사이언스나 통계에서도 광범위하게 사용되고 있어요.

 

논리 연산을 위한 연산자는 여러개가 있는데 그 중 4개 정도의 연산자를 소개하고 이를 구성하는 네트워크를 구성하려고 합니다.

 

 

1. 논리합(OR, ∨) 연산자 (Disjunction)

논리합은 임의의 명제를 나타낼 때, '또는(or)'이라는 논리적 언어로 연결된 합성 명제로
수리 논리학에서 1개 이상의 참이 있는지를 나타내는 논리 연산이다.

입력값 1	입력값 2	OR 연산 결과
참(1)	참(1)	참(1)
참(1)	거짓(0)	참(1)
거짓(0)	참(1)	참(1)
거짓(0)	거짓(0)	거짓(0)

 

따라서 논리합은 입력 중 하나의 값만 참이라면 결과도 참이며, 모든 값이 거짓이라면 거짓이 나오는 연산자입니다.

대부분의 프로그래밍에서는 참(True)을 1로, 거짓(False)를 0으로 표현하기에 코드를 구성할때도 0과 1을 사용해 구성하겠습니다.

import tensorflow as tf
import numpy as np 

x = np.array([[1,1],[1,0],[0,1],[0,0]])
y = np.array([1,1,1,0])
w = tf.random.normal([2],0,1)
b = tf.random.normal([1],0,1)
learning_rate = 0.1

for i in range(5000) :
    total_error = 0
    
    for j in range(len(x)) :
        tmp = np.sum(x[j]*w) + b
        output = tf.math.sigmoid(tmp)
        error = output - y[j]
        w = w - learning_rate * error * x[j]
        b = b - learning_rate * error
        total_error = total_error + error
    
    if i % 500 == 499 :
        if i == 499 : 
            pass
        else :
            print("[",i+1,"] error : ", total_error.numpy(), " slope : ", w.numpy()," intercept : ", b.numpy(), sep="")

• [코드설명 1] x = np.array([[1,1],[1,0],[0,1],[0,0]])으로 되어있는 부분은 입력값으로 순차적으로 (1,1), (1,0), (0,1), (0,0)와 같은 방식으로 4번씩 입력값으로 들어가게 되며 y=np.array([1,1,1,0])은 (1,1)(=x의 첫번째)이 들어왔을때 1(=y의 첫번째)을 출력하고싶다! 와 같이 이해하시면 좋을 것 같습니다. 
• [코드설명 2] w는 가중치, b는 편향을 의미합니다. 정확한 값을 모르기에 random 모듈을 이용해 초기화해줍니다.
• [코드설명 3] output = tf.math.sigmoid(tmp)는 출력값으로 입력값(x)와 가중치(w)를 곱해 더한값에 편향(b)를 더한 $\sum_{i=1}^{n} (x_i*w_i) + b$를 시그모이드 함수에 적용한 값을 출력으로 합니다.
• [코드설명 4] 오차(error)는 "예측값(predict)-실제값(real Value)"으로 계산됩니다.
• [코드설명 5] 파라미터 w, b는 경사하강법(Gradient Descent, GD)를 통해 학습시켜줍니다.

오차항은 점점 감소하는 경향이 존재하며 입력 가중치와 편향 가중치 역시 국소적으로 수렴하고 있습니다.

for i in range(len(x)) :
    print("Input :", x[i], "Output :", tf.math.sigmoid(np.sum(x[i]*w)+b))

입력값에 따라 분류가 잘 되고 있는것을 알 수 있습니다.

 

 

 

2. 논리곱(AND, ∧) 연산자 (Conjunction)

논리곱은 임의의 명제를 나타낼 때, '그리고(AND)'이라는 논리적 언어로 연결된 합성 명제로
수리 논리학에서 모두 참인지를 판별하는 논리 연산이다.

입력값1	입력값2	AND 연산 결과
참(1)	참(1)	참(1)
참(1)	거짓(0)	거짓(0)
거짓(0)	참(1)	거짓(0)
거짓(0)	거짓(0)	거짓(0)

 

논리곱은 1개 이상의 거짓이 있으면 거짓이 나오므로 입력값이 [1,1] 일때만 [1]이 나오도록 설계해야 합니다.

 

이때 입력값($x_1$, $x_2$)과 편향 $b$을 받아 선형적으로 연결한 $w_1*x_1 + w_2*x_2 + b$값을

활성화함수인 시그모이드(Sigmoid)를 적용해 출력값을 내보내며 목표값($y$)과의 차이를 최소화하는 방식입니다.

import tensorflow as tf
import numpy as np

x = np.array([[1,1],[1,0],[0,1],[0,0]])
y = np.array([1,0,0,0])
w = tf.random.normal([2],0,1)
b = tf.random.normal([1],0,1)
learning_rate = 0.1

for i in range(int(5e3)) :
    total_error = 0
    
    for j in range(len(x)) :
        tmp = np.sum(x[j]*w) + b
        output = tf.math.sigmoid(tmp)
        error = output - y[j]
        w = w - learning_rate * error * x[j]
        b = b - learning_rate * error
        total_error = total_error + error
    
    if i % 500 == 499 :
        if i == 499 :
            pass
        else :
            print("[",i+1,"] error : ", total_error.numpy(), " slope : ", w.numpy()," intercept : ", b.numpy(), sep="")

학습 횟수가 증가할수록 오차는 점점 작아지며 가중치 파라미터가 국소적으로 수렴하는것을 알 수 있습니다.

for i in range(len(x)) : 
    print("Input :", x[i], "Output :", tf.math.sigmoid(np.sum(x[i]*w)+b))

입력값이 [1, 1] 일때만 결과가 1에 가깝게 나오고 그 외의 경우에는 0에 가깝게 나오므로 분류가 잘 되고 있습니다

 

 

 

3. 부정(NOT, ¬) 연산자 (Negation)

부정은 수리 논리학에서 명제의 참과 거짓을 반전하는 논리 연산이다

따라서 입력이 참이면 거짓이 나와야하며 반대로 입력이 거짓이면 결과가 참이 나와야 합니다.

해당 연산자는 입력을 1개만 받기에 논리곱과 논리합의 코드와는 조금 다른 것을 확인할 수 있습니다.

import numpy as np
import tensorflow as tf

x = np.array([1,0])
y = np.array([0,1])
w = tf.random.normal([1],0,1)
b = tf.random.normal([1],0,1)
learning_rate = 0.1

for i in range(int(5e3)) :
    total_error = 0
    
    for j in range(len(x)) :
        tmp = x[j] * w + b
        output = tf.math.sigmoid(tmp)
        error = output - y[j]
        w = w - learning_rate * error * x[j]
        b = b - learning_rate * error
        total_error = total_error + error
    
    if i % 500 == 499 :
        if i == 499 : 
            pass
        else :
            print("[",i+1,"] error : ", total_error.numpy(), " slope : ", w.numpy()," intercept : ", b.numpy(), sep="")

for i in range(len(x)) : 
    print("Input :", x[i], "Output :", tf.math.sigmoid(x[i]*w+b))

 

 

4. 베타적 논리합(XOR, Exclusive OR)

베타적 논리합은 수리 논리학에서 주어진 2개의 명제 가운데 1개만 참일 경우를 판단하는 논리 연산이다

입력값 1	입력값 2	XOR 연산 결과
참	참	거짓
참	거짓	참
거짓	참	참
거짓	거짓	거짓

 

XOR 연산을 위한 네트워크는 1개의 퍼셉트론으로 구성할 수 없다는 한계가 있습니다.

논리곱, 논리합, 부정의 경우에는 단일 퍼셉트론으로 구분이 가능하나

XOR 연산은 단일 퍼셉트론으로 구분할 수 없다는것이 증명되어 있습니다.

따라서 1개의 퍼셉트론을 사용하는것이 아닌 여러개의 퍼셉트론을 사용해야 합니다!

코드는 아래와 같으며 keras를 이용하였습니다.

# 깊이가 2인 퍼셉트론을 사용해 XOR 네트워크 구성
import tensorflow as tf
import numpy as np

x = np.array([[1,1],[1,0],[0,1],[0,0]])
y = np.array([[0],[1],[1],[0]])

model = tf.keras.Sequential([
    tf.keras.layers.Dense(units=2, activation = "sigmoid", input_shape=(2,)),
    tf.keras.layers.Dense(units=1, activation = "sigmoid")
])

# 손실함수를 MSE(mean squared error)로 사용
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.1), loss="mse")
model.summary()

• [코드설명1] input_shape=(2,)는 한번 입력받을때 [1, 1]와 같이 길이가 2인 입력값을 처리하겠다는 뜻입니다.
• [코드설명2] 신경망을 구성할때 모델구축 -> 모델설정(컴파일) -> 적합(Fit) 순서로 하는것을 권장합니다.
• [코드설명3] Optimizer는 최적화를 의미하며 다양한 최적화 방법이 있습니다. 여기서는 SGD(확률경사하강법)을 사용합니다.
• [코드설명4] loss = "mse"는 손실함수를 의미하며 최종출력값과 y에 적용되는 함수입니다.

모델은 총 9개의 파라미터를 가지며 층이 2개인 레이어로 구성되어 있습니다.

모델을 구성한 후 x, y를 이용해 반복적으로 학습을 시켜주는 코드는 다음과 같습니다.

history = model.fit(x, y, epochs=5000, batch_size=1)

학습이 완료된 모델로 x값이 주어질때 예측값을 구하면 다음과 같습니다.

model.predict(x)