1
import torch
2
import torchvision
3
import torchvision.transforms as transforms
4
import torch.nn as nn
5
import torch.nn.functional as F
6
import torch.optim as optim

1
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])

1
# 学習データ
2
train_data_with_teacher_labels = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
3
train_data_loader = torch.utils.data.DataLoader(train_data_with_teacher_labels, batch_size=4, shuffle=True, num_workers=2)
4

5
# 検証データ
6
test_data_with_teacher_labels = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
7
test_data_loader = torch.utils.data.DataLoader(test_data_with_teacher_labels, batch_size=4, shuffle=False, num_workers=2)

1
class CNN(nn.Module):
2
    def __init__(self):
3
        super(CNN, self).__init__()
4
        self.conv1 = nn.Conv2d(3, 6, 5)
5
        self.pool = nn.MaxPool2d(2, 2)
6
        self.conv2 = nn.Conv2d(6, 16, 5)
7
        self.layer1 = nn.Linear(16 * 5 * 5, 120)
8
        self.layer2 = nn.Linear(120, 84)
9
        self.layer3 = nn.Linear(84, 10)
10

11
    def forward(self, input_data):
12
        input_data = self.pool(F.relu(self.conv1(input_data)))
13
        input_data = self.pool(F.relu(self.conv2(input_data)))
14
        input_data = input_data.view(-1, 16 * 5 * 5)
15
        input_data = F.relu(self.layer1(input_data))
16
        input_data = F.relu(self.layer2(input_data))
17
        input_data = self.layer3(input_data)
18
        return input_data

1
from keras.models import Sequential
2
from keras.layers import Conv2D
3
from keras.layers import Activation, Flatten, Dense
4

5
model = Sequential()
6

7
model.add(Conv2D(filters=10, kernel_size=(3, 3), padding='same', input_shape=(32,32,3)) activation='relu'))
8
model.add(Flatten())
9
model.add(Dense(10, activation='softmax'))
10

11
model.compile(loss='categorical_crossentropy', optimizer=Adam(), metrics=['accuracy'])

1
criterion = nn.CrossEntropyLoss()
2
optimizer = optim.SGD(params=model.parameters(), lr=0.001, momentum=0.9)

1
import torch
2
import torchvision
3
import torchvision.transforms as transforms
4
import torch.nn as nn
5
import torch.nn.functional as F
6
import torch.optim as optim
7

8
# エポック数
9
MAX_EPOCH = 3
10

11

12
# ニューラルネットワークの定義
13
class CNN(nn.Module):
14
    def __init__(self):
15
        super(CNN, self).__init__()
16
        self.conv1 = nn.Conv2d(3, 6, 5)
17
        self.pool = nn.MaxPool2d(2, 2)
18
        self.conv2 = nn.Conv2d(6, 16, 5)
19
        self.layer1 = nn.Linear(16 * 5 * 5, 120)
20
        self.layer2 = nn.Linear(120, 84)
21
        self.layer3 = nn.Linear(84, 10)
22

23
    def forward(self, input_data):
24
        input_data = self.pool(F.relu(self.conv1(input_data)))
25
        input_data = self.pool(F.relu(self.conv2(input_data)))
26
        input_data = input_data.view(-1, 16 * 5 * 5)
27
        input_data = F.relu(self.layer1(input_data))
28
        input_data = F.relu(self.layer2(input_data))
29
        input_data = self.layer3(input_data)
30
        return input_data
31

32

33
def main():
34

35
    # transform定義
36
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
37

38
    # 学習データ
39
    train_data_with_teacher_labels = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
40
    train_data_loader = torch.utils.data.DataLoader(train_data_with_teacher_labels, batch_size=4, shuffle=True, num_workers=2)
41

42
    model = CNN()
43

44
    # optimizerの設定
45
    criterion = nn.CrossEntropyLoss()
46
    optimizer = optim.SGD(params=model.parameters(), lr=0.001, momentum=0.9)
47

48
    # 学習
49
    for epoch in range(MAX_EPOCH):
50
        total_loss = 0.0
51
        for i, data in enumerate(train_data_loader, 0):
52
            # 学習データと教師ラベルデータを取得
53
            train_data, teacher_labels = data
54
            # 勾配情報を削除
55
            optimizer.zero_grad()
56
            # モデルで予測を計算
57
            outputs = model(train_data)
58
            # 微分計算
59
            loss = criterion(outputs, teacher_labels)
60
            loss.backward()
61
            # 勾配を更新
62
            optimizer.step()
63
            # 誤差
64
            total_loss += loss.item()
65
            # 1000ミニバッチずつ進捗を表示
66
            if i % 1000 == 999:
67
                print('学習進捗：[学習回数：%d, ミニバッチ数：%5d] loss: %.3f' % (epoch + 1, i + 1, total_loss / 1000))
68
                total_loss = 0.0
69

70
    # モデル保存
71
    torch.save(model.state_dict(), "model.pth")
72

73
    print("-----学習完了-----")

1
import torch
2
import torchvision
3
import torchvision.transforms as transforms
4
from torch_sample import CNN
5

6
def main():
7

8
    # モデル読み込み
9
    model = CNN()
10
    model.load_state_dict(torch.load("model.pth"))
11

12
    # transform定義
13
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
14

15
    # 検証データ
16
    test_data_with_teacher_labels = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
17
    test_data_loader = torch.utils.data.DataLoader(test_data_with_teacher_labels, batch_size=4, shuffle=False, num_workers=2)
18

19
    # クラスの中身を設定
20
    class_names = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
21

22
    # クラスごとの検証結果
23
    class_corrent = list(0. for i in range(10))
24
    class_total = list(0.for i in range(10))
25

26
    with torch.no_grad(): # 勾配の計算をしない
27
        for data in test_data_loader:
28
            # 検証データと教師ラベルデータを取得
29
            test_data, teacher_labels = data
30
            # 検証データをモデルに渡し予測
31
            results = model(test_data)
32
            # 予測結果を取得
33
            _, predicted = torch.max(results, 1)
34
            c = (predicted == teacher_labels).squeeze()
35
            for i in range(4):
36
                label = teacher_labels[i]
37
                class_corrent[label] += c[i].item()
38
                class_total[label] += 1
39
    # 結果表示
40
    for i in range(10):
41
        print(' %5s クラスの正解率: %2d %%' % (class_names[i], 100 * class_corrent[i] / class_total[i]))