
# batch normalization 예제


from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive


import torch
import matplotlib.pyplot as plt
import numpy as np

import torchvision
import torchvision.transforms as transforms

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


trainset = torchvision.datasets.FashionMNIST(root='/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data', train=True, 
                                        download=True, 
                                        transform=transforms.ToTensor()) # torchvision에서 제공하는 FashionMNIST dataset을 다운받아 사용용


batch_size = 4


# trainset = '/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/FashionMNIST/raw/'
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True) # batch_size에 맞춰서 data를 불러옴
# trainloader 변수가 호출될 때 memory로 데이터를 불러옴


images, labels = next(iter(trainloader)) # trainloader에 있는 데이터를 불러옴. batch_size = 4이므로 4개의 데이터를 불러옴
print(images.shape)
print(images[0].shape)
print(labels[0].item())

torch.Size([4, 1, 28, 28])
torch.Size([1, 28, 28])
5


def imshow(img, title):    
    plt.figure(figsize=(batch_size * 4, 4))
    plt.axis('off')
    plt.imshow(np.transpose(img, (1, 2, 0))) # plt로 표현하기 위해 축 변경. pytorch에서 기본적으로 b, c, w, h 순으로 dataset를 다루는데
    # matplot에서는 w, h, c다.
    plt.title(title)
    plt.show()


def show_batch_images(dataloader):
    images, labels = next(iter(dataloader))
    
    img = torchvision.utils.make_grid(images) # 좌표에 이미지 픽셀을 대응시켜 그리드 형태로 출력
    imshow(img, title=[str(x.item()) for x in labels])
    
    return images, labels


images, labels = show_batch_images(trainloader)


class NormalNet(nn.Module):
    def __init__(self): 
        super(NormalNet, self).__init__()
        self.classifier = nn.Sequential(
            nn.Linear(784, 48),  # 28 x 28 = 784
            nn.ReLU(),
            nn.Linear(48, 24),
            nn.ReLU(),
            nn.Linear(24, 10) # FashionMnist dataset class는 10개이므로 이와 같이 작성
        )
             
    def forward(self, x):
        x = x.view(x.size(0), -1) # image를 batchsize, 28*28 크기로 change. flatten이라 보면 된다.
        x = self.classifier(x)
        return x


class BNNet(nn.Module):
    def __init__(self): 
        super(BNNet, self).__init__()
        self.classifier = nn.Sequential(
            nn.Linear(784, 48),
            nn.BatchNorm1d(48), # BatchNorm1d에서 사용되는 parameter는 feature 개수로 이전 계층의 출력 채널이 된다.
            nn.ReLU(),
            nn.Linear(48, 24),
            nn.BatchNorm1d(24),
            nn.ReLU(),
            nn.Linear(24, 10)
        )
             
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x


model = NormalNet()
print(model)

NormalNet(
  (classifier): Sequential(
    (0): Linear(in_features=784, out_features=48, bias=True)
    (1): ReLU()
    (2): Linear(in_features=48, out_features=24, bias=True)
    (3): ReLU()
    (4): Linear(in_features=24, out_features=10, bias=True)
  )
)


model_bn = BNNet()
print(model_bn)

BNNet(
  (classifier): Sequential(
    (0): Linear(in_features=784, out_features=48, bias=True)
    (1): BatchNorm1d(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU()
    (3): Linear(in_features=48, out_features=24, bias=True)
    (4): BatchNorm1d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU()
    (6): Linear(in_features=24, out_features=10, bias=True)
  )
)


batch_size = 512


trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)


loss_fn = nn.CrossEntropyLoss() # classifier 문제니까 crossentropy loss를 사용
opt = optim.SGD(model.parameters(), lr=0.01)
opt_bn = optim.SGD(model_bn.parameters(), lr=0.01)


loss_arr = []
loss_bn_arr = []
max_epochs = 20

