[Python] PyTorchでCPUとGPUを切り替える方法

2025-01-18更新日: 2025-01-18

PyTorchでは、CPUとGPUを簡単に切り替えることができます。

PyTouchはCPU版とGPU対応版に分かれており、GPU対応版をインストールしておかないと正しく動作しません。例(Windows/CUDA12.4の場合)：pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

標準インストールしている場合は、PyTouch公式サイトで自身の環境に合うインストールコマンドを確認して再インストールしてください。

PyTorch – Start Locally

Select preferences and run the command to install PyTorch locally, or get started quickly with one of the supported cloud platforms.

PyTorch

まず、GPUが利用可能かどうかを確認するためにtorch.cuda.is_available()を使用します。

GPUが利用可能な場合、torch.device("cuda")でGPUを指定し、利用できない場合はtorch.device("cpu")でCPUを指定します。

モデルやテンソルを特定のデバイスに移動するには、.to(device)メソッドを使用します。

例えば、model.to(device)やtensor.to(device)のように記述します。

目次から探す

PyTorchにおけるデバイス管理の基本
GPUの利用条件と確認方法
CPUとGPUの切り替え方法
実際のコード例
GPUを使ったパフォーマンス向上のポイント
応用例：GPUを使ったモデルのトレーニング
まとめ

PyTorchにおけるデバイス管理の基本

CPUとGPUの違い

CPU (Central Processing Unit):
- 汎用性が高く、シングルスレッド処理に優れる。
- 複雑な計算を行う際に適しているが、並列処理には限界がある。
GPU (Graphics Processing Unit):
- 大量のデータを並列処理するのに特化している。
- 特に行列演算やベクトル演算において高いパフォーマンスを発揮する。

特徴	CPU	GPU
処理能力	シングルスレッド処理に強い	並列処理に強い
用途	汎用計算	ディープラーニング、画像処理
コア数	少ない(通常4〜16コア)	多い(数百〜数千コア)

PyTorchでのデバイスの概念

PyTorchでは、計算を行うデバイスを明示的に指定することができます。

主にCPUとGPUの2つのデバイスがあり、モデルやテンソルをどのデバイスで処理するかを選択することが重要です。

これにより、計算の効率を最大化し、トレーニング時間を短縮することが可能です。

デバイスの確認方法

PyTorchでは、現在使用可能なデバイスを確認するために、以下のコードを使用します。

import torch
# 利用可能なデバイスを確認
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用するデバイス: {device}")

このコードを実行すると、使用するデバイスが表示されます。

使用するデバイス: cuda

デバイスの指定方法

PyTorchでデバイスを指定するには、torch.deviceを使用します。

以下のように、CPUまたはGPUを指定することができます。

import torch
# CPUを指定
device_cpu = torch.device("cpu")
# GPUを指定
device_gpu = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"CPUデバイス: {device_cpu}")
print(f"GPUデバイス: {device_gpu}")

CPUデバイス: cpu
GPUデバイス: cuda

このように、デバイスを指定することで、計算を行う環境を柔軟に変更することができます。

GPUの利用条件と確認方法

GPUが利用可能か確認する方法

PyTorchでGPUが利用可能かどうかを確認するには、torch.cuda.is_available()を使用します。

この関数は、GPUが利用可能な場合にTrueを返します。

以下のコードで確認できます。

import torch
# GPUが利用可能か確認
is_cuda_available = torch.cuda.is_available()
print(f"GPUが利用可能: {is_cuda_available}")

GPUが利用可能: True

この結果がTrueであれば、GPUを使用して計算を行うことができます。

複数のGPUがある場合の確認方法

複数のGPUがある場合、それぞれのGPUの数を確認するには、torch.cuda.device_count()を使用します。

以下のコードで確認できます。

import torch
# 利用可能なGPUの数を確認
gpu_count = torch.cuda.device_count()
print(f"利用可能なGPUの数: {gpu_count}")

利用可能なGPUの数: 2

このコードを実行することで、システムに搭載されているGPUの数を知ることができます。

GPUのメモリ使用状況の確認

GPUのメモリ使用状況を確認するには、torch.cuda.memory_allocated()とtorch.cuda.memory_reserved()を使用します。

これにより、現在使用中のメモリと予約されているメモリの量を確認できます。

import torch
# メモリ使用状況を確認
allocated_memory = torch.cuda.memory_allocated()
reserved_memory = torch.cuda.memory_reserved()
print(f"使用中のメモリ: {allocated_memory / (1024 ** 2):.2f} MB")
print(f"予約されているメモリ: {reserved_memory / (1024 ** 2):.2f} MB")

使用中のメモリ: 50.00 MB
予約されているメモリ: 100.00 MB

このように、GPUのメモリ使用状況を把握することで、リソースの管理や最適化に役立てることができます。

CPUとGPUの切り替え方法

torch.deviceを使ったデバイス指定

PyTorchでは、torch.deviceを使用して計算を行うデバイスを指定できます。

以下のコードでは、CPUまたはGPUを選択する方法を示します。

import torch
# デバイスを指定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用するデバイス: {device}")

使用するデバイス: cuda

このコードを実行することで、利用可能なデバイスを自動的に選択できます。

モデルを特定のデバイスに移動する方法

モデルを特定のデバイスに移動するには、.to()メソッドを使用します。

以下の例では、モデルをGPUに移動させる方法を示します。

import torch
import torch.nn as nn
# 簡単なモデルの定義
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 2)
    def forward(self, x):
        return self.fc(x)
# モデルのインスタンスを作成
model = SimpleModel()
# モデルを指定したデバイスに移動
model.to(device)
print(f"モデルのデバイス: {next(model.parameters()).device}")

モデルのデバイス: cuda:0

このように、モデルを指定したデバイスに移動させることができます。

テンソルを特定のデバイスに移動する方法

テンソルを特定のデバイスに移動するには、to()メソッドを使用します。

以下のコードでは、テンソルをGPUに移動させる方法を示します。

import torch
# テンソルを作成
tensor = torch.randn(3, 3)
# テンソルを指定したデバイスに移動
tensor = tensor.to(device)
print(f"テンソルのデバイス: {tensor.device}")

テンソルのデバイス: cuda:0

このように、テンソルも簡単に指定したデバイスに移動できます。

CPUとGPU間でのデータ転送の注意点

CPUとGPU間でデータを転送する際には、以下の点に注意が必要です。

転送コスト: CPUとGPU間のデータ転送は時間がかかるため、頻繁に行うとパフォーマンスが低下します。

可能な限りデータを一度に転送することが推奨されます。

デバイスの一致: モデルとテンソルは同じデバイス上に存在する必要があります。

異なるデバイス間で計算を行うとエラーが発生します。

メモリ管理: GPUのメモリは限られているため、大きなデータセットやモデルを扱う際には、メモリ使用量を常に監視することが重要です。

これらの注意点を考慮することで、効率的にCPUとGPUを活用することができます。

実際のコード例

GPUが利用可能な場合のコード例

以下のコードは、GPUが利用可能な場合に簡単な線形回帰モデルをトレーニングする例です。

データはランダムに生成され、モデルはGPU上でトレーニングされます。

import torch
import torch.nn as nn
import torch.optim as optim
# デバイスを指定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# データの生成
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、デバイスに移動
model = LinearRegressionModel().to(device)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
print("トレーニング完了")

トレーニング完了

CPUのみを使用する場合のコード例

以下のコードは、CPUのみを使用して同様の線形回帰モデルをトレーニングする例です。

import torch
import torch.nn as nn
import torch.optim as optim
# デバイスをCPUに指定
device = torch.device("cpu")
# データの生成
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、デバイスに移動
model = LinearRegressionModel().to(device)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
print("トレーニング完了")

トレーニング完了

複数GPUを使用する場合のコード例

以下のコードは、複数のGPUを使用してデータ並列処理を行う例です。

DataParallelを使用して、モデルを複数のGPUに分散させます。

import torch
import torch.nn as nn
import torch.optim as optim
# デバイスを指定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# データの生成
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、DataParallelでラップ
model = nn.DataParallel(LinearRegressionModel()).to(device)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
print("トレーニング完了")

トレーニング完了

デバイス切り替えを自動化するコード例

以下のコードは、デバイスの切り替えを自動化する方法を示しています。

デバイスの選択を関数にまとめ、モデルとデータを適切なデバイスに移動させます。

import torch
import torch.nn as nn
import torch.optim as optim
def get_device():
    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
# デバイスを取得
device = get_device()
# データの生成
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、デバイスに移動
model = LinearRegressionModel().to(device)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
print("トレーニング完了")

トレーニング完了

このように、デバイスの切り替えを自動化することで、コードの可読性と再利用性が向上します。

GPUを使ったパフォーマンス向上のポイント

GPUを使うメリット

高速な計算: GPUは多数のコアを持ち、並列処理に特化しているため、大量のデータを同時に処理できます。

これにより、トレーニング時間が大幅に短縮されます。

効率的なメモリ使用: GPUは大容量のメモリを持ち、特に行列演算やベクトル演算において効率的にデータを処理できます。
ディープラーニングの最適化: 多くのディープラーニングフレームワーク(PyTorchやTensorFlowなど)は、GPUを利用することでモデルのトレーニングを最適化しています。

GPUを使う際の注意点

メモリ制限: GPUのメモリは限られているため、大きなモデルやデータセットを扱う際には、メモリ使用量を監視する必要があります。

メモリ不足になると、エラーが発生します。

データ転送のオーバーヘッド: CPUとGPU間でデータを転送する際には時間がかかるため、頻繁に転送を行うとパフォーマンスが低下します。

データはできるだけ一度に転送することが推奨されます。

デバイスの互換性: 使用するGPUの種類によっては、特定の機能や最適化が利用できない場合があります。

使用するライブラリやフレームワークの互換性を確認することが重要です。

バッチサイズとGPUメモリの関係

バッチサイズは、モデルのトレーニング時に一度に処理するデータの数を指します。

バッチサイズが大きいほど、GPUのメモリを効率的に使用できますが、メモリ制限を超えるとエラーが発生します。

以下のポイントに注意が必要です。

大きなバッチサイズ: 計算効率が向上し、トレーニングが速くなりますが、GPUのメモリを消費します。
小さなバッチサイズ: メモリ使用量は少なくなりますが、トレーニングが遅くなる可能性があります。

また、勾配の更新が不安定になることがあります。

最適なバッチサイズは、使用するGPUのメモリ容量やモデルの複雑さに依存します。

データ並列処理の活用

データ並列処理は、複数のGPUを使用してトレーニングを行う手法です。

これにより、トレーニング時間を短縮し、モデルのスケーラビリティを向上させることができます。

以下の方法でデータ並列処理を活用できます。

DataParallelの使用: PyTorchでは、torch.nn.DataParallelを使用して、モデルを複数のGPUに分散させることができます。

これにより、各GPUが異なるデータのバッチを処理し、トレーニングを加速します。

分散トレーニング: より大規模なシステムでは、複数のマシンにまたがる分散トレーニングを行うことも可能です。

これにより、さらに大きなデータセットやモデルを扱うことができます。

データ並列処理を活用することで、トレーニングの効率を大幅に向上させることができます。

応用例：GPUを使ったモデルのトレーニング

GPUを使ったモデルのトレーニング手順

GPUを使用してモデルをトレーニングする手順は以下の通りです。

デバイスの設定: GPUが利用可能か確認し、使用するデバイスを指定します。
データの準備: トレーニングデータとテストデータを用意し、必要に応じて前処理を行います。
モデルの定義: ニューラルネットワークモデルを定義します。
損失関数とオプティマイザの設定: モデルのトレーニングに使用する損失関数とオプティマイザを選択します。
トレーニングループの実装: データをバッチごとに処理し、モデルをトレーニングします。
評価: テストデータを使用してモデルの性能を評価します。

以下は、GPUを使ったモデルのトレーニングの簡単なコード例です。

import torch
import torch.nn as nn
import torch.optim as optim
# デバイスを指定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# データの生成
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、デバイスに移動
model = LinearRegressionModel().to(device)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
print("トレーニング完了")

トレーニング完了

複数GPUを使った分散トレーニング

複数のGPUを使用して分散トレーニングを行うことで、トレーニング時間を短縮できます。

PyTorchでは、torch.nn.DataParallelを使用してモデルを複数のGPUに分散させることができます。

以下は、複数GPUを使用したトレーニングの例です。

import torch
import torch.nn as nn
import torch.optim as optim
# デバイスを指定
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# データの生成
x = torch.randn(100, 1).to(device)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、DataParallelでラップ
model = nn.DataParallel(LinearRegressionModel()).to(device)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(x)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()
print("トレーニング完了")

トレーニング完了

GPUを使った推論の高速化

トレーニングが完了したモデルを使用して推論を行う際にも、GPUを活用することで高速化が可能です。

以下は、GPUを使用した推論の例です。

import torch
# モデルを評価モードに設定
model.eval()
# 新しいデータを生成
new_data = torch.randn(10, 1).to(device)
# 推論を実行
with torch.no_grad():
    predictions = model(new_data)
print("推論結果:", predictions)

推論結果: tensor([[...], [...], ...], device='cuda:0')

GPUとCPUを併用したハイブリッド処理

GPUとCPUを併用することで、計算の効率を最大化することができます。

例えば、データの前処理をCPUで行い、モデルのトレーニングや推論をGPUで行うことが考えられます。

以下は、ハイブリッド処理の例です。

import torch
import torch.nn as nn
import torch.optim as optim
# デバイスを指定
device_gpu = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device_cpu = torch.device("cpu")
# データの生成(CPUで前処理)
x = torch.randn(100, 1).to(device_cpu)
y = 3 * x + 2 + 0.1 * torch.randn(100, 1).to(device_cpu)
# モデルの定義
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)
    def forward(self, x):
        return self.linear(x)
# モデルのインスタンスを作成し、GPUに移動
model = LinearRegressionModel().to(device_gpu)
# 損失関数とオプティマイザの定義
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
# トレーニングループ
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    
    # データをGPUに移動
    x_gpu = x.to(device_gpu)
    y_gpu = y.to(device_gpu)
    
    outputs = model(x_gpu)
    loss = criterion(outputs, y_gpu)
    loss.backward()
    optimizer.step()
print("トレーニング完了")