Hugging Face's logo

Transformers documentation

Evolla

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2025-07-26.

Evolla

Aperçu

The Evolla model was proposed in Decoding the Molecular Language of Proteins with Evolla by Zhou et al..

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 frontière 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 des protéines 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 cadre novateur, l’Espace de Réponse Instructionnelle (IRS), démontrant qu’Evolla fournit des analyses de niveau expert, faisant avancer la recherche en protéomique et en génomique fonctionnelle tout en éclairant la logique moléculaire encodée dans les protéines. La démo en ligne est disponible à l’adresse http://www.chat-protein.com/.

Exemples :

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 :

EvollaConfig

classe transformers.EvollaConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneprotein_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevocab_size: int = 128256hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int | None = 8hidden_act: str = 'silu'max_position_embeddings: int = 8192rms_norm_eps: float = 1e-05rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_bias: bool = Falseattention_dropout: float | int | None = 0.0mlp_bias: bool = Falsealigner_ffn_mult: int | None = 4aligner_enable_bias: bool | None = Truealigner_attention_probs_dropout_prob: float | None = 0.1aligner_num_add_layers: int | None = 8resampler_depth: int | None = 6resampler_dim_head: int | None = 64resampler_heads: int | None = 8resampler_num_latents: int | None = 64resampler_ff_mult: int | None = 4initializer_range: float = 0.02pad_token_id: int | None = Nonebos_token_id: int | None = 128000eos_token_id: int | list[int] | None = 128009use_cache: bool = Falsetie_word_embeddings: bool = Falseis_decoder: bool | None = Falseadd_cross_attention: bool | None = False )

Paramètres

  • protein_encoder_config (dict, facultatif) — Dictionnaire des options de configuration utilisées pour initialiser SaProtConfig.
  • vocab_size (int, facultatif, 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, par défaut 4096) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 14336) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, 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) — Ceci 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 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut sera 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) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, facultatif, par défaut 8192) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • rms_norm_eps (float, facultatif, valeur 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, par défaut False) — Indique s'il faut utiliser un biais dans les couches de projection des requêtes, des clés, des valeurs et de la 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, 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 aligner.
  • 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 aligner.
  • 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 resampler dans le modèle llama.
  • resampler_dim_head (int, facultatif, valeur 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 resampler 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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • pad_token_id (int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif, 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, par défaut 128009) — Identifiant du 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • 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, par défaut False) — Indique si le modèle est utilisé comme décodeur ou non. Si False, le modèle est utilisé comme encodeur.
  • add_cross_attention (bool, facultatif, valeur 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, définissant ainsi 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> 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

classe transformers.EvollaModel

< >

( config: EvollaConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneprotein_input_ids: typing.Optional[torch.LongTensor] = Noneprotein_attention_mask: typing.Optional[torch.Tensor] = Nonestructure_feats: typing.Optional[torch.Tensor] = Nonemsa_feats: typing.Optional[torch.Tensor] = Nonestructure_batch_mask: typing.Optional[torch.Tensor] = Nonemsa_batch_mask: typing.Optional[torch.Tensor] = None**kwargs ) → BaseModelOutputWithPast or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur 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 prenant en compte la structure. Doit avoir la forme (batch_size, protein_seq_length) et le 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 basées uniquement 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 l’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 ou tuple(torch.Tensor)

Un BaseModelOutputWithPast ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (None) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

EvollaForProteinText2Text

classe transformers.EvollaForProteinText2Text

< >

( config: EvollaConfig )

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneprotein_input_ids: typing.Optional[torch.LongTensor] = Noneprotein_attention_mask: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs )

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 que 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 dans [0, ..., config.vocab_size] ou -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 dans [0, ..., config.vocab_size].
  • protein_input_ids (torch.LongTensor, facultatif) — Les identifiants d’entrée pour la séquence de protéine. Doit avoir la forme (batch_size, protein_seq_length) et le 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 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 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 é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. Cela 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 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 :

>>> 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

classe transformers.EvollaProcessor

< >

( protein_tokenizertokenizer = Noneprotein_max_length = 1024text_max_length = 512**kwargs )

Paramètres

  • protein_tokenizer (EsmTokenizer) — Une instance de EsmTokenizer. Le tokenizer 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, 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 offre toutes les fonctionnalités de {protein_tokenizer_class} et de tokenizer_class. Consultez ~{protein_tokenizer_class} et ~tokenizer_class pour plus d’informations.

__call__

< >

( proteins: list[dict] | dict | None = Nonemessages_list: list[list[dict]] | list[dict] | None = Noneprotein_max_length: int | None = Nonetext_max_length: int | None = None**kwargs ) → a dict with following keys

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, par défaut 512) — La longueur maximale du texte.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

Retourne

un dictionnaire avec les clés suivantes

  • 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.
Update on GitHub

←ernie4_5_vl_moe FastVLM→