for epoch in range(max_epochs):
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        opt.zero_grad()
        outputs = model(inputs) # without batch normalization model에 대한 pred
        loss = loss_fn(outputs, labels) # without batch normalization model에 대한 loss
        loss.backward()
        opt.step()
        
        opt_bn.zero_grad()
        outputs_bn = model_bn(inputs) # with batch normalization model에 대한 pred
        loss_bn = loss_fn(outputs_bn, labels) # with batch normalization model에 대한 loss
        loss_bn.backward()
        opt_bn.step()
        
        loss_arr.append(loss.item())
        loss_bn_arr.append(loss_bn.item())
           
    plt.plot(loss_arr, 'yellow', label='Normal')
    plt.plot(loss_bn_arr, 'blue', label='BatchNorm')    
    plt.legend()
    plt.show()


# dropout 예제


x = torch.linspace(-1, 1, 50)
print(x, x.shape)
y = torch.unsqueeze(x, 1)
print(y, y.shape)

tensor([-1.0000, -0.9592, -0.9184, -0.8776, -0.8367, -0.7959, -0.7551, -0.7143,
        -0.6735, -0.6327, -0.5918, -0.5510, -0.5102, -0.4694, -0.4286, -0.3878,
        -0.3469, -0.3061, -0.2653, -0.2245, -0.1837, -0.1429, -0.1020, -0.0612,
        -0.0204,  0.0204,  0.0612,  0.1020,  0.1429,  0.1837,  0.2245,  0.2653,
         0.3061,  0.3469,  0.3878,  0.4286,  0.4694,  0.5102,  0.5510,  0.5918,
         0.6327,  0.6735,  0.7143,  0.7551,  0.7959,  0.8367,  0.8776,  0.9184,
         0.9592,  1.0000]) torch.Size([50])
tensor([[-1.0000],
        [-0.9592],
        [-0.9184],
        [-0.8776],
        [-0.8367],
        [-0.7959],
        [-0.7551],
        [-0.7143],
        [-0.6735],
        [-0.6327],
        [-0.5918],
        [-0.5510],
        [-0.5102],
        [-0.4694],
        [-0.4286],
        [-0.3878],
        [-0.3469],
        [-0.3061],
        [-0.2653],
        [-0.2245],
        [-0.1837],
        [-0.1429],
        [-0.1020],
        [-0.0612],
        [-0.0204],
        [ 0.0204],
        [ 0.0612],
        [ 0.1020],
        [ 0.1429],
        [ 0.1837],
        [ 0.2245],
        [ 0.2653],
        [ 0.3061],
        [ 0.3469],
        [ 0.3878],
        [ 0.4286],
        [ 0.4694],
        [ 0.5102],
        [ 0.5510],
        [ 0.5918],
        [ 0.6327],
        [ 0.6735],
        [ 0.7143],
        [ 0.7551],
        [ 0.7959],
        [ 0.8367],
        [ 0.8776],
        [ 0.9184],
        [ 0.9592],
        [ 1.0000]]) torch.Size([50, 1])


# 데이터셋의 분포를 출력하기 위해 작성
N = 50
noise = 0.3

x_train = torch.unsqueeze(torch.linspace(-1, 1, N), 1) # -1 ~ 1 사이를 50개로 균등하게 나누고 50, 1 차원의 tensor로 change
y_train = x_train + noise * torch.normal(torch.zeros(N, 1), torch.ones(N, 1)) # torch.normal(x, y)일 때 x는 평균, y는 표준편차를 의미하고
# torch.normal은 정규분포로부터 무작위로 표본 추출을 한다.
# 즉 평균은 (N, 1) 차원을 0으로 채워진 tensor가 되고 표준편차는 (N, 1) 차원을 1로 채워진 tensor가 된다.
x_test = torch.unsqueeze(torch.linspace(-1, 1, N), 1)
y_test = x_test + noise * torch.normal(torch.zeros(N, 1), torch.ones(N, 1))


plt.scatter(x_train.data.numpy(), y_train.data.numpy(), c='purple', alpha=0.5, label='train')
# x_train.data.numpy()는 x축, y_train.data.numpy()는 y축에 위치할 데이터, alpha는 투명도, label은 plt.legend()와 함께 사용해야 한다.
plt.scatter(x_test.data.numpy(), y_test.data.numpy(), c='yellow', alpha=0.5, label='test')
plt.legend()
plt.show()


