๊ธฐ์ดˆ/์ธ๊ณต์ง€๋Šฅ

ํผ์…‰ํŠธ๋ก (Percetron)

James Hwang๐Ÿ˜Ž 2021. 8. 25. 23:58
๐Ÿ’ก 'Deep Learning from Scratch'๋ฅผ ์ฐธ๊ณ ํ•˜์—ฌ ์ž‘์„ฑ

  ํผ์…‰ํŠธ๋ก (perceptron)์€ 1957๋…„ ํ”„๋ผํ‚ ๋กœ์  ๋ธ”๋ผํŠธ(Frank Rosenblatt)๊ฐ€ ๊ณ ์•ˆํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค. ๋”ฅ๋Ÿฌ๋‹์˜ ๊ธฐ์›์ด ๋˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ ํผ์…‰ํŠธ๋ก ์˜ ๊ตฌ์กฐ๋ฅผ ๋ฐฐ์šฐ๋Š” ๊ฒƒ์€ ๋”ฅ๋Ÿฌ๋‹(deep-learning)์„ ์ดํ•ดํ•˜๋Š”๋ฐ ๋„์›€์ด ๋ฉ๋‹ˆ๋‹ค.

1. ํผ์…‰ํŠธ๋ก ์ด๋ž€?

  ํผ์…‰ํŠธ๋ก ์€ ๋‹ค์ˆ˜์˜ ์‹ ํ˜ธ๋ฅผ ์ž…๋ ฅ ๋ฐ›์•„ ํ•˜๋‚˜์˜ ์‹ ํ˜ธ๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. 'Deep Learning from Scratch'์—์„œ ๊ธฐ์ˆ ํ•˜๋Š” ํผ์…‰ํŠธ๋ก ์€ ์ •ํ™•ํžˆ๋Š” '์ธ๊ณต ๋‰ด๋Ÿฐ' ํ˜น์€ '๋‹จ์ˆœ ํผ์…‰ํŠธ๋ก (simple perceptron)'์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ํผ์…‰ํŠธ๋ก ์€ ์‹ ํ˜ธ๋ฅผ ํ๋ฆ„์œผ๋กœ ๋งŒ๋“ค๊ณ  ์ •๋ณด๋ฅผ ์•ž์œผ๋กœ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค. ํผ์…‰ํŠธ๋ก ์˜ ์‹ ํ˜ธ๋Š” '์‹ ํ˜ธ๊ฐ€ ํ๋ฅธ๋‹ค(1)'์™€ '์‹ ํ˜ธ๊ฐ€ ํ๋ฅด์ง€ ์•Š๋Š”๋‹ค(0)' 2๊ฐ€์ง€์˜ ๊ฐ’์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 1. ์ž…๋ ฅ์ด 2๊ฐœ์ธ ํผ์…‰ํŠธ๋ก 

  ๊ทธ๋ฆผ 1์€ ํผ์…‰ํŠธ๋ก ์˜ ์˜ˆ์‹œ์ž…๋‹ˆ๋‹ค.

  • $ x_1 $๊ณผ $ x_2 $๋Š” ์ž…๋ ฅ ์‹ ํ˜ธ(input), $ y $๋Š” ์ถœ๋ ฅ ์‹ ํ˜ธ(output), $ w_1 $๊ณผ $ w_2 $๋Š” ๊ฐ€์ค‘์น˜(weight)๋ฅผ ์˜๋ฏธํ•จ
  • ๊ทธ๋ฆผ์˜ ์›์€ ๋‰ด๋Ÿฐ(neuron) ํ˜น์€ ๋…ธ๋“œ(node)๋ผ ๋ถ€๋ฆ„
  • ์ž…๋ ฅ ์‹ ํ˜ธ๊ฐ€ ๋‰ด๋Ÿฐ์— ๋ณด๋‚ด์งˆ ๋•Œ, ๊ฐ๊ฐ์˜ ๊ณ ์œ ํ•œ ๊ฐ€์ค‘์น˜๊ฐ€ ๊ณฑํ•ด์ง($ w_1x_1, w_2x_2 $)
  • ๋‰ด๋Ÿฐ์—์„œ ๋ณด๋‚ด์˜จ ์‹ ํ˜ธ์˜ ์ดํ•ฉ์ด ์ž„๊ณ„๊ฐ’($ \theta $)์„ ๋„˜์–ด์„ค ๋•Œ๋งŒ 1์„ ์ถœ๋ ฅ(์ด๋ฅผ '๋‰ด๋Ÿฐ์ด ํ™œ์„ฑํ™”ํ•œ๋‹ค'๋ผ๊ณ  ํ‘œํ˜„ํ•˜๊ธฐ๋„ ํ•จ)

  ์ด๋ฅผ ์ˆ˜์‹์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

