AWSとGoogleColaboratoryの比較

Question

https://meditech-ai.com/pytorch-efficientnet/
このサイトのコードの変形です。

import glob
import os
中略しました。
print(f"Loss: {loss_sum.item() / len(valid_loader)}, Accuracy: {100*correct/len(valid_data)}% ({correct}/{len(valid_data)})")

20230813現時点のコードです（確かこれ）
使用しているPythonは3.10です。
画像はリンゴとオレンジです。

import glob
import os
import random

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from PIL import Image
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import DataLoader, Dataset
from torchvision import datasets, transforms
from tqdm.notebook import tqdm

from pathlib import Path
import seaborn as sns
import timm
from pprint import pprint

import copy
from tqdm import tqdm

# Training settings,epochs50から2へ変更
epochs = 2
lr = 3e-5
gamma = 0.7
seed = 42

def seed_everything(seed):
    random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True

seed_everything(seed)

device = 'cpu'
train_dataset_dir = Path('./Gender01/train')
val_dataset_dir = Path('./Gender01/validation')
test_dataset_dir = Path('./Gender01/test')

files = glob.glob('./Gender01/*/*/*.png')
random_idx = np.random.randint(1, len(files), size=9)
fig, axes = plt.subplots(3, 3, figsize=(8, 6))

for idx, ax in enumerate(axes.ravel()):
    img = Image.open(files[idx])
    ax.imshow(img)

train_transforms = transforms.Compose(
    [
        transforms.Resize((224, 224)),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ]
)

val_transforms = transforms.Compose(
    [
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ]
)

test_transforms = transforms.Compose(
    [
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ]
)

train_data = datasets.ImageFolder(train_dataset_dir,train_transforms)
valid_data = datasets.ImageFolder(val_dataset_dir, val_transforms)
test_data = datasets.ImageFolder(test_dataset_dir, test_transforms)

train_loader = DataLoader(dataset = train_data, batch_size=16, shuffle=True )
valid_loader = DataLoader(dataset = valid_data, batch_size=16, shuffle=False)
test_loader = DataLoader(dataset = test_data, batch_size=16, shuffle=False)

model_names = timm.list_models(pretrained=True)
pprint(model_names)

model = timm.create_model('tf_efficientnetv2_s_in21ft1k', pretrained=True, num_classes=2)
model = model.to(device)

# loss function
criterion = nn.CrossEntropyLoss()
# optimizer
optimizer = optim.Adam(model.parameters(), lr=lr)
# scheduler
scheduler = StepLR(optimizer, step_size=1, gamma=gamma)

best_loss = None

# Accuracy計算用の関数
def calculate_accuracy(output, target):
    output = (torch.sigmoid(output) >= 0.5)
    target = (target == 1.0)
    accuracy = torch.true_divide((target == output).sum(dim=0), output.size(0)).item()
    return accuracy

train_acc_list = []
val_acc_list = []
train_loss_list = []
val_loss_list = []

for epoch in range(epochs):
    epoch_loss = 0
    epoch_accuracy = 0

    for data, label in tqdm(train_loader):
        data = data.to(device)
        label = label.to(device)

        output = model(data)
        loss = criterion(output, label)

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

        acc = (output.argmax(dim=1) == label).float().mean()
        epoch_accuracy += acc / len(train_loader)
        epoch_loss += loss / len(train_loader)              

    print("bbb") #元なかったが追記
    with torch.no_grad():
        epoch_val_accuracy = 0
        epoch_val_loss = 0
        for data, label in valid_loader:
            data = data.to(device)
            label = label.to(device)

            val_output = model(data)
            val_loss = criterion(val_output, label)

            acc = (val_output.argmax(dim=1) == label).float().mean()
            epoch_val_accuracy += acc / len(valid_loader)
            epoch_val_loss += val_loss / len(valid_loader)

    print(
        f"Epoch : {epoch+1} - loss : {epoch_loss:.4f} - acc: {epoch_accuracy:.4f} - val_loss : {epoch_val_loss:.4f} - val_acc: {epoch_val_accuracy:.4f}\n"
    )

    train_acc_list.append(epoch_accuracy)
    val_acc_list.append(epoch_val_accuracy)
    train_loss_list.append(epoch_loss)
    val_loss_list.append(epoch_val_loss)

    if (best_loss is None) or (best_loss > val_loss):
        best_loss = val_loss
        model_path = './Gender01/save/bestViTmodel.pth'
        torch.save(model.state_dict(), model_path)
        
    print()

device2 = torch.device('cpu')

train_acc = []
train_loss = []
val_acc = []
val_loss = []

for i in range(epochs):
    train_acc2 = train_acc_list[i].to(device2)
    train_acc3 = train_acc2.clone().numpy()
    train_acc.append(train_acc3)
    
    train_loss2 = train_loss_list[i].to(device2)
    train_loss3 = train_loss2.clone().detach().numpy()
    train_loss.append(train_loss3)
    
    val_acc2 = val_acc_list[i].to(device2)
    val_acc3 = val_acc2.clone().numpy()
    val_acc.append(val_acc3)
    
    val_loss2 = val_loss_list[i].to(device2)
    val_loss3 = val_loss2.clone().numpy()
    val_loss.append(val_loss3)

