DDPG by gymnasium １２日目

GPUをニューラルネットワークのテンソル演算に利用します。

Contents

GPUへの飛ばし方

#変数deviceを’cuda’にする

device = torch.device(“cuda” if torch.cuda.is_available() else “cpu”)

#ネットワークのインスタンスを.to(‘cuda’)する

net_gpu.to(device)

# ネットワークへの入力xを.to(‘cuda’)する

x = x.to(device)

# ネットワークへの正解ラベルyをy.to(‘cuda’)する

y = y.to(device)

これでGPU上のnetへxとyを入れることができるので演算可能になります。

    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

loss = criterion(outputs, y)

loss.backward()

optimizer.step()

速度比較

class SimpleNet(nn.Module):クラスとしてネットワークを作成します。

n_inputs:2

バッチ数:4

n_output:1

n_hidden:1024

hidden layer 4層をもつ全５層のネットワークです。

ネットワークのインスタンスを２つ作って

net_cpu = SimpleNet()

net_gpu = SimpleNet()

エポック数：1000でそれぞれ回してみましょう。

結果は

CPU training time: 9.972002267837524 seconds
GPU training time: 2.5578291416168213 seconds

ということで。GPUのほうが高速です。

しかし、n_hiddenを64にすると、

CPU training time: 0.5419738292694092 seconds
GPU training time: 2.506857395172119 seconds

となり、node数が少ない場合はcpuのほうが高速になります。

GPUならいつでも高速というわけではないことに注意しましょう。

スクリプト

import torch
import torch.nn as nn
import torch.optim as optim
import time

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        hidden = 1024
        self.fc1 = nn.Linear(2, hidden)
        self.fc2 = nn.Linear(hidden, hidden)
        self.fc3 = nn.Linear(hidden, hidden)
        self.fc4 = nn.Linear(hidden, hidden)
        self.fc5 = nn.Linear(hidden, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.relu(self.fc3(x))
        x = torch.relu(self.fc4(x))
        x = self.fc5(x)
        return x

# データの生成
x = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# ネットワークの初期化
net_cpu = SimpleNet()
net_gpu = SimpleNet()

# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(net_cpu.parameters(), lr=0.1)

# ==== CPUでのトレーニング時間の測定
start_time = time.time()

for epoch in range(1000):
    optimizer.zero_grad()
    outputs = net_cpu(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

end_time = time.time()
cpu_training_time = end_time - start_time
print("CPU training time:", cpu_training_time, "seconds")


# GPUでのトレーニング時間の測定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net_gpu.to(device)
x = x.to(device)
y = y.to(device)

start_time = time.time()

for epoch in range(1000):
    optimizer.zero_grad()
    outputs = net_gpu(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

end_time = time.time()
gpu_training_time = end_time - start_time
print("GPU training time:", gpu_training_time, "seconds")

import torch

import torch.nn as nn

import torch.optim as optim

import time

class SimpleNet(nn.Module):

def __init__(self):

super(SimpleNet, self).__init__()

hidden = 1024

self.fc1 = nn.Linear(2, hidden)

self.fc2 = nn.Linear(hidden, hidden)

self.fc3 = nn.Linear(hidden, hidden)

self.fc4 = nn.Linear(hidden, hidden)

self.fc5 = nn.Linear(hidden, 1)

def forward(self, x):

x = torch.relu(self.fc1(x))

x = torch.relu(self.fc2(x))

x = torch.relu(self.fc3(x))

x = torch.relu(self.fc4(x))

x = self.fc5(x)

return x

# データの生成

x = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)

y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# ネットワークの初期化

net_cpu = SimpleNet()

net_gpu = SimpleNet()

# 損失関数とオプティマイザの定義

criterion = nn.MSELoss()

optimizer = optim.SGD(net_cpu.parameters(), lr=0.1)

# ==== CPUでのトレーニング時間の測定

start_time = time.time()

for epoch in range(1000):

optimizer.zero_grad()

outputs = net_cpu(x)

loss = criterion(outputs, y)

loss.backward()

optimizer.step()

end_time = time.time()

cpu_training_time = end_time - start_time

print("CPU training time:", cpu_training_time, "seconds")

# GPUでのトレーニング時間の測定

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

net_gpu.to(device)

x = x.to(device)

y = y.to(device)

start_time = time.time()

for epoch in range(1000):

optimizer.zero_grad()

outputs = net_gpu(x)

loss = criterion(outputs, y)

loss.backward()

optimizer.step()

end_time = time.time()

gpu_training_time = end_time - start_time

print("GPU training time:", gpu_training_time, "seconds")

次回はDDPGコードをGPU対応していきます。

この記事を書いた人
最新の記事

月	火	水	木	金	土	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

GPUへの飛ばし方

速度比較

スクリプト

Keita N

最新記事 by Keita N (全て見る)