# Evolla ## Visão geral The Evolla model was proposed in [Decoding the Molecular Language of Proteins with Evolla](https://doi.org/10.1101/2025.01.05.630192) by [Zhou et al.](https://doi.org/10.1101/2025.01.05.630192). Evolla é um modelo generativo avançado de linguagem proteica com 80 bilhões de parâmetros, projetado para decodificar a linguagem molecular das proteínas. Ele integra informações de sequências, estruturas e consultas do usuário para gerar insights precisos e contextualmente matizados sobre a função proteica. Treinado em um conjunto de dados gerado por IA sem precedentes, composto por 546 milhões de pares de perguntas e respostas sobre proteínas e 150 bilhões de tokens de palavras, o Evolla avança significativamente a pesquisa em proteômica e genômica funcional, fornecendo insights de nível especialista e esclarecendo a lógica molecular codificada nas proteínas. O resumo do artigo é o seguinte: *As proteínas, as intrincadas máquinas moleculares da natureza, são o resultado de bilhões de anos de evolução e desempenham papéis fundamentais na sustentação da vida. No entanto, decifrar sua linguagem molecular — ou seja, compreender como as sequências e estruturas proteicas codificam e determinam as funções biológicas — continua sendo um desafio central na biologia moderna. Aqui, apresentamos o Evolla, um modelo generativo de linguagem proteica de fronteira com 80 bilhões de parâmetros, projetado para decodificar a linguagem molecular das proteínas. Ao integrar informações de sequências, estruturas e consultas do usuário, o Evolla gera insights precisos e contextualmente matizados sobre a função proteica. Uma inovação-chave do Evolla reside em seu treinamento em um conjunto de dados gerado por IA sem precedentes: 546 milhões de pares de perguntas e respostas sobre proteínas e 150 bilhões de tokens de palavras, projetados para refletir a imensa complexidade e diversidade funcional das proteínas. Após o pré-treinamento, o Evolla integra a Direct Preference Optimization (DPO) para refinar o modelo com base em sinais de preferência e a Retrieval-Augmented Generation (RAG) para a incorporação de conhecimento externo, melhorando a qualidade e a relevância das respostas. Para avaliar seu desempenho, propomos um novo framework, o Instructional Response Space (IRS), demonstrando que o Evolla fornece insights de nível especialista, avançando a pesquisa em proteômica e genômica funcional, ao mesmo tempo que lança luz sobre a lógica molecular codificada nas proteínas. A demonstração online está disponível em http://www.chat-protein.com/.* Exemplos: ```python processor = EvollaProcessor.from_pretrained("westlake-repl/Evolla-10B-DPO-hf") model = EvollaForProteinText2Text.from_pretrained("westlake-repl/Evolla-10B-DPO-hf", device_map="auto") # aa_seq should have same length as foldseek protein_inputs = [ { "aa_seq": "MATGGRRG...", "foldseek": "###lqpfd...", # hashtag means the low-confidence foldseek tokens }, { "aa_seq": "MLPGLALL...", "foldseek": "dfwwkwad...", } ] message_list = [ [ { "role": "system", "content": "You are an AI expert that can answer any questions about protein.", }, {"role": "user", "content": "What is the function of this protein?"}, ], [ { "role": "system", "content": "You are an AI expert that can answer any questions about protein.", }, {"role": "user", "content": "What is the function of this protein?"}, ] ] input_dict = processor( protein_inputs, messages_list, return_tensors="pt", text_max_length=512, protein_max_length=1024 ) with torch.no_grad(): generated_ids = hf_model.generate(**input_dict) generated_texts = processor.batch_decode( generated_ids, skip_special_tokens=True ) ``` Dicas: - Este modelo foi contribuído por [Xibin Bayes Zhou](https://huggingface.co/XibinBayesZhou). - O código original pode ser encontrado [aqui](https://github.com/westlake-repl/Evolla). ## EvollaConfig[[transformers.EvollaConfig]] #### transformers.EvollaConfig[[transformers.EvollaConfig]] ```python transformers.EvollaConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, protein_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vocab_size: int = 128256, hidden_size: int = 4096, intermediate_size: int = 14336, num_hidden_layers: int = 32, num_attention_heads: int = 32, num_key_value_heads: int | None = 8, hidden_act: str = 'silu', max_position_embeddings: int = 8192, rms_norm_eps: float = 1e-05, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | int | None = 0.0, mlp_bias: bool = False, aligner_ffn_mult: int | None = 4, aligner_enable_bias: bool | None = True, aligner_attention_probs_dropout_prob: float | None = 0.1, aligner_num_add_layers: int | None = 8, resampler_depth: int | None = 6, resampler_dim_head: int | None = 64, resampler_heads: int | None = 8, resampler_num_latents: int | None = 64, resampler_ff_mult: int | None = 4, initializer_range: float = 0.02, pad_token_id: int | None = None, bos_token_id: int | None = 128000, eos_token_id: int | list[int] | None = 128009, use_cache: bool = False, tie_word_embeddings: bool = False, is_decoder: bool | None = False, add_cross_attention: bool | None = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/configuration_evolla.py#L64) **Parâmetros:** protein_encoder_config (`dict`, *opcional*) : Dicionário de opções de configuração usadas para inicializar `SaProtConfig`. vocab_size (`int`, *opcional*, padrão `128256`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. hidden_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `14336`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `32`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `32`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `8`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. hidden_act (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *opcional*, padrão `8192`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. mlp_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas up_proj, down_proj e gate_proj das camadas MLP. aligner_ffn_mult (`int`, *opcional*, padrão 4) : O multiplicador do FFN para a camada de alinhador. aligner_enable_bias (`bool`, *opcional*, padrão `True`) : Se deve usar viés na camada de alinhamento. aligner_attention_probs_dropout_prob (`float`, *opcional*, padrão 0.1) : A taxa de dropout para as probabilidades de atenção na camada de alinhamento. aligner_num_add_layers (`int`, *opcional*, padrão 8) : O número de camadas adicionais para a camada de alinhador. resampler_depth (`int`, *opcional*, padrão 6) : A profundidade da camada de resampler no modelo llama. resampler_dim_head (`int`, *opcional*, padrão 64) : A dimensão dos cabeçalhos na camada de resampler no modelo llama. resampler_heads (`int`, *opcional*, padrão 8) : O número de cabeças na camada de resampler no modelo llama. resampler_num_latents (`int`, *opcional*, padrão 64) : O número de latentes na camada resampler no modelo Llama. resampler_ff_mult (`int`, *opcional*, padrão 4) : O multiplicador do FFN para a camada de resampler. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário. bos_token_id (`int`, *opcional*, padrão `128000`) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `128009`) : ID do token usado para o fim do fluxo no vocabulário. use_cache (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador. add_cross_attention (`bool`, *opcional*, padrão `False`) : Se as camadas de atenção cruzada devem ser adicionadas ao modelo. Esta é a classe de configuração para armazenar a configuração de um EvollaModel. Ela é usada para instanciar um modelo Evolla de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [westlake-repl/Evolla-10B-hf](https://huggingface.co/westlake-repl/Evolla-10B-hf) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import EvollaModel, EvollaConfig >>> # Initializing a Evolla evolla-10b style configuration >>> configuration = EvollaConfig() >>> # Initializing a model from the evolla-10b style configuration >>> model = EvollaModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## EvollaModel[[transformers.EvollaModel]] #### transformers.EvollaModel[[transformers.EvollaModel]] ```python transformers.EvollaModel(config: EvollaConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/modeling_evolla.py#L1269) #### forward[[transformers.EvollaModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, protein_input_ids: typing.Optional[torch.LongTensor] = None, protein_attention_mask: typing.Optional[torch.Tensor] = None, structure_feats: typing.Optional[torch.Tensor] = None, msa_feats: typing.Optional[torch.Tensor] = None, structure_batch_mask: typing.Optional[torch.Tensor] = None, msa_batch_mask: typing.Optional[torch.Tensor] = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/modeling_evolla.py#L1297) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). protein_input_ids (`torch.LongTensor`, *opcional*) : Os IDs de entrada para a sequência de proteína em tokens com consciência de estrutura. Deve ter a forma `(batch_size, protein_seq_length)` e o tipo `torch.LongTensor`. protein_attention_mask (`torch.Tensor`, *opcional*) : A máscara de atenção para a sequência de proteína. Deve ter a forma `(batch_size, protein_seq_length)` e o tipo `torch.Tensor`. structure_feats (`torch.Tensor`, *opcional*) : Os IDs de entrada para recursos baseados puramente em estrutura. Deve ter a forma `(batch_size, structure_seq_length, structure_feat_dim)` e o tipo `torch.Tensor`. Entrada fictícia por enquanto. msa_feats (`torch.Tensor`, *opcional*) : Os IDs de entrada para recursos baseados puramente em MSA. Deve ter a forma `(batch_size, msa_seq_length, msa_feat_dim)` e o tipo `torch.Tensor`. Entrada fictícia por enquanto. structure_batch_mask (`torch.Tensor`, *opcional*) : A máscara do lote para decidir quais sequências de proteínas são puramente baseadas em estrutura. Deve ter a forma `(batch_size)` e o tipo `torch.Tensor`. Deve ser pareada com `structure_feats`. Entrada fictícia por enquanto. msa_batch_mask (`torch.Tensor`, *opcional*) : A máscara do lote para decidir quais sequências de proteína são puramente baseadas em MSA. Deve ter a forma `(batch_size)` e o tipo `torch.Tensor`. Deve ser pareada com `msa_feats`. Entrada fictícia por enquanto. **Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração (`None`) e das entradas. O método forward do [EvollaModel](/docs/transformers/main/pt/model_doc/evolla#transformers.EvollaModel) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## EvollaForProteinText2Text[[transformers.EvollaForProteinText2Text]] #### transformers.EvollaForProteinText2Text[[transformers.EvollaForProteinText2Text]] ```python transformers.EvollaForProteinText2Text(config: EvollaConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/modeling_evolla.py#L1396) #### forward[[transformers.EvollaForProteinText2Text.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, protein_input_ids: typing.Optional[torch.LongTensor] = None, protein_attention_mask: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/modeling_evolla.py#L1411) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. protein_input_ids (`torch.LongTensor`, *opcional*) : Os IDs de entrada para a sequência de proteína. Deve ter a forma `(batch_size, protein_seq_length)` e o tipo `torch.LongTensor`. protein_attention_mask (`torch.Tensor`, *opcional*) : A máscara de atenção para a sequência de proteína. Deve ter a forma `(batch_size, protein_seq_length)` e o tipo `torch.Tensor`. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). O método forward de [EvollaForProteinText2Text](/docs/transformers/main/pt/model_doc/evolla#transformers.EvollaForProteinText2Text) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. Exemplo: ```python >>> from transformers import EvollaProcessor, EvollaForProteinText2Text >>> model = EvollaForProteinText2Text.from_pretrained("westlake/Evolla-10B-hf") >>> processor = EvollaProcessor.from_pretrained("westlake/Evolla-10B-hf") >>> protein_information = { "aa_seq": "your amino acid sequence", "foldseek": "your foldseek sequence", } >>> question = "What is the function of this protein?" >>> message = [ {"role": "system", "content": "You are an AI expert that can answer any questions about protein."}, {"role": "user", "content": question}, ] >>> inputs = processor(proteins=[protein_information], messages_list=[message], return_tensors="pt", padding="longest") >>> outputs = model.generate(**inputs) >>> print(processor.batch_decode(outputs, skip_special_tokens=True)) ``` ## EvollaProcessor[[transformers.EvollaProcessor]] #### transformers.EvollaProcessor[[transformers.EvollaProcessor]] ```python transformers.EvollaProcessor(protein_tokenizer, tokenizer = None, protein_max_length = 1024, text_max_length = 512, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/processing_evolla.py#L27) **Parâmetros:** protein_tokenizer (`EsmTokenizer`) : Uma instância de [EsmTokenizer](/docs/transformers/main/pt/model_doc/esm#transformers.EsmTokenizer). O tokenizador de proteínas é uma entrada obrigatória. tokenizer (`tokenizer_class`) : O tokenizer é uma entrada obrigatória. protein_max_length (`int`, *opcional*, padrão 1024) : O comprimento máximo da sequência a ser gerada. text_max_length (`int`, *opcional*, padrão 512) : O comprimento máximo do texto a ser gerado. Constrói um EvollaProcessor que encapsula um tokenizador de proteínas e um tokenizador em um único processador. [EvollaProcessor](/docs/transformers/main/pt/model_doc/evolla#transformers.EvollaProcessor) oferece todas as funcionalidades de `{protein_tokenizer_class}` e `tokenizer_class`. Consulte `~{protein_tokenizer_class}` e `~tokenizer_class` para mais informações. #### __call__[[transformers.EvollaProcessor.__call__]] ```python __call__(proteins: list[dict] | dict | None = None, messages_list: list[list[dict]] | list[dict] | None = None, protein_max_length: int | None = None, text_max_length: int | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/processing_evolla.py#L85) **Parâmetros:** proteins (`Union[List[dict], dict]`) : Uma lista de dicionários ou um único dicionário contendo as seguintes chaves: - `"aa_seq"` (`str`) -- A sequência de aminoácidos da proteína. - `"foldseek"` (`str`) -- A string foldseek da proteína. messages_list (`Union[List[List[dict]], List[dict]]`) : Uma lista de listas de dicionários ou uma lista de dicionários contendo as seguintes chaves: - `"role"` (`str`) -- O papel da mensagem. - `"content"` (`str`) -- O conteúdo da mensagem. protein_max_length (`int`, *opcional*, padrão 1024) : O comprimento máximo da sequência a ser gerada. text_max_length (`int`, *opcional*, padrão 512) : O comprimento máximo do texto. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. **Retorna:** `a dict with following keys` - `protein_input_ids` (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Os IDs de entrada para a sequência de proteína. - `protein_attention_mask` (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- A máscara de atenção para a sequência de proteína. - `text_input_ids` (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Os IDs de entrada para a sequência de texto. - `text_attention_mask` (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- A máscara de atenção para a sequência de texto.