Pytorch GPU内存占用很高,但是利用率很低如何解决

当PyTorch GPU内存占用很高，但是利用率很低时，可能是由于以下原因：

1. 数据加载器的num_workers参数设置过高，导致CPU和GPU之间的数据传输效率低下。
2. 模型过于复杂，导致GPU内存占用过高，而GPU利用率低下。
3. 训练数据集过小，导致GPU利用率低下。

为了解决这个问题，我们可以采取以下措施：

1. 调整数据加载器的num_workers参数，使其不要设置过高。通常，将其设置为CPU核心数的一半是一个不错的选择。
2. 优化模型结构，减少GPU内存占用。可以尝试使用更小的模型、减少层数或使用更小的批量大小等方法。
3. 增加训练数据集的大小，以提高GPU利用率。可以使用数据增强技术来扩充数据集，或者使用预训练模型进行微调。

下面是两个示例说明：

示例1：调整数据加载器的num_workers参数

import torch
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# 加载MNIST数据集
train_dataset = datasets.MNIST(root='data/', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root='data/', train=False, transform=transforms.ToTensor(), download=True)

# 定义超参数
num_epochs = 10
batch_size = 100
learning_rate = 0.001

# 创建数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False, num_workers=4)

# 定义全连接神经网络
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = torch.nn.Linear(784, 128)
        self.relu = torch.nn.ReLU()
        self.fc2 = torch.nn.Linear(128, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型实例、损失函数和优化器
model = Net()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # 前向传播
        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}/{len(train_loader)}], Loss: {loss.item():.4f}")

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f"Accuracy: {100 * correct / total}%")

在这个示例中，我们加载MNIST数据集，并将其分为训练集和测试集。然后，我们定义了一个全连接神经网络，并使用数据加载器来加载数据。我们将num_workers参数设置为4，这意味着我们将使用4个CPU核心来加载数据。在训练过程中，我们使用一个循环遍历训练集中的所有数据，并计算损失和梯度。最后，我们使用测试集评估模型的准确性。

示例2：使用预训练模型进行微调

import torch
import torchvision.datasets as datasets
import torchvision.transforms as transforms
import torchvision.models as models

# 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(root='data/', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.CIFAR10(root='data/', train=False, transform=transforms.ToTensor(), download=True)

# 定义超参数
num_epochs = 10
batch_size = 100
learning_rate = 0.001

# 创建数据加载器
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)

# 加载预训练模型
model = models.resnet18(pretrained=True)

# 替换最后一层全连接层
num_ftrs = model.fc.in_features
model.fc = torch.nn.Linear(num_ftrs, 10)

# 创建损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # 前向传播
        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}/{len(train_loader)}], Loss: {loss.item():.4f}")

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f"Accuracy: {100 * correct / total}%")

在这个示例中，我们加载CIFAR-10数据集，并将其分为训练集和测试集。然后，我们加载了一个预训练的ResNet-18模型，并替换了最后一层全连接层，以便将其用于CIFAR-10分类。在训练过程中，我们使用一个循环遍历训练集中的所有数据，并计算损失和梯度。最后，我们使用测试集评估模型的准确性。

总之，当PyTorch GPU内存占用很高，但是利用率很低时，我们可以采取一些措施来解决这个问题。可以调整数据加载器的num_workers参数，优化模型结构，增加训练数据集的大小等。