#取得したデータをグラフ化する
sns.set()
num_epochs = epochs

fig = plt.subplots(figsize=(12, 4), dpi=80)

ax1 = plt.subplot(1,2,1)
ax1.plot(range(num_epochs), train_acc, c='b', label='train acc')
ax1.plot(range(num_epochs), val_acc, c='r', label='val acc')
ax1.set_xlabel('epoch', fontsize='12')
ax1.set_ylabel('accuracy', fontsize='12')
ax1.set_title('training and val acc', fontsize='14')
ax1.legend(fontsize='12')

ax2 = plt.subplot(1,2,2)
ax2.plot(range(num_epochs), train_loss, c='b', label='train loss')
ax2.plot(range(num_epochs), val_loss, c='r', label='val loss')
ax2.set_xlabel('epoch', fontsize='12')
ax2.set_ylabel('loss', fontsize='12')
ax2.set_title('training and val loss', fontsize='14')
ax2.legend(fontsize='12')
plt.show()

print("aaa")  # 元は無かったが追記
model.eval()  # モデルを評価モードにする

loss_sum = 0
correct = 0

print("bbb") #元なかったが追記
with torch.no_grad():
    for data, labels in test_loader:

        # GPUが使えるならGPUにデータを送る
        data = data.to(device)
        labels = labels.to(device)

        # ニューラルネットワークの処理を実施
        outputs = model(data)
        print(outputs) # 新たに追記
        # 損失(出力とラベルとの誤差)の計算
        loss_sum += criterion(outputs, labels)

        # 正解の値を取得
        pred = outputs.argmax(1)
        print(pred) # 新たに追記
        # 正解数をカウント
        correct += pred.eq(labels.view_as(pred)).sum().item()

print(f"Loss: {loss_sum.item() / len(test_loader)}, Accuracy: {100*correct/len(test_data)}% ({correct}/{len(test_data)})")

print("ccc") #元なかったが追記

実行結果がこちらです。
'xcit_tiny_24_p16_384.fb_dist_in1k']
C:\Users\user\AppData\Local\Programs\Python\Python310\lib\site-packages\timm\models_factory.py:114: UserWarning: Mapping deprecated model name tf_efficientnetv2_s_in21ft1k to current tf_efficientnetv2_s.in21k_ft_in1k.
model = create_fn(
100%|████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:32<00:00, 10.81s/it]
bbb
Epoch : 1 - loss : 6.1771 - acc: 0.4754 - val_loss : 8.3888 - val_acc: 0.4688

100%|████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:29<00:00, 9.98s/it]
bbb
Epoch : 2 - loss : 1.1589 - acc: 0.8030 - val_loss : 7.3929 - val_acc: 0.4688

C:\Users\user\Desktop\0813nn.py:196: MatplotlibDeprecationWarning: Auto-removal of overlapping axes is deprecated since 3.6 and will be removed two minor releases later; explicitly call ax.remove() as needed.
ax1 = plt.subplot(1,2,1)
aaa
bbb
tensor([[ 24.5468, -7.7497],
[ 4.6458, 5.0631],
[ -0.3985, -10.5740],
[ 8.4914, -17.8499],
[ 12.2553, -2.8605],
[ 14.7144, -12.8341],
[ 26.6738, 5.5297],
[ 14.7019, -9.2587],
[ 13.5414, 0.3043],
[ 13.3540, -8.5363],
[ 7.1949, 6.6422],
[ 33.3601, -4.4459],
[ 16.8021, 5.1939],
[ -4.7226, -11.2997],
[ 4.4507, -4.2222],
[ 8.8262, -7.5904]])
tensor([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
tensor([[ 20.1546, -3.7890],
[ 20.6143, 1.0150],
[ 4.4203, 21.4808],
[ 0.0692, 4.3055],
[ -9.2077, 15.0064],
[ -0.0940, 18.2106],
[ -7.7337, 18.9897],
[-11.1088, 2.6819],
[ -8.8662, 21.3578],
[ -3.6728, 23.6316],
[ -0.6814, 11.9310],
[ -2.1048, 25.2059],
[ -3.5031, 21.3227]])
tensor([0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
Loss: 0.04366261884570122, Accuracy: 96.55172413793103% (28/29)
ccc

このコードは自分のPCで実行できるものなのですが、先端の研究では最新のGPUなどを使う必要があると聞きます、
そこでAWSやGoogleColaboratoryを使いたいのですが、両者の違いはなんでしょうか？AWSは無料でしょうか？
また、普通のPCよりもそんなに高性能なんでしょうか？
AWSで使えるようにするためにはコードをどのように変形する必要があるのでしょうか？
などを教えてください。