파이썬 머신러닝, 딥러닝
(Python) 데이터 로더
흰둥아솜사탕
2023. 6. 16. 15:21
728x90
반응형
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% 입니다!
728x90
반응형