$$ y = \begin{cases} 0\ (w_1x_1 + w_2x_2 \leq \theta \\ 1\ (w_1x_1 + w_2x_2 > \theta \end{cases} $$

  ํผ์…‰ํŠธ๋ก ์€ ๋ณต์ˆ˜์˜ ์ž…๋ ฅ ์‹ ํ˜ธ ๊ฐ๊ฐ์— ๊ณ ์œ ํ•œ ๊ฐ€์ค‘์น˜๋ฅผ ๋ถ€์—ฌํ•ฉ๋‹ˆ๋‹ค. ๊ฐ€์ค‘์น˜๋Š” ๊ฐ ์‹ ํ˜ธ๊ฐ€ ๊ฒฐ๊ณผ์— ์ฃผ๋Š” ์˜ํ–ฅ๋ ฅ์„ ์กฐ์ ˆํ•˜๋Š” ์š”์†Œ๋กœ ์ž‘์šฉํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰, ๊ฐ€์ค‘์น˜๊ฐ€ ํด์ˆ˜๋ก ๋” ๊ฐ•ํ•œ ์‹ ํ˜ธ๋ฅผ ํ˜๋ ค๋ณด๋‚ด๋ฉฐ ์ด๋Š” ํ•ด๋‹น ์‹ ํ˜ธ๊ฐ€ ๊ทธ๋งŒํผ ๋” ์ค‘์š”ํ•˜๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.


2. ๋‹จ์ˆœํ•œ ๋…ผ๋ฆฌ ํšŒ๋กœ

2.1 AND ๊ฒŒ์ดํŠธ

  AND ๊ฒŒ์ดํŠธ๋Š” ์ž…๋ ฅ์ด ๋‘˜์ด๊ณ  ์ถœ๋ ฅ์€ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค. ์•„๋ž˜์˜ ํ‘œ 1๊ณผ ๊ฐ™์€ ์ž…๋ ฅ ์‹ ํ˜ธ์™€ ์ถ”๋ ฅ ์‹ ํ˜ธ์˜ ๋Œ€์‘ํ‘œ๋ฅผ ์ง„๋ฆฌํ‘œ๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์•„๋ž˜์˜ ํ‘œ๋Š” ๋‘ ์ž…๋ ฅ์ด ๋ชจ๋‘ 1์ผ ๋•Œ๋งŒ 1์„ ์ถœ๋ ฅํ•˜๊ณ , ๊ทธ ์™ธ์—๋Š” 0์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

ํ‘œ 1. AND ๊ฒŒ์ดํŠธ์˜ ์ง„๋ฆฌํ‘œ

2.2 NAND์™€ OR ๊ฒŒ์ดํŠธ

  NAND ๊ฒŒ์ดํŠธ๋Š” Not AND๋ฅผ ์˜๋ฏธํ•˜๋ฉฐ AND ๊ฒŒ์ดํŠธ๋ฅผ ๋’ค์ง‘์€ ๊ฒƒ์ž…๋‹ˆ๋‹ค. $ x_1 $๊ณผ $ x_2 $๊ฐ€ ๋ชจ๋‘ 1์ผ ๋•Œ๋งŒ 0์„ ์ถœ๋ ฅํ•˜๊ณ , ๊ทธ ์™ธ์—๋Š” 1์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. OR ๊ฒŒ์ดํŠธ๋Š” ์ž…๋ ฅ ์‹ ํ˜ธ ๊ฐ€์šด๋ฐ ํ•˜๋‚˜ ์ด์ƒ์ด 1์ด๋ฉด ์ถœ๋ ฅ์ด 1์ด ๋˜๋Š” ๋…ผ๋ฆฌํšŒ๋กœ ์ž…๋‹ˆ๋‹ค.


3. ํผ์…‰ํŠธ๋ก  ๊ตฌํ˜„

3.1 ๊ฐ„๋‹จํ•œ ๊ตฌํ˜„

  1์ ˆ์˜ ์ˆ˜์‹์„ python์œผ๋กœ ๊ตฌํ˜„ํ•˜๋ฉด ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค. $ x_1$๊ณผ $ x_2 $๋ฅผ ์ธ์ˆ˜๋กœ ๋ฐ›๋Š” AND ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค.

def AND(x1: int, x2: int) -> int:
    w1, w2, theta = 0.5, 0.5, 0.7
    tmp = x1 * w1 + x2 * w2
    if tmp <= theta:
        return 0
    else:
        return 1

  ๋งค๊ฐœ๋ณ€์ˆ˜(parameter)์ธ w1๊ณผ w2, theta๋Š” ํ•จ์ˆ˜ ์•ˆ์—์„œ ์ดˆ๊ธฐํ™”ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ€์ค‘์น˜๋ฅผ ๊ณฑํ•œ ์ž…๋ ฅ์˜ ์ดํ•ฉ์ด ์ž„๊ณ„๊ฐ’์„ ๋„˜์œผ๋ฉด 1์„ ๋ฐ˜ํ™˜ํ•˜๊ณ  ๊ทธ ์™ธ์—๋Š” 0์„ ๋ฐ˜ํ™”ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ์ถœ๋ ฅํ•˜๋ฉด ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

AND(0, 0), AND(1, 0), AND(0, 1), AND(1, 1)
-> (0, 0, 0, 1)

 3.2 ๊ฐ€์ค‘์น˜์™€ ํŽธํ–ฅ(Bias) ๊ตฌํ˜„

  ์•„๋ž˜์˜ ์‹์€ $ \theta $๋ฅผ $ -b $๋กœ ์น˜ํ™˜ํ•œ ํผ์…‰ํŠธ๋ก  ์‹์ž…๋‹ˆ๋‹ค.

$$ y=\begin{cases} 0 (b + w_1x_1 + w_2x_2 \leq 0)\\ 1(b + w_1x_1 + w_2x_2 > 0) \end{cases} $$

  ์—ฌ๊ธฐ์„œ $ b $๋Š” ํŽธํ–ฅ์„ ์˜๋ฏธํ•˜๋ฉฐ $ w_1 $๊ณผ $ w_2 $๋Š” ์—ฌ์ „ํžˆ ๊ฐ€์ค‘์น˜๋กœ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ด ๋‘ ๊ฐœ๋…์„ ๋„์ž…ํ•œ AND ๊ฒŒ์ดํŠธ๋Š” ์•„๋ž˜์™€ ๊ฐ™์ด ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

import numpy as np

def AND(x1: int, x2: int) -> int:
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.7
    tmp = np.sum(x * w) + b
    if tmp <= 0:
        return 0
    else:
        return 1

  ์—ฌ๊ธฐ์„œ $ -\theta $๋Š” ํŽธํ–ฅ $ b $๋กœ ์น˜ํ™˜๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ํŽธํ–ฅ์€ ๊ฐ€์ค‘์น˜ $ w_1, w_2 $์™€ ๊ธฐ๋Šฅ์ด ๋‹ค๋ฅด๋‹ค๋Š” ์‚ฌ์‹ค์„ ์•Œ์•„์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ€์ค‘์น˜ $ w_1 $๊ณผ $ w_2 $๋Š” ๊ฐ ์ž…๋ ฅ ์‹ ํ˜ธ์™€ ๊ฒฐ๊ณผ์— ์ฃผ๋Š” ์˜ํ–ฅ๋ ฅ(์ค‘์š”๋„)๋ฅผ ์กฐ์ ˆํ•˜๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜์ž…๋‹ˆ๋‹ค. ๋ฐ˜๋ฉด ํŽธํ–ฅ์€ ๋‰ด๋Ÿฐ์ด ์–ผ๋งˆ๋‚˜ ์‰ฝ๊ฒŒ ํ™œ์„ฑํ™”(๊ฒฐ๊ณผ๋กœ 1์„ ์ถœ๋ ฅ)๋˜๋Š”์ง€ ๊ฒฐ์ •ํ•˜๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜์ž…๋‹ˆ๋‹ค.

  NAND์™€ OR ๊ฒŒ์ดํŠธ๋Š” ์•„๋ž˜์™€ ๊ฐ™์ด ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

import numpy as np

def NAND(x1: int, x2: int) -> int:
    x = np.array([x1, x2])
    w = np.array([-0.5, -0.5])  # AND์™€ ๊ฐ€์ค‘์น˜ w, b๊ฐ€ ๋‹ค๋ฆ„
    b = 0.7
    tmp = np.sum(x * w) + b
    if tmp <= 0:
        return 0
    else:
        return 1
import numpy as np

def OR(x1: int, x2: int) -> int:
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])  # AND์™€ ๊ฐ€์ค‘์น˜ b๊ฐ€ ๋‹ค๋ฆ„
    b = -0.2
    tmp = np.sum(x * w) + b
    if tmp <= 0:
        return 0
    else:
        return 1