N_h = 100
model = torch.nn.Sequential( # without dropout model
    torch.nn.Linear(1, N_h),
    torch.nn.ReLU(),
    torch.nn.Linear(N_h, N_h),
    torch.nn.ReLU(),
    torch.nn.Linear(N_h, 1),
)

model_dropout = torch.nn.Sequential( # with dropout
    torch.nn.Linear(1, N_h),
    torch.nn.Dropout(0.2),
    torch.nn.ReLU(),
    torch.nn.Linear(N_h, N_h),
    torch.nn.Dropout(0.2),
    torch.nn.ReLU(),
    torch.nn.Linear(N_h, 1),
)


opt = torch.optim.Adam(model.parameters(), lr=0.01)
opt_dropout = torch.optim.Adam(model_dropout.parameters(), lr=0.01)
loss_fn = torch.nn.MSELoss()


max_epochs = 1000
for epoch in range(max_epochs):    
    pred = model(x_train) 
    loss = loss_fn(pred, y_train)
    opt.zero_grad()
    loss.backward()
    opt.step()
    
    pred_dropout = model_dropout(x_train)
    loss_dropout = loss_fn(pred_dropout, y_train)
    opt_dropout.zero_grad()
    loss_dropout.backward()
    opt_dropout.step()    
    # x_train, y_train 값으로 train을 하고 x_test, y_test 값으로 정확도 측정
    
    if epoch % 50 == 0:        
        model.eval()
        model_dropout.eval()
        
        test_pred = model(x_test)
        test_loss = loss_fn(test_pred, y_test)
        
        test_pred_dropout = model_dropout(x_test)
        test_loss_dropout = loss_fn(test_pred_dropout, y_test)
        
        plt.scatter(x_train.data.numpy(), y_train.data.numpy(), c='purple', alpha=0.5, label='train')
        plt.scatter(x_test.data.numpy(), y_test.data.numpy(), c='yellow', alpha=0.5, label='test')
        plt.plot(x_test.data.numpy(), test_pred.data.numpy(), 'b-', lw=3, label='normal')
        plt.plot(x_test.data.numpy(), test_pred_dropout.data.numpy(), 'g--', lw=3,  label='dropout')
        
        plt.title('Epoch %d, Loss = %0.4f, Loss with dropout = %0.4f' % (epoch, test_loss, test_loss_dropout))
        plt.legend()
        model.train()
        model_dropout.train()        
        plt.pause(0.05)

# dropout을 적용한 model의 정확도가 좀 더 좋은 것을 볼 수 있다.
# dropout을 적용하지 않은 model은 train dataset을 너무 따라가 overfitting되는 경향을 보인다.


# early stopping & learning rate 예제


import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.models as models
from torchvision import transforms, datasets

import matplotlib
import matplotlib.pyplot as plt
import time
import argparse
from tqdm import tqdm
matplotlib.style.use('ggplot') # 출력 그래프에서 격자로 숫자 범위가 눈에 잘 띄도록 하는 스타일


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

device(type='cuda')


# data preprocessing
train_transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.RandomHorizontalFlip(),
        transforms.RandomVerticalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                             std=[0.229, 0.224, 0.225])
    ])
val_transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                             std=[0.229, 0.224, 0.225])
    ])


# 핫도그 이미지와 아닌 이미지가 존재
# https://www.kaggle.com/dansbecker/hot-dog-not-hot-dog or Food 101 dataset
train_dataset = datasets.ImageFolder(
    root=r'/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/archive/train', 
    transform=train_transform
)
train_dataloader = torch.utils.data.DataLoader(
    train_dataset, batch_size=32, shuffle=True,
)
val_dataset = datasets.ImageFolder(
    root=r'/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/archive/test',
    transform=val_transform
)
val_dataloader = torch.utils.data.DataLoader(
    val_dataset, batch_size=32, shuffle=False,
)


