DNABERT
1.0.0
Este repositório inclui a implementação de 'Dnabert: representações bidirecionais pré-treinadas do modelo Transformers para linguagem de DNA no genoma'. Cite nosso papel se você usar os modelos ou códigos. O repositório ainda está ativamente em desenvolvimento, por isso, por favor, relate gentilmente se houver algum problema encontrado.
Neste pacote, fornecemos recursos, incluindo: códigos de origem do modelo DNABERT, exemplos de uso, modelos pré-treinados, modelos de ajuste fino e ferramenta de visulização. Este pacote ainda está em desenvolvimento, pois mais recursos serão incluídos gradualmente. O treinamento do DNABERT consiste em ajuste fino pré-treinamento e específico para tarefas. Como contribuição do nosso projeto, lançamos os modelos pré-treinados neste repositório. Estendemos os códigos de Huggingface e os adaptamos ao cenário de DNA.
A segunda geração de Dnabert, chamada Dnabert-2, está publicamente disponível em https://github.com/zhihan1996/dnabert_2. O DNABERT-2 é treinado em genomas de várias espécies e é mais eficiente, poderoso e fácil de usar do que sua primeira geração. Também fornecemos um uso mais simples do DNABERT no novo pacote. Uma avaliação abrangente de entendimento do genoma de referência (Gue), que contém
Se você usou o DNABERT em sua pesquisa, cite as seguintes publicações a seguir:
@article{ji2021dnabert,
author = {Ji, Yanrong and Zhou, Zhihan and Liu, Han and Davuluri, Ramana V},
title = "{DNABERT: pre-trained Bidirectional Encoder Representations from Transformers model for DNA-language in genome}",
journal = {Bioinformatics},
volume = {37},
number = {15},
pages = {2112-2120},
year = {2021},
month = {02},
issn = {1367-4803},
doi = {10.1093/bioinformatics/btab083},
url = {https://doi.org/10.1093/bioinformatics/btab083},
eprint = {https://academic.oup.com/bioinformatics/article-pdf/37/15/2112/50578892/btab083.pdf},
}
@misc{zhou2023dnabert2,
title={DNABERT-2: Efficient Foundation Model and Benchmark For Multi-Species Genome},
author={Zhihan Zhou and Yanrong Ji and Weijian Li and Pratik Dutta and Ramana Davuluri and Han Liu},
year={2023},
eprint={2306.15006},
archivePrefix={arXiv},
primaryClass={q-bio.GN}
}
Recomendamos que você construa um ambiente virtual do Python com a Anaconda. Além disso, verifique se você possui pelo menos uma GPU da NVIDIA com Linux X86_64 Driver Version> = 410.48 (compatível com CUDA 10.0). Aplicamos treinamento distribuído no 8 Nvidia GeForce RTX 2080 Ti com memória gráfica de 11 GB, e o tamanho do lote corresponde a ele. Se você usar a GPU com outras especificações e tamanhos de memória, considere ajustar o tamanho do seu lote de acordo.
conda create -n dnabert python=3.6
conda activate dnabert
(Obrigatório)
conda install pytorch torchvision cudatoolkit=10.0 -c pytorch
git clone https://github.com/jerryji1993/DNABERT
cd DNABERT
python3 -m pip install --editable .
cd examples
python3 -m pip install -r requirements.txt
(Opcional, instale o APEX para treinamento FP16)
Mudar para um diretório desejado por cd PATH_NAME
git clone https://github.com/NVIDIA/apex
cd apex
pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./
Consulte os dados do modelo em /example/sample_data/pre . Se você estiver tentando pré-treinar o DNABERT com seus próprios dados, processe os dados no mesmo formato que ele. Observe que as seqüências estão no formato KMER, portanto, você precisará converter suas seqüências nisso. Também fornecemos uma função personalizada seq2kmer em motif/motif_utils.py para esta conversão.
No exemplo a seguir, usamos o dnabert com kmer = 6 como exemplo.
cd examples
export KMER=6
export TRAIN_FILE=sample_data/pre/6_3k.txt
export TEST_FILE=sample_data/pre/6_3k.txt
export SOURCE=PATH_TO_DNABERT_REPO
export OUTPUT_PATH=output$KMER
python run_pretrain.py
--output_dir $OUTPUT_PATH
--model_type=dna
--tokenizer_name=dna$KMER
--config_name=$SOURCE/src/transformers/dnabert-config/bert-config-$KMER/config.json
--do_train
--train_data_file=$TRAIN_FILE
--do_eval
--eval_data_file=$TEST_FILE
--mlm
--gradient_accumulation_steps 25
--per_gpu_train_batch_size 10
--per_gpu_eval_batch_size 6
--save_steps 500
--save_total_limit 20
--max_steps 200000
--evaluate_during_training
--logging_steps 500
--line_by_line
--learning_rate 4e-4
--block_size 512
--adam_epsilon 1e-6
--weight_decay 0.01
--beta1 0.9
--beta2 0.98
--mlm_probability 0.025
--warmup_steps 10000
--overwrite_output_dir
--n_process 24
Adicione -tag - -fp16 se você quiser obter precisão mista. (Você precisa instalar o 'Apex' da fonte primeiro).
Consulte os dados do modelo em /example/sample_data/ft/ . Se você estiver tentando ajustar o DNABERT com seus próprios dados, processe os dados no mesmo formato que ele. Observe que as seqüências estão no formato KMER, portanto, você precisará converter suas seqüências nisso. Também fornecemos uma função personalizada seq2kmer em motif/motif_utils.py para esta conversão.
Dnabert3
Dnabert4
Dnabert5
Dnabert6
Faça o download do modelo pré-treinado em um diretório. (Se você deseja replicar os seguintes exemplos, faça o download do DNABERT 6). Em seguida, descompacte o pacote executando:
unzip 6-new-12w-0.zip
Também fornecemos um modelo com KMER=6 que é ajustado no conjunto de dados de amostra para previsão/visulização/motiv_análise. Se você usar o modelo ajustado em vez de ajustar um modelo por si mesmo, faça o download do tune fino e coloque-o em examples/ft/6 .
Modelo ajustado
No exemplo a seguir, usamos o dnabert com kmer = 6 como exemplo. Usamos prom-core , uma tarefa de classificação de 2 classes como exemplo.
cd examples
export KMER=6
export MODEL_PATH=PATH_TO_THE_PRETRAINED_MODEL
export DATA_PATH=sample_data/ft/$KMER
export OUTPUT_PATH=./ft/$KMER
python run_finetune.py
--model_type dna
--tokenizer_name=dna$KMER
--model_name_or_path $MODEL_PATH
--task_name dnaprom
--do_train
--do_eval
--data_dir $DATA_PATH
--max_seq_length 100
--per_gpu_eval_batch_size=32
--per_gpu_train_batch_size=32
--learning_rate 2e-4
--num_train_epochs 5.0
--output_dir $OUTPUT_PATH
--evaluate_during_training
--logging_steps 100
--save_steps 4000
--warmup_percent 0.1
--hidden_dropout_prob 0.1
--overwrite_output
--weight_decay 0.01
--n_process 8
Adicione -tag - -fp16 se você quiser obter precisão mista. (Você precisa instalar o 'Apex' da fonte primeiro).
Também fornecemos um modelo com KMER=6 que é ajustado no conjunto de dados de amostra para previsão/visulização/motiv_análise. Se você usar o modelo ajustado em vez de ajustar um modelo por si mesmo, faça o download do tune fino e coloque-o em examples/ft/6 .
Modelo ajustado
Depois que o modelo é ajustado, podemos obter previsões executando
export KMER=6
export MODEL_PATH=./ft/$KMER
export DATA_PATH=sample_data/ft/$KMER
export PREDICTION_PATH=./result/$KMER
python run_finetune.py
--model_type dna
--tokenizer_name=dna$KMER
--model_name_or_path $MODEL_PATH
--task_name dnaprom
--do_predict
--data_dir $DATA_PATH
--max_seq_length 75
--per_gpu_pred_batch_size=128
--output_dir $MODEL_PATH
--predict_dir $PREDICTION_PATH
--n_process 48
Com o comando acima, o modelo DNABERT ajustado fino será carregado do MODEL_PATH e fará previsão no arquivo dev.tsv que salva em DATA_PATH e salvar o resultado da previsão em PREDICTION_PATH .
Adicione -tag - -fp16 se você quiser obter precisão mista. (Você precisa instalar o 'Apex' da fonte primeiro).
A Visualiazation of Dnabert consiste em 2 etapas. Calcular pontuações de atenção e plotagem.
Calcule com apenas um modelo (por exemplo, dnabert6)
export KMER=6
export MODEL_PATH=./ft/$KMER
export DATA_PATH=sample_data/ft/$KMER
export PREDICTION_PATH=./result/$KMER
python run_finetune.py
--model_type dna
--tokenizer_name=dna$KMER
--model_name_or_path $MODEL_PATH
--task_name dnaprom
--do_visualize
--visualize_data_dir $DATA_PATH
--visualize_models $KMER
--data_dir $DATA_PATH
--max_seq_length 81
--per_gpu_pred_batch_size=16
--output_dir $MODEL_PATH
--predict_dir $PREDICTION_PATH
--n_process 96
Com o comando acima, o modelo DNABERT ajustado fino será carregado do MODEL_PATH e calcula as pontuações de atenção no arquivo dev.tsv que salvou em DATA_PATH e salvar o resultado em PREDICTION_PATH .
Adicione -tag - -fp16 se você quiser obter precisão mista. (Você precisa instalar o 'Apex' da fonte primeiro).
Ferramenta de plotagem 5.2 5.2
Depois que as pontuações de atenção forem geradas, podemos prosseguir para realizar análises de motivos usando motif/find_motifs.py :
cd ../motif
export KMER=6
export DATA_PATH=../examples/sample_data/ft/$KMER
export PREDICTION_PATH=../examples/result/$KMER
export MOTIF_PATH=./result/$KMER
python find_motifs.py
--data_dir $DATA_PATH
--predict_dir $PREDICTION_PATH
--window_size 24
--min_len 5
--pval_cutoff 0.005
--min_n_motif 3
--align_all_ties
--save_file_dir $MOTIF_PATH
--verbose
O script gerará um arquivo .txt e um arquivo weblogo .png para cada motivo sob MOTIF_PATH .
Para realizar análises de variantes genômicas (por exemplo, SNPs), precisamos primeiro garantir que as previsões das seqüências foram geradas. Em seguida, crie um arquivo (modelo em SNP/example_mut_file.txt ) especificando para quais sequências no dev.tsv e índices iniciais e finais, onde precisamos executar a mutação. A primeira coluna indica o índice de sequência no dev.tsv a ser mutado. Segunda e terceira colunas são os índices de início e final, enquanto a quarta coluna é o alvo da mutação (pode ser substituição, inserção, exclusão etc.)
Depois que esse arquivo é criado, podemos realizar mutação nas seqüências:
cd ../SNP
python mutate_seqs.py ./../examples/sample_data/ft/6/dev.tsv ./examples/ --mut_file ./example_mut_file.txt --k 6
Como alternativa, podemos optar por deixar o argumento --mut_file em branco, onde o programa tentaria realizar a substituição de todas as bases pelos quatro nucleotídeos possíveis ('a', 't', 'c' ou 'g') para todas as seqüências. Isso seria útil para plotar um mapa de calor de mutação, conforme incluído no papel. Observe que isso seria lento se o dev.tsv contiver muitas sequências ou as seqüências de entrada forem muito longas, pois o comando tentaria realizar mutação em todos os locais possíveis deles .
cd ../SNP
python mutate_seqs.py ./../examples/sample_data/ft/6/dev.tsv ./examples/ --k 6
Depois disso, podemos prever novamente as seqüências geradas. Nota: Se você tiver inserção/exclusões em seu mut_file.txt , considere alterar o max_seq_length que usamos ao fazer previsões.
export KMER=6
export MODEL_PATH=../examples/ft/$KMER
export DATA_PATH=examples
export PREDICTION_PATH=examples
python ../examples/run_finetune.py
--model_type dna
--tokenizer_name=dna$KMER
--model_name_or_path $MODEL_PATH
--task_name dnaprom
--do_predict
--data_dir $DATA_PATH
--max_seq_length 75
--per_gpu_pred_batch_size=128
--output_dir $MODEL_PATH
--predict_dir $PREDICTION_PATH
--n_process 48
Isso criará novamente o arquivo pred_results.npy no $PREDICTION_PATH . Depois de termos tudo o exposto, podemos calcular o efeito dessas mutações por:
python SNP.py
--orig_seq_file ../examples/sample_data/ft/6/dev.tsv
--orig_pred_file ../examples/result/6/pred_results.npy
--mut_seq_file examples/dev.tsv
--mut_pred_file examples/pred_results.npy
--save_file_dir examples
Isso salvaria dev.tsv arquivo mutations.tsv save_file_dir
Por favor, certifique -se de que você atendeu a todos os requisitos do sistema para o DNABERT e que tenha um ambiente do CONDA configurado corretamente. Recentemente, testamos com sucesso nosso pipeline no Amazon EC2 Deep Learning AMI (Ubuntu 18.04). Como opção, você pode comparar sua configuração de sistema/ambiente com este AMI.