4. ํผ์…‰ํŠธ๋ก ์˜ ํ•œ๊ณ„

4.1 XOR ๊ฒŒ์ดํŠธ

  XOR ๊ฒŒ์ดํŠธ๋Š” ๋ฐฐํƒ€์  ๋…ผ๋ฆฌํ•ฉ(exclusive or)์ด๋ผ๋Š” ๋…ผ๋ฆฌ ํšŒ๋กœ์ž…๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ '๋ฐฐํƒ€์ '์ด๋ž€, ์ž๊ธฐ ์™ธ์—๋Š” ๊ฑฐ๋ถ€ํ•œ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ $ x_1 $๊ณผ $ x_2 $ ๊ฐ€์šด๋ฐ ํ•œ ์ชฝ์ด 1์ผ ๋•Œ๋งŒ 1์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

  ์ง€๊ธˆ๊นŒ์ง€ ์‚ดํŽด๋ณธ ํผ์…‰ํŠธ๋ก ์œผ๋กœ๋Š” XOR ๊ฒŒ์ดํŠธ๋ฅผ ๊ตฌํ˜„ํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ์ง€๊ธˆ๊นŒ์ง€์˜ AND, NAND, OR ๊ฒŒ์ดํŠธ๋Š” ์•„๋ž˜์˜ ๊ทธ๋ฆผ 2์˜ ์™ผ์ชฝ๊ณผ ๊ฐ™์ด ์ง์„  ํ•˜๋‚˜๋กœ ๋‘ ์˜์—ญ์„ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ XOR ๊ฒŒ์ดํŠธ์˜ ๊ฒฝ์šฐ, ํ•˜๋‚˜์˜ ์ง์„ ์œผ๋กœ ๋‘ ์˜์—ญ์„ ๋‚˜๋ˆ„๋Š” ๊ฒƒ์€ ๋ถˆ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 2. OR ๊ฒŒ์ดํŠธ(์ขŒ)์™€ XOR ๊ฒŒ์ดํŠธ(์šฐ) ๊ทธ๋ž˜ํ”„