def resnet50(pretrained=True): # resnet50 model을 호출하는 함수 생성
    model = models.resnet50(progress=True, pretrained=pretrained) 
    if requires_grad == False: # parameter를 고정해 backward() 중에 기울기가 계산되지 않도록 설정
        for param in model.parameters(): 
            param.requires_grad = False
    elif requires_grad == True:
        for param in model.parameters():
            param.requires_grad = True
    model.fc = nn.Linear(2048, 2) # 제공하는 resnet50 model의 fully connected layer를 change
    return model


class LRScheduler():
    def __init__(
        self, optimizer, patience=5, min_lr=1e-6, factor=0.5
    ):
        self.optimizer = optimizer
        self.patience = patience 
        self.min_lr = min_lr
        self.factor = factor 
        self.lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( 
                self.optimizer,
                mode='min',
                patience=self.patience,
                factor=self.factor,
                min_lr=self.min_lr,
                verbose=True
            )
        # lr_scheduler.ReduceLROnPlateau: ReduceLROnPlateau는 검증 데이터셋에 대한 오차의 변동이 없으면 학습률을 factor 배로 감소시킨다
        # mode: 언제 learning rate를 조정할지에 대한 기준이 되는 값. 만약 valid dataset에 대한 오차를 기준으로 사용하면 오차가 더 이상 감소되지 않을 때 학습률을 조정
        # 이때 오차 값이 최소(min)가 되어야 하는지 최대(max)가 되어야 한느지 알려주는 파라미터. 만약 기준을 valid acc를 한다면 max로 지정.
        # patience: 학습률을 업데이트하기 전에 몇 번의 epoch을 기다려야 하는지 결정
        # factor: 학습률을 얼마나 감소시킬지 지정. 기존 learning rate에 factor를 곱해 그 다음 learning rate를 설정
        # min_lr: 학습률의 하한선. 예를 들어 현재 learning rate가 0.1이고 factor가 0.5, min_lr이 0.03이라면 첫 번째로 콜백 함수가 적용될 때 학습률의 하한선 값은
        # 0.03 * 0.1 * 0.5 가 된다.
        # verbose: 조기 종료의 시작과 끝을 출력하기 위해서 사용
    def __call__(self, val_loss):
        self.lr_scheduler.step(val_loss)


class EarlyStopping():
    def __init__(self, patience=5, verbose=False, delta=0, path='/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/checkpoint.pt'):
        self.patience = patience
        self.verbose = verbose
        self.counter = 0
        self.best_score = None # valid dataset에 대한 오차 최적화 값
        self.early_stop = False # 조기 종료를 의미
        self.val_loss_min = np.Inf
        self.delta = delta
        self.path = path # model save path
        
    def __call__(self, val_loss, model): # epoch 만큼  train이 반복되면서 best_loss가 경신되고, best_loss의 진전이 없으면 early stop하고 model 저장
        score = -val_loss

        if self.best_score is None:
            self.best_score = score
            self.save_checkpoint(val_loss, model)
        elif score < self.best_score + self.delta: # best_loss가 경신되지 않는 경우
            self.counter += 1
            print(f'EarlyStopping counter: {self.counter} out of {self.patience}')
            if self.counter >= self.patience: # patience만큼 best_loss의 경신이 이루어지지 않으면 early_stop
                self.early_stop = True
        else: # train하면서 best_loss가 경신되는 경우
            self.best_score = score
            self.save_checkpoint(val_loss, model)
            self.counter = 0

    def save_checkpoint(self, val_loss, model):
        if self.verbose:
            print(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}).  Saving model ...')
        torch.save(model.state_dict(), self.path)
        self.val_loss_min = val_loss


# keras에서 제공하는 early stop을 사용해도 된다.
from keras.callbacks import ModelCheckpoint, EarlyStopping
checkpoint = ModelCheckpoint('checkpoint-epochh.5'.format(EPOCH, BATCH_SIZE), # file name
                             monitor = 'val_loss',# val_loss 값이 개선되었을 때 호출
                             verbose = 1,
                             save_best_only = True, # 가장 최적의 값만 저장
                             mode = 'auto' # auto일 시 시스템이 알아서 best 값을 찾아줌
                             )

