pycharm在进行神经网络训练时怎么利用GPU加速

pip install tensorflow-gpu

pip install torch torchvision torchaudio

import tensorflow as tf
# 检查TensorFlow是否看到GPU
print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))
# 配置策略以在GPU上运行操作
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        # 将第一个GPU设置为优先设备
        tf.config.set_visible_devices(gpus[0], 'GPU')
        
        # 强制TensorFlow使用单个GPU
        tf.config.experimental.set_per_process_gpu_memory_fraction(0.9)
    except RuntimeError as e:
        # 如果在设备上设置Visible Devices失败，则打印错误信息
        print(e)

import torch
# 检查PyTorch是否看到GPU
print("Num GPUs Available: ", torch.cuda.device_count())
# 指定使用哪个GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Using {device} device")
# 将模型和数据转移到GPU
model = YourModel().to(device)
data = data.to(device)
# 执行模型训练...

# 导入所需的库
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
# 定义设备配置，确保在GPU上进行训练
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using {device} device")
# 定义神经网络的类
class SimpleNeuralNetwork(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(SimpleNeuralNetwork, 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
# 定义训练函数
def train(model, train_loader, optimizer, criterion, epoch, device):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f"Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} ({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}")
# 定义评估函数
def evaluate(model, test_loader, criterion, device):
    model.eval（)
    total_correct = 0
    total_loss = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            loss = criterion(output, target)
            total_loss += loss.item()
            pred = output.argmax(dim=1, keepdim=True)
            total_correct += pred.eq(target.view_as(pred)).sum().item()
    
    print(f"Accuracy of the network on the test images: {100. * total_correct / len(test_loader.dataset):.2f}%")
    print(f"Average loss: {total_loss / len(test_loader):.4f}")
# 训练和验证的步骤
def main():
    # 设置训练和测试数据集
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
    train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
    test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
    
    train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
    test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
    # 定义模型、优化器和损失函数
    input_size = 784
    hidden_size = 500
    num_classes = 10
    model = SimpleNeuralNetwork(input_size, hidden_size, num_classes).to(device)
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    criterion = nn.CrossEntropyLoss()
    # 开始训练过程
    for epoch in range