4.2 ์„ ํ˜•(Linear)๊ณผ ๋น„์„ ํ˜•(Non-linear)

  ํผ์…‰ํŠธ๋ก ์€ ์ง์„  ํ•˜๋‚˜๋กœ ๋‚˜๋ˆˆ ์˜์—ญ๋งŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ํ•œ๊ณ„๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ์•„๋ž˜์˜ ๊ทธ๋ฆผ 3๊ณผ ๊ฐ™์€ ๊ณก์„ ์€ ํ‘œํ˜„ํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆผ 3๊ณผ ๊ฐ™์€ ๊ณก์„ ์˜ ์˜์—ญ์„ ๋น„์„ ํ˜• ์˜์—ญ, ์ง์„ ์˜ ์˜์—ญ์„ ์„ ํ˜• ์˜์—ญ์ด๋ผ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 3.  ๋น„์„ ํ˜•์œผ๋กœ ํ‘œํ˜„ํ•œ XOR


5. ๋‹ค์ธต ํผ์…‰ํŠธ๋ก (Multi-layer perceptron)

  ์•ˆํƒ€๊น๊ฒŒ๋„ ๋‹จ์ผ ํผ์…‰ํŠธ๋ก ์œผ๋กœ๋Š” XOR ๊ฒŒ์ดํŠธ๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์—†์—ˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ํผ์…‰ํŠธ๋ก ์€ '์ธต(layer)๋ฅผ ์Œ“์•„' ๋‹ค์ธต ํผ์…‰ํŠธ๋ก ์œผ๋กœ XOR ๊ฒŒ์ดํŠธ๋ฅผ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