earlystopping = EarlyStopping(monitor = 'val_loss', # 학습률 update 기준 설정
                              patience = 10
                              )


parser = argparse.ArgumentParser() # 인수 값을 받을 수 있는 인스턴스 생성
parser.add_argument('--lr-scheduler', dest='lr_scheduler', action='store_true') # 원하는 인수 값을 추가. parser.add_argument()는 인수 개수만큼 만들어 줘야 한다.
# '--lr-scheduler': 옵션 문자열의 이름으로 명령을 실행할 때 사용
# dest: 입력 값이 저장되는 변수 위 경우 lr_scheduler 변수에 입력 값이 저장된다
# action: store_true로 지정하면 입력 값을 dest paramter에 의해 생성된 변수를 저장한다
parser.add_argument('--early-stopping', dest='early_stopping', action='store_true')
parser.add_argument("-f", "--fff", help="a dummy argument to fool ipython", default="1") #주피터 노트북에서 실행할때 필요합니다
args = vars(parser.parse_args())
# 입력 받은 인수 값이 실제로 args 변수에 저장된다


#!pip install ipywidgets 혹은
#anaconda prompt에서 conda install -c conda-forge ipywidgets 실행
print(f"Computation device: {device}\n")
model = models.resnet50(pretrained=True).to(device) # pretrain된 resnet50 사용
total_params = sum(p.numel() for p in model.parameters()) # resnet50의 parameter 수
print(f"{total_params:,} total parameters.")
total_trainable_params = sum(
    p.numel() for p in model.parameters() if p.requires_grad) # 학습 가능한 parameter 수
print(f"{total_trainable_params:,} training parameters.")

Computation device: cuda

