JupyterLab GPU + CUDA em 1 Clique

Colab Pro está caro, instável e às vezes bloqueia conta. Kaggle limita 30h/semana. Configurar CUDA + PyTorch + drivers em sua própria GPU dá uma tarde fácil de trabalho. JupyterLab no GPUBrasil resolve em 90 segundos: notebook pronto com CUDA, PyTorch, TensorFlow, JAX e tudo o que você precisa para ML/IA.

O que está incluído

• JupyterLab 4.x com extensões: Git, Variable Explorer, code formatter
• CUDA 12.4 + cuDNN drivers configurados
• PyTorch 2.5 + torchvision + torchaudio
• TensorFlow 2.18 com GPU
• JAX com CUDA
• Transformers, Datasets, Accelerate, PEFT (HuggingFace)
• xformers + bitsandbytes para fine-tuning eficiente
• scikit-learn, pandas, numpy, polars
• matplotlib, plotly, seaborn
• Volume persistente em /workspace
• Acesso SSH opcional para devs avançados

Casos de uso brasileiros

• Pesquisa acadêmica: universidades brasileiras sem cluster próprio
• Data scientists: análise exploratória com GPU acelerando
• Fine-tuning LLM: Mistral, Llama, Qwen com LoRA/QLoRA
• Treino de visão: YOLO, detecção, segmentação
• NLP em PT-BR: embeddings, classificação, NER
• Aulas e workshops: ambiente unificado para alunos
• Kaggle local: sem limite de horas semanais
• Reprodutibilidade: snapshot do ambiente para papers

Hardware recomendado

• RTX A4000 (16GB): entrada — modelos até 7B com QLoRA
• RTX 4090 (24GB): sweet spot — 13B fine-tune, vision pesada
• L40S / A6000 (48GB): 30B+ models, ressearch sério
• H100 (80GB): top tier — 70B fine-tune e treino do zero

Deploy em 1 clique

Passo 1: Iniciar template

1. Console → Templates → 📓 Notebooks & Dev
2. Selecione JupyterLab GPU
3. Escolha GPU conforme seu projeto
4. Clique em Iniciar

O template usa imagem CUDA + Jupyter pré-configurada, expõe Jupyter na porta 8888 com token gerado e mostra a URL no console assim que estiver pronto.

Passo 2: Verificar GPU

import torch

print("CUDA disponível:", torch.cuda.is_available())
print("Device:", torch.cuda.get_device_name(0))
print("VRAM total:", f"{torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# Teste rápido
x = torch.randn(10000, 10000, device="cuda")
y = x @ x.T
print("Matmul OK:", y.shape)

Passo 3: Fine-tune Llama 3 com QLoRA

from transformers import (
    AutoTokenizer, AutoModelForCausalLM,
    TrainingArguments, BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer
from datasets import load_dataset

model_id = "meta-llama/Meta-Llama-3.1-8B-Instruct"

# Quantização 4-bit
bnb = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id, quantization_config=bnb, device_map="auto"
)

# LoRA
lora = LoraConfig(
    r=16, lora_alpha=32,
    target_modules=["q_proj","k_proj","v_proj","o_proj"],
    bias="none", task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora)

# Dataset
ds = load_dataset("seu-user/dataset-br", split="train")

trainer = SFTTrainer(
    model=model,
    train_dataset=ds,
    tokenizer=tok,
    args=TrainingArguments(
        output_dir="/workspace/llama-br",
        num_train_epochs=3,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        bf16=True,
        save_steps=100
    )
)
trainer.train()
trainer.save_model("/workspace/llama-br-final")

Passo 4: Conectar com seu Qdrant/vLLM

from qdrant_client import QdrantClient
from openai import OpenAI

# Qdrant brasileiro
qdrant = QdrantClient("https://qdrant.gpubrasil.com.br", port=443, https=True)

# vLLM brasileiro como cliente OpenAI
llm = OpenAI(
    base_url="https://vllm.gpubrasil.com.br/v1",
    api_key="dummy"
)

resp = llm.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role":"user","content":"Resumo da B3 hoje?"}]
)
print(resp.choices[0].message.content)

Passo 5: Acesso SSH (opcional)

Para devs que preferem VS Code Remote ou terminal puro:

# No console do GPUBrasil → Instâncias → Detalhes → SSH
ssh -i ~/.ssh/sua-key.pem ubuntu@<ip-instancia>
# Ou abra direto no VS Code com Remote-SSH

Persistência e backup

Tudo em /workspace é volume persistente — sobrevive a stop/start. Para backup:

# Snapshot via console GPUBrasil (1 clique)
# Ou via rsync para S3 brasileiro
rsync -avz /workspace/ s3://meu-bucket-br/jupyter-backup/

Dicas de produtividade

• nvidia-smi watch: watch -n 1 nvidia-smi em terminal
• JupyterLab Git: commit notebooks direto da UI
• nbdime: diff de notebooks decentes
• papermill: rode notebook como script com parâmetros
• tensorboard: visualize treino em tempo real
• Multi-kernel: Python 3.11 + R + Julia se precisar

JupyterLab vs alternativas

• vs Colab Pro: sem desconexão, sem limite de quota, GPU melhor
• vs Kaggle: sem 30h/semana, sem dataset upload limitado
• vs SageMaker Studio: sem complexidade AWS, custo previsível
• vs Paperspace Gradient: dados no Brasil, suporte em PT
• vs setup local: sem brigar com drivers/CUDA por horas

Conclusão

JupyterLab no GPUBrasil é a forma mais rápida de ter um ambiente ML/IA profissional em GPU brasileira. Sem desconexões do Colab, sem cota do Kaggle, sem ódio configurando CUDA. Pague pelo tempo de uso e foque no código que importa.

Combine com: vLLM · Qdrant