(Python) 데이터 로더

1. 손글씨 인식 모델 만들기

 

In [ ]:

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits

 

In [ ]:

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(device)

 

 

cuda

 

In [ ]:

digits = load_digits()

x_data = digits['data']
y_data = digits['target']

print(x_data.shape)
print(y_data.shape)

 

 

(1797, 64)
(1797,)

 

In [ ]:

fig, axes = plt.subplots(nrows=2, ncols=5, figsize=(14, 8))

for i, ax in enumerate(axes.flatten()):
    ax.imshow(x_data[i].reshape((8, 8)), cmap='gray')
    ax.set_title(y_data[i])
    ax.axis('off')

 

 

 

In [ ]:

x_data = torch.FloatTensor(x_data)
y_data = torch.LongTensor(y_data)

print(x_data.shape)
print(y_data.shape)

 

 

torch.Size([1797, 64])
torch.Size([1797])

 

In [ ]:

y_one_hot = nn.functional.one_hot(y_data, num_classes=10).float()
y_one_hot[:10]

 

Out[ ]:

tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

 

In [ ]:

from sklearn.model_selection import train_test_split

 

In [ ]:

x_train, x_test, y_train, y_test = train_test_split(x_data, y_one_hot, test_size=0.2, random_state=10)
print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)

 

 

torch.Size([1437, 64]) torch.Size([1437, 10])
torch.Size([360, 64]) torch.Size([360, 10])

 

 

2. 데이터 로더

• 데이터의 양이 많을 때 배치 단위로 학습하는 방법

 

In [ ]:

loader = torch.utils.data.DataLoader(
    dataset=list(zip(x_train, y_train)),
    batch_size=64,
    shuffle=True
)

imgs, labels = next(iter(loader))

fig, axes = plt.subplots(nrows=8, ncols=8, figsize=(14, 14))

for ax, img, label in zip(axes.flatten(), imgs, labels):
    ax.imshow(img.reshape((8, 8)), cmap='gray')
    ax.set_title(str(torch.argmax(label)))
    ax.axis('off')

 

 

 

In [ ]:

model = nn.Sequential(
    nn.Linear(64, 10)
)

optimizer = optim.Adam(model.parameters(), lr=0.01)

epochs = 50

for epoch in range(epochs + 1):
    sum_losses = 0
    sum_accs = 0

    for x_batch, y_batch in loader:
        y_pred = model(x_batch)
        loss = nn.CrossEntropyLoss()(y_pred, y_batch)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        sum_losses = sum_losses + loss

        # 배치 단위 정확도 저장
        y_prob = nn.Softmax(1)(y_pred)
        y_pred_index = torch.argmax(y_prob, axis=1)
        y_batch_index = torch.argmax(y_batch, axis=1)
        acc = (y_batch_index == y_pred_index).float().sum() / len(y_batch) * 100

        sum_accs = sum_accs + acc

    avg_loss = sum_losses / len(loader)
    avg_acc = sum_accs / len(loader)

    print(f'Epoch {epoch:4d}/{epochs} Loss: {avg_loss:.6f} Accuracy: {avg_acc:.2f}%')

 

 