5.1 ๊ธฐ์กด ๊ฒŒ์ดํŠธ์˜ ์กฐํ•ฉ

  XOR ๊ฒŒ์ดํŠธ๋ฅผ ๋งŒ๋“œ๋Š” ๋ฐฉ๋ฒ•์€ ๋‹ค์–‘ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ ์ค‘ ํ•˜๋‚˜๋Š” ์•ž์„œ ๋งŒ๋“  AND์™€ NAND, OR ๊ฒŒ์ดํŠธ๋ฅผ ์กฐํ•ฉํ•˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. ์•„๋ž˜์˜ ๊ทธ๋ฆผ๊ณผ ๊ฐ™์€ ์กฐํ•ฉ์ด๋ฉด XOR ๊ฒŒ์ดํŠธ๋ฅผ ๊ตฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 4. XOR ๊ฒŒ์ดํŠธ

  • $ x_1 $๊ณผ $ x_2 $๋Š” ์ž…๋ ฅ ์‹ ํ˜ธ, $ y $๋Š” ์ถœ๋ ฅ ์‹ ํ˜ธ๋ฅผ ์˜๋ฏธ
  • $ x_1 $๊ณผ $ x_2 $๋Š” NAND์™€ OR ๊ฒŒ์ดํŠธ์˜ ์ž…๋ ฅ์ด ๋˜๊ณ , NAND์™€ OR ๊ฒŒ์ดํŠธ์˜ ์ถœ๋ ฅ์ด AND ๊ฒŒ์ดํŠธ์˜ ์ž…๋ ฅ์ด ๋จ
  • NAND์˜ ์ถœ๋ ฅ์€ $ s_1 $, OR์˜ ์ถœ๋ ฅ์€ $ s_2 $๋ผ ํ‘œํ˜„

  ์ด๋ฅผ ์ด์šฉํ•ด ์ง„๋ฆฌํ‘œ๋ฅผ ๋งŒ๋“ค๋ฉด ์•„๋ž˜์˜ ํ‘œ 2์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค. $ x_1, x_2, y $์— ์ฃผ๋ชฉํ•˜๋ฉด XOR์˜ ์ถœ๋ ฅ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

ํ‘œ 2. XOR ๊ฒŒ์ดํŠธ์˜ ์ง„๋ฆฌํ‘œ

