ํผ์ ํธ๋ก (Perceptron)์ด๋?
1. ํผ์ ํธ๋ก ์ ์
ํผ์ ํธ๋ก (Perceptron)์ ์ธ๊ณต ์ ๊ฒฝ๋ง(Artificial Neural Network, ANN)์ ๊ฐ์ฅ ๊ธฐ์ด์ ์ธ ํํ๋ก, 1958๋ ์ ํ๋ํฌ ๋ก์ ๋ธ๋ผํธ(Frank Rosenblatt)๊ฐ ๊ฐ๋ฐํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ํผ์ ํธ๋ก ์ ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ ๊ฐ์ค์น๋ฅผ ์ ์ฉํ๊ณ , ํ์ฑํ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ
์ต์ข ์ถ๋ ฅ์ ๊ฒฐ์ ํ๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ๋๋ค.
ํผ์ ํธ๋ก ์ ์ธ๊ณต ๋ด๋ฐ ๋ชจ๋ธ์ด๋ฉฐ, ์๋ฌผํ์ ๋ด๋ฐ(Neuron)์์ ์๊ฐ์ ๋ฐ์ ์ค๊ณ๋์๋ค. ์ด ๋ชจ๋ธ์ ์ด์ง ๋ถ๋ฅ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ
์ฃผ๋ก ์ฌ์ฉ๋๋ค.
2. ํผ์ ํธ๋ก ์ ๊ตฌ์กฐ
ํผ์ ํธ๋ก ์ ๋ค์๊ณผ ๊ฐ์ ๊ตฌ์ฑ ์์๋ฅผ ๊ฐ์ง๋ค:
1) ์ ๋ ฅ(Input)
- ์ฌ๋ฌ ๊ฐ์ ์ ๋ ฅ ์ ํธ(`x1, x2, ..., xn`)๋ฅผ ๋ฐ์
2) ๊ฐ์ค์น(Weight)
- ๊ฐ ์ ๋ ฅ์ ๊ฐ์ค์น(`w1, w2, ..., wn`)๋ฅผ ๊ณฑํ์ฌ ์ค์๋๋ฅผ ๋ถ์ฌํจ
3) ํธํฅ(Bias)
- ๋ชจ๋ธ์ด ์ข ๋ ์ ์ฐํ๊ฒ ํ์ตํ ์ ์๋๋ก ์ถ๊ฐ๋๋ ์์ ๊ฐ(`b` = ๋ฐ์ด์ด์ค)
4) ๊ฐ์คํฉ(Weighted Sum)
- ์ ๋ ฅ ๊ฐ๊ณผ ๊ฐ์ค์น๋ฅผ ๊ณฑํ ๊ฐ๋ค์ ๋ชจ๋ ๋ํ๊ณ ํธํฅ์ ์ถ๊ฐ
- ์์:
5) ํ์ฑํ ํจ์(Activation Function)
- ๊ฐ์คํฉ์ ํน์ ๊ธฐ์ค(์๊ณ๊ฐ)์ ๋ฐ๋ผ ์ด์ง ์ถ๋ ฅ(0 ๋๋ 1)์ผ๋ก ๋ณํํ๋ ์ญํ ์
- ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํ์ฑํ ํจ์๋ก ๊ณ๋จ ํจ์(Step Function)๊ฐ ์ฌ์ฉ๋จ
- ์ด๋ ๊ณ๋จ ํจ์์ ์ฌ์ฉ๋ ์ด ์๊ณ์น๊ฐ์ ์์์ผ๋ก ํํํ ๋๋ ๋ณดํต ์ธํ(Θ)๋ก ํํํจ
์์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์
6) ์ถ๋ ฅ(Output)
- ์ต์ข ์ ์ผ๋ก 0 ๋๋ 1์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅ
3. ํผ์ ํธ๋ก ์ ๋์ ์๋ฆฌ
ํผ์ ํธ๋ก ์ ๋ค์ ๊ณผ์ ์ ๊ฑฐ์ณ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ค:
- ์ ๋ ฅ ๋ฐ์ดํฐ ์์ง: `x1, x2, ..., xn` ๊ฐ์ ์ ๋ ฅ๋ฐ์
- ๊ฐ์คํฉ ๊ณ์ฐ: ๊ฐ ์ ๋ ฅ ๊ฐ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํ๊ณ ํธํฅ์ ๋ํจ
- ํ์ฑํ ํจ์ ์ ์ฉ: ๊ฐ์คํฉ ๊ฒฐ๊ณผ๊ฐ ์๊ณ๊ฐ์ ๋์ผ๋ฉด 1, ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅ
- ๊ฒฐ๊ณผ ์ถ๋ ฅ: ์ต์ข ์ ์ผ๋ก 0 ๋๋ 1์ ๋ฐํํ์ฌ ์ด์ง ๋ถ๋ฅ๋ฅผ ์ํ
4. ํผ์ ํธ๋ก ํ์ต ์๊ณ ๋ฆฌ์ฆ
ํผ์ ํธ๋ก ์ ์ง๋ ํ์ต(Supervised Learning) ๋ฐฉ์์ผ๋ก ํ์ตํ๋ฉฐ, ์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ํตํด ๊ฐ์ค์น๋ฅผ ์กฐ์ ํ๋ ๊ณผ์ ์ด ํฌํจ๋๋ค.
ํ์ต ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค:
- ์ด๊ธฐํ
- ๊ฐ์ค์น(`w1, w2, ..., wn`)์ ํธํฅ(`b`)์ ์์ ๋๋ค ๊ฐ์ผ๋ก ์ค์
- ์์ธก ๋ฐ ์ค์ฐจ ๊ณ์ฐ
- ํ์ฌ ๊ฐ์ค์น์ ํธํฅ์ผ๋ก ์์ธก ๊ฐ์ ๊ณ์ฐํจ
- ์์ธก ๊ฐ๊ณผ ์ค์ ๊ฐ(์ ๋ต) ์ฌ์ด์ ์ค์ฐจ๋ฅผ ๊ณ์ฐ
- ๊ฐ์ค์น ์
๋ฐ์ดํธ
- ์ค์ฐจ๋ฅผ ์ค์ด๊ธฐ ์ํด ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธ
- ๋ฐ๋ณต
- ์ผ์ ์กฐ๊ฑด(์ํฌํฌ ์ ๋๋ฌ ๋๋ ์ค์ฐจ ์ต์ํ)๊น์ง ๋ฐ๋ณต
5. ํผ์ ํธ๋ก ์ ํ๊ณ
ํผ์ ํธ๋ก ์ ๋จ์ํ์ง๋ง ๋ช ๊ฐ์ง ํ๊ณ๋ฅผ ๊ฐ์ง๋ค:
1) ์ ํ ๋ถ๋ฆฌ ๋ฌธ์ ๋ง ํด๊ฒฐ ๊ฐ๋ฅ
- ํผ์ ํธ๋ก ์ ์ ํ์ ์ผ๋ก ๋ถ๋ฆฌ ๊ฐ๋ฅํ ๋ฌธ์ (์: AND, OR ๊ฒ์ดํธ)๋ง ํด๊ฒฐํ ์ ์์
- BUT! XOR ๋ฌธ์ ์ ๊ฐ์ ๋น์ ํ ๋ฌธ์ ๋ ํด๊ฒฐํ ์ ์์
2) ๋ค์ธต ํผ์ ํธ๋ก (MLP)์ ํ์์ฑ
- ํผ์ ํธ๋ก ์ ํ๊ณ๋ฅผ ๊ทน๋ณตํ๊ธฐ ์ํด ์ฌ๋ฌ ๊ฐ์ ๋ด๋ฐ์ ์์ ๋ค์ธต ํผ์ ํธ๋ก (MLP, Multi-Layer Perceptron)์ด ๋ฑ์ฅ
- MLP๋ ์๋์ธต(Hidden Layer)์ ์ถ๊ฐํ์ฌ ๋น์ ํ ๋ฌธ์ ๋ ํด๊ฒฐ ๊ฐ๋ฅ
3) ๋ค๋ฅธ ํ์ฑํ ํจ์ ํ์
- ๋จ์ํ ๊ณ๋จ ํจ์(Step Function) ๋์ , ์ฐ์์ ์ธ ํ์ฑํ ํจ์์ธ ์๊ทธ๋ชจ์ด๋(Sigmoid), ReLU, tanh ๋ฑ์ด ์ฌ์ฉ๋๋ฉด์ ํผ์ ํธ๋ก ์ด ๋ ๊ฐ๋ ฅํด์ง
6. ํผ์ ํธ๋ก ๊ตฌํ (Python ์ฝ๋)
import numpy as np
class Perceptron:
def __init__(self, input_size, lr=0.1, epochs=10):
self.weights = np.zeros(input_size + 1) # ๊ฐ์ค์น + ํธํฅ
self.lr = lr # ํ์ต๋ฅ
self.epochs = epochs # ํ์ต ๋ฐ๋ณต ํ์
def activation(self, x):
return 1 if x >= 0 else 0 # ๊ณ๋จ ํจ์
def predict(self, x):
x = np.insert(x, 0, 1) # ํธํฅ ์ถ๊ฐ
return self.activation(np.dot(self.weights, x))
def train(self, X, y):
for _ in range(self.epochs):
for i in range(len(X)):
x_i = np.insert(X[i], 0, 1) # ํธํฅ ์ถ๊ฐ
y_pred = self.activation(np.dot(self.weights, x_i))
self.weights += self.lr * (y[i] - y_pred) * x_i # ๊ฐ์ค์น ์
๋ฐ์ดํธ
โ ์ฌ์ฉ ์์ :
# AND ๊ฒ์ดํธ ํ์ต
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])
p = Perceptron(input_size=2)
p.train(X, y)
print(p.predict([0, 0])) # 0
print(p.predict([1, 1])) # 1
ํผ์ ํธ๋ก ์ ๋ฆฌ:
1๏ธโฃ ํผ์ ํธ๋ก ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ธ๊ณต ์ ๊ฒฝ๋ง ๋ชจ๋ธ์ด๋ค~
2๏ธโฃ ์ ๋ ฅ → ๊ฐ์ค์น → ํ์ฑํ ํจ์ → ์ถ๋ ฅ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ค~
3๏ธโฃ ํ์ต ์๊ณ ๋ฆฌ์ฆ์ ํตํด ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธํ๋ฉฐ ์ด์ง ๋ถ๋ฅ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค~
4๏ธโฃ ๋น์ ํ ๋ฌธ์ (XOR ๋ฑ)๋ ํด๊ฒฐํ ์ ์์ด์ ๋ค์ธต ํผ์ ํธ๋ก (MLP)์ผ๋ก ํ์ฅ๋์๋ค~
์~ ๊ทธ๋ ๊ตฌ๋~~
'AI ๐ค > ML & DL ๐ง ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[250212] LangChain์ด ๋ญ๋ฐ~ (2) | 2025.02.12 |
---|---|
[250210] LLM ํน๊ฐ ๋๋ฒ์งธ ์๊ฐ~ (1) | 2025.02.10 |
[250207] LLM ํน๊ฐ ์ ๋ฆฌ~ (0) | 2025.02.07 |
[241226] ๋ฐ์ดํฐ ์๊ฐํ ์ ๋ฆฌ (2) | 2024.12.26 |
[241217] ๋จธ์ ๋ฌ๋ ๊ฐ๋ ์ ๋ฆฌ ๋๋ฒ์งธ (0) | 2024.12.17 |