# 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:

conda 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.

#!/bin/bash
#SBATCH --job-name=deep_learning_job
#SBATCH --partition=gpu
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --gres=gpu:4
#SBATCH --time=24:00:00
#SBATCH --mem=1500G
#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.