5.2 XOR ๊ฒŒ์ดํŠธ ๊ตฌํ˜„

  ์ง€๊ธˆ๊นŒ์ง€ ์ •์˜ํ•œ ํ•จ์ˆ˜ AND์™€ NAND, OR๋ฅผ ์ด์šฉํ•˜๋ฉด ์•„๋ž˜์™€ ๊ฐ™์ด ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

def XOR(x1: int, x2: int) -> int:
    s1 = NAND(x1, x2)
    s2 = OR(x1, x2)
    y = AND(s1, s2)
    return y

  ์ด XOR ํ•จ์ˆ˜์˜ ์ถœ๋ ฅ์€ ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

XOR(0, 0), XOR(1, 0), XOR(0, 1), XOR(1, 1)
-> (0, 1, 1, 0)

  XOR์€ ์•„๋ž˜์˜ ๊ทธ๋ฆผ 4์™€ ๊ฐ™์€ ๋‹ค์ธต ๊ตฌ์กฐ์˜ ๋„คํŠธ์›Œํฌ์ž…๋‹ˆ๋‹ค. ์™ผ์ชฝ๋ถ€ํ„ฐ ์ฐจ๋ก€๋กœ 0์ธต, 1์ธต, 2์ธต์ด๋ผ ์นญํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆผ 4์˜ ํผ์…‰ํŠธ๋ก ์€ ๋ชจ๋‘ 3์ธต์œผ๋กœ ๊ตฌ์„ฑ๋˜์ง€๋งŒ, ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ๊ฐ–๋Š” ์ธต์€ 2๊ฐœ์— ๋ถˆ๊ณผํ•˜๋‹ˆ '2์ธต ํผ์…‰ํŠธ๋ก '์ด๋ผ ๋ถ€๋ฆ…๋‹ˆ๋‹ค. ์ด๋ ‡๊ฒŒ ์ธต์ด ์—ฌ๋Ÿฌ ๊ฐœ์ธ ํผ์…‰ํŠธ๋ก ์„ ๋‹ค์ธต ํผ์…‰ํŠธ๋ก ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. 2์ธต ํผ์…‰ํŠธ๋ก ์˜ ๋กœ์ง์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 4. XOR์˜ ํผ์…‰ํŠธ๋ก 

  • 0์ธต์˜ ๋‘ ๋‰ด๋Ÿฐ์ด ์ž…๋ ฅ ์‹ ํ˜ธ๋ฅผ ๋ฐ›์•„ 1์ธต์˜ ๋‰ด๋Ÿฐ์œผ๋กœ ์‹ ํ˜ธ๋ฅผ ๋ณด๋ƒ„
  • 1์ธต์˜ ๋‰ด๋Ÿฐ์ด 2์ธต์˜ ๋‰ด๋Ÿฐ์œผ๋กœ ์‹ ํ˜ธ๋ฅผ ๋ณด๋‚ด๊ณ , 2์ธต์˜ ๋‰ด๋Ÿฐ์€ y๋ฅผ ์ถœ๋ ฅํ•จ

  ์ด๋ ‡๊ฒŒ 2์ธต ๊ตฌ์กฐ๋ฅผ ํ™œ์šฉํ•˜์—ฌ ํผ์…‰ํŠธ๋ก ์œผ๋กœ XOR ๊ฒŒ์ดํŠธ๋ฅผ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ๋‹จ์ธต ํผ์…‰ํŠธ๋ก ์œผ๋กœ๋Š” ํ‘œํ˜„ํ•  ์ˆ˜ ์—†๋˜ ๊ฒƒ์„ ์ธต ํ•˜๋‚˜๋ฅผ ์ถ”๊ฐ€ํ•จ์œผ๋กœ์จ ๊ตฌํ˜„ ๊ฐ€๋Šฅํ–ˆ์Šต๋‹ˆ๋‹ค. ์ด์ฒ˜๋Ÿผ ํผ์…‰ํŠธ๋ก ์€ ์ธต์„ ์Œ“์•„(๊นŠ๊ฒŒ ํ•˜์—ฌ) ๋” ๋‹ค์–‘ํ•œ ๊ฒƒ์„ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.