Python(Colab) 파이토치(Pytorch) + 딥러닝 해보기

✔️ 퍼셉트론(Perceptron)

생물학적 뉴런 : 화학적,전기적 신호를 처리하고 서로 전달하는 연결된 뇌신경 세포

인공 뉴런 : 퍼셉트론이라 불림
-1943년 웨렌 맥컬론, 월터 피츠가 단순화된 뇌세포 개념을 발표

 

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

문제: 0,1중 1개라도 1이 있으면 정답은 1

 

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}/{epoch} Loss: {loss:.6f}, Accuracy:{accuracy:.2f}')

 

 

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

문제: 0,0은 정답은 0 / 1,0은 0 / 1,1은 1

 

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}/{epoch} Loss: {loss:.6f}, Accuracy:{accuracy:.2f}')

 

 

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

문제: 0,1은  1 / 1,0은 1 / 1,1은 0  / 0,0은 0

 

# 선형으로 아무 만들려해도

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()

)

print(model)

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}/{epoch} Loss: {loss:.6f}, Accuracy:{accuracy:.2f}')

XOR문제는 아무리해도 100퍼센트가 나오질 않는다.

 

 

그래서 나온 개념이 역전파

 

✔️ 역전파
INPUT - > OUTPUT 단방향이 순방향이라면 
OUTPUT-> INPUT으로 오차를 전파(전달)하며 각 층마다 가중치를 업데이트해서 출력을 내는 것 !


단점)
역전파 알고리즘 또한 경사 하강법의 기울기를 이용하여 오차를 줄이는 방법을 따르므로
항상 global minimum으로 수렴할 것이라는 보장이 없습니다.

또한 기울기를 이용하는 방법은 모델의 층이 깊어질수록 기울기가 사라지는(0이 되는) 
기울기 소실(vanishing gradient)현상

따라서 깊은 층을 가진 모델에서 역전파 알고리즘을 적용할 때 위와 같은 문제들을 인지해야 합니다. 

https://yhyun225.tistory.com/22

신경망 (3) - 역전파 알고리즘(BackPropagation algorithm)

# 차원을 여러개를 만듬

# 답이 1개가 아니려 64개로 쪼갠다.

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()

    )

# n층으로 쌓기 (현재 4층)

print(model)

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

epochs = 10000

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}/{epoch} Loss: {loss:.6f}, Accuracy:{accuracy:.2f}')