Encaixe de GPU compatível com Autodock‑GPU/VINA em grande escala

O encaixe é um trabalho de produtividade. As GPUs fazem sentido quando você prepara entradas limpas e executa muitas réplicas em paralelo. Este guia mostra como executar o encaixe de GPU, agrupar milhares de ligantes e rastrear custo por 10k ligantes.

O que abordaremos

• Escolhendo um Modelo pronto para CUDA em seu locatário de GPU e trazendo os binários de encaixe
• Mínimo preparação de receptor/ligante que não desmorona no meio da corrida
• UM lançador de lotes que preenche a GPU sem ser babá
• UM autoavaliação matemática de aproveite e custe que você pode copiar
• VRAM, E/S de arquivos e armadilhas de erros comuns

Start in seconds with the fastest, most affordable cloud GPU clusters.

Launch an instance in under a minute. Enjoy flexible pricing, powerful hardware, and 24/7 support. Scale as you grow—no long-term commitment needed.

Try Compute now

1) Escolha sua imagem

Na maioria dos locatários de GPU, seu trabalho funciona dentro de uma imagem. Dois caminhos que funcionam bem:

A) Use um modelo CUDA e ferramentas de encaixe de montagem (simples)

• Modelo: Ubuntu 24.04 LTS (CUDA 12.6)
• Instale ou monte binários de GPU compatíveis com Autodock‑GPU/VINA no contêiner em tempo de execução (mantenha-os fora da imagem).

B) Traga sua própria imagem (mais rápida de reutilizar)

• Crie uma imagem privada que contenha suas ferramentas de encaixe e a pilha Python para preparação.
• Adicione variáveis de ambiente:
  • NVIDIA_VISIBLE_DEVICES=Todos
  • nvidia_driver_capabilities=Computação, utilitário
• O script de entrada imprime versões, cria /trabalhoe espera (ou inicia o lote).

Você faz não precisa do Docker‑in‑Docker em geral, pois seu provedor passa o driver do host para seu contêiner.

2) Preparação mínima de entrada que é reproduzível

Layout do diretório

/trabalho
─ receptor/
│ ─ proteína.pdbqt
│ ─ grid/ # mapas e configuração
── ligantes/
│ ─ L000001.pdbQt
│ ─ L000002.pdbQt
│ ─...
── postos de trabalhos/
─ (saídas aqui)


Receptor

• Prepare-se uma vez com seu pipeline padrão. Salvar PDBQT e arquivos de caixa de grade/configuração usados por sua ferramenta de encaixe.
• Mantenha um README com centro/tamanho e qualquer opção de protonação.

Ligantes

• Converter em PDBQT em uma etapa de preparação separada (SMILES/SDF → PDBQT). Mantenha um determinista script que define protonação, tautômeros e cargas da mesma forma todas as vezes.
• Valide encaixando um painel minúsculo primeiro (10—20 ligantes) e revisando poses/pontuações.

3) Lançador de lotes (GPU única)

Esse esqueleto executa ligantes em pequenos pedaços, mantém a GPU alimentada e grava registros que você pode analisar posteriormente. Substitua o DOCK_CMD com a chamada exata da sua ferramenta (Autodock‑GPU, Vina‑GPU, Uni‑Dock etc.).

#! /usr/bin/env bash
set -euo pipefail
LIG_DIR=$ {1: -ligantes}
OUT_DIR=$ {2: -jobs}
N_PAR=$ {3: -8} # processos simultâneos por GPU (ajuste)
mkdir -p “$OUT_DIR”

# Edite isso em seu comando de encaixe. Exemplos de espaços reservados:
# autodock_gpu --receptor rígido/proteína. pdbqt --ffile receptor/grid/maps.fld\
<ligand.pdbqt># --lfile --center_x... --centro_y... --centro_z... --tamanho_x... --tamanho_y... --tamanho_z... \
<out.pdbqt># --exhaustivity 8 --out --log <out.log>

DOCK_CMD () {:;}

exportação -f DOCK_CMD
ls “$LIG_DIR” /*.pdbqt | awk '{print NR, $0}' | enquanto lia idx lig; faça
base=$ (nome base “$lig” .pdbqt)
out="$out_dir/$base”
mkdir -p “$out”
(
DOCK_CMD “$lig” “$out” >"$out/run.log” 2>&1 || echo “FAIL $base” >> “$OUT_DIR/failures.txt”
) &
# acelerador simples
if (($ (jobs -rp | wc -l) >= N_PAR)); então espere -n; fi

concluído
esperar

echo “Feito. Saídas em $OUT_DIR/”


Ajustando N_PAR

• Comece com 4—8 processa por GPU e, em seguida, aumente até que a utilização fique em torno de ~ 90% sem prejudicar a VRAM.
• Relógio nvidia-smi para memória e utilização.

4) Escalabilidade horizontal de várias GPUs

Se sua instância tiver Sem GPUs, inicie um lote por GPU e fixe cada grupo de processos:

# GPU 0
CUDA_VISIBLE_DEVICES=0 bash dock_batch.sh ligantes jobs/gpu0 8 &
# GPU 1
CUDA_VISIBLE_DEVICES=1 bash dock_batch.sh ligantes jobs/gpu1 8 &
esperar


Mantenha as saídas separadas por GPU para facilitar a auditoria.

5) Autoavaliação e matemática de custos

Registre somente o que importa:

entradas: N_ligantes, receptor, grade (centro/tamanho), exaustividade/semente
hardware: modelo de GPU/VRAM, CUDA, driver
código: versão da ferramenta de encaixe + sinalizadores
métricas: ligantes/hora, falhas, wall_hours


Custo por 10k ligantes

custo_por_10k = preço_por_hora × horas_parede × (10_000/ N_ligantes)


Relatório ligantes/hora e custo por 10k por GPU. Mantenha a linha de comando completa em seus Métodos.

6) Botões práticos que movem a taxa de transferência

• Exaustividade//etapas de pesquisa: maior alavanca. Encontre a configuração mais baixa que passa na verificação de enriquecimento antecipado.
• Tamanho do lote (N_PAR): aumente até que a VRAM ou as opções de contexto o impeçam. Moléculas pequenas → N_PAR mais alto.
• I/O: escreva somente o que você precisa. Evite registros falantes por propósito ao examinar milhões.
• Sementes: corrija as sementes para comparabilidade entre as corridas; randomize para a tela final, se preferir.

7) Solução de problemas

SALA DE GPU
Diminua o N_PAR, reduza a exaustividade ou mude para uma GPU de VRAM maior.

Todos os trabalhos falham rapidamente
Grade incorreta ou sinalizadores incompatíveis. Execute novamente um único ligante com registro detalhado e compare com uma execução de CPU em boas condições.

Pontuações ou poses estranhas
Diferenças de preparação de entrada (protonação/tautômeros/cargas). Normalize sua preparação e teste em um pequeno conjunto selecionado.

GPU ociosa
N_PAR muito baixo ou a ferramenta tem longos estágios de pré/pós-processamento da CPU. Paralelize as grades de preparação ou pré-estágio.

Trecho de métodos (copiar e colar)

hardware:
gpu: "<model>(<VRAM>GB)”
motorista: "<NVIDIA driver>”
<CUDA version>cuda: "”
software:
imagem: "<your docking image or CUDA template>”
<ver><ver>ferramenta: “Autodock-GPU | Vina-GPU <ver>| Uni-Dock”
entradas:
receptor: “protein.pdbqt”
grade: {center: [<x>,<y>,<z>], tamanho: [<sx>,<sy>,<sz>]}
<path>ligantes: “N=<... > de”
executar:
lote:
script: "dock_batch.sh”
N_PAR: <int>
<exhaustiveness, seed, etc.>bandeiras: “”
saídas:
ligantes_por_hora: “<... >”
wall_hours: “<... >”
custo_por_10k: “<... >”
falhas: "<count>(<file path>)”


Leitura relacionada

• Modelagem científica em GPUs em nuvem — o que funciona e o que não funciona

Experimente o Compute hoje

Inicie uma instância de GPU com um modelo pronto para CUDA (por exemplo, Ubuntu 24.04 LTS/CUDA 12.6) ou sua própria imagem GROMACS. Aproveite o faturamento flexível por segundo com modelos personalizados e a capacidade de iniciar, interromper e retomar suas sessões a qualquer momento. Não tem certeza sobre os requisitos do FP64? Entre em contato com o suporte para ajudá-lo a selecionar o perfil de hardware ideal para suas necessidades computacionais.

‍