# Evolla ## Aperçu 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 est un modèle génératif avancé de langage protéique à 80 milliards de paramètres, conçu pour décoder le langage moléculaire des protéines. Il intègre des informations issues des séquences, des structures et des requêtes des utilisateurs pour générer des analyses précises et contextuellement nuancées sur la fonction des protéines. Entraîné sur un jeu de données généré par IA sans précédent, composé de 546 millions de paires question-réponse sur les protéines et de 150 milliards de jetons de mots, Evolla fait progresser de manière significative la recherche en protéomique et en génomique fonctionnelle, en offrant des analyses de niveau expert et en éclairant la logique moléculaire encodée dans les protéines. L'abstract de l'article est le suivant : *Les protéines, machines moléculaires complexes de la nature, sont le fruit de milliards d'années d'évolution et jouent des rôles fondamentaux dans le maintien de la vie. Pourtant, déchiffrer leur langage moléculaire — c'est-à-dire comprendre comment les séquences et les structures des protéines encodent et déterminent les fonctions biologiques — reste un défi majeur de la biologie moderne. Nous présentons ici Evolla, un modèle génératif de langage protéique de pointe de 80 milliards de paramètres, conçu pour décoder le langage moléculaire des protéines. En intégrant des informations issues des séquences, des structures et des requêtes des utilisateurs, Evolla génère des analyses précises et nuancées sur le contexte de la fonction des protéines. Une innovation clé d'Evolla réside dans son entraînement sur un jeu de données généré par IA sans précédent : 546 millions de paires question-réponse sur les protéines et 150 milliards de jetons de mots, conçus pour refléter l'immense complexité et la diversité fonctionnelle des protéines. Après l'entraînement initial, Evolla intègre l'Optimisation des Préférences Directes (DPO) pour affiner le modèle sur la base de signaux de préférence, ainsi que la Génération Augmentée par Récupération (RAG) pour l'incorporation de connaissances externes, améliorant ainsi la qualité et la pertinence des réponses. Pour évaluer ses performances, nous proposons un nouveau cadre, l'Espace de Réponse Instructionnelle (IRS), démontrant qu'Evolla fournit des analyses de niveau expert, faisant ainsi progresser la recherche en protéomique et en génomique fonctionnelle tout en jetant une lumière sur la logique moléculaire encodée dans les protéines. La démonstration en ligne est disponible à l'adresse http://www.chat-protein.com/.* Exemples : ```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 ) ``` Astuces : - Ce modèle a été contribué par [Xibin Bayes Zhou](https://huggingface.co/XibinBayesZhou). - Le code original peut être trouvé [ici](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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/configuration_evolla.py#L64) **Paramètres :** protein_encoder_config (`dict`, *facultatif*) : Dictionnaire des options de configuration utilisées pour initialiser `SaProtConfig`. vocab_size (`int`, *facultatif*, valeur par défaut `128256`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `14336`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `32`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `32`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_key_value_heads (`int`, *facultatif*, valeur par défaut `8`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`. hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *facultatif*, valeur par défaut `8192`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. rms_norm_eps (`float`, *facultatif*, par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation rms. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs. attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. mlp_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches up_proj, down_proj et gate_proj des couches MLP. aligner_ffn_mult (`int`, *facultatif*, valeur par défaut : 4) : Le multiplicateur FFN pour la couche d'alignement. aligner_enable_bias (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser un biais dans la couche d'alignement. aligner_attention_probs_dropout_prob (`float`, *facultatif*, valeur par défaut 0,1) : Le taux de dropout appliqué aux probabilités d'attention dans la couche d'alignement. aligner_num_add_layers (`int`, *facultatif*, valeur par défaut : 8) : Le nombre de couches supplémentaires pour la couche d'alignement. resampler_depth (`int`, *facultatif*, valeur par défaut : 6) : La profondeur de la couche de rééchantillonnage dans le modèle Llama. resampler_dim_head (`int`, *facultatif*, par défaut 64) : La dimension des têtes dans la couche resampler du modèle Llama. resampler_heads (`int`, *facultatif*, valeur par défaut : 8) : Le nombre de têtes dans la couche de rééchantillonnage du modèle Llama. resampler_num_latents (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de latents dans la couche resampler du modèle Llama. resampler_ff_mult (`int`, *facultatif*, valeur par défaut : 4) : Le multiplicateur FFN pour la couche resampler. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur par défaut `128000`) : Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `128009`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. use_cache (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. is_decoder (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle est utilisé comme décodeur. Si `False`, le modèle est utilisé comme encodeur. add_cross_attention (`bool`, *facultatif*, par défaut `False`) : Indique si des couches d'attention croisée doivent être ajoutées au modèle. Ceci est la classe de configuration destinée à stocker la configuration d'un EvollaModel. Elle est utilisée pour instancier un modèle Evolla en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [westlake-repl/Evolla-10B-hf](https://huggingface.co/westlake-repl/Evolla-10B-hf) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```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) ``` [Source](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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/modeling_evolla.py#L1297) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). protein_input_ids (`torch.LongTensor`, *facultatif*) : Les identifiants d'entrée pour la séquence de protéine en jetons tenant compte de la structure. Doit être de forme `(batch_size, protein_seq_length)` et de type `torch.LongTensor`. protein_attention_mask (`torch.Tensor`, *facultatif*) : Le masque d'attention pour la séquence de protéine. Doit être de forme `(batch_size, protein_seq_length)` et de type `torch.Tensor`. structure_feats (`torch.Tensor`, *facultatif*) : Les identifiants d'entrée pour les fonctionnalités purement basées sur la structure. Doit avoir la forme `(batch_size, structure_seq_length, structure_feat_dim)` et le type `torch.Tensor`. Entrée factice pour le moment. msa_feats (`torch.Tensor`, *facultatif*) : Les identifiants d'entrée pour les fonctionnalités basées uniquement sur MSA. Doit avoir la forme `(batch_size, msa_seq_length, msa_feat_dim)` et le type `torch.Tensor`. Entrée factice pour le moment. structure_batch_mask (`torch.Tensor`, *facultatif*) : Le masque de lot pour déterminer quelles séquences de protéines sont purement basées sur la structure. Doit avoir la forme `(batch_size)` et le type `torch.Tensor`. Doit être associé à `structure_feats`. Entrée factice pour le moment. msa_batch_mask (`torch.Tensor`, *facultatif*) : Le masque de lot pour déterminer quelles séquences de protéines sont purement basées sur MSA. Doit avoir la forme `(batch_size)` et le type `torch.Tensor`. Doit être associé à `msa_feats`. Entrée factice pour le moment. **Retourne :** [BaseModelOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration (`None`) et les entrées. La méthode forward de [EvollaModel](/docs/transformers/main/fr/model_doc/evolla#transformers.EvollaModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## EvollaForProteinText2Text[[transformers.EvollaForProteinText2Text]] #### transformers.EvollaForProteinText2Text[[transformers.EvollaForProteinText2Text]] ```python transformers.EvollaForProteinText2Text(config: EvollaConfig) ``` [Source](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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/modeling_evolla.py#L1411) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`. protein_input_ids (`torch.LongTensor`, *facultatif*) : Les identifiants d'entrée pour la séquence de protéine. Doit être de forme `(batch_size, protein_seq_length)` et de type `torch.LongTensor`. protein_attention_mask (`torch.Tensor`, *facultatif*) : Le masque d'attention pour la séquence de protéine. Doit être de forme `(batch_size, protein_seq_length)` et de type `torch.Tensor`. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_ids` (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence). La méthode forward de [EvollaForProteinText2Text](/docs/transformers/main/fr/model_doc/evolla#transformers.EvollaForProteinText2Text) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. Exemple : ```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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/processing_evolla.py#L27) **Paramètres :** protein_tokenizer (`EsmTokenizer`) : une instance de [EsmTokenizer](/docs/transformers/main/fr/model_doc/esm#transformers.EsmTokenizer). Le tokeniseur de protéines est une entrée obligatoire. tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire. protein_max_length (`int`, *facultatif*, valeur par défaut 1024) : La longueur maximale de la séquence à générer. text_max_length (`int`, *facultatif*, valeur par défaut : 512) : La longueur maximale du texte à générer. Construit un EvollaProcessor qui encapsule un tokenizer de protéines et un tokenizer dans un seul processeur. [EvollaProcessor](/docs/transformers/main/fr/model_doc/evolla#transformers.EvollaProcessor) offre toutes les fonctionnalités de `{protein_tokenizer_class}` et de `tokenizer_class`. Consultez `~{protein_tokenizer_class}` et `~tokenizer_class` pour plus d’informations. #### __appel__[[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) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/evolla/processing_evolla.py#L85) **Paramètres :** proteins (`Union[List[dict], dict]`) : Une liste de dictionnaires ou un dictionnaire unique contenant les clés suivantes : - `"aa_seq"` (`str`) -- La séquence d'acides aminés de la protéine. - `"foldseek"` (`str`) -- La chaîne foldseek de la protéine. messages_list (`Union[List[List[dict]], List[dict]]`) : une liste de listes de dictionnaires ou une liste de dictionnaires contenant les clés suivantes : - `"role"` (`str`) -- le rôle du message. - `"content"` (`str`) -- le contenu du message. protein_max_length (`int`, *facultatif*, valeur par défaut 1024) : La longueur maximale de la séquence à générer. text_max_length (`int`, *facultatif*, valeur par défaut 512) : La longueur maximale du texte. return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. **Retourne :** `a dict with following keys` - `protein_input_ids` (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Les identifiants d'entrée pour la séquence de protéine. - `protein_attention_mask` (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Le masque d'attention pour la séquence de protéine. - `text_input_ids` (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Les identifiants d'entrée pour la séquence de texte. - `text_attention_mask` (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Le masque d'attention pour la séquence de texte.