# ESMC ## Visão geral ESMC (ESM Cambrian) é uma família de modelos de linguagem de proteínas lançada pela [BioHub](https://biohub.org/). Trata-se de um codificador Transformer bidirecional treinado com um objetivo de modelagem de linguagem mascarada sobre sequências de aminoácidos. Assim como o [ESM-2](./esm), o ESMC produz representações por resíduo que são úteis para tarefas de modelagem de proteínas em etapas subsequentes. O ESMC é adequado para ajuste fino em tarefas de classificação de proteínas ou classificação de tokens. Ele também é usado como a espinha dorsal do [ESMFold2](./esmfold2), onde gera representações que são usadas como entrada para a cabeça de dobramento. Os checkpoints pré-treinados estão disponíveis no Hugging Face Hub: - [`biohub/ESMC-300M`](https://huggingface.co/biohub/ESMC-300M) - [`biohub/ESMC-600M`](https://huggingface.co/biohub/ESMC-600M) - [`biohub/ESMC-6B`](https://huggingface.co/biohub/ESMC-6B) ## Exemplo de uso O ESMC está registrado nas classes automáticas (`AutoModel`, `AutoModelForMaskedLM`, `AutoModelForSequenceClassification`, `AutoModelForTokenClassification`). ```python import torch from transformers import pipeline extractor = pipeline( task="feature-extraction", model="biohub/ESMC-300M", ) # Per-residue representations of shape (batch, sequence_length, hidden_size). representations = extractor("MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQ", return_tensors="pt") ``` ```python import torch from transformers import AutoModel, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("biohub/ESMC-300M") model = AutoModel.from_pretrained("biohub/ESMC-300M") inputs = tokenizer("MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQ", return_tensors="pt") with torch.no_grad(): outputs = model(**inputs) # Per-residue representations of shape (batch, sequence_length, hidden_size). representations = outputs.last_hidden_state ``` ## EsmcConfig[[transformers.EsmcConfig]] #### transformers.EsmcConfig[[transformers.EsmcConfig]] ```python transformers.EsmcConfig(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, vocab_size: int = 64, hidden_size: int = 2560, intermediate_size: int = 6912, num_hidden_layers: int = 80, num_attention_heads: int = 40, num_key_value_heads: int | None = None, hidden_act: str = 'silu', max_position_embeddings: int = 2048, initializer_range: float = 0.02, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, mlp_bias: bool = False, head_dim: int | None = None, mask_token_id: int | None = 32, classifier_dropout: float | None = 0.1) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/configuration_esmc.py#L30) **Parâmetros:** vocab_size (*int*, *opcional*, padrão *64*) : 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 *2560*) : Dimensão das representações ocultas. intermediate_size (*int*, *opcional*, padrão *6912*) : Dimensão das representações do MLP. num_hidden_layers (*int*, *optional*, padrão *80*) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (*int*, *opcional*, padrão *40*) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (*int*, *optional*) : 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 grupo de cabeças de chave e valor deve ser construído por meio do 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 *2048*) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. 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*, padrão *1*) : ID do token usado para preenchimento no vocabulário. bos_token_id (*int*, *opcional*, padrão *0*) : ID do token usado para o início do fluxo no vocabulário. eos_token_id (*Union[int, list[int]]*, *opcional*, padrão *2*) : ID do token usado para o fim do fluxo no vocabulário. 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. 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[int, float]*, *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. head_dim (*int*, *opcional*) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads mask_token_id (*int*, *opcional*, padrão 32) : Índice do token de máscara no vocabulário (`"<mask>"`), usado para modelagem de linguagem mascarada. classifier_dropout (*float*, *optional*, padrão 0.1) : Razão de dropout para a cabeça de classificação. Esta é a classe de configuração para armazenar a configuração de um EsmcModel. Ela é usada para instanciar um modelo Esmc 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 [biohub/ESMC-6B](https://huggingface.co/biohub/ESMC-6B) Os objetos de configuração herdam de [*PreTrainedConfig*] e podem ser usados para controlar as saídas do modelo. Leia a documentação de [*PreTrainedConfig*] para obter mais informações. Exemplos: ```python >>> from transformers import EsmcConfig, EsmcModel >>> # Initializing an ESMC biohub/ESMC-6B style configuration >>> configuration = EsmcConfig() >>> # Initializing a model (with random weights) from the configuration >>> model = EsmcModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## EsmcTokenizer[[transformers.EsmcTokenizer]] #### transformers.EsmcTokenizer[[transformers.EsmcTokenizer]] ```python transformers.EsmcTokenizer(unk_token = '', cls_token = '', pad_token = '', mask_token = '', eos_token = '', bos_token = None, chain_break_token = '|', extra_special_tokens = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/tokenization_esmc.py#L67) **Parâmetros:** unk_token (*str*, *opcional*, padrão *"<unk>"*) : O token desconhecido. cls_token (*str*, *opcional*, padrão *"<cls>"*) : O token de classificação (adicionado ao início de cada sequência). pad_token (*str*, *opcional*, padrão *"<pad>"*) : O token de preenchimento. mask_token (*str*, *opcional*, padrão *"<mask>"*) : O token de máscara, usado para modelagem de linguagem mascarada. eos_token (*str*, *opcional*, padrão *"<eos>"*) : O token de fim de sequência (anexado a cada sequência). bos_token (*str*, *opcional*, padrão *"<cls>"*) : O token de início de sequência (adicionado ao início de cada sequência). Quando não definido, usa cls_token. chain_break_token (*str*, *opcional*, padrão *"|"*) : Token inserido entre cadeias em entradas de proteínas de múltiplas cadeias. Registrado como um token especial específico do modelo, portanto, é exposto como *chain_break_token* / *chain_break_token_id*. extra_special_tokens (*list[str]*, *opcional*) : Tokens especiais adicionais para registrar no tokenizer (recuperados de uma configuração salva). Construa um tokenizador ESMC. Este tokenizer é um tokenizer de nível de caractere baseado na biblioteca *tokenizers* do HuggingFace. Ele envolve cada sequência com os tokens `<cls>` e `<eos>` e suporta um token de quebra de cadeia `|` para entradas de múltiplas cadeias. Exemplos: ```python >>> from transformers import EsmcTokenizer >>> tokenizer = EsmcTokenizer() >>> tokenizer("ACDEFGHIKLMNPQRSTVWY")["input_ids"] [0, 5, 23, 13, 9, 18, 6, 21, 12, 15, 4, 20, 17, 14, 16, 10, 8, 11, 7, 22, 19, 2] ``` ## EsmcModel[[transformers.EsmcModel]] #### transformers.EsmcModel[[transformers.EsmcModel]] ```python transformers.EsmcModel(config: EsmcConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L306) **Parâmetros:** config ([EsmcConfig](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Esmc puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.EsmcModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, sequence_id: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L316) **Parâmetros:** input_ids (*torch.Tensor* 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*]. Consulte [*PreTrainedTokenizer.encode*] e [*PreTrainedTokenizer.__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 da 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.Tensor* de forma *(batch_size, sequence_length)*, *opcional*) : Posição de cada token na sequência, usada pelo RoPE. O valor padrão é `arange(sequence_length)`. As posições ESMC são absolutas para todo o input e continuam *através* das fronteiras de cadeia em um input de múltiplas cadeias. A estrutura da cadeia é transportada separadamente por `sequence_id`, que mascara a atenção: diferentemente do formato de sequência empacotada usado em outras partes da biblioteca, portanto, estas não são ids de posição por cadeia reiniciando em 0, e a estrutura da cadeia é deliberadamente não inferida a partir delas. sequence_id (*torch.Tensor* de forma *(batch_size, sequence_length)*, *opcional*) : Tensor de ID de cadeia de inteiros para mascaramento de atenção consciente de cadeia. Tokens com o mesmo valor inteiro não negativo podem prestar atenção uns aos outros; tokens com valores diferentes não podem (mascaramento entre cadeias). As posições de preenchimento devem ser definidas como `-1` e as entradas devem ser **preenchidas à direita** (o RoPE usa posições absolutas começando em 0). Quando fornecido, `attention_mask` é ignorado. Passar `sequence_id` constrói uma máscara de atenção personalizada, o que requer `torch>=2.6`. Entradas de múltiplas cadeias exigem adicionalmente uma `attn_implementation` não-flash (`'sdpa'` / `'eager'` / `'flex_attention'`); a flash attention suporta apenas o caso de cadeia única. **Retorna:** [*~modeling_outputs.BaseModelOutput*] ou *tuple(torch.Tensor)* Um [*~modeling_outputs.BaseModelOutput*] 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 ([*EsmcConfig*]) e das entradas. O método forward do [*EsmcModel*] 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. - **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. - **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) de 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. Exemplos: ```python >>> from transformers import AutoTokenizer, EsmcModel >>> model = EsmcModel.from_pretrained("biohub/ESMC-300M") >>> tokenizer = AutoTokenizer.from_pretrained("biohub/ESMC-300M") >>> inputs = tokenizer(["MLKNVQVQLV"], return_tensors="pt") >>> outputs = model(**inputs) >>> outputs.last_hidden_state.shape torch.Size([1, 12, 960]) ``` ## EsmcForMaskedLM[[transformers.EsmcForMaskedLM]] #### transformers.EsmcForMaskedLM[[transformers.EsmcForMaskedLM]] ```python transformers.EsmcForMaskedLM(config: EsmcConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L414) **Parâmetros:** config ([EsmcConfig](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Esmc com uma cabeça de `language modeling` no topo." Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.EsmcForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, sequence_id: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L430) **Parâmetros:** input_ids (*torch.Tensor* 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*]. Consulte [*PreTrainedTokenizer.encode*] e [*PreTrainedTokenizer.__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 da 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.Tensor* 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) sequence_id (*torch.Tensor* de forma *(batch_size, sequence_length)*, *opcional*) : Tensor de ID de cadeia de inteiros encaminhado para o codificador para mascaramento de atenção consciente de cadeia. Consulte [EsmcModel.forward()](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcModel.forward) para a codificação. labels (*torch.LongTensor* de forma *(batch_size, sequence_length)*, *opcional*) : Rótulos para a perda de modelagem de linguagem mascarada. As posições com rótulo `-100` são ignoradas. As outras posições devem estar em `[0, config.vocab_size)`. **Retorna:** [*~modeling_outputs.MaskedLMOutput*] ou *tuple(torch.Tensor)* Um [*~modeling_outputs.MaskedLMOutput*] ou uma tupla de *torch.Tensor* (se *return_dict=False* for passado ou quando *config.return_dict=False*) compreendendo vários elementos dependendo da configuração ([*EsmcConfig*]) e das entradas. O método forward da [*EsmcForMaskedLM*] 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. - **loss** (*torch.Tensor* de forma *(1,)*, *opcional*, retornado quando *labels* é fornecido) -- Perda de modelagem de linguagem mascarada (MLM). - **logits** (*torch.Tensor* de forma *(batch_size, sequence_length, config.vocab_size)*) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **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) de 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. Exemplos: ```python >>> from transformers import AutoTokenizer, EsmcForMaskedLM >>> import torch >>> model = EsmcForMaskedLM.from_pretrained("biohub/ESMC-300M") >>> tokenizer = AutoTokenizer.from_pretrained("biohub/ESMC-300M") >>> inputs = tokenizer(["MLKNVQ<mask>LV"], return_tensors="pt") >>> outputs = model(**inputs) >>> outputs.logits.shape torch.Size([1, 11, 64]) ``` ## EsmcForSequenceClassification[[transformers.EsmcForSequenceClassification]] #### transformers.EsmcForSequenceClassification[[transformers.EsmcForSequenceClassification]] ```python transformers.EsmcForSequenceClassification(config: EsmcConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L511) **Parâmetros:** config ([EsmcConfig](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Modelo transformer ESMC com uma cabeça de classificação/regressão de sequência no topo (uma camada linear sobre a saída agregada), por exemplo, para tarefas GLUE. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### forward[[transformers.EsmcForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L521) **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) 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,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada). **Retorna:** [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)` Um [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 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 ([EsmcConfig](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcConfig)) e das entradas. O método forward de [EsmcForSequenceClassification](/docs/transformers/main/pt/model_doc/esmc#transformers.EsmcForSequenceClassification) 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1). - **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). - **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. Exemplo de classificação de rótulo único: ```python >>> import torch >>> from transformers import AutoTokenizer, EsmcForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("biohub/ESMC-6B") >>> model = EsmcForSequenceClassification.from_pretrained("biohub/ESMC-6B") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_id = logits.argmax().item() >>> model.config.id2label[predicted_class_id] ... >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = EsmcForSequenceClassification.from_pretrained("biohub/ESMC-6B", num_labels=num_labels) >>> labels = torch.tensor([1]) >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` Exemplo de classificação multirótulo: ```python >>> import torch >>> from transformers import AutoTokenizer, EsmcForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("biohub/ESMC-6B") >>> model = EsmcForSequenceClassification.from_pretrained("biohub/ESMC-6B", problem_type="multi_label_classification") >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5] >>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)` >>> num_labels = len(model.config.id2label) >>> model = EsmcForSequenceClassification.from_pretrained( ... "biohub/ESMC-6B", num_labels=num_labels, problem_type="multi_label_classification" ... ) >>> labels = torch.sum( ... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1 ... ).to(torch.float) >>> loss = model(**inputs, labels=labels).loss ``` ## EsmcForTokenClassification[[transformers.EsmcForTokenClassification]] #### transformers.EsmcForTokenClassification[[transformers.EsmcForTokenClassification]] ```python transformers.EsmcForTokenClassification(config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/esmc/modeling_esmc.py#L575) #### forward[[transformers.EsmcForTokenClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L275) **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`, *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 cache kv](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 formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(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. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`. 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`). **Retorna:** `TokenClassifierOutput` O método forward de `GenericForTokenClassification` 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.