/usr/local/lib/python3.8/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.
  warnings.warn(
/usr/local/lib/python3.8/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.
  warnings.warn(msg)
Downloading: "https://download.pytorch.org/models/resnet50-0676ba61.pth" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth

  0%|          | 0.00/97.8M [00:00<?, ?B/s]

25,557,032 total parameters.
25,557,032 training parameters.


lr = 0.001
epochs = 100
optimizer = optim.Adam(model.parameters(), lr=lr)
criterion = nn.CrossEntropyLoss()


loss_plot_name = 'loss'
acc_plot_name = 'accuracy'
model_name = 'model'


if args['lr_scheduler']: # lr_scheduler 인수를 사용할 때 오차, 정확도 및 모델의 이름을 정의
    print('INFO: Initializing learning rate scheduler')
    lr_scheduler = LRScheduler(optimizer)
    loss_plot_name = 'lrs_loss'
    acc_plot_name = 'lrs_accuracy'
    model_name = 'lrs_model'
if args['early_stopping']: # early_stopping 인수를 사용할 때 오차, 정확도 및 모델의 이름을 정의
    print('INFO: Initializing early stopping')
    early_stopping = EarlyStopping()
    loss_plot_name = 'es_loss'
    acc_plot_name = 'es_accuracy'
    model_name = 'es_model'


def training(model, train_dataloader, train_dataset, optimizer, criterion):
    print('Training')
    model.train()
    train_running_loss = 0.0
    train_running_correct = 0
    counter = 0
    total = 0
    prog_bar = tqdm(enumerate(train_dataloader), total=int(len(train_dataset)/train_dataloader.batch_size))
    for i, data in prog_bar:
        counter += 1
        data, target = data[0].to(device), data[1].to(device)
        total += target.size(0)
        optimizer.zero_grad()
        outputs = model(data)
        loss = criterion(outputs, target)
        train_running_loss += loss.item()
        _, preds = torch.max(outputs.data, 1)
        train_running_correct += (preds == target).sum().item()
        loss.backward()
        optimizer.step()
        
    train_loss = train_running_loss / counter
    train_accuracy = 100. * train_running_correct / total
    return train_loss, train_accuracy


def validate(model, test_dataloader, val_dataset, criterion):
    print('Validating')
    model.eval()
    val_running_loss = 0.0
    val_running_correct = 0
    counter = 0
    total = 0
    prog_bar = tqdm(enumerate(test_dataloader), total=int(len(val_dataset)/test_dataloader.batch_size))
    with torch.no_grad():
        for i, data in prog_bar:
            counter += 1
            data, target = data[0].to(device), data[1].to(device)
            total += target.size(0)
            outputs = model(data)
            loss = criterion(outputs, target)
            
            val_running_loss += loss.item()
            _, preds = torch.max(outputs.data, 1)
            val_running_correct += (preds == target).sum().item()
        
        val_loss = val_running_loss / counter
        val_accuracy = 100. * val_running_correct / total
        return val_loss, val_accuracy


train_loss, train_accuracy = [], []
val_loss, val_accuracy = [], []
start = time.time()
for epoch in range(epochs):
    print(f"Epoch {epoch+1} of {epochs}")
    train_epoch_loss, train_epoch_accuracy = training(
        model, train_dataloader, train_dataset, optimizer, criterion
    )
    val_epoch_loss, val_epoch_accuracy = validate(
        model, val_dataloader, val_dataset, criterion
    )
    train_loss.append(train_epoch_loss)
    train_accuracy.append(train_epoch_accuracy)
    val_loss.append(val_epoch_loss)
    val_accuracy.append(val_epoch_accuracy)
    if args['lr_scheduler']:
        lr_scheduler(val_epoch_loss)
    if args['early_stopping']:
        early_stopping(val_epoch_loss, model)
        if early_stopping.early_stop:
            break
    print(f"Train Loss: {train_epoch_loss:.4f}, Train Acc: {train_epoch_accuracy:.2f}")
    print(f'Val Loss: {val_epoch_loss:.4f}, Val Acc: {val_epoch_accuracy:.2f}')
end = time.time()
print(f"Training time: {(end-start)/60:.3f} minutes")

Epoch 1 of 100
Training

16it [02:21,  8.86s/it]

Validating

16it [02:37,  9.87s/it]

Train Loss: 1.3414, Train Acc: 63.45
Val Loss: 3.6836, Val Acc: 44.40
Epoch 2 of 100
Training

16it [00:08,  1.90it/s]

Validating

16it [00:04,  3.23it/s]

Train Loss: 0.5746, Train Acc: 73.49
Val Loss: 0.8954, Val Acc: 62.00
Epoch 3 of 100
Training

16it [00:08,  1.94it/s]


# 여기서 그려지는 그래프는 아무런 옵션 없이 train한 결과
# early stop, learning_rate decay를 넣으려면 설정을 따로해서 진행하면 된다.
plt.figure(figsize=(10, 7))
plt.plot(train_accuracy, color='green', label='train accuracy')
plt.plot(val_accuracy, color='blue', label='validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.savefig(f"/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/img{acc_plot_name}.png")
plt.show()

plt.figure(figsize=(10, 7))
plt.plot(train_loss, color='orange', label='train loss')
plt.plot(val_loss, color='red', label='validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.savefig(f"/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/img{loss_plot_name}.png")
plt.show()
    
print('Saving model...')
torch.save(model.state_dict(), f"/content/drive/MyDrive/deel_learning_pytorch_book/deep learning pytorch book/8장/data/{model_name}.pth")
print('TRAINING COMPLETE')

Saving model...
TRAINING COMPLETE

티스토리

[Pytorch] Deep Learning Pytorch 8. 성능 최적화

[Pytorch] Deep Learning Pytorch 8. 성능 최적화

8. 성능 최적화¶

8.1 성능 최적화¶

8.1.1 데이터를 사용한 성능 최적화¶

8.1.2 알고리즘을 이용한 성능 최적화¶

8.1.3 알고리즘 튜닝을 위한 성능 최적화¶

8.1.4 앙상블을 이용한 성능 최적화¶

8.2 하드웨어를 이용한 성능 최적화¶

8.2.1 CPU와 GPU 사용의 차이¶

8.3 하이퍼파라미터를 이용한 성능 최적화¶

8.3.1 배치 정규화를 이용한 성능 최적화¶

8.3.2 드롭아웃을 이용한 성능 최적화¶

8.3.3 조기 종료를 이용한 성능 최적화¶

학습률 감소(learning rate decay)¶