Epoch    0/50 Loss: 1.785950 Accuracy: 59.05%
Epoch    1/50 Loss: 0.242098 Accuracy: 91.92%
Epoch    2/50 Loss: 0.154366 Accuracy: 95.77%
Epoch    3/50 Loss: 0.127805 Accuracy: 96.33%
Epoch    4/50 Loss: 0.101294 Accuracy: 97.21%
Epoch    5/50 Loss: 0.096875 Accuracy: 97.58%
Epoch    6/50 Loss: 0.104534 Accuracy: 96.51%
Epoch    7/50 Loss: 0.122834 Accuracy: 96.25%
Epoch    8/50 Loss: 0.078480 Accuracy: 97.96%
Epoch    9/50 Loss: 0.058389 Accuracy: 98.51%
Epoch   10/50 Loss: 0.054488 Accuracy: 98.85%
Epoch   11/50 Loss: 0.054858 Accuracy: 98.64%
Epoch   12/50 Loss: 0.050631 Accuracy: 98.76%
Epoch   13/50 Loss: 0.049025 Accuracy: 99.05%
Epoch   14/50 Loss: 0.046688 Accuracy: 98.83%
Epoch   15/50 Loss: 0.038865 Accuracy: 98.83%
Epoch   16/50 Loss: 0.037411 Accuracy: 99.39%
Epoch   17/50 Loss: 0.038344 Accuracy: 99.03%
Epoch   18/50 Loss: 0.047135 Accuracy: 98.78%
Epoch   19/50 Loss: 0.053952 Accuracy: 97.89%
Epoch   20/50 Loss: 0.032036 Accuracy: 99.25%
Epoch   21/50 Loss: 0.028855 Accuracy: 99.31%
Epoch   22/50 Loss: 0.024913 Accuracy: 99.59%
Epoch   23/50 Loss: 0.025803 Accuracy: 99.71%
Epoch   24/50 Loss: 0.030520 Accuracy: 99.32%
Epoch   25/50 Loss: 0.025767 Accuracy: 99.46%
Epoch   26/50 Loss: 0.019142 Accuracy: 99.71%
Epoch   27/50 Loss: 0.020312 Accuracy: 99.59%
Epoch   28/50 Loss: 0.017569 Accuracy: 99.80%
Epoch   29/50 Loss: 0.018797 Accuracy: 99.73%
Epoch   30/50 Loss: 0.017709 Accuracy: 99.73%
Epoch   31/50 Loss: 0.018190 Accuracy: 99.58%
Epoch   32/50 Loss: 0.017534 Accuracy: 99.66%
Epoch   33/50 Loss: 0.015367 Accuracy: 99.80%
Epoch   34/50 Loss: 0.015875 Accuracy: 99.93%
Epoch   35/50 Loss: 0.013177 Accuracy: 99.80%
Epoch   36/50 Loss: 0.013919 Accuracy: 99.86%
Epoch   37/50 Loss: 0.014653 Accuracy: 99.80%
Epoch   38/50 Loss: 0.011699 Accuracy: 99.93%
Epoch   39/50 Loss: 0.012374 Accuracy: 99.73%
Epoch   40/50 Loss: 0.010301 Accuracy: 99.93%
Epoch   41/50 Loss: 0.012538 Accuracy: 99.80%
Epoch   42/50 Loss: 0.013084 Accuracy: 99.93%
Epoch   43/50 Loss: 0.010639 Accuracy: 99.86%
Epoch   44/50 Loss: 0.013248 Accuracy: 99.59%
Epoch   45/50 Loss: 0.014584 Accuracy: 99.73%
Epoch   46/50 Loss: 0.012013 Accuracy: 99.80%
Epoch   47/50 Loss: 0.011807 Accuracy: 100.00%
Epoch   48/50 Loss: 0.019520 Accuracy: 99.39%
Epoch   49/50 Loss: 0.012789 Accuracy: 99.73%
Epoch   50/50 Loss: 0.008869 Accuracy: 99.93%

 

In [ ]:

plt.imshow(x_test[0].reshape((8, 8)), cmap='gray')

 

Out[ ]:

<matplotlib.image.AxesImage at 0x7f0c185f84f0>

 

 

In [ ]:

y_pred = model(x_test)
y_pred[0]

 

Out[ ]:

tensor([ 4.9706e+00, -2.0035e+00, -2.8697e+00,  9.0571e-01, -1.8976e+00,
         1.8455e+01, -3.1769e+00,  9.4648e-01,  4.0241e-03, -1.5943e+00],
       grad_fn=<SelectBackward0>)

 

In [ ]:

y_prob = nn.Softmax(1)(y_pred)
y_prob[0]

 

Out[ ]:

tensor([1.3925e-06, 1.3030e-09, 5.4800e-10, 2.3901e-08, 1.4486e-09, 1.0000e+00,
        4.0304e-10, 2.4896e-08, 9.7011e-09, 1.9620e-09],
       grad_fn=<SelectBackward0>)

 

In [ ]:

for i in range(10):
    print(f'숫자 {i}일 확률: {y_prob[0][i]:.2f}')

 

 

숫자 0일 확률: 0.00
숫자 1일 확률: 0.00
숫자 2일 확률: 0.00
숫자 3일 확률: 0.00
숫자 4일 확률: 0.00
숫자 5일 확률: 1.00
숫자 6일 확률: 0.00
숫자 7일 확률: 0.00
숫자 8일 확률: 0.00
숫자 9일 확률: 0.00

 

In [ ]:

y_pred_index = torch.argmax(y_prob, axis=1)
y_test_index = torch.argmax(y_test, axis=1)
accuracy = (y_test_index == y_pred_index).float().sum() / len(y_test) * 100
print(f'테스트 정확도는 {accuracy:.2f}% 입니다!')

 

 

테스트 정확도는 96.11% 입니다!