Buckets:
| # BART | |
| [BART](https://huggingface.co/papers/1910.13461) é um modelo de sequência-para-sequência que combina os objetivos de pré-treino do BERT e do GPT. Ele é pré-treinado corrompendo o texto de diferentes maneiras, como excluir palavras, embaralhar frases ou mascarar tokens, e aprendendo a corrigi-lo. O codificador codifica o documento corrompido e o texto corrompido é corrigido pelo decodificador. À medida que aprende a recuperar o texto original, o BART se torna muito bom tanto em compreender quanto em gerar linguagem. | |
| Você pode encontrar todos os checkpoints originais do BART na organização [AI at Meta](https://huggingface.co/facebook?search_models=bart). | |
| O exemplo abaixo demonstra como prever o token `[MASK]` com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel) e pela linha de comando. | |
| ```python | |
| from transformers import pipeline | |
| fill_mask_pipeline = pipeline( | |
| task="fill-mask", | |
| model="facebook/bart-large", | |
| device=0 | |
| ) | |
| pipeline("Plants create <mask> through a process known as photosynthesis.") | |
| ``` | |
| ```python | |
| import torch | |
| from transformers import AutoModelForMaskedLM, AutoTokenizer | |
| tokenizer = AutoTokenizer.from_pretrained( | |
| "facebook/bart-large", | |
| ) | |
| model = AutoModelForMaskedLM.from_pretrained( | |
| "facebook/bart-large", | |
| device_map="auto", | |
| attn_implementation="sdpa" | |
| ) | |
| inputs = tokenizer("Plants create <mask> through a process known as photosynthesis.", return_tensors="pt").to(model.device) | |
| with torch.no_grad(): | |
| outputs = model(**inputs) | |
| predictions = outputs.logits | |
| masked_index = torch.where(inputs['input_ids'] == tokenizer.mask_token_id)[1] | |
| predicted_token_id = predictions[0, masked_index].argmax(dim=-1) | |
| predicted_token = tokenizer.decode(predicted_token_id) | |
| print(f"The predicted token is: {predicted_token}") | |
| ``` | |
| ## Observações | |
| - Os inputs devem ser preenchidos à direita, pois o BART usa embeddings de posição absoluta. | |
| - O checkpoint [facebook/bart-large-cnn](https://huggingface.co/facebook/bart-large-cnn) não inclui `mask_token_id`, o que significa que ele não pode executar tarefas de preenchimento de máscara. | |
| - O BART não usa `token_type_ids` para classificação de sequência. Use [BartTokenizer](/docs/transformers/main/pt/model_doc/led#transformers.RobertaTokenizer) ou [encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) para obter a divisão adequada. | |
| - A passagem direta de [BartModel](/docs/transformers/main/pt/model_doc/bart#transformers.BartModel) cria o `decoder_input_ids` caso ele não seja fornecido. Isso pode ser diferente de outras APIs de modelo, mas é um recurso útil para tarefas de preenchimento de máscara. | |
| - As previsões do modelo devem ser idênticas às da implementação original quando `forced_bos_token_id=0`. Isso só funciona se o texto passado para `fairseq.encode` começar com um espaço. | |
| - [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) deve ser usado para tarefas de geração condicional, como sumarização. | |
| ## BartConfig[[transformers.BartConfig]] | |
| #### transformers.BartConfig[[transformers.BartConfig]] | |
| ```python | |
| transformers.BartConfig(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, 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, is_encoder_decoder: bool | None = True, vocab_size: int = 50265, max_position_embeddings: int = 1024, encoder_layers: int | None = 12, encoder_ffn_dim: int | None = 4096, encoder_attention_heads: int | None = 16, decoder_layers: int | None = 12, decoder_ffn_dim: int | None = 4096, decoder_attention_heads: int | None = 16, encoder_layerdrop: float | None = 0.0, decoder_layerdrop: float | None = 0.0, activation_function: str | None = 'gelu', d_model: int | None = 1024, dropout: float | int | None = 0.1, attention_dropout: float | int | None = 0.0, activation_dropout: float | int | None = 0.0, init_std: float | None = 0.02, classifier_dropout: float | int | None = 0.0, scale_embedding: bool | None = False, use_cache: bool = True, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, decoder_start_token_id: int | None = 2, forced_eos_token_id: int | list[int] | None = 2, is_decoder: bool | None = False, tie_word_embeddings: bool = True) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/configuration_bart.py#L24) | |
| **Parâmetros:** | |
| is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não. | |
| vocab_size (`int`, *opcional*, padrão `50265`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. | |
| max_position_embeddings (`int`, *opcional*, padrão `1024`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. | |
| encoder_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. | |
| encoder_ffn_dim (`int`, *opcional*, padrão `4096`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no codificador. | |
| encoder_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer. | |
| decoder_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido. | |
| decoder_ffn_dim (`int`, *opcional*, padrão `4096`) : Dimensionalidade da camada "intermediária" (frequentemente chamada de feed-forward) no decodificador. | |
| decoder_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. | |
| encoder_layerdrop (`float`, *opcional*, padrão `0.0`) : A probabilidade de LayerDrop para o codificador. Consulte o [artigo do LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes. | |
| decoder_layerdrop (`float`, *opcional*, padrão `0.0`) : A probabilidade de LayerDrop para o decodificador. Consulte o [artigo LayerDrop](see https://huggingface.co/papers/1909.11556) para mais detalhes. | |
| activation_function (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. | |
| d_model (`int`, *opcional*, padrão `1024`) : Tamanho das camadas do codificador e da camada pooler. | |
| dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout. | |
| attention_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. | |
| activation_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as ativações dentro da camada totalmente conectada. | |
| init_std (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. | |
| classifier_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para o classificador. | |
| scale_embedding (`bool`, *opcional*, padrão `False`) : Se as embeddings devem ser escalonadas dividindo por sqrt(d_model). | |
| use_cache (`bool`, *opcional*, padrão `True`) : 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. | |
| 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. | |
| decoder_start_token_id (`int`, *opcional*, padrão `2`) : Se um modelo encoder-decoder inicia a decodificação com um token diferente de `bos`, o id desse token. | |
| forced_eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `2`) : O id do token a ser forçado como o último token gerado quando `max_length` é atingido. Geralmente definido como `eos_token_id`. | |
| is_decoder (`bool`, *opcional*, padrão `False`) : Indica se o modelo é usado como decodificador ou não. Se `False`, o modelo é usado como codificador. | |
| tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. | |
| Esta é a classe de configuração para armazenar a configuração de um BartModel. Ela é usada para instanciar um modelo Bart 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 [facebook/bart-large](https://huggingface.co/facebook/bart-large) | |
| 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 BartConfig, BartModel | |
| >>> # Initializing a BART facebook/bart-large style configuration | |
| >>> configuration = BartConfig() | |
| >>> # Initializing a model (with random weights) from the facebook/bart-large style configuration | |
| >>> model = BartModel(configuration) | |
| >>> # Accessing the model configuration | |
| >>> configuration = model.config | |
| ``` | |
| ## BartTokenizer[[transformers.RobertaTokenizer]] | |
| #### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]] | |
| ```python | |
| transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', bos_token: str = '<s>', eos_token: str = '</s>', sep_token: str = '</s>', cls_token: str = '<s>', unk_token: str = '<unk>', pad_token: str = '<pad>', mask_token: str = '<mask>', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/roberta/tokenization_roberta.py#L28) | |
| **Parâmetros:** | |
| vocab (`str`, `dict` ou `list`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, o vocabulário é carregado de vocab_file. | |
| merges (`str` ou `list`, *opcional*) : Lista de mesclagens personalizada. Se não for fornecida, as mesclagens são carregadas de merges_file. | |
| errors (`str`, *opcional*, padrão `"replace"`) : Paradigma a ser seguido ao decodificar bytes para UTF-8. Consulte [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) para mais informações. | |
| bos_token (`str`, *opcional*, padrão `"<s>"`) : O token de início de sequência usado durante o pré-treinamento. Pode ser usado como token de classificador de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o início da sequência. O token utilizado é o `cls_token`. | |
| eos_token (`str`, *opcional*, padrão `"</s>"`) : O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o `sep_token`. | |
| sep_token (`str`, *opcional*, padrão `"</s>"`) : O token separador, usado ao montar uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência montada com tokens especiais. | |
| cls_token (`str`, *opcional*, padrão `"<s>"`) : O token de classificador usado na classificação de sequência (classificação da sequência inteira, em vez da classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais. | |
| unk_token (`str`, *opcional*, padrão `"<unk>"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso. | |
| pad_token (`str`, *opcional*, padrão `"<pad>"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. | |
| mask_token (`str`, *opcional*, padrão `"<mask>"`) : O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever. | |
| add_prefix_space (`bool`, *opcional*, padrão `False`) : Indica se deve ou não adicionar um espaço inicial à entrada. Isso permite tratar a palavra inicial como qualquer outra palavra. (O tokenizer do RoBERTa detecta o início das palavras pelo espaço que as precede). | |
| trim_offsets (`bool`, *opcional*, padrão `True`) : Se a etapa de pós-processamento deve aparar os deslocamentos para evitar a inclusão de espaços em branco. | |
| Construa um tokenizador RoBERTa (baseado na biblioteca tokenizers da HuggingFace). Baseado em Byte-Pair-Encoding. | |
| Este tokenizer foi treinado para tratar espaços como partes dos tokens (um pouco como o sentencepiece), de modo que uma palavra será | |
| ser codificado de forma diferente, dependendo se está no início da frase (sem espaço) ou não: | |
| ```python | |
| >>> from transformers import RobertaTokenizer | |
| >>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base") | |
| >>> tokenizer("Hello world")["input_ids"] | |
| [0, 31414, 232, 2] | |
| >>> tokenizer(" Hello world")["input_ids"] | |
| [0, 20920, 232, 2] | |
| ``` | |
| Você pode contornar esse comportamento passando `add_prefix_space=True` ao instanciar este tokenizer ou ao chamá-lo em algum texto, mas, como o modelo não foi pré-treinado dessa forma, isso pode resultar em uma queda de desempenho. | |
| Quando usado com `is_split_into_words=True`, este tokenizer precisa ser instanciado com `add_prefix_space=True`. | |
| Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos. | |
| ## BartTokenizerFast[[transformers.RobertaTokenizer]] | |
| #### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]] | |
| ```python | |
| transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', bos_token: str = '<s>', eos_token: str = '</s>', sep_token: str = '</s>', cls_token: str = '<s>', unk_token: str = '<unk>', pad_token: str = '<pad>', mask_token: str = '<mask>', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/roberta/tokenization_roberta.py#L28) | |
| **Parâmetros:** | |
| vocab (`str`, `dict` ou `list`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, o vocabulário é carregado de vocab_file. | |
| merges (`str` ou `list`, *opcional*) : Lista de mesclagens personalizada. Se não for fornecida, as mesclagens são carregadas de merges_file. | |
| errors (`str`, *opcional*, padrão `"replace"`) : Paradigma a ser seguido ao decodificar bytes para UTF-8. Consulte [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) para mais informações. | |
| bos_token (`str`, *opcional*, padrão `"<s>"`) : O token de início de sequência usado durante o pré-treinamento. Pode ser usado como token de classificador de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o início da sequência. O token utilizado é o `cls_token`. | |
| eos_token (`str`, *opcional*, padrão `"</s>"`) : O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o `sep_token`. | |
| sep_token (`str`, *opcional*, padrão `"</s>"`) : O token separador, usado ao montar uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para resposta a perguntas. Também é usado como o último token de uma sequência montada com tokens especiais. | |
| cls_token (`str`, *opcional*, padrão `"<s>"`) : O token de classificador usado na classificação de sequência (classificação da sequência inteira, em vez da classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais. | |
| unk_token (`str`, *opcional*, padrão `"<unk>"`) : O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso. | |
| pad_token (`str`, *opcional*, padrão `"<pad>"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. | |
| mask_token (`str`, *opcional*, padrão `"<mask>"`) : O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever. | |
| add_prefix_space (`bool`, *opcional*, padrão `False`) : Indica se deve ou não adicionar um espaço inicial à entrada. Isso permite tratar a palavra inicial como qualquer outra palavra. (O tokenizer do RoBERTa detecta o início das palavras pelo espaço que as precede). | |
| trim_offsets (`bool`, *opcional*, padrão `True`) : Se a etapa de pós-processamento deve aparar os deslocamentos para evitar a inclusão de espaços em branco. | |
| Construa um tokenizador RoBERTa (baseado na biblioteca tokenizers da HuggingFace). Baseado em Byte-Pair-Encoding. | |
| Este tokenizer foi treinado para tratar espaços como partes dos tokens (um pouco como o sentencepiece), de modo que uma palavra será | |
| ser codificado de forma diferente, dependendo se está no início da frase (sem espaço) ou não: | |
| ```python | |
| >>> from transformers import RobertaTokenizer | |
| >>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base") | |
| >>> tokenizer("Hello world")["input_ids"] | |
| [0, 31414, 232, 2] | |
| >>> tokenizer(" Hello world")["input_ids"] | |
| [0, 20920, 232, 2] | |
| ``` | |
| Você pode contornar esse comportamento passando `add_prefix_space=True` ao instanciar este tokenizer ou ao chamá-lo em algum texto, mas, como o modelo não foi pré-treinado dessa forma, isso pode resultar em uma queda de desempenho. | |
| Quando usado com `is_split_into_words=True`, este tokenizer precisa ser instanciado com `add_prefix_space=True`. | |
| Este tokenizer herda de [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend), que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos. | |
| ## BartModel[[transformers.BartModel]] | |
| #### transformers.BartModel[[transformers.BartModel]] | |
| ```python | |
| transformers.BartModel(config: BartConfig) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L680) | |
| **Parâmetros:** | |
| config ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) : 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 Bart básico 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.BartModel.forward]] | |
| ```python | |
| forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L707) | |
| **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) | |
| decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. 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 do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `input_ids` para a direita para o pré-treinamento de desruido, conforme o artigo. | |
| decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) para mais informações sobre a estratégia padrão. | |
| encoder_outputs (`list[torch.Tensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. | |
| 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. | |
| decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. | |
| 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:** [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) ou `tuple(torch.Tensor)` | |
| Um [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) e das entradas. | |
| O método forward do [BartModel](/docs/transformers/main/pt/model_doc/bart#transformers.BartModel) 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 decoder 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** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). 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 nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. | |
| - **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do decodificador na saída de cada camada, além das saídas opcionais do embedding inicial. | |
| - **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. | |
| - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo. | |
| - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do codificador na saída de cada camada, além das saídas opcionais do embedding inicial. | |
| - **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| ## BartForConditionalGeneration[[transformers.BartForConditionalGeneration]] | |
| #### transformers.BartForConditionalGeneration[[transformers.BartForConditionalGeneration]] | |
| ```python | |
| transformers.BartForConditionalGeneration(config: BartConfig) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L801) | |
| **Parâmetros:** | |
| config ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) : 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 BART com uma cabeça de modelagem de linguagem. Pode ser usado para sumarização. | |
| 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.BartForConditionalGeneration.forward]] | |
| ```python | |
| forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L833) | |
| **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) | |
| decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. 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 do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `input_ids` para a direita para o pré-treinamento de desruido, conforme o artigo. | |
| decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) para mais informações sobre a estratégia padrão. | |
| encoder_outputs (`list[torch.Tensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do codificador. Usado na cross-attention do decodificador. | |
| 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. | |
| decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. | |
| 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]`. | |
| 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:** [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)` | |
| Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) e das entradas. | |
| O método forward de [BartForConditionalGeneration](/docs/transformers/main/pt/model_doc/bart#transformers.BartForConditionalGeneration) 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. | |
| - **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). | |
| - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). 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 nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. | |
| - **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial. | |
| - **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. | |
| - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo. | |
| - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. | |
| - **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| Exemplo de resumo: | |
| ```python | |
| >>> from transformers import AutoTokenizer, BartForConditionalGeneration | |
| >>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn") | |
| >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn") | |
| >>> ARTICLE_TO_SUMMARIZE = ( | |
| ... "PG&E stated it scheduled the blackouts in response to forecasts for high winds " | |
| ... "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were " | |
| ... "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow." | |
| ... ) | |
| >>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="pt") | |
| >>> # Generate Summary | |
| >>> summary_ids = model.generate(inputs["input_ids"], num_beams=2, min_length=0, max_length=20) | |
| >>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] | |
| 'PG&E scheduled the blackouts in response to forecasts for high winds amid dry conditions' | |
| ``` | |
| Exemplo de preenchimento de máscara: | |
| ```python | |
| >>> from transformers import AutoTokenizer, BartForConditionalGeneration | |
| >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base") | |
| >>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-base") | |
| >>> TXT = "My friends are <mask> but they eat too many carbs." | |
| >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"] | |
| >>> logits = model(input_ids).logits | |
| >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() | |
| >>> probs = logits[0, masked_index].softmax(dim=0) | |
| >>> values, predictions = probs.topk(5) | |
| >>> tokenizer.decode(predictions).split() | |
| ['not', 'good', 'healthy', 'great', 'very'] | |
| ``` | |
| ## BartForSequenceClassification[[transformers.BartForSequenceClassification]] | |
| #### transformers.BartForSequenceClassification[[transformers.BartForSequenceClassification]] | |
| ```python | |
| transformers.BartForSequenceClassification(config: BartConfig, **kwargs) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L966) | |
| **Parâmetros:** | |
| config ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) : 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 Bart com uma classificação de sequência/cabeça no topo (uma camada linear no topo da 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.BartForSequenceClassification.forward]] | |
| ```python | |
| forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L980) | |
| **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) | |
| decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. 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 do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `input_ids` para a direita para o pré-treinamento de desruido, conforme o artigo. | |
| decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) para mais informações sobre a estratégia padrão. | |
| encoder_outputs (`list[torch.Tensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. | |
| 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. | |
| decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. | |
| 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). | |
| 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:** [Seq2SeqSequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput) ou `tuple(torch.Tensor)` | |
| Um [Seq2SeqSequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo diversos elementos, dependendo da configuração ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) e das entradas. | |
| O método forward de [BartForSequenceClassification](/docs/transformers/main/pt/model_doc/bart#transformers.BartForSequenceClassification) 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. | |
| - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `label` é fornecido) -- Perda de classificação (ou 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). | |
| - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). 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 nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. | |
| - **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial. | |
| - **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. | |
| - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo. | |
| - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. | |
| - **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do codificador, 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, BartForSequenceClassification | |
| >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large") | |
| >>> model = BartForSequenceClassification.from_pretrained("facebook/bart-large") | |
| >>> 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 = BartForSequenceClassification.from_pretrained("facebook/bart-large", 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, BartForSequenceClassification | |
| >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large") | |
| >>> model = BartForSequenceClassification.from_pretrained("facebook/bart-large", 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 = BartForSequenceClassification.from_pretrained( | |
| ... "facebook/bart-large", 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 | |
| ``` | |
| ## BartForQuestionAnswering[[transformers.BartForQuestionAnswering]] | |
| #### transformers.BartForQuestionAnswering[[transformers.BartForQuestionAnswering]] | |
| ```python | |
| transformers.BartForQuestionAnswering(config: BartConfig) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L1091) | |
| **Parâmetros:** | |
| config ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) : 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 transformador Bart com uma cabeça de classificação de intervalos no topo para tarefas de resposta a perguntas extrativas, como SQuAD (uma camada linear no topo da saída dos estados ocultos para calcular `span start logits` e `span end logits`). | |
| 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.BartForQuestionAnswering.forward]] | |
| ```python | |
| forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: list[torch.Tensor] | None = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L1104) | |
| **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](/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) | |
| decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada do decodificador no vocabulário. 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 do decodificador?](../glossary#decoder-input-ids) O Bart usa o `eos_token_id` como token inicial para a geração de `decoder_input_ids`. Se `past_key_values` for usado, opcionalmente apenas os últimos `decoder_input_ids` precisam ser fornecidos (veja `past_key_values`). Para treinamento de tradução e sumarização, `decoder_input_ids` deve ser fornecido. Se nenhum `decoder_input_ids` for fornecido, o modelo criará este tensor deslocando os `input_ids` para a direita para o pré-treinamento de desruido, conforme o artigo. | |
| decoder_attention_mask (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamento padrão: gera um tensor que ignora os tokens de preenchimento em `decoder_input_ids`. A máscara causal também será usada por padrão. Se você quiser alterar o comportamento de preenchimento, deve ler `modeling_bart._prepare_decoder_attention_mask` e modificar conforme suas necessidades. Veja o diagrama 1 em [o artigo](https://huggingface.co/papers/1910.13461) para mais informações sobre a estratégia padrão. | |
| encoder_outputs (`list[torch.Tensor]`, *opcional*) : A tupla consiste em (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder. | |
| start_positions (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda. | |
| end_positions (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do final do trecho rotulado, para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda. | |
| 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. | |
| decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `decoder_input_ids`, você pode escolher passar diretamente uma representação incorporada. Se `past_key_values` for usado, opcionalmente apenas o último `decoder_inputs_embeds` precisa ser inserido (veja `past_key_values`). Isso é útil se você quiser ter mais controle sobre como converter os índices de `decoder_input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. Se `decoder_input_ids` e `decoder_inputs_embeds` estiverem ambos não definidos, `decoder_inputs_embeds` assume o valor de `inputs_embeds`. | |
| 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:** [Seq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput) ou `tuple(torch.Tensor)` | |
| Um [Seq2SeqQuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput) 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 ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) e das entradas. | |
| O método forward de [BartForQuestionAnswering](/docs/transformers/main/pt/model_doc/bart#transformers.BartForQuestionAnswering) 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. | |
| - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecida) -- A perda total de extração de spans é a soma de uma Cross-Entropy para as posições de início e fim. | |
| - **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de início de span (antes do SoftMax). | |
| - **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de fim de span (antes do SoftMax). | |
| - **past_key_values** (`EncoderDecoderCache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). 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 nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. | |
| - **decoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do decodificador na saída de cada camada, além das saídas do embedding inicial. | |
| - **decoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) com forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. | |
| - **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Sequência de estados ocultos na saída da última camada do encoder do modelo. | |
| - **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`. | |
| Estados ocultos do codificador na saída de cada camada, além das saídas do embedding inicial. | |
| - **encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos de atenção do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. | |
| Exemplo: | |
| ```python | |
| >>> from transformers import AutoTokenizer, BartForQuestionAnswering | |
| >>> import torch | |
| >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large") | |
| >>> model = BartForQuestionAnswering.from_pretrained("facebook/bart-large") | |
| >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" | |
| >>> inputs = tokenizer(question, text, return_tensors="pt") | |
| >>> with torch.no_grad(): | |
| ... outputs = model(**inputs) | |
| >>> answer_start_index = outputs.start_logits.argmax() | |
| >>> answer_end_index = outputs.end_logits.argmax() | |
| >>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1] | |
| >>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True) | |
| ... | |
| >>> # target is "nice puppet" | |
| >>> target_start_index = torch.tensor([14]) | |
| >>> target_end_index = torch.tensor([15]) | |
| >>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index) | |
| >>> loss = outputs.loss | |
| >>> round(loss.item(), 2) | |
| ... | |
| ``` | |
| ## BartForCausalLM[[transformers.BartForCausalLM]] | |
| #### transformers.BartForCausalLM[[transformers.BartForCausalLM]] | |
| ```python | |
| transformers.BartForCausalLM(config: BartConfig) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L1216) | |
| **Parâmetros:** | |
| config ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) : 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. | |
| Decodificador BART com uma cabeça de modelagem de linguagem no topo (camada linear com pesos vinculados aos embeddings de entrada). | |
| 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.BartForCausalLM.forward]] | |
| ```python | |
| forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>) | |
| ``` | |
| [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bart/modeling_bart.py#L1238) | |
| **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) | |
| encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder. | |
| encoder_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 da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. | |
| 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. | |
| 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]`. | |
| 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). | |
| **Retorna:** [CausalLMOutputWithCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou `tuple(torch.Tensor)` | |
| Um [CausalLMOutputWithCrossAttentions](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) 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 ([BartConfig](/docs/transformers/main/pt/model_doc/bart#transformers.BartConfig)) e das entradas. | |
| O método forward de [BartForCausalLM](/docs/transformers/main/pt/model_doc/bart#transformers.BartForCausalLM) 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 (para previsão do próximo token). | |
| - **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) 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. | |
| - **cross_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. | |
| Pesos das atenções cruzadas após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada. | |
| - **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 atenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. | |
| Exemplo: | |
| ```python | |
| >>> from transformers import AutoTokenizer, BartForCausalLM | |
| >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base") | |
| >>> model = BartForCausalLM.from_pretrained("facebook/bart-base") | |
| >>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder." | |
| >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") | |
| >>> outputs = model(**inputs) | |
| >>> logits = outputs.logits | |
| >>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size] | |
| >>> list(logits.shape) == expected_shape | |
| True | |
| ``` | |
Xet Storage Details
- Size:
- 83.3 kB
- Xet hash:
- 6e013ed420a746fcb43d193624800d1a2bbd7531f49511ddbb1e88c0ffa94c8b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.