Cnn 1 (fashion mnist (1) cnn 기본 모델)
신경망 학습 (Fashion MNIST in Pytorch)
from IPython.display import Image
Image('./images/fashion-mnist-sprite.png', width=600)
 CNN 기본 모델)/output_1_0.png)
import torch # 파이토치 기본 라이브러리
# torchvision : 데이터셋, 모델 아키텍처, 컴퓨터 비전의 이미지 변환 기능 제공
from torchvision import datasets # torchvision에서 제공하는 데이터셋
from torchvision import transforms # 이미지 변환기능을 제공하는 패키지
# torch.utils.data : 파이토치 데이터 로딩 유틸리티
from torch.utils.data import DataLoader # 모델 훈련에 사용할 수 있는 미니 배치 구성하고
# 매 epoch마다 데이터를 샘플링, 병렬처리 등의 일을 해주는 함수
from torch.utils.data import random_split
import numpy as np
import matplotlib.pyplot as plt
!nvidia-smi
Fri Apr 7 04:51:33 2023
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.85.12 Driver Version: 525.85.12 CUDA Version: 12.0 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |
| N/A 67C P8 14W / 70W | 0MiB / 15360MiB | 0% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
| No running processes found |
+-----------------------------------------------------------------------------+
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
device
device(type='cuda')
1. 데이터 불러오기
# Compose를 통해 원하는 전처리기를 차례대로 넣을 수 있음음
# mnist_transform = transforms.Compose([transforms.Resize(16), transforms.ToTensor()])
# trainset = datasets.MNIST('./datasets/', download=True, train=True, transform = mnist_transform)
# dataset = datasets.MNIST(다운받을 디렉토리, 다운로드여부, 학습용여부, 전처리방법)
trainset = datasets.FashionMNIST('./datasets/', download=True, train=True, transform = transforms.ToTensor())
testset = datasets.FashionMNIST('./datasets/', download=True, train=False, transform = transforms.ToTensor())
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ./datasets/FashionMNIST/raw/train-images-idx3-ubyte.gz
100%|██████████| 26421880/26421880 [00:01<00:00, 16118765.53it/s]
Extracting ./datasets/FashionMNIST/raw/train-images-idx3-ubyte.gz to ./datasets/FashionMNIST/raw
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ./datasets/FashionMNIST/raw/train-labels-idx1-ubyte.gz
100%|██████████| 29515/29515 [00:00<00:00, 269477.25it/s]
Extracting ./datasets/FashionMNIST/raw/train-labels-idx1-ubyte.gz to ./datasets/FashionMNIST/raw
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ./datasets/FashionMNIST/raw/t10k-images-idx3-ubyte.gz
100%|██████████| 4422102/4422102 [00:00<00:00, 4968875.64it/s]
Extracting ./datasets/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ./datasets/FashionMNIST/raw
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ./datasets/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz
100%|██████████| 5148/5148 [00:00<00:00, 5959778.36it/s]
Extracting ./datasets/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ./datasets/FashionMNIST/raw
# trainset을 다시 train용과 valid 용으로 나누고자 할 때
trainset, validset = random_split(trainset, [50000, 10000])
print(type(trainset), len(trainset))
print(type(validset), len(validset))
print(type(testset), len(testset))
<class 'torch.utils.data.dataset.Subset'> 50000
<class 'torch.utils.data.dataset.Subset'> 10000
<class 'torchvision.datasets.mnist.FashionMNIST'> 10000
# 0번째 샘플에 2개의 원소가 있는데, 그중 첫번째 원소는 이미지, 두번째 원소는 정답
# 그러나 파이토치로 읽어들인 이미지 텐서의 형상이 channels * height * width 임
# 그에 비해 opencv, matplotlib으로 읽어들인 이미지 array의 형상은 height * width * channels
print(trainset[0][0].size(), trainset[0][1])
torch.Size([1, 28, 28]) 8
2. 데이터 시각화
labels_map = {0 : 'T-Shirt', 1 : 'Trouser', 2 : 'Pullover', 3 : 'Dress', 4 : 'Coat', 5 : 'Sandal', 6 : 'Shirt',
7 : 'Sneaker', 8 : 'Bag', 9 : 'Ankle Boot'}
figure, axes = plt.subplots(nrows=4, ncols=8, figsize=(16, 8))
axes = axes.flatten()
for i in range(32):
rand_i = np.random.randint(0, len(trainset))
image, label= trainset[rand_i][0], trainset[rand_i][1]
axes[i].axis('off')
axes[i].imshow(image.squeeze(), cmap='gray')
axes[i].set_title(labels_map[label])
 CNN 기본 모델)/output_12_0.png)
