딥러닝

1. 뉴런(neuron)

1-1. 생물학적 뉴런

인간의 뇌는 약 수십억 개의 뉴런으로 이루어져 있습니다. 이 뉴런들은 화학적 및 전기적인 신호를 처리하고 전달하는 연결된 뇌 신경 세포입니다. 뇌의 복잡한 네트워크에서 각 뉴런은 다른 뉴런들과 상호 작용하며 정보를 처리하고 전달합니다.

1-2. 인공뉴런

1943년에 워렌 맥컬록과 월터 피츠는 생물학적 뉴런의 단순화된 모델을 제시했습니다. 이 모델에서 뉴런은 이진 출력을 갖는 단순한 논리 게이트로 설명되었습니다. 인공 뉴런은 이러한 개념을 바탕으로 하여, 각 뉴런이 입력을 받아 개별적으로 가중치를 곱한 후 그 합계를 비선형 함수로 전달하여 최종 출력을 생성하는 수학적 기능을 수행합니다. 이는 생물학적 뉴런의 동작을 모방하면서도 수학적으로 효과적인 정보 처리를 가능케 합니다.

2. 퍼셉트론(Perceptron)

퍼셉트론은 1957년에 처음으로 소개된, 인공 신경망의 기본 형태입니다. 이는 입력과 출력을 갖는 단일 뉴런 모델을 기반으로 하며, 초기에는 주로 이진 분류 문제를 해결하는 데 사용되었습니다.

퍼셉트론은 각 입력에 대해 가중치를 부여하고, 이 가중치를 사용하여 입력 신호의 가중합을 계산합니다. 그 후, 계산된 값에 활성화 함수를 적용하여 최종 출력을 생성합니다.

퍼셉트론은 단순하면서도 이진 분류 작업에서 효과적으로 동작하는 모델로, 기계 학습 알고리즘의 시작을 알리는 중요한 개념 중 하나입니다.

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

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

x_data = torch.FloatTensor([[0,0],[0,1],[1,0],[1,1]])
y_data = 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_data)
    loss = nn.BCELoss()(y_pred, y_data)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

Epoch    0/1000 Loss:0.651412 Accuracy:50.00%
Epoch  100/1000 Loss:0.136238 Accuracy:100.00%
Epoch  200/1000 Loss:0.079086 Accuracy:100.00%
Epoch  300/1000 Loss:0.055254 Accuracy:100.00%
Epoch  400/1000 Loss:0.042288 Accuracy:100.00%
Epoch  500/1000 Loss:0.034177 Accuracy:100.00%
Epoch  600/1000 Loss:0.028641 Accuracy:100.00%
Epoch  700/1000 Loss:0.024630 Accuracy:100.00%
Epoch  800/1000 Loss:0.021592 Accuracy:100.00%
Epoch  900/1000 Loss:0.019215 Accuracy:100.00%
Epoch 1000/1000 Loss:0.017305 Accuracy:100.00%

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

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} Accuray: {accuracy:.2f}%')

Epoch    0/1000 Loss: 0.738705 Accuray: 50.00%
Epoch  100/1000 Loss: 0.093747 Accuray: 100.00%
Epoch  200/1000 Loss: 0.048159 Accuray: 100.00%
Epoch  300/1000 Loss: 0.032009 Accuray: 100.00%
Epoch  400/1000 Loss: 0.023869 Accuray: 100.00%
Epoch  500/1000 Loss: 0.018994 Accuray: 100.00%
Epoch  600/1000 Loss: 0.015756 Accuray: 100.00%
Epoch  700/1000 Loss: 0.013454 Accuray: 100.00%
Epoch  800/1000 Loss: 0.011733 Accuray: 100.00%
Epoch  900/1000 Loss: 0.010401 Accuray: 100.00%
Epoch 1000/1000 Loss: 0.009338 Accuray: 100.00%

2-3. 논리 회귀(단층 퍼셉트론)로 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} Accuray: {accuracy:.2f}%')

