1,028 views
【1】やりたいこと
NVIDIA GeForce RTX5070tiを入手したので、PyTorchを動かしてみたい。
MNIST 1epochが何秒で実行できるのか？
RTX 5070ti搭載マシンへの PyTorchのインストール手順はこちらを参照のこと。
(163) Ubuntu 24.04に NVIDIAドライバをインストールする。
(128) RTX 5070tiで PyTorchを動かす。
【2】やってみた
(1) サンプルプログラムを入手
こちらで公開されているプログラムを使わせていただいた。
https://github.com/pytorch/examples/tree/main/mnist
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.dropout1 = nn.Dropout(0.25)
self.dropout2 = nn.Dropout(0.5)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = self.dropout1(x)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.dropout2(x)
x = self.fc2(x)
output = F.log_softmax(x, dim=1)
return output
def train(args, model, device, train_loader, optimizer, epoch):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.step()
if batch_idx % args.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))
if args.dry_run:
break
def test(model, device, test_loader):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss
pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
test_loss, correct, len(test_loader.dataset),
100. * correct / len(test_loader.dataset)))
def main():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=14, metavar='N',
help='number of epochs to train (default: 14)')
parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
help='learning rate (default: 1.0)')
parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
help='Learning rate step gamma (default: 0.7)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--no-mps', action='store_true', default=False,
help='disables macOS GPU training')
parser.add_argument('--dry-run', action='store_true', default=False,
help='quickly check a single pass')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--save-model', action='store_true', default=False,
help='For Saving the current Model')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
use_mps = not args.no_mps and torch.backends.mps.is_available()
torch.manual_seed(args.seed)
if use_cuda:
device = torch.device("cuda")
elif use_mps:
device = torch.device("mps")
else:
device = torch.device("cpu")
train_kwargs = {'batch_size': args.batch_size}
test_kwargs = {'batch_size': args.test_batch_size}
if use_cuda:
cuda_kwargs = {'num_workers': 1,
'pin_memory': True,
'shuffle': True}
train_kwargs.update(cuda_kwargs)
test_kwargs.update(cuda_kwargs)
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
dataset1 = datasets.MNIST('../data', train=True, download=True,
transform=transform)
dataset2 = datasets.MNIST('../data', train=False,
transform=transform)
train_loader = torch.utils.data.DataLoader(dataset1,**train_kwargs)
test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
model = Net().to(device)
optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
for epoch in range(1, args.epochs + 1):
train(args, model, device, train_loader, optimizer, epoch)
test(model, device, test_loader)
scheduler.step()
if args.save_model:
torch.save(model.state_dict(), "mnist_cnn.pt")
if __name__ == '__main__':
main()
(2) MNISTデータセットを入手
過去記事 (1) MNIST画像データをダウンロードで紹介した公式ページが消えている・・・
今回は以下のページからダウンロードさせていただいた。
https://systemds.apache.org/datasets/mnist
(3) データセットを配置
main.pyから相対パスで下記の位置にデータセットを置く。
../data/MNIST/raw/
※gzファイルを解凍せずにそのまま置くこと。
でも・・・
torchvision.datasets.MNIST クラスはとても親切で、データセットファイルが存在しなければ自動的にダウンロードしてくれるのだそうな。
(4) プログラムを実行
PyTorchをインストールした Python仮想環境に入り、以下を実行する。
$ python main.py --epochs 1
1 epoch指定で実行した結果は以下の通り。テストデータの正解率は98.42%だった。
$ python main.py --epochs 1 /home/hoge/MNIST/main.py:48: UserWarning: Converting a tensor with requires_grad=True to a scalar may lead to unexpected behavior. Consider using tensor.detach() first. (Triggered internally at /pytorch/aten/src/ATen/native/Scalar.cpp:22.) 100. * batch_idx / len(train_loader), loss.item())) Train Epoch: 1 [0/60000 (0%)] Loss: 2.285540 Train Epoch: 1 [640/60000 (1%)] Loss: 1.665781 Train Epoch: 1 [1280/60000 (2%)] Loss: 0.914229 Train Epoch: 1 [1920/60000 (3%)] Loss: 0.535744 Train Epoch: 1 [2560/60000 (4%)] Loss: 0.455426 Train Epoch: 1 [3200/60000 (5%)] Loss: 0.411212 ： Train Epoch: 1 [58240/60000 (97%)] Loss: 0.101669 Train Epoch: 1 [58880/60000 (98%)] Loss: 0.058996 Train Epoch: 1 [59520/60000 (99%)] Loss: 0.078567 Test set: Average loss: 0.0466, Accuracy: 9842/10000 (98.42%)
次に、3 epochsだと・・・ 98.92%
$ python main.py --epochs 3 : Test set: Average loss: 0.0338, Accuracy: 9892/10000 (98.92%)
5 epochsだと・・・ 99.09%
$ python main.py --epochs 5 : Test set: Average loss: 0.0281, Accuracy: 9909/10000 (99.09%)
10 epochsだと・・・ 99.21%
$ python main.py --epochs 10 : Test set: Average loss: 0.0244, Accuracy: 9921/10000 (99.21%)
プログラムを少し改造し、epoch各回の正解率を並べて表示してみた。
$ python main2.py --epochs 10 use cuda Test set (1): Average loss: 0.0461, Accuracy: 9841/10000 (98.41%) Test set (2): Average loss: 0.0324, Accuracy: 9896/10000 (98.96%) Test set (3): Average loss: 0.0334, Accuracy: 9893/10000 (98.93%) Test set (4): Average loss: 0.0297, Accuracy: 9903/10000 (99.03%) Test set (5): Average loss: 0.0264, Accuracy: 9917/10000 (99.17%) Test set (6): Average loss: 0.0275, Accuracy: 9916/10000 (99.16%) Test set (7): Average loss: 0.0264, Accuracy: 9911/10000 (99.11%) Test set (8): Average loss: 0.0251, Accuracy: 9922/10000 (99.22%) Test set (9): Average loss: 0.0264, Accuracy: 9920/10000 (99.20%) Test set (10): Average loss: 0.0253, Accuracy: 9918/10000 (99.18%)
【3】改造してみる
(1) ネットワーク構成変更：{入力層}−{隠れ層:フル接続128}−{出力層}
main.pyの NETクラスの中身を以下のように改造した。
上記プログラムのこの部分だけを変更すれば、レイヤー構成を変更できる。
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 28x28の画像を1次元にフラット化 -> 入力サイズは 784
self.fc1 = nn.Linear(28 * 28, 128) # 第1隠れ層
self.output = nn.Linear(128, 10) # 出力層（10クラス）
def forward(self, x):
x = x.view(-1, 28 * 28) # フラット化
x = F.relu(self.fc1(x)) # 隠れ層1 + ReLU
x = self.output(x) # 出力層（softmax前）
output = F.softmax(x, dim=1) # softmaxで確率化
return output
実行結果は以下の通り。
Test set (1): Average loss: -0.9397, Accuracy: 9442/10000 (94.42%) Test set (2): Average loss: -0.9548, Accuracy: 9592/10000 (95.92%) Test set (3): Average loss: -0.9633, Accuracy: 9664/10000 (96.64%) Test set (4): Average loss: -0.9656, Accuracy: 9683/10000 (96.83%) Test set (5): Average loss: -0.9674, Accuracy: 9704/10000 (97.04%) Test set (6): Average loss: -0.9677, Accuracy: 9712/10000 (97.12%) Test set (7): Average loss: -0.9694, Accuracy: 9718/10000 (97.18%) Test set (8): Average loss: -0.9697, Accuracy: 9728/10000 (97.28%) Test set (9): Average loss: -0.9697, Accuracy: 9724/10000 (97.24%) Test set (10): Average loss: -0.9699, Accuracy: 9726/10000 (97.26%)
(2) ネットワーク構成変更：{入力層}−{隠れ層:フル接続256}−{隠れ層:フル接続64}−{出力層}
main.pyの NETクラスの中身を以下のように改造した。
上記プログラムのこの部分だけを変更すれば、レイヤー構成を変更できる。
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 28x28の画像を1次元にフラット化 -> 入力サイズは 784
self.fc1 = nn.Linear(28 * 28, 256) # 第1隠れ層
self.fc2 = nn.Linear(256, 64) # 第2隠れ層
self.output = nn.Linear(64, 10) # 出力層（10クラス）
def forward(self, x):
x = x.view(-1, 28 * 28) # フラット化
x = F.relu(self.fc1(x)) # 隠れ層1 + ReLU
x = F.relu(self.fc2(x)) # 隠れ層2 + ReLU
x = self.output(x) # 出力層（softmax前）
output = F.softmax(x, dim=1) # softmaxで確率化
return output
実行結果は以下の通り。
Test set (1): Average loss: -0.9258, Accuracy: 9289/10000 (92.89%) Test set (2): Average loss: -0.9520, Accuracy: 9542/10000 (95.42%) Test set (3): Average loss: -0.9645, Accuracy: 9659/10000 (96.59%) Test set (4): Average loss: -0.9683, Accuracy: 9697/10000 (96.97%) Test set (5): Average loss: -0.9713, Accuracy: 9725/10000 (97.25%) Test set (6): Average loss: -0.9729, Accuracy: 9749/10000 (97.49%) Test set (7): Average loss: -0.9732, Accuracy: 9745/10000 (97.45%) Test set (8): Average loss: -0.9736, Accuracy: 9755/10000 (97.55%) Test set (9): Average loss: -0.9733, Accuracy: 9742/10000 (97.42%) Test set (10): Average loss: -0.9739, Accuracy: 9750/10000 (97.50%)
【4】所感
・いろいろなネットワーク構成を手軽に試せそう。
・データさえ揃えれば、いろいろな実験に活用できそう。
↓
アイディアさえあれば、面白いことに使えそうだ！
アクセス数（直近7日）: ※試験運用中、BOT除外簡易実装済2026-05-07: 0回 2026-05-06: 0回 2026-05-05: 1回 2026-05-04: 0回 2026-05-03: 0回 2026-05-02: 0回 2026-05-01: 1回