3. 데이터 적재
DataLoader
- 모델 훈련에 사용할 수 있는 미니 배치 구성하고
- 매 epoch마다 데이터를 샘플링, 병렬처리 등의 일을 해주는 함수
배치 사이즈
- 배치 사이즈 중요한 하이퍼 파라미터
-
16 이하로 사용하는것이 성능에 좋다고 알려져 있음
- 배치 사이즈가 크다는 것은 실제 Loss, Gradient, Weight를 구하는 데 참여하는 데이타가 많다라는 뜻
-
배치 사이즈가 작을 수록 모델이 학습을 하는데 한번도 보지 않은 신선한 데이터가 제공될 확률이 큼
- 배치 사이즈가 크면 학습시간은 줄일 수 있으나 적절한 배치사이즈로 학습을 해야 성능을 높일 수 있음
- (60000개의 데이터를 100개의 미니배치로 학습하면 1 epoch당 걸리는 횟수가 600번인데, 10개의 미니배치로 학습하면 1 epoch당 걸리는 횟수가 6000번)
batch_size = 16 # 100 -> 16
# dataloader = DataLoader(데이터셋, 배치사이즈, 셔플여부.....)
trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True) # 훈련용 50000개의 데이터를 100개씩 준비
validloader = DataLoader(validset, batch_size=batch_size, shuffle=False) # 검증용 10000개의 데이터를 100개씩 준비
testloader = DataLoader(testset, batch_size=batch_size, shuffle=False) # 테스트용 10000개의 데이터를 100개씩 준비
print(type(trainloader), len(trainloader))
print(type(validloader), len(validloader))
print(type(testloader), len(testloader))
<class 'torch.utils.data.dataloader.DataLoader'> 3125
<class 'torch.utils.data.dataloader.DataLoader'> 625
<class 'torch.utils.data.dataloader.DataLoader'> 625
train_iter = iter(trainloader)
images, labels = next(train_iter)
images.size(), labels.size()
(torch.Size([16, 1, 28, 28]), torch.Size([16]))
4. 모델 생성
from IPython.display import Image
Image('./images/cnn architecture 2.png', width=700)
 CNN 기본 모델)/output_20_0.png)
