Python 딥러닝

뉴런(neuron)

 

1. 생물학적 뉴런

- 인간의 뇌는 수십억 개의 뉴런을 가지고 있다.

- 뉴런은 화학적, 전기적 신호를 처리하고 전달하는 연결된 뇌신경 세포이다.

 

2. 인공 뉴런

- 1943년에 워렌 맥컬록, 월터 피츠가 단순화된 뇌세포 개념을 발표

- 신경 세포를 이진 출력을 가진 단순한, 논리 게이트라고 설명하였다.

- 생물학적 뉴런의 모델에 기초한 수학적 기능으로 각 뉴런이 입력을 받아 개별적으로 가중치를 곱하여 나온 합계를 비선형 함수를 전달하여 출력을 생성한다.

 

퍼셉트론(Perceptron)

 

- 인공 신경망의 가장 기본적인 형태로 1957년에 처음 소개되었다.

- 입력과 출력을 가진 단일 뉴런 모델을 기반으로 한다.

- 초기에 기계 학습 알고리즘 중 하나로 이진 분류 문제를 해결하기 위해 설계되었다.

 

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

# 필요한 모듈 import
import torch
import torch.nn as nn
import torch.optim as optim

# AND 형식으로 데이터를 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}&")

결과

 

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

# OR 형식으로 데이터를 Tensor로 넣기
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}&")

결과

 

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

# XOR 형식으로 데이터를 Tensor로 넣기
X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]])
y = torch.FloatTensor([[0], [1], [1], [0]])

# 모델 생성
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}&")

결과

 

• 다층 퍼셉트론으로 XOR 문제 풀기

- 여러 개의 은닉층을 만들어 해결한다.

- https://colah.github.io/posts/2015-09-NN-Types-FP/

Neural Networks, Types, and Functional Programming -- colah's blog

# 모델 생성
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()
)

print(model)

결과

 

 

# Tensor 형식으로 넣기
X = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]])
y = torch.FloatTensor([[0], [1], [1], [0]])

# 최적화를 위한 함수
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}&")

결과