Uso de GPUs

Introdução a GPUs

As GPUs (Unidades de Processamento Gráfico) são projetadas para lidar com tarefas altamente paralelas, tornando-as ideais para aplicações que demandam alto poder computacional, como aprendizado profundo, simulações científicas, e processamento de imagens.

NVIDIA L40S: Este servidor está equipado com 4 GPUs NVIDIA L40S, uma GPU de alto desempenho otimizada para cargas de trabalho em aprendizado de máquina e inferência, processamento gráfico avançado e análises massivas.

Capacidades:

  • Arquitetura Ada Lovelace de última geração.

  • 48 GB de memória gráfica (GDDR6) por GPU.

  • Suporte a frameworks populares como PyTorch e TensorFlow.

  • Benefícios em aplicações como treinamento de redes neurais profundas, análise de dados em larga escala e renderização 3D.

  • A arquitetura do servidor inclui 1.5 TB de RAM, permitindo um fluxo de trabalho eficiente para aplicações que demandam grande quantidade de memória.

Política de Uso

Partição de Execução

A nova partição do Slurm chamada gpu foi configurada exclusivamente para o uso do servidor com GPUs L40S.

Apenas esta partição pode acessar os recursos de GPU. Requisições para a partição gpu precisam ser feitas explicitamente nos scripts de submissão.

Tempo Máximo de Uso

O tempo máximo permitido para jobs na partição gpu é de 24 horas. Caso um job ultrapasse esse limite, ele será automaticamente encerrado pelo Slurm.

Recomenda-se monitorar o tempo de execução e ajustar os parâmetros do script de submissão para evitar interrupções inesperadas.

Exemplo de Submissão

Exemplo de Aplicação Python de Deep Learning

Abaixo está um exemplo básico de treinamento de uma rede neural usando PyTorch, otimizando o uso das GPUs disponíveis.

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Configuração
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
num_gpus = torch.cuda.device_count()
print(f"GPUs disponíveis: {num_gpus}")

# Definição de uma rede neural simples
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc = nn.Linear(28 * 28, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)
        return self.fc(x)

model = SimpleNN().to(device)
if num_gpus > 1:
    model = nn.DataParallel(model)

# Dados
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# Treinamento
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(3):
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item()}")

Ambiente de execução

Para que a exeucção possa ser bem sucedida, precisamos criar o ambiente chamado deep_learning_env. Para tal, usaremos as seguintes instruções:

Criar o Ambiente Conda

Ative o Miniconda:

module load miniconda

Crie um ambiente Conda chamado deep_learning_env com Python 3.9:

conda create --name deep_learning_env python=3.9 -y

Ative o ambiente criado:

source activate deep_learning_env

Instalar as Dependências

Instale o PyTorch com suporte a CUDA:

Exemplo de instalação para CUDA 11.8:

conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia

O retorno esperado deve ser True.

Exemplo Script de Submissão para o Gerenciador Slurm

Este é um exemplo de script para submissão de jobs à partição gpu. Nele são usadas 2 GPUs.

#!/bin/bash
#SBATCH --job-name=deep_learning_job
#SBATCH --partition=gpu
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --gres=gpu:2
#SBATCH --time=24:00:00
#SBATCH --mem=500G
#SBATCH --output=output_%j.log
#SBATCH --error=error_%j.log

module load miniconda

# Ativando o ambiente virtual
source activate deep_learning_env

# Executando o script Python
python deep_learning_example.py

Após o término do job, os arquivos output_%j.log e error_%j.log conterão as saídas padrão e erros, respectivamente. Também será criada a pasta data/ contendo arquivos de saída.