import torch.nn as nn # 파이토치에서 제공하는 다양한 계층 (Linear Layer, ....)
import torch.optim as optim # 옵티마이저 (경사하강법...)
import torch.nn.functional as F # 파이토치에서 제공하는 함수(활성화 함수...)
# 가중치 초기화
# https://pytorch.org/docs/stable/nn.init.html
# 현재 default 값
# Linear :
# https://github.com/pytorch/pytorch/blob/9cf62a4b5d3b287442e70c0c560a8e21d8c3b189/torch/nn/modules/linear.py#L168
# Conv :
# https://github.com/pytorch/pytorch/blob/9cf62a4b5d3b287442e70c0c560a8e21d8c3b189/torch/nn/modules/conv.py#L111
# 가중치 초기화시 고려할 사항
# 1. 값이 충분히 작아야 함
# 2. 값이 하나로 치우쳐선 안됨
# 3. 적당한 분산으로 골고루 분포가 되어야 함
option 4 : nn.Module 서브클래싱하기
- 파라미터 관리가 필요없는 기능(활성화 함수, …) 함수형(functional)으로 작성
- 함수형이란 출력이 입력에 의해 결정
class FMnist_CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv_block1 = nn.Sequential(
nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
) # batch_size x 32 x 14 x 14
self.conv_block2 = nn.Sequential(
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
) # batch_size x 64 x 7 x 7
self.linear1 = nn.Linear(in_features=64*7*7, out_features=128)
self.linear2 = nn.Linear(in_features=128, out_features=10)
def forward(self, x):
x = self.conv_block1(x) # batch_size x 32 x 14 x 14
x = self.conv_block2(x) # batch_size x 64 x 7 x 7
x = x.view(-1, 64*7*7) # flatten
x = self.linear1(x)
x = F.relu(x)
x = self.linear2(x)
return x
model = FMnist_CNN()
model.to(device)
model
FMnist_CNN(
(conv_block1): Sequential(
(0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(conv_block2): Sequential(
(0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(linear1): Linear(in_features=3136, out_features=128, bias=True)
(linear2): Linear(in_features=128, out_features=10, bias=True)
)
for name, parameter in model.named_parameters():
print(name, parameter.size())
conv1.weight torch.Size([32, 1, 3, 3])
conv1.bias torch.Size([32])
conv2.weight torch.Size([64, 32, 3, 3])
conv2.bias torch.Size([64])
linear1.weight torch.Size([128, 3136])
linear1.bias torch.Size([128])
linear2.weight torch.Size([10, 128])
linear2.bias torch.Size([10])
5. 모델 설정 (손실함수, 옵티마이저 선택)
# Note. CrossEntropyLoss 관련
# https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html?highlight=crossentropyloss#torch.nn.CrossEntropyLoss
# Note that this case is equivalent to the combination of LogSoftmax and NLLLoss.
# CrossEntropy를 손실함수로 사용하게 되면 forward() 계산시에 softmax() 함수를 사용하면 안됨(otherwise 중복)
# softmax 를 사용하면 부동 소수점 부정확성으로 인해 정확도가 떨어지고 불안정해질 수 있음
# forward()의 마지막 출력은 확률값이 아닌 score(logit)이어야 함
learning_rate = 0.001
# 손실함수
loss_fn = nn.CrossEntropyLoss()
# 옵티마이저(최적화함수, 예:경사하강법)
# optimizer = optim.SGD(model.parameters(), lr=learning_rate)
# 규제의 강도 설정 weight_decay
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
# optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=0.001)
# Learning Rate Schedule
# https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html
# 모니터링하고 있는 값(예:valid_loss)의 최소값(min) 또는 최대값(max) patience 기간동안 줄어들지 않을 때(OnPlateau) lr에 factor(0.1)를 곱해주는 전략
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=4, verbose=True)
from torchsummary import summary
# summary(모델, (채널, 인풋사이즈))
summary(model, (1, 28, 28))
----------------------------------------------------------------
Layer (type) Output Shape Param #
================================================================
Conv2d-1 [-1, 32, 28, 28] 320
ReLU-2 [-1, 32, 28, 28] 0
MaxPool2d-3 [-1, 32, 14, 14] 0
Conv2d-4 [-1, 64, 14, 14] 18,496
ReLU-5 [-1, 64, 14, 14] 0
MaxPool2d-6 [-1, 64, 7, 7] 0
Linear-7 [-1, 128] 401,536
Linear-8 [-1, 10] 1,290
================================================================
Total params: 421,642
Trainable params: 421,642
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.65
Params size (MB): 1.61
Estimated Total Size (MB): 2.26
----------------------------------------------------------------
32 * 3 * 3 + 32
320
64 * (32 * 3 * 3) + 64
18496
3136 * 128 + 128
401536
128 * 10 + 10
1290
6. 모델 훈련
# torch.no_grad()
# https://pytorch.org/docs/stable/generated/torch.no_grad.html
# Context-manager that disabled gradient calculation.
# Disabling gradient calculation is useful for inference, when you are sure that you will not call Tensor.backward().
# It will reduce memory consumption for computations that would otherwise have requires_grad=True.
def validate(model, validloader, loss_fn):
total = 0
correct = 0
valid_loss = 0
valid_accuracy = 0
# 전방향 예측을 구할 때는 gradient가 필요가 없음음
with torch.no_grad():
for images, labels in validloader: # 이터레이터로부터 next()가 호출되며 미니배치 100개씩을 반환(images, labels)
# images, labels : (torch.Size([16, 1, 28, 28]), torch.Size([16]))
# 0. Data를 GPU로 보내기
images, labels = images.to(device), labels.to(device)
# 1. 입력 데이터 준비
# not Flatten !!
# images.resize_(images.size()[0], 784)
# 2. 전방향(Forward) 예측
logit = model(images) # 예측 점수
_, preds = torch.max(logit, 1) # 배치에 대한 최종 예측
# preds = logit.max(dim=1)[1]
correct += int((preds == labels).sum()) # 배치 중 맞은 것의 개수가 correct에 누적
total += labels.shape[0] # 배치 사이즈만큼씩 total에 누적
loss = loss_fn(logit, labels)
valid_loss += loss.item() # tensor에서 값을 꺼내와서, 배치의 loss 평균값을 valid_loss에 누적
valid_accuracy = correct / total
return valid_loss, valid_accuracy
# 파이토치에서 텐서보드 사용하기
# https://pytorch.org/tutorials/recipes/recipes/tensorboard_with_pytorch.html
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()
50000/16
3125.0
def train_loop(model, trainloader, loss_fn, epochs, optimizer):
steps = 0
steps_per_epoch = len(trainloader)
min_loss = 1000000
max_accuracy = 0
trigger = 0
patience = 7
for epoch in range(epochs):
model.train() # 훈련 모드
train_loss = 0
for images, labels in trainloader: # 이터레이터로부터 next()가 호출되며 미니배치를 반환(images, labels)
steps += 1
# images, labels : (torch.Size([16, 1, 28, 28]), torch.Size([16]))
# 0. Data를 GPU로 보내기
images, labels = images.to(device), labels.to(device)
# 1. 입력 데이터 준비
# not Flatten !!
# images.resize_(images.shape[0], 784)
# 2. 전방향(forward) 예측
predict = model(images) # 예측 점수
loss = loss_fn(predict, labels) # 예측 점수와 정답을 CrossEntropyLoss에 넣어 Loss값 반환
# 3. 역방향(backward) 오차(Gradient) 전파
optimizer.zero_grad() # Gradient가 누적되지 않게 하기 위해
loss.backward() # 모델파리미터들의 Gradient 전파
# 4. 경사 하강법으로 모델 파라미터 업데이트
optimizer.step() # W <- W -lr*Gradient
train_loss += loss.item()
if (steps % steps_per_epoch) == 0 :
model.eval() # 평가 모드 : 평가에서 사용하지 않을 계층(배치 정규화, 드롭아웃)들을 수행하지 않게 하기 위해서
valid_loss, valid_accuracy = validate(model, validloader, loss_fn)
# tensorboard 시각화를 위한 로그 이벤트 등록
writer.add_scalar('Train Loss', train_loss/len(trainloader), epoch+1)
writer.add_scalar('Valid Loss', valid_loss/len(validloader), epoch+1)
writer.add_scalars('Train Loss and Valid Loss',
{'Train' : train_loss/len(trainloader),
'Valid' : valid_loss/len(validloader)}, epoch+1)
writer.add_scalar('Valid Accuracy', valid_accuracy, epoch+1)
# -------------------------------------------
print('Epoch : {}/{}.......'.format(epoch+1, epochs),
'Train Loss : {:.3f}'.format(train_loss/len(trainloader)),
'Valid Loss : {:.3f}'.format(valid_loss/len(validloader)),
'Valid Accuracy : {:.3f}'.format(valid_accuracy)
)
# Best model 저장
# option 1 : valid_loss 모니터링
# if valid_loss < min_loss: # 바로 이전 epoch의 loss보다 작으면 저장하기
# min_loss = valid_loss
# torch.save(model.state_dict(), 'best_checkpoint.pth')
# option 2 : valid_accuracy 모니터링
if valid_accuracy > max_accuracy : # 바로 이전 epoch의 accuracy보다 크면 저장하기
max_accuracy = valid_accuracy
torch.save(model.state_dict(), 'best_checkpoint.pth')
# -------------------------------------------
# Early Stopping (조기 종료)
if valid_loss > min_loss: # valid_loss가 min_loss를 갱신하지 못하면
trigger += 1
print('trigger : ', trigger)
if trigger > patience:
print('Early Stopping !!!')
print('Training loop is finished !!')
writer.flush()
return
else:
trigger = 0
min_loss = valid_loss
# -------------------------------------------
# Learning Rate Scheduler
scheduler.step(valid_loss)
# -------------------------------------------
writer.flush()
return
epochs = 50
train_loop(model, trainloader, loss_fn, epochs, optimizer)
Epoch : 1/50....... Train Loss : 0.404 Valid Loss : 0.296 Valid Accuracy : 0.889
Epoch : 2/50....... Train Loss : 0.259 Valid Loss : 0.289 Valid Accuracy : 0.896
Epoch : 3/50....... Train Loss : 0.212 Valid Loss : 0.234 Valid Accuracy : 0.914
Epoch : 4/50....... Train Loss : 0.177 Valid Loss : 0.246 Valid Accuracy : 0.908
trigger : 1
Epoch : 5/50....... Train Loss : 0.149 Valid Loss : 0.235 Valid Accuracy : 0.916
trigger : 2
Epoch : 6/50....... Train Loss : 0.125 Valid Loss : 0.283 Valid Accuracy : 0.908
trigger : 3
Epoch : 7/50....... Train Loss : 0.104 Valid Loss : 0.274 Valid Accuracy : 0.913
trigger : 4
Epoch : 8/50....... Train Loss : 0.087 Valid Loss : 0.309 Valid Accuracy : 0.916
trigger : 5
Epoch 00008: reducing learning rate of group 0 to 1.0000e-04.
Epoch : 9/50....... Train Loss : 0.042 Valid Loss : 0.285 Valid Accuracy : 0.925
trigger : 6
Epoch : 10/50....... Train Loss : 0.032 Valid Loss : 0.299 Valid Accuracy : 0.925
trigger : 7
Epoch : 11/50....... Train Loss : 0.026 Valid Loss : 0.309 Valid Accuracy : 0.925
trigger : 8
Early Stopping !!!
Training loop is finished !!
# %load_ext tensorboard
%tensorboard --logdir=runs
Output hidden; open in https://colab.research.google.com to view.
writer.close()
7. 모델 예측
# testloader에서 미니 배치 가져오기
test_iter = iter(testloader)
images, labels = next(test_iter)
images, labels = images.to(device), labels.to(device)
print(images.size(), labels.size())
# random한 index로 이미지 한장 준비하기
rnd_idx = 10
print(images[rnd_idx].shape, labels[rnd_idx])
torch.Size([16, 1, 28, 28]) torch.Size([16])
torch.Size([1, 28, 28]) tensor(4, device='cuda:0')
# not Flatten!
# flattend_img = images[rnd_idx].view(1, 784)
# 준비된 이미지로 예측하기
model.eval()
with torch.no_grad():
logit = model(images[rnd_idx])
pred = logit.max(dim=1)[1]
print(pred == labels[rnd_idx]) # True : 잘 예측
tensor([True], device='cuda:0')
plt.imshow(images[rnd_idx].squeeze().cpu(), cmap='gray')
<matplotlib.image.AxesImage at 0x7f367fe04370>
 CNN 기본 모델)/output_51_1.png)
8. 모델 평가
def evaluation(model, testloader, loss_fn):
total = 0
correct = 0
test_loss = 0
test_accuracy = 0
# 전방향 예측을 구할 때는 gradient가 필요가 없음음
with torch.no_grad():
for images, labels in testloader: # 이터레이터로부터 next()가 호출되며 미니배치 100개씩을 반환(images, labels)
# 0. Data를 GPU로 보내기
images, labels = images.to(device), labels.to(device)
# 1. 입력 데이터 준비
# not Flatten
# images.resize_(images.size()[0], 784)
# 2. 전방향(Forward) 예측
logit = model(images) # 예측 점수
_, preds = torch.max(logit, 1) # 100개에 대한 최종 예측
# preds = logit.max(dim=1)[1]
correct += int((preds == labels).sum()) # 100개 중 맞은 것의 개수가 coorect에 누적
total += labels.shape[0] # 배치 사이즈만큼씩 total에 누적
loss = loss_fn(logit, labels)
test_loss += loss.item() # tensor에서 값을 꺼내와서, 100개의 loss 평균값을 valid_loss에 누적
test_accuracy = correct / total
print('Test Loss : {:.3f}'.format(test_loss/len(testloader)),
'Test Accuracy : {:.3f}'.format(test_accuracy))
model.eval()
evaluation(model, testloader, loss_fn)
Test Loss : 0.326 Test Accuracy : 0.927
9. 모델 저장
# 모델을 저장하는 이유
# 1. 예측을 할 때마다 훈련시키는것은 비효율적
# 2. 기존 훈련 결과에 이어서 학습을 하고자 할 때
# 파이토치에서 모델 저장하기
# https://pytorch.org/tutorials/beginner/saving_loading_models.html
# 현재 모델에 저장되어 있는 모델 파라미터터
model.state_dict().keys()
odict_keys(['conv_block1.0.weight', 'conv_block1.0.bias', 'conv_block2.0.weight', 'conv_block2.0.bias', 'linear1.weight', 'linear1.bias', 'linear2.weight', 'linear2.bias'])
torch.save(model.state_dict(), 'last_checkpoint.pth')
# 시간이 흐른뒤 다시 모델 가져오기
last_state_dict = torch.load('last_checkpoint.pth')
last_state_dict.keys()
odict_keys(['conv_block1.0.weight', 'conv_block1.0.bias', 'conv_block2.0.weight', 'conv_block2.0.bias', 'linear1.weight', 'linear1.bias', 'linear2.weight', 'linear2.bias'])
# 읽어들인 모델 파라미터는 모델 아키텍처에 연결을 시켜줘야 함
# load_state_dict() 사용
last_model = FMnist_CNN()
last_model.to(device)
last_model.load_state_dict(last_state_dict)
<All keys matched successfully>
last_model.eval()
evaluation(last_model, testloader, loss_fn)
Test Loss : 0.326 Test Accuracy : 0.927
# valid loss or accuracy 기준 best model
best_state_dict = torch.load('best_checkpoint.pth')
best_model = FMnist_CNN()
best_model.to(device)
best_model.load_state_dict(best_state_dict)
<All keys matched successfully>
best_model.eval()
evaluation(best_model, testloader, loss_fn)
Test Loss : 0.317 Test Accuracy : 0.927
댓글남기기