[머신러닝과 딥러닝] 17. 딥러닝(AND, OR, XOR 게이트)

뉴런(neuron)의 종류

1-1. 생물학적 뉴런

• 인간의 뇌는 수십억 개의 뉴런을 가지고 있음.
• 뉴런은 화학적, 전기적 신호를 처리하고 전달하는 연결된 뇌신경 세포

 

1-2. 인공 뉴런

• 1943년에 워렌 맥컬록, 월터 피츠가 단순화된 뇌세포 개념을 발표함.
• 신경 세포를 이진 출력을 가진 단순한 논리 게이트라고 설명
• 생물학적 뉴런의 모델에 기초한 수학적 기능으로, 각 뉴런이 입력을 받아 개별적으로 가중치를 곱하여 나온 합계를 비선형 함수를 전달하여 출력을 생성한것을 뜻함.

2. 퍼셉트론(Perceptron)

• 인공 신경망의 가장 기본적인 형태로 1957년에 처음 소개되었음.
• 입력과 출력을 가진 단일 뉴런 모델을 기반으로 개발됨
• 초기의 기계 학습 알고리즘 중 하나로 이진 분류 문제를 해결하기 위해 설계되었음.

---

논리 회귀(단층 퍼셉트론)으로 AND 게이트 문제 풀기

※조건

1. optimizer는 SGD를 사용하며 lr=1로 설정할것.
2. epoch를 1000번 돌려서 Accuracy값은 100%가 되도록 할것

---

풀이 시작

1. 필요 모듈 임포트

import torch
import torch.nn as nn
import torch.optim as optim

 

2. X, y에 Tensor형식으로 값 지정 후 학습

X = torch.FloatTensor([[0,0], [0,1], [1,0], [1,1]])
y = torch.FloatTensor([[0], [0], [0], [1]])

model = nn.Sequential(
    nn.Linear(2, 1),
    nn.Sigmoid()
)

optimizer = optim.SGD(model.parameters(), lr=1)

epochs = 1000

for epoch in range(epochs + 1):
    y_pred = model(X)
    loss = nn.BCELoss()(y_pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        y_bool = (y_pred >= 0.5).float()
        accuracy = (y  == y_bool).float().sum() / len(y) * 100
        print(f'Epoch {epoch:4d}/{epochs} Loss: {loss:.6f} Accuracy: {accuracy:.2f}')

 

3. 결과값 

---

논리 회귀(단층 퍼셉트론)으로 OR 게이트 문제 풀기

※조건

1. optimizer는 SGD를 사용하며 lr=1로 설정할것.
2. epoch를 1000번 돌려서 Accuracy값은 100%가 되도록 할것

---

1. 작업 코드

X = torch.FloatTensor([[0,0], [0,1], [1,0], [1,1]])
y = torch.FloatTensor([[0], [1], [1], [1]])

model = nn.Sequential(
    nn.Linear(2, 1),
    nn.Sigmoid()
)

optimizer = optim.SGD(model.parameters(), lr=1)

epochs = 1000

for epoch in range(epochs + 1):
    y_pred = model(X)
    loss = nn.BCELoss()(y_pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        y_bool = (y_pred >= 0.5).float()
        accuracy = (y  == y_bool).float().sum() / len(y) * 100
        print(f'Epoch {epoch:4d}/{epochs} Loss: {loss:.6f} Accuracy: {accuracy:.2f}')

 

2. 결과값 

---

 

논리 회귀(단층 퍼셉트론)으로 XOR 문제 풀기

※조건

1. optimizer는 SGD를 사용하며 lr=1로 설정할것.
2. epoch를 5000번 돌려서 Accuracy값은 100%가 되도록 할것

---

1. 모델 지정

힌트 : 여러개의 층을 만들어 해결

model = nn.Sequential(
    nn.Linear(2, 64),
    nn.Sigmoid(), # 곡선화
    nn.Linear(64, 32),
    nn.Sigmoid(),
    nn.Linear(32, 16),
    nn.Sigmoid(),
    nn.Linear(16, 1),
    nn.Sigmoid()
)
# 여러가지 추가한 것을 히든레이어라고 하는데 1개 이상이 있으면 딥러닝이라고 함.
print(model)

# 결과값 => 
# Sequential(
#   (0): Linear(in_features=2, out_features=64, bias=True)
#   (1): Sigmoid()
#   (2): Linear(in_features=64, out_features=32, bias=True)
#   (3): Sigmoid()
#   (4): Linear(in_features=32, out_features=16, bias=True)
#   (5): Sigmoid()
#   (6): Linear(in_features=16, out_features=1, bias=True)
#   (7): Sigmoid()
# )

 

2. X, y 값 지정 후 epochs를 5000번 돌리도록 설정

X = torch.FloatTensor([[0,0], [0,1], [1,0], [1,1]])
y = torch.FloatTensor([[0], [0], [0], [1]])

optimizer = optim.SGD(model.parameters(), lr=1)

epochs = 5000

for epoch in range(epochs + 1):
    y_pred = model(X)
    loss = nn.BCELoss()(y_pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        y_bool = (y_pred >= 0.5).float()
        accuracy = (y  == y_bool).float().sum() / len(y) * 100
        print(f'Epoch {epoch:4d}/{epochs} Loss: {loss:.6f} Accuracy: {accuracy:.2f}')

 

3. 결과값 

GPU를 사용하여 Loss값이 매우 낮음.