Epoch    0/1000 Loss: 0.736936 Accuray: 50.00%
Epoch  100/1000 Loss: 0.693147 Accuray: 50.00%
Epoch  200/1000 Loss: 0.693147 Accuray: 25.00%
Epoch  300/1000 Loss: 0.693147 Accuray: 75.00%
Epoch  400/1000 Loss: 0.693147 Accuray: 50.00%
Epoch  500/1000 Loss: 0.693147 Accuray: 50.00%
Epoch  600/1000 Loss: 0.693147 Accuray: 50.00%
Epoch  700/1000 Loss: 0.693147 Accuray: 50.00%
Epoch  800/1000 Loss: 0.693147 Accuray: 50.00%
Epoch  900/1000 Loss: 0.693147 Accuray: 50.00%
Epoch 1000/1000 Loss: 0.693147 Accuray: 50.00%

좌표 평면에 결괏값이 0이면 흰점으로, 1이면 검은점으로 나타낸 그래프입니다. AND와 OR 게이트는 직선을 그어 결괏값이 1인 값(검은점)을 구별할 수 있습니다. 그러나 XOR의 경우 단순 직선을 그어서는 구분할 수 없습니다.

XOR 문제의 해결은 평면을 휘어주는 것입니다. XOR 문제를 해결하기 위해서 우리는 두 개의 퍼셉트론을 한 번에 계산할 수 있어야 합니다. 이를 가능하게 하려면 숨어있는 층, 즉 은닉층(hidden layer)을 만들어야 합니다.

⭐ 2-4. 다층 퍼셉트론으로 XOR문제 풀기.

히든 레이어가 한 개 이상 있는 신경망을 가진 경우 해당 모델을 딥러닝이라고 할 수 있습니다.

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

nn.Linear(2, 64) (입력 레이어): 입력 데이터의 특성(2개)을 받아들이고, 64개의 출력을 생성하는 선형 변환을 수행합니다. 이는 입력과 가중치를 곱하고 편향을 더하는 연산을 수행하는 레이어입니다.
nn.Sigmoid() (곡선화 레이어): Sigmoid 활성화 함수를 적용합니다. 비선형성을 추가합니다. 이 단계는 모델이 복잡한 관계를 학습할 수 있도록 돕습니다.
nn.Linear(64, 32) (히든 레이어): 이전 레이어의 출력을 입력으로 받아들이고, 32개의 출력을 생성하는 선형 변환을 수행합니다. 이는 두 번째 히든 레이어로, 입력 특성을 더 복잡한 표현으로 변환합니다.
nn.Sigmoid() (곡선화 레이어): 다시 Sigmoid 활성화 함수를 적용하여 비선형성을 추가합니다.
nn.Linear(32, 16) (히든 레이어): 두 번째 히든 레이어의 출력을 입력으로 받아들이고, 16개의 출력을 생성하는 선형 변환을 수행합니다. 이 레이어도 모델의 표현력을 증가시킵니다.
nn.Sigmoid() (곡선화 레이어): Sigmoid 활성화 함수를 다시 적용하여 비선형성을 추가합니다.
nn.Linear(16, 1) (출력 레이어): 마지막 히든 레이어의 출력을 받아들이고, 최종 출력값을 생성하는 선형 변환을 수행합니다. 이는 이진 분류 문제에서 모델의 최종 예측을 나타냅니다.
nn.Sigmoid() (출력 활성화 레이어): 마지막으로 Sigmoid 활성화 함수를 적용하여 최종 예측값을 0과 1 사이의 확률값으로 변환합니다. 이는 이진 분류 문제에서 주로 사용됩니다.

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} Accuray: {accuracy:.2f}%')

Epoch    0/5000 Loss: 0.693138 Accuray: 50.00%
Epoch  100/5000 Loss: 0.693129 Accuray: 50.00%
Epoch  200/5000 Loss: 0.693124 Accuray: 50.00%
Epoch  300/5000 Loss: 0.693117 Accuray: 50.00%
Epoch  400/5000 Loss: 0.693111 Accuray: 50.00%
Epoch  500/5000 Loss: 0.693104 Accuray: 50.00%
Epoch  600/5000 Loss: 0.693097 Accuray: 50.00%
Epoch  700/5000 Loss: 0.693088 Accuray: 50.00%
Epoch  800/5000 Loss: 0.693079 Accuray: 50.00%
Epoch  900/5000 Loss: 0.693069 Accuray: 75.00%
Epoch 1000/5000 Loss: 0.693057 Accuray: 75.00%
Epoch 1100/5000 Loss: 0.693044 Accuray: 100.00%
Epoch 1200/5000 Loss: 0.693028 Accuray: 100.00%
Epoch 1300/5000 Loss: 0.693010 Accuray: 75.00%
Epoch 1400/5000 Loss: 0.692989 Accuray: 75.00%
Epoch 1500/5000 Loss: 0.692963 Accuray: 75.00%
Epoch 1600/5000 Loss: 0.692933 Accuray: 75.00%
Epoch 1700/5000 Loss: 0.692895 Accuray: 75.00%
Epoch 1800/5000 Loss: 0.692848 Accuray: 75.00%
Epoch 1900/5000 Loss: 0.692788 Accuray: 75.00%
Epoch 2000/5000 Loss: 0.692710 Accuray: 75.00%
Epoch 2100/5000 Loss: 0.692606 Accuray: 50.00%
Epoch 2200/5000 Loss: 0.692463 Accuray: 50.00%
Epoch 2300/5000 Loss: 0.692256 Accuray: 50.00%
Epoch 2400/5000 Loss: 0.691942 Accuray: 50.00%
Epoch 2500/5000 Loss: 0.691427 Accuray: 50.00%
Epoch 2600/5000 Loss: 0.690486 Accuray: 50.00%
Epoch 2700/5000 Loss: 0.688451 Accuray: 50.00%
Epoch 2800/5000 Loss: 0.682454 Accuray: 50.00%
Epoch 2900/5000 Loss: 0.734790 Accuray: 50.00%
Epoch 3000/5000 Loss: 0.654522 Accuray: 50.00%
Epoch 3100/5000 Loss: 0.526799 Accuray: 50.00%
Epoch 3200/5000 Loss: 0.014548 Accuray: 100.00%
Epoch 3300/5000 Loss: 0.004809 Accuray: 100.00%
Epoch 3400/5000 Loss: 0.002752 Accuray: 100.00%
Epoch 3500/5000 Loss: 0.001892 Accuray: 100.00%
Epoch 3600/5000 Loss: 0.001428 Accuray: 100.00%
Epoch 3700/5000 Loss: 0.001140 Accuray: 100.00%
Epoch 3800/5000 Loss: 0.000945 Accuray: 100.00%
Epoch 3900/5000 Loss: 0.000805 Accuray: 100.00%
Epoch 4000/5000 Loss: 0.000699 Accuray: 100.00%
Epoch 4100/5000 Loss: 0.000617 Accuray: 100.00%
Epoch 4200/5000 Loss: 0.000552 Accuray: 100.00%
Epoch 4300/5000 Loss: 0.000498 Accuray: 100.00%
Epoch 4400/5000 Loss: 0.000454 Accuray: 100.00%
Epoch 4500/5000 Loss: 0.000416 Accuray: 100.00%
Epoch 4600/5000 Loss: 0.000384 Accuray: 100.00%
Epoch 4700/5000 Loss: 0.000357 Accuray: 100.00%
Epoch 4800/5000 Loss: 0.000333 Accuray: 100.00%
Epoch 4900/5000 Loss: 0.000311 Accuray: 100.00%
Epoch 5000/5000 Loss: 0.000293 Accuray: 100.00%

학습 성공!!

'AI' 카테고리의 다른 글

CNN 기초 (0)	2024.01.10
비선형 활성화 함수 (0)	2024.01.10
데이터 로더 (0)	2024.01.09
파이토치로 구현한 논리회귀 (0)	2024.01.08
기온에 따른 지면 온도 예측 (0)	2024.01.08

춤추는 고래의 알고리즘 어드벤처!

딥러닝

1. 뉴런(neuron)

2. 퍼셉트론(Perceptron)

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

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

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

⭐ 2-4. 다층 퍼셉트론으로 XOR문제 풀기.

'AI' 카테고리의 다른 글

티스토리툴바

딥러닝

1. 뉴런(neuron)

2. 퍼셉트론(Perceptron)

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

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

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

⭐ 2-4. 다층 퍼셉트론으로 XOR문제 풀기.

'AI' 카테고리의 다른 글

관련글

티스토리툴바