pip3.11 install torchviz
pip3.11 install torchinfo
python3.11
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# データセット準備1 ランダムデータの場合
#####
rng = np.random.default_rng()
image_train = rng.uniform(-1,1,(600, 784))
image_train = torch.tensor(image_train).float()
print(image_train)
print(image_train.shape)
label_train = rng.integers(10, size=(600))
label_train = torch.tensor(label_train).long()
print(label_train)
print(label_train.shape)
rng = np.random.default_rng()
image_test = rng.uniform(-1,1,(100, 784))
image_test = torch.tensor(image_test).float()
print(image_test)
print(image_test.shape)
label_test = rng.integers(10, size=(100))
label_test = torch.tensor(label_test).long()
print(label_test)
print(label_test.shape)
train_set = tuple(zip(image_train, label_train))
test_set = tuple(zip(image_test, label_test))
print(train_set[599])
print(test_set[99])
#####
# データローダ準備
from torch.utils.data import DataLoader
batch_size = 10
train_loader = DataLoader(
train_set, batch_size = batch_size,
shuffle = True)
test_loader = DataLoader(
test_set, batch_size = batch_size,
shuffle = False)
print(len(train_loader))
print(len(test_loader))
for images, labels in train_loader:
break
print(images.shape)
print(labels.shape)
# モデル定義
n_input = 1 * 28 * 28
n_output = 10
n_hidden = 128
import torch.nn.functional as F
class DropConnectLinear(nn.Module):
def __init__(self, in_features, out_features, drop_rate=0.5):
super().__init__()
self.drop_rate = drop_rate
self.weight = nn.Parameter(torch.randn(out_features, in_features) * 0.01)
self.bias = nn.Parameter(torch.zeros(out_features))
def forward(self, x):
if self.training:
keep_rate = 1.0 - self.drop_rate
r = torch.rand_like(self.weight)
r += keep_rate
mask = r.floor()
weight = self.weight * mask / keep_rate
else:
weight = self.weight
return F.linear(x, weight, self.bias)
class Net(nn.Module):
def __init__(self, n_input, n_output, n_hidden):
super().__init__()
self.l1 = DropConnectLinear(n_input, n_hidden, drop_rate=0.5)
self.relu = nn.ReLU(inplace=True)
self.l2 = DropConnectLinear(n_hidden, n_output, drop_rate=0.5)
def forward(self, x):
x1 = self.l1(x)
x2 = self.relu(x1)
x3 = self.l2(x2)
return x3
# インスタンス生成
net = Net(n_input, n_output, n_hidden)
net = net.to(device)
for parameter in net.named_parameters():
print(parameter)
for parameter in net.parameters():
print(parameter)
print(net)
from torchinfo import summary
summary(net, (1 * 28 * 28,))
# 損失関数
criterion = nn.CrossEntropyLoss()
# 学習率
lr = 0.01
# 最適化関数
optimizer = optim.SGD(net.parameters(), lr=lr)
# 繰り返し回数
num_epochs = 5
# 繰り返し計算
for epoch in range(num_epochs):
# 1エポックあたりの正解数(精度計算用)
n_train_acc, n_val_acc = 0, 0
# 1エポックあたりの累積損失(平均化前)
train_loss, val_loss = 0, 0
# 1エポックあたりのデータ累積件数
n_train, n_test = 0, 0
# 訓練フェーズ
for inputs, labels in train_loader:
# 1バッチあたりのデータ件数
train_batch_size = len(labels)
# 1エポックあたりのデータ累積件数
n_train += train_batch_size
# GPUヘ転送
inputs = inputs.to(device)
labels = labels.to(device)
#勾配の初期化★
optimizer.zero_grad()
# 予測計算
outputs = net(inputs)
# 損失計算
loss = criterion(outputs, labels)
# 勾配計算★
loss.backward()
# パラメータ修正★
optimizer.step()
# 予測ラベル導出
predicted = torch.max(outputs, 1)[1]
# 平均前の損失と正解数の計算
# lossは平均計算が行われているので平均前の損失に戻して加算
train_loss += loss.item() * train_batch_size
n_train_acc += (predicted == labels).sum().item()
#予測フェーズ
for inputs_test, labels_test in test_loader:
# 1バッチあたりのデータ件数
test_batch_size = len(labels_test)
# 1エポックあたりのデータ累積件数
n_test += test_batch_size
# GPUヘ転送
inputs_test = inputs_test.to(device)
labels_test = labels_test.to(device)
# 予測計算
outputs_test = net(inputs_test)
# 損失計算
loss_test = criterion(outputs_test, labels_test)
#予測ラベル導出
predicted_test = torch.max(outputs_test, 1)[1]
# 平均前の損失と正解数の計算
# lossは平均計算が行われているので平均前の損失に戻して加算
val_loss += loss_test.item() * test_batch_size
n_val_acc += (predicted_test == labels_test).sum().item()
# 精度計算
train_acc = n_train_acc / n_train
val_acc = n_val_acc / n_test
# 損失計算
ave_train_loss = train_loss / n_train
ave_val_loss = val_loss / n_test
# 結果表示
print (f'Epoch [{epoch+1}/{num_epochs}], loss: {ave_train_loss:.5f} acc: {train_acc:.5f} val_loss: {ave_val_loss:.5f}, val_acc: {val_acc:.5f}')
# 重み行列
print(net.l1.weight.data)
print(net.l2.weight.data)
# バイアス
print(net.l1.bias.data)
print(net.l2.weight.data)
