2023.06.16 Deep Learning(딥러닝)

1.퍼셉트론(Perceptron)

• 1-1. 생물학적 뉴런
• 1-2.인공뉴런(perceptron)
• 1-3.논리회귀(단층 퍼셉트론)로 OR 문제 풀기
• 1-4.논리회귀(단층 퍼셉트론)로 AND 문제 풀기
• 1-5.논리회귀(단층 퍼셉트론)로 XOR 문제 풀기

2.역전파(Backpropagation)

---

16.딥러닝.ipynb

 

---

1.퍼셉트론(Perceptron)

1-1. 생물학적 뉴런

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

---

1-2.인공뉴런(perceptron)

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

---

1-3.논리회귀(단층 퍼셉트론)로 OR 문제 풀기

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

# 데이터 생성
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}%')

1-4.논리회귀(단층 퍼셉트론)로 AND 문제 풀기

# 데이터 생성
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}%')

1-5.논리회귀(단층 퍼셉트론)로 XOR 문제 풀기

 

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}%')

2.역전파(Backpropagation)

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)

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}%')