-
[AI] ํผ์ ํธ๋ก ๊ณผ ํผ์ ํธ๋ก ์ ๊ตฌํ / ํผ์ ํธ๋ก ์ ํ๊ณ (๋ฐ๋ฐ๋ฅ๋ถํฐ ์์ํ๋ ๋ฅ๋ฌ๋)๐ปProgramming/AI 2023. 12. 16. 17:30
๐ ํผ์ ํธ๋ก
- ๋ค์์ ์ ํธ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ํ๋์ ์ ํธ๋ฅผ ์ถ๋ ฅ
- ํผ์ ํธ๋ก ์ ์ ํธ๋ 'ํ๋ฅธ๋ค/์ํ๋ฅธ๋ค(1/0)'์ ๋ ๊ฐ์ง ๊ฐ์ ๊ฐ์ง ์ ์๋ค.
- ๊ทธ๋ฆผ์ ์์ ๋ด๋ฐ ํน์ ๋ ธ๋๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์ ๋ ฅ ์ ํธ๊ฐ ๋ด๋ฐ์ ๋ณด๋ด์ง ๋, ๊ฐ๊ฐ ๊ณ ์ ํ ๊ฐ์ค์น๊ฐ ๊ณฑํด์ง๋ค.
- ๋ด๋ฐ์์ ๋ณด๋ด์จ ์ ํธ์ ์ดํฉ์ด ํ๊ณ๋ฅผ ๋์ด์ค ๋๋ง 1์ ์ถ๋ ฅ -> ์ด๋ฅผ '๋ด๋ฐ์ด ํ์ฑํํ๋ค'๋ผ๊ณ ๋ ํํ
- ๊ทธ ํ๊ณ๋ฅผ ์๊ณ๊ฐ์ด๋ผ๊ณ ํ๋ฉฐ ๊ธฐํธ๋ก ์ธํ๋ผ๊ณ ๋ ํํํ๋ค.
๐ ํผ์ ํธ๋ก ์ ๋ ผ๋ฆฌ ํ๋ก
๐ AND ๊ฒ์ดํธ
- ์ ๋ ฅ์ด ๋๊ฐ์ด๊ณ ์ถ๋ ฅ์ด ํ๋
- ์๋์ ๊ฐ์ ์ ๋ ฅ ์ ํธ์ ์ถ๋ ฅ ์ ํธ์ ๋์ํ๋ฅผ ์ง๋ฆฌํ๋ผ๊ณ ํ๋ค.
- ๋ ์ ๋ ฅ์ด ๋ชจ๋ 1์ผ ๋๋ง 1์ ์ถ๋ ฅํ๊ณ , ๊ทธ ์ด์ธ๋ 0์ ์ถ๋ ฅ
โจ AND ๊ฒ์ดํธ์ ๊ตฌํ
def AND(x1, x2): w1, w2, theta = 0.5, 0.5, 0.7 tmp = x1*w1 + x2*w2 if tmp <= theta: return 0 elif tmp > theta: return 1
๐ NAND ๊ฒ์ดํธ
- AND ๊ฒ์ดํธ์ ์ถ๋ ฅ์ ๋ค์ง์ ๊ฒ๊ณผ ๊ฐ๋ค.
- ์ ๋ ฅ์ด ๋ชจ๋ 1์ผ ๋๋ง 0์ ์ถ๋ ฅํ๊ณ , ๊ทธ ์ด์ธ์๋ 1์ ์ถ๋ ฅ
๐ OR ๊ฒ์ดํธ
- ์ ๋ ฅ ์ ํธ ์ค ํ๋ ์ด์์ด 1์ด๋ฉด 1์ ์ถ๋ ฅ
๐ ๊ฐ์ค์น์ ํธํฅ ๋์
- ์์ ํผ์ ํธ๋ก ์ ์์ ํํ ์์์ ์ธํ๋ฅผ -b๋ก ์นํํ ๊ฒ๊ณผ ๊ฐ๋ค.
- ํผ์ ํธ๋ก ์ ์ ๋ ฅ ์ ํธ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํ ๊ฐ๊ณผ ํธํฅ์ ํฉํ์ฌ, ๊ทธ ๊ฐ์ด 0์ ๋์ผ๋ฉด 1์ ์ถ๋ ฅํ๊ณ ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅํ๋ค.
โจ ๊ฐ์ค์น์ ํธํฅ์ ์ด์ฉํ AND ๊ฒ์ดํธ์ ๊ตฌํ
def AND(x1, x2): x = np.array([x1, x2]) w = np.array([0.5, 0.5]) b = -0.7 tmp = np.sum(w*x) + b if tmp <= 0: return 0 else: return 1
- ๊ฐ์ค์น์ ํธํฅ์ ๊ธฐ๋ฅ์ด ๋ค๋ฅด๋ค๋ ์ฌ์ค์ ์ฃผ์ํด์ผํ๋ค.
- ๊ฐ์ค์น๋ ๊ฐ ์ ๋ ฅ ์ ํธ๊ฐ ๊ฒฐ๊ณผ์ ์ฃผ๋ ์ํฅ๋ ฅ์ ์กฐ์ ํ๋ ๋งค๊ฐ๋ณ์
- ํธํฅ์ ๋ด๋ฐ์ด ์ผ๋ง๋ ์ฝ๊ฒ ํ์ฑํ(๊ฒฐ๊ณผ๋ก 1์ ์ถ๋ ฅ)ํ๋๋๋ฅผ ์กฐ์ ํ๋ ๋งค๊ฐ๋ณ์
โจ ๊ฐ์ค์น์ ํธํฅ์ ์ด์ฉํ NAND ๊ฒ์ดํธ์ OR ๊ฒ์ดํธ์ ๊ตฌํ
def NAND(x1, x2): x = np.array([x1, x2]) w = np.array([-0.5, -0.5]) b = 0.7 tmp = np.sum(w*x) + b if tmp <= 0: return 0 else: return 1 def OR(x1, x2): x = np.array([x1, x2]) w = np.array([0.5, 0.5]) b = -0.2 tmp = np.sum(w*x) + b if tmp <= 0: return 0 else: return 1
๐ ํผ์ ํธ๋ก ์ ํ๊ณ
- XOR ๊ฒ์ดํธ๋ ๋ฐฐํ์ ๋ ผ๋ฆฌํฉ์ด๋ผ๋ ๋ ผ๋ฆฌ ํ๋ก๋ก ์ ๋ ฅ ์ ํธ ๋ ๊ฐ ์ค ํ์ชฝ์ด 1์ผ ๋๋ง 1์ ์ถ๋ ฅ.
- ์ง๊ธ๊น์ง์ ํผ์ ํธ๋ก ์ผ๋ก๋ XOR๊ฒ์ดํธ๋ฅผ ๊ตฌํ ๋ถ๊ฐ๋ฅ
- ์ง์ ์ผ๋ก ๋๊ทธ๋ผ๋ฏธ์ ์ธ๋ชจ๋ฅผ ๋๋ ์ ์๋ค.
- ์ง์ ์ผ๋ก๋ ๋๊ทธ๋ผ๋ฏธ์ ์ธ๋ชจ๋ฅผ ๋๋๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค. ๊ณก์ ์ด๋ผ๋ฉด ๊ฐ๋ฅํ๋ค.
โจ ํผ์ ํธ๋ก ์ ํ๊ณ
- ์ง์ ํ๋๋ก ๋๋ ์์ญ๋ง ํํํ ์ ์๋ค๋ ํ๊ณ๊ฐ ์กด์ฌํ๋ค. XOR ๊ฒ์ดํธ์ ๊ฐ์ ๊ณก์ ์์ญ์ ํํํ ์ ์๋ค.
- (๋ํ ๊ณก์ ์ ์์ญ์ ๋น์ ํ ์์ญ, ์ง์ ์ ์์ญ์ ์ ํ ์์ญ์ด๋ผ๊ณ ํ๋ค.)
- ์ด ํผ์ ํธ๋ก ์ ํ๊ณ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ค์ธต ํผ์ ํธ๋ก ์ด ๋ฑ์ฅํ์๋ค.
๐ ๋ค์ธต ํผ์ ํธ๋ก
- ๋จ์ธต ํผ์ ํธ๋ก ์ ์ธต์ ์ฌ๋ฌ๊ฐ ์์์ ๊ตฌํ
- ๊ธฐ์กด ๊ฒ์ดํธ๋ค์ ์กฐํฉํ์ฌ XOR ๊ฒ์ดํธ๋ฅผ ๊ตฌํ ๊ฐ๋ฅ.
def XOR(x1, x2): s1 = NAND(x1, x2) s2 = OR(x1, x2) y = AND(s1, s2) return y
- ์ด์ฒ๋ผ ์ธต์ด ์ฌ๋ฌ๊ฐ์ธ ํผ์ ํธ๋ก ์ ๋ค์ธต ํผ์ ํธ๋ก ์ด๋ผ๊ณ ํ๋ค.
โจ XOR ๋ค์ธต ํผ์ ํธ๋ก ์ ๋์ ๊ณผ์
1. 0์ธต์ ๋ ๋ด๋ฐ์ด ์ ๋ ฅ ์ ํธ๋ฅผ ๋ฐ์์ 1์ธต์ ๋ด๋ฐ์ผ๋ก ์ ํธ๋ฅผ ๋ณด๋ธ๋ค.
2. 1์ธต์ ๋ด๋ฐ์ด 2์ธต์ ๋ด๋ฐ์ผ๋ก ์ ํธ๋ฅผ ๋ณด๋ด๊ณ , 2์ธต์ ๋ด๋ฐ์ y๋ฅผ ์ถ๋ ฅํ๋ค.
๐ ์ ๋ฆฌ
- ํผ์ ํธ๋ก ์ ์ ์ถ๋ ฅ์ ๊ฐ์ถ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ ๋ ฅ์ ์ฃผ๋ฉด ์ ํด์ง ๊ท์น์ ๋ฐ๋ฅธ ๊ฐ์ ์ถ๋ ฅ
- ํผ์ ํธ๋ก ์ ๊ฐ์ค์น์ ํธํฅ์ ๋งค๊ฐ๋ณ์๋ก ์ค์
- ํผ์ ํธ๋ก ์ผ๋ก AND, OR ๊ฒ์ดํธ ๋ฑ์ ๋ ผ๋ฆฌ ํ๋ก๋ฅผ ํํ ๊ฐ๋ฅ
- XOR ๊ฒ์ดํธ๋ ๋จ์ธต ํผ์ ํธ๋ก ์ผ๋ก ํํ์ด ๋ถ๊ฐ๋ฅ
- 2์ธต ํผ์ ํธ๋ก ์ ์ด์ฉํ๋ฉด XOR ๊ฒ์ดํธ ํํ ๊ฐ๋ฅ
- ๋จ์ธต ํผ์ ํธ๋ก ์ ์ง์ ํ ์์ญ๋ง ํํ ๊ฐ๋ฅํ๊ณ , ๋ค์ธต ํผ์ ํธ๋ก ์ ๋น์ ํ ์์ญ๋ ํํ ๊ฐ๋ฅ
'๐ปProgramming > AI' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