PythonでDeepLearning - フレームワーク

TensorFlowとPytorchを並べてみてみましょう。TensorFlowの方がスッキリしている感じがして使い印象を受けます。以下比較されているサイトです。

TensorflowとKeras、PyTorchの比較

今現在はPytorchがよく使われている印象です。柔軟性が高いのがポイントでしょうか。

TensorFlow

Googleが開発していて使い方も比較的簡単に使えるようになっています。チュートリアルも日本語の解説もあります。

TensorFlow

import tensorflow as tf
mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
  loss='sparse_categorical_crossentropy',
  metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test)

クイックスタートとしてコードもトップページに紹介されておりすぐColabで試せるようになっています。

まず必要なライブラリ、データを取り込みます。

import tensorflow as tf
mnist = tf.keras.datasets.mnist

試すのに必要なデータを使えるように変数に入れていきまします。

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

次にモデルの作成。入力層、隠れ層、出力層を作ります。

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])　

最適化していきます。

model.compile(optimizer='adam',
  loss='sparse_categorical_crossentropy',
  metrics=['accuracy'])

最後に学習します。正解のデータを使ってパラメータを決めていきます。

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test)

実行すると

Epoch 1/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - accuracy: 0.8583 - loss: 0.4848
Epoch 2/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - accuracy: 0.9537 - loss: 0.1555
Epoch 3/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - accuracy: 0.9671 - loss: 0.1097
Epoch 4/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 6s 2ms/step - accuracy: 0.9740 - loss: 0.0881
Epoch 5/5
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - accuracy: 0.9764 - loss: 0.0755
313/313 - 1s - 3ms/step - accuracy: 0.9777 - loss: 0.0739
[0.0738915503025055, 0.9776999950408936]

テストの結果97%の確率で正解を出しているとの分析が出てきます。

Pytorch

PyTorch

チュートリアルで紹介されて入りものをColabで実行してみます。
まず必要なライブラリを取り込みます。

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

初期のパラメータを決めます。

input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

使うデータの準備。PytorchではTensorFlowではないデータローダーの作成をします。

train_dataset = datasets.MNIST(root='./data',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

test_dataset = datasets.MNIST(root='./data',
                              train=False,
                              transform=transforms.ToTensor())

データローダーの作成。参考サイト。

PyTorch入門講座：データローディングと前処理編！

train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)

モデルの作成。

class Net(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

作ったモデルを使って最適化

model = Net(input_size, hidden_size, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

最後に学習します。正解のデータを使ってパラメータを決めていきます。

total_step = len(train_loader)
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # 画像を1次元ベクトルに変換
        images = images.reshape(-1, 28*28)

        # 順伝播
        outputs = model(images)
        loss = criterion(outputs, labels)

        # 逆伝播と最適化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{total_step}], Loss: {loss.item():.4f}')

評価

model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.reshape(-1, 28*28)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')

実行すると

Epoch [1/5], Step [100/600], Loss: 0.3624
Epoch [1/5], Step [200/600], Loss: 0.1881
Epoch [1/5], Step [300/600], Loss: 0.2672
・
・
Epoch [4/5], Step [500/600], Loss: 0.0098
Epoch [4/5], Step [600/600], Loss: 0.0282
Epoch [5/5], Step [100/600], Loss: 0.0385
Epoch [5/5], Step [200/600], Loss: 0.0343
Epoch [5/5], Step [300/600], Loss: 0.0090
Epoch [5/5], Step [400/600], Loss: 0.0931
Epoch [5/5], Step [500/600], Loss: 0.0508
Epoch [5/5], Step [600/600], Loss: 0.0984
Accuracy of the network on the 10000 test images: 98.11%

テストの結果98.11%の確率で正解を出しているとの分析が出てきます。

参考　Keras

Kerasで始める深層学習 - Qiita