Como gerar DeepVariant

O DeepVariant é um canal de análise que usa uma rede neural profunda para chamar variantes genéticas de dados de sequenciamento de DNA de última geração.

Esta página explica como executar o DeepVariant no Google Cloud usando uma única instância do Compute Engine.

Existem configurações mais complexas disponíveis no repositório DeepVariant do GitHub. Por exemplo, é possível executar o DeepVariant usando várias instâncias. Essas variações proporcionam melhorias na velocidade de processamento e na redução de custos.

A execução do DeepVariant consiste em três estágios:

  1. Criar exemplos: o DeepVariant pré-processa os dados de entrada e salva exemplos dos dados usando um formato interno do TensorFlow. É possível executar esse estágio paralelamente, onde os fragmentos de entrada são processados de forma independente.

  2. Variantes de chamada: o DeepVariant executa uma rede neural profunda que faz inferências a partir dos exemplos e as salva em arquivos compartilhados usando um formato interno do TensorFlow.

  3. Variantes de pós-processamento: o DeepVariant converte variantes do formato interno do TensorFlow em arquivos VCF ou gVCF. Essa etapa é executada em uma única linha de execução.

Neste tutorial, você executará esses estágios usando uma única instância. O primeiro e o segundo estágios se beneficiam do carregamento em paralelo de vários núcleos. O terceiro estágio não tem os mesmos benefícios porque é executado em uma única linha de execução.

Objetivos

Depois de concluir este tutorial, você saberá como:

  • Executar o DeepVariant no Google Cloud

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

  • Compute Engine

Gere uma estimativa de custo com base no uso previsto usando a calculadora de preços. Usuários novos do Cloud Platform podem ter direito a uma avaliação gratuita.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative a API Compute Engine.

    Ative a API

  5. Instale e inicialize o SDK do Cloud..
  6. Dica: precisa de um prompt de comando? É possível usar o Cloud Shell. O Cloud Shell é um ambiente de linha de comando que já inclui o SDK do Cloud. Dessa maneira, você não precisa instalá-lo.

Como criar uma instância do Compute Engine

É necessário criar uma instância do Compute Engine para executar o DeepVariant. É possível criar a instância usando o Console do Google Cloud ou a ferramenta gcloud.

Console

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página Instâncias de VM

  2. Clique em Criar instância.
  3. Escolha um Nome para a instância no formato PROJECT_ID-deepvariant-run onde PROJECT_ID é o ID do seu projeto do Google Cloud.
  4. Escolha uma região e zona para a instância. A menos que você tenha um motivo específico para executar a instância em um determinado local, selecione us-central1 (Iowa) para a Região e us-central1-a para a Zona.
  5. No menu tipo de máquina, selecione n1-standard-64 (64 vCPU, 240 GB de memória).
  6. No menu da plataforma de CPU, selecione Intel Skylake ou posterior.
  7. Na seção Disco de inicialização, clique em Alterar para configurar o disco de inicialização.
  8. Na guia imagens do sistema operacional, escolha Google Drawfork Ubuntu 16.04 LTS. No menu Tipo de disco de inicialização, selecione Disco permanente padrão. No campo Tamanho (GB), insira 300. Clique em Selecionar.
  9. Clique em Criar para criar a instância.

gcloud

gcloud compute instances create \
    PROJECT_ID-deepvariant-run \
    --project PROJECT_ID \
    --zone ZONE \
    --scopes "cloud-platform" \
    --image-project ubuntu-os-cloud \
    --image-family ubuntu-1604-lts \
    --machine-type n1-standard-64 \
    --min-cpu-platform "Intel Skylake" \
    --boot-disk-size=300GB

onde:

  • PROJECT_ID é o ID do seu projeto do Google Cloud;
  • ZONE é a zona em que a instância é implantada. Uma zona é um local regional aproximado em que a instância e os recursos estão ativos. Por exemplo, us-west1-a é uma zona na região us-west. Se você definiu uma zona padrão anteriormente usando gcloud config set compute/zone, o valor dessa sinalização substitui esse padrão.

Aguarde até que a instância seja inicializada. Quando estiver pronto, ele será listado na página Instâncias de VM com um ícone de status verde.

Como se conectar à instância

É possível se conectar à instância usando o Console do Cloud ou a ferramenta gcloud:

Console

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar a página Instâncias de VM

  2. Na lista de instâncias de máquina virtual, clique em SSH na linha da instância que você criou.

gcloud

gcloud compute ssh PROJECT_ID-deepvariant-run --zone ZONE

Como gerar DeepVariant

Configure seu ambiente e execute o DeepVariant concluindo as seguintes etapas na instância do Compute Engine que você criou:

  1. Instale o Docker Community Edition (CE) executando os seguintes comandos:

    sudo apt-get -qq -y install \
      apt-transport-https \
      ca-certificates \
      curl \
      gnupg-agent \
      software-properties-common
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
    sudo add-apt-repository \
      "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
      $(lsb_release -cs) \
      stable"
    sudo apt-get -qq -y update
    sudo apt-get -qq -y install docker-ce
    
  2. Configure as variáveis de ambiente do DeepVariant copiando e colando os seguintes comandos:

    BIN_VERSION="1.1.0"
    BASE="${HOME}/deepvariant-run"
    INPUT_DIR="${BASE}/input"
    REF="GRCh38_no_alt_analysis_set.fasta"
    BAM="HG003.novaseq.pcr-free.35x.dedup.grch38_no_alt.chr20.bam"
    OUTPUT_DIR="${BASE}/output"
    DATA_DIR="${INPUT_DIR}/data"
    OUTPUT_VCF="HG003.output.vcf.gz"
    OUTPUT_GVCF="HG003.output.g.vcf.gz"
    
  3. Crie a estrutura de diretório local para o diretório de dados de entrada e o diretório de saída:

    mkdir -p "${OUTPUT_DIR}"
    mkdir -p "${INPUT_DIR}"
    mkdir -p "${DATA_DIR}"
    
  4. Este tutorial usa um genoma HG003 disponível publicamente com uma cobertura de 30x mapeada para a referência GRCh38. No entanto, para garantir um ambiente de execução mais rápido, você precisa adicionar a sinalização --regions chr20 ao executar o DeepVariant para que o DeepVariant seja executado somente no cromossomo 20 (chr20).

    Os dados de amostra foram criados usando o sequenciamento Illumina, mas o DeepVariant também é compatível com estes tipos de dados de entrada:

    • Whole genome (Illumina) (WGS)
    • Exome (Illumina) (WES)
    • Whole genome (PacBio)
    • Todo o genoma PacBio e Illumina híbrido (HYBRID_PACBIO_ILLUMINA)

    Copie os dados de teste de entrada do bucket do Cloud Storage deepvariant para os diretórios na instância que você criou. É possível copiar os dados executando o comando gsutil cp:

    # Input BAM and BAI files:
    gsutil cp gs://deepvariant/case-study-testdata/"${BAM}" "${DATA_DIR}"
    gsutil cp gs://deepvariant/case-study-testdata/"${BAM}".bai "${DATA_DIR}"
    
    # GRCh38 reference FASTA file:
    FTPDIR=ftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCA/000/001/405/GCA_000001405.15_GRCh38/seqs_for_alignment_pipelines.ucsc_ids
    curl ${FTPDIR}/GCA_000001405.15_GRCh38_no_alt_analysis_set.fna.gz | gunzip > "${DATA_DIR}/${REF}"
    curl ${FTPDIR}/GCA_000001405.15_GRCh38_no_alt_analysis_set.fna.fai > "${DATA_DIR}/${REF}".fai
    
  5. O DeepVariant é um aplicativo em contêiner preparado em uma imagem do Docker pré-criada no Container Registry. Para receber a imagem, execute o seguinte comando:

    sudo docker pull gcr.io/deepvariant-docker/deepvariant:"${BIN_VERSION}"
    
  6. Para iniciar o DeepVariant, execute o seguinte comando:

    sudo docker run \
        -v "${DATA_DIR}":"/input" \
        -v "${OUTPUT_DIR}:/output" \
        gcr.io/deepvariant-docker/deepvariant:"${BIN_VERSION}"  \
        /opt/deepvariant/bin/run_deepvariant \
        --model_type=WGS \
        --ref="/input/${REF}" \
        --reads="/input/${BAM}" \
        --output_vcf=/output/${OUTPUT_VCF} \
        --output_gvcf=/output/${OUTPUT_GVCF} \
        --regions chr20 \
        --num_shards=$(nproc) \
        --intermediate_results_dir /output/intermediate_results_dir
    

    A tabela a seguir descreve as sinalizações passadas para o comando:

    Sinalização Descrição
    model_type O DeepVariant é compatível com vários tipos diferentes de dados de entrada. Neste tutorial usamos o sequenciamento completo do genoma (Whole Genome Sequencing, WSG, em inglês).
    ref O local do arquivo de referência FASTA.
    reads O local do arquivo BAM de entrada.
    output_vcf O local dos arquivos VCF de saída.
    output_gvcf O local dos arquivos gVCF de saída.
    regions (Opcional) Uma lista separada por espaços de regiões de cromossomo a serem processadas. Elementos individuais podem ser literais de região, como chr20:10-20 ou caminhos para arquivos BED/BEDPE.
    num_shards O número de fragmentos a serem executados em paralelo. Para resultados melhores, defina o valor dessa sinalização com o número de núcleos na máquina em que o DeepVariant é executado.
    intermediate_results_dir Sinalização opcional que especifica o diretório das saídas intermediárias dos estágios make_examples e call_variants. Após a conclusão do comando, os arquivos serão salvos no diretório local nos seguintes formatos:
    call_variants_output.tfrecord.gz
    gvcf.tfrecord-SHARD_NUMBER-of-NUM_OF_SHARDS.gz
    make_examples.tfrecord-SHARD_NUMBER-of-NUM_OF_SHARDS.gz
    

    Se o comando começar a executar corretamente, ele emitirá uma mensagem que começa com o seguinte:

    ***** Running the command:*****
    time seq 0 63 | parallel
    -k
    --line-buffer /opt/deepvariant/bin/make_examples
    --mode calling
    --ref "/input/GRCh38_no_alt_analysis_set.fasta"
    --reads "/input/HG003.novaseq.pcr-free.35x.dedup.grch38_no_alt.chr20.bam"
    --examples "/output/intermediate_results_dir/make_examples.tfrecord@64.gz"
    --regions "chr20"
    --gvcf "/output/intermediate_results_dir/gvcf.tfrecord@64.gz"
    --task {}
    
  7. Depois que DeepVariant terminar, ele gera os seguintes arquivos para o diretório deepvariant-run/output:

    • HG003.output.g.vcf.gz
    • HG003.output.g.vcf.gz.tbi
    • HG003.output.vcf.gz
    • HG003.output.vcf.gz.tbi
    • HG003.output.visual_report.html

    Execute este comando para listar os arquivos no diretório de saída e verificar se todos os arquivos de saída são exibidos:

    ls $OUTPUT_DIR
    

Estimativas de custo e ambiente de execução

A tabela a seguir mostra o ambiente de execução e os custos aproximados para executar o DeepVariant usando uma amostra de 30x do genoma inteiro em um arquivo BAM. Essas estimativas não incluem o tempo necessário para configurar a instância e fazer o download de dados de amostra do Cloud Storage.

A tabela contém estimativas para VMs preemptivas e VMs não preemptivas. As estimativas do ambiente de execução são baseadas no uso de VMs não preemptivas.

As VMs preemptivas são até 80% mais baratas do que as VMs comuns. No entanto, se o Compute Engine exigir acesso a esses recursos para outras tarefas, ele poderá encerrar (interromper) essas instâncias. As VMs preemptivas não são cobertas por nenhum contrato de nível de serviço (SLA, na sigla em inglês). Portanto, se você precisar de garantias sobre o tempo de resposta, não use a sinalização --preemptible.

Consulte as práticas recomendadas do Compute Engine para saber como usar as VMs preemptivas de maneira eficaz.

Tipo de máquina Ambiente de execução em horas Custo (não preemptiva) Custo (preemptiva)
n1-standard-8 27,6 US$ 11,3 US$ 3,04
n1-standard-16 15,4 US$ 12,1 US$ 2,92
n1-standard-32 9,47 US$ 14,7 US$ 3,32
n1-standard-64 6.8 US$ 20.9 US$ 4,55
n1-standard-96 5,58 US$ 25,6 US$ 5,53

Limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud, siga estas etapas:

Após concluir este tutorial sobre como executar o DeepVariant, é possível limpar os recursos que você criou no Google Cloud para que não sejam faturados no futuro. Nas seções a seguir, você aprenderá a excluir e desativar esses recursos.

Excluir o projeto

A maneira mais fácil de evitar a cobrança é excluir o projeto usado no tutorial.

Para excluir o projeto, faça o seguinte:

  1. No Console do Cloud, acesse a página "Projetos".

    Acessar a página "Projetos"

  2. Na lista de projetos, selecione o que você quer excluir e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir