Transformers documentation
DPR
Este modelo foi publicado em papers do HF em 2020-04-10 e contribuído para o Hugging Face Transformers em 2020-11-16.
DPR
Visão geral
Dense Passage Retrieval (DPR) é um conjunto de ferramentas e modelos para pesquisa de ponta em Q&A de domínio aberto. Foi introduzido em Dense Passage Retrieval for Open-Domain Question Answering por Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, Wen-tau Yih.
O resumo do artigo é o seguinte:
A resposta a perguntas em domínio aberto depende de uma recuperação eficiente de trechos para selecionar contextos candidatos, em que modelos tradicionais de espaço vetorial esparsos, como TF-IDF ou BM25, são o método de fato. Neste trabalho, mostramos que a recuperação pode ser implementada na prática usando apenas representações densas, em que os embeddings são aprendidos a partir de um pequeno número de perguntas e trechos por meio de um framework simples de dual-encoder. Ao ser avaliado em uma ampla variedade de conjuntos de dados de QA em domínio aberto, nosso recuperador denso supera um sistema Lucene-BM25 forte em grande medida, com uma diferença absoluta de 9%-19% em termos de precisão de recuperação dos 20 melhores trechos, e ajuda nosso sistema de QA de ponta a ponta a estabelecer novos state-of-the-art em múltiplos benchmarks de QA em domínio aberto.
Este modelo foi contribuído por lhoestq. O código original pode ser encontrado aqui.
Dicas de uso
O DPR consiste em três modelos:
- Codificador de perguntas: codifique perguntas como vetores
- Codificador de contexto: codifique contextos como vetores
- Leitor: extrai a resposta das perguntas nos contextos recuperados, juntamente com uma pontuação de relevância (alta se o trecho inferido realmente responde à pergunta).
DPRConfig
classe transformers.DPRConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0bos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Noneprojection_dim: int = 0is_decoder: bool = Falseadd_cross_attention: bool = False )
Parâmetros
- vocab_size (
int, opcional, padrão30522) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão768) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão12) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - intermediate_size (
int, opcional, padrão3072) — Dimensão das representações do MLP. - hidden_act (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], opcional, padrão0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no codificador e no pooler. - attention_probs_dropout_prob (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - max_position_embeddings (
int, opcional, padrão512) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - type_vocab_size (
int, opcional, padrão2) — O tamanho do vocabulário dostoken_type_ids. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-12) — O epsilon usado pelas camadas de normalização de camada. - pad_token_id (
int, opcional, padrão0) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário. - projection_dim (
int, opcional, padrão0) — Dimensão das camadas de projeção de texto e visão. - is_decoder (
bool, opcional, padrãoFalse) — Indica se o modelo é usado como decodificador ou não. SeFalse, o modelo é usado como codificador. - add_cross_attention (
bool, opcional, padrãoFalse) — Se camadas de atenção cruzada devem ser adicionadas ao modelo.
Esta é a classe de configuração para armazenar a configuração de um DPRQuestionEncoder. Ela é usada para instanciar um modelo Dpr 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/dpr-ctx_encoder-single-nq-base
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> from transformers import DPRConfig, DPRContextEncoder
>>> # Initializing a DPR facebook/dpr-ctx_encoder-single-nq-base style configuration
>>> configuration = DPRConfig()
>>> # Initializing a model (with random weights) from the facebook/dpr-ctx_encoder-single-nq-base style configuration
>>> model = DPRContextEncoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configDPRContextEncoderTokenizer
Construa um tokenizer DPRContextEncoder.
DPRContextEncoderTokenizer é idêntico ao BertTokenizer e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.
Consulte a superclasse BertTokenizer para exemplos de uso e documentação sobre os parâmetros.
DPRContextEncoderTokenizerFast
classe transformers.DPRContextEncoderTokenizerFast
< source >( vocab: str | dict[str, int] | None = Nonedo_lower_case: bool = Trueunk_token: str = '[UNK]'sep_token: str = '[SEP]'pad_token: str = '[PAD]'cls_token: str = '[CLS]'mask_token: str = '[MASK]'tokenize_chinese_chars: bool = Truestrip_accents: bool | None = None**kwargs )
Construa um tokenizador “fast” do DPRContextEncoder (baseado na biblioteca tokenizers do HuggingFace).
DPRContextEncoderTokenizerFast é idêntico ao BertTokenizer e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.
Consulte a superclasse BertTokenizer para exemplos de uso e documentação sobre os parâmetros.
DPRQuestionEncoderTokenizer
Constrói um tokenizer DPRQuestionEncoder.
DPRQuestionEncoderTokenizer é idêntico ao BertTokenizer e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.
Consulte a superclasse BertTokenizer para exemplos de uso e documentação sobre os parâmetros.
DPRQuestionEncoderTokenizerFast
classe transformers.DPRQuestionEncoderTokenizerFast
< source >( vocab: str | dict[str, int] | None = Nonedo_lower_case: bool = Trueunk_token: str = '[UNK]'sep_token: str = '[SEP]'pad_token: str = '[PAD]'cls_token: str = '[CLS]'mask_token: str = '[MASK]'tokenize_chinese_chars: bool = Truestrip_accents: bool | None = None**kwargs )
Constrói um tokenizador “rápido” DPRQuestionEncoder (baseado na biblioteca tokenizers do HuggingFace).
DPRQuestionEncoderTokenizerFast é idêntico ao BertTokenizer e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece.
Consulte a superclasse BertTokenizer para exemplos de uso e documentação sobre os parâmetros.
DPRReaderTokenizer
classe transformers.DPRReaderTokenizer
< source >( *argsdo_lower_case = False**kwargs ) → dict[str, list[list[int]]]
Parâmetros
- questions (
stroulist[str]) — As perguntas a serem codificadas. Você pode especificar uma pergunta para muitas passagens. Nesse caso, a pergunta será duplicada como[questions] * n_passages. Caso contrário, você deve especificar tantas perguntas quanto emtitlesoutexts. - titles (
stroulist[str]) — Os títulos das passagens a serem codificados. Isso pode ser uma string ou uma lista de strings, caso haja várias passagens. - texts (
stroulist[str]) — Os textos das passagens a serem codificados. Pode ser uma string ou uma lista de strings, caso haja várias passagens. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido.'only_first': Trunca para o comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.'only_second': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo Numpy.
- return_attention_mask (
bool, opcional) — Indica se a attention mask deve ser retornada. Se não for definido, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributoreturn_outputs.
Retorna
dict[str, list[list[int]]]
Um dicionário com as seguintes chaves:
input_ids: Lista de ids de tokens a serem fornecidos a um modelo.attention_mask: Lista de índices que especifica quais tokens devem ser considerados pelo modelo.
Construa um tokenizer DPRReader.
DPRReaderTokenizer é quase idêntico ao BertTokenizer e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece. A diferença é que ele possui três strings de entrada: question, titles e texts, que são combinadas para serem fornecidas ao modelo DPRReader.
Consulte a superclasse BertTokenizer para exemplos de uso e documentação sobre os parâmetros.
Retorna um dicionário com os ids dos tokens das strings de entrada e outras informações para passar a .decode_best_spans.
Ele converte as strings de uma pergunta e de diferentes passagens (título e texto) em uma sequência de IDs (inteiros),
usando o tokenizer e o vocabulário. O input_ids resultante é uma matriz de tamanho (n_passages, sequence_length)
DPRReaderTokenizerFast
classe transformers.DPRReaderTokenizerFast
< source >( vocab: str | dict[str, int] | None = Nonedo_lower_case: bool = Trueunk_token: str = '[UNK]'sep_token: str = '[SEP]'pad_token: str = '[PAD]'cls_token: str = '[CLS]'mask_token: str = '[MASK]'tokenize_chinese_chars: bool = Truestrip_accents: bool | None = None**kwargs ) → dict[str, list[list[int]]]
Parâmetros
- questions (
stroulist[str]) — As perguntas a serem codificadas. Você pode especificar uma pergunta para muitas passagens. Nesse caso, a pergunta será duplicada como[questions] * n_passages. Caso contrário, você deve especificar tantas perguntas quanto emtitlesoutexts. - titles (
stroulist[str]) — Os títulos das passagens a serem codificados. Isso pode ser uma string ou uma lista de strings, caso haja várias passagens. - texts (
stroulist[str]) — Os textos das passagens a serem codificados. Pode ser uma string ou uma lista de strings, caso haja várias passagens. - padding (
bool,strou PaddingStrategy, opcional, padrão éFalse) — Ativa e controla o padding. Aceita os seguintes valores:Trueou'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).'max_length': Preenche até o comprimento máximo especificado com o argumentomax_lengthou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.Falseou'do_not_pad'(padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
- truncation (
bool,strou TruncationStrategy, opcional, padrão éFalse) — Ativa e controla a truncagem. Aceita os seguintes valores:Trueou'longest_first': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido.'only_first': Trunca para o comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.'only_second': Trunca para um comprimento máximo especificado com o argumentomax_lengthou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.Falseou'do_not_truncate'(padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
- max_length (
int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.Se não for definido ou for definido como
None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado. - return_tensors (
strou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:'pt': Retorna objetostorch.Tensordo PyTorch.'np': Retorna objetosnp.ndarraydo Numpy.
- return_attention_mask (
bool, opcional) — Indica se a attention mask deve ser retornada. Se não for definido, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributoreturn_outputs.
Retorna
dict[str, list[list[int]]]
Um dicionário com as seguintes chaves:
input_ids: Lista de ids de tokens a serem fornecidos a um modelo.attention_mask: Lista de índices que especifica quais tokens devem ser considerados pelo modelo.
Constrói um tokenizador DPRReader “rápido” (baseado na biblioteca tokenizers do HuggingFace).
DPRReaderTokenizerFast é quase idêntico ao BertTokenizer e executa a tokenização de ponta a ponta: divisão de pontuação e wordpiece. A diferença é que ele possui três strings de entrada: question, titles e texts, que são combinadas para serem fornecidas ao modelo DPRReader.
Consulte a superclasse BertTokenizer para exemplos de uso e documentação sobre os parâmetros.
Retorna um dicionário com os ids dos tokens das strings de entrada e outras informações para passar a .decode_best_spans.
Ele converte as strings de uma pergunta e de diferentes passagens (título e texto) em uma sequência de IDs (inteiros),
usando o tokenizer e o vocabulário. O input_ids resultante é uma matriz de tamanho (n_passages, sequence_length) com o formato:
[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>
Saídas específicas do DPR
classe transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput
< source >( pooler_output: Tensorhidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- pooler_output (
torch.Tensorde forma(batch_size, embeddings_size)) — O codificador DPR produz o pooler_output que corresponde à representação do contexto. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar contextos para consultas de vizinhos mais próximos com incorporações de perguntas. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Classe para as saídas de DPRQuestionEncoder.
classe transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput
< source >( pooler_output: Tensorhidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- pooler_output (
torch.Tensorde forma(batch_size, embeddings_size)) — O codificador DPR produz o pooler_output que corresponde à representação da pergunta. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar perguntas para consultas de vizinhos mais próximos com incorporações de contexto. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Classe para as saídas de DPRQuestionEncoder.
classe transformers.DPRReaderOutput
< source >( start_logits: Tensorend_logits: typing.Optional[torch.Tensor] = Nonerelevance_logits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Parâmetros
- start_logits (
torch.Tensorde forma(n_passages, sequence_length)) — Logits do índice inicial do trecho para cada passagem. - end_logits (
torch.Tensorde forma(n_passages, sequence_length)) — Logits do índice final do trecho para cada passagem. - relevance_logits (
torch.Tensorde forma(n_passages, )) — Saídas do classificador de QA do DPRReader que correspondem às pontuações de cada passagem para responder à pergunta, em comparação com todas as outras passagens. - hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.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 nos cabeçalhos de autoatenção.
Classe para as saídas de DPRQuestionEncoder.
DPRContextEncoder
classe transformers.DPRContextEncoder
< source >( config: DPRConfig )
Parâmetros
- config (DPRConfig) — 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() para carregar os pesos do modelo.
O transformador DPRContextEncoder puro, que produz as saídas do pooler como representações de contexto.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DPRContextEncoderOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. Para corresponder ao pré-treinamento, a sequência de entrada do DPR deve ser formatada com os tokens [CLS] e [SEP] da seguinte forma:(a) Para pares de sequências (por exemplo, um par título + texto):
- attention_mask (
torch.Tensorde 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.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0, 1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token de sentence B.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
DPRContextEncoderOutput ou tuple(torch.Tensor)
Um DPRContextEncoderOutput 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 (DPRConfig) e das entradas.
O método forward de DPRContextEncoder 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
Moduleem 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.
pooler_output (
torch.Tensorde forma(batch_size, embeddings_size)) — O codificador DPR produz o pooler_output que corresponde à representação do contexto. Estado oculto da última camada do primeiro token da sequência (token de classificação) processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar contextos para consultas de vizinhos mais próximos com incorporações de perguntas.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
token_type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1(b) Para sequências únicas (por exemplo, para uma pergunta):
tokens: [CLS] the dog is hairy . [SEP]
token_type_ids: 0 0 0 0 0 0 0O DPR é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher os inputs à direita em vez da esquerda.
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Exemplos:
>>> from transformers import DPRContextEncoder, DPRContextEncoderTokenizer
>>> tokenizer = DPRContextEncoderTokenizer.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> model = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"]
>>> embeddings = model(input_ids).pooler_outputDPRQuestionEncoder
classe transformers.DPRQuestionEncoder
< source >( config: DPRConfig )
Parâmetros
- config (DPRConfig) — 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() para carregar os pesos do modelo.
O transformador DPRQuestionEncoder puro, que produz saídas do pooler como representações de perguntas.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DPRQuestionEncoderOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. Para corresponder ao pré-treinamento, a sequência de entrada do DPR deve ser formatada com os tokens [CLS] e [SEP] da seguinte forma:(a) Para pares de sequências (por exemplo, um par título + texto):
- attention_mask (
torch.Tensorde 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.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0, 1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token de sentence B.
- inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
DPRQuestionEncoderOutput ou tuple(torch.Tensor)
Um DPRQuestionEncoderOutput 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 (DPRConfig) e das entradas.
O método forward de DPRQuestionEncoder 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
Moduleem 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.
pooler_output (
torch.Tensorde forma(batch_size, embeddings_size)) — O codificador DPR produz o pooler_output que corresponde à representação da pergunta. Estado oculto da última camada do primeiro token da sequência (token de classificação), processado adicionalmente por uma camada Linear. Esta saída deve ser usada para incorporar perguntas para consultas de vizinhos mais próximos com incorporações de contexto.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
tokens: [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
token_type_ids: 0 0 0 0 0 0 0 0 1 1 1 1 1 1(b) Para sequências únicas (por exemplo, para uma pergunta):
tokens: [CLS] the dog is hairy . [SEP]
token_type_ids: 0 0 0 0 0 0 0O DPR é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher os inputs à direita em vez da esquerda.
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
Exemplos:
>>> from transformers import DPRQuestionEncoder, DPRQuestionEncoderTokenizer
>>> tokenizer = DPRQuestionEncoderTokenizer.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> model = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
>>> input_ids = tokenizer("Hello, is my dog cute ?", return_tensors="pt")["input_ids"]
>>> embeddings = model(input_ids).pooler_outputDPRReader
classe transformers.DPRReader
< source >( config: DPRConfig )
Parâmetros
- config (DPRConfig) — 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() para carregar os pesos do modelo.
O transformador DPRReader puro que gera previsões de trechos.
Este modelo herda de 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DPRReaderOutput or tuple(torch.Tensor)
Parâmetros
- input_ids (
tuple[torch.LongTensor]de formas(n_passages, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. Deve ser uma tríade de sequências com 1) a pergunta, 2) os títulos das passagens e 3) os textos das passagens. Para corresponder ao pré-treinamento, o DPRinput_idsa sequência deve ser formatada com [CLS] e [SEP] no formato:[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>O DPR é um modelo com embeddings de posição absoluta, portanto, geralmente é recomendado preencher os inputs à direita em vez da esquerda.
Os índices podem ser obtidos usando DPRReaderTokenizer. Consulte a documentação desta classe para mais detalhes.
- attention_mask (
torch.Tensorde 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.
- inputs_embeds (
torch.Tensorde forma(n_passages, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - output_attentions (
bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulteattentionsnos tensores retornados para mais detalhes. - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
DPRReaderOutput ou tuple(torch.Tensor)
Um DPRReaderOutput 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 (DPRConfig) e das entradas.
O método forward do DPRReader 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
Moduleem 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.
start_logits (
torch.Tensorde forma(n_passages, sequence_length)) — Logits do índice inicial do trecho para cada passagem.end_logits (
torch.Tensorde forma(n_passages, sequence_length)) — Logits do índice final do trecho para cada passagem.relevance_logits (
torch.Tensorde forma(n_passages, )) — Saídas do classificador de QA do DPRReader que correspondem às pontuações de cada passagem para responder à pergunta, em comparação com todas as outras passagens.hidden_states (
tuple[torch.Tensor, ...], opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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 quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com 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 nos cabeçalhos de autoatenção.
Exemplos:
>>> from transformers import DPRReader, DPRReaderTokenizer
>>> tokenizer = DPRReaderTokenizer.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> model = DPRReader.from_pretrained("facebook/dpr-reader-single-nq-base")
>>> encoded_inputs = tokenizer(
... questions=["What is love ?"],
... titles=["Haddaway"],
... texts=["'What Is Love' is a song recorded by the artist Haddaway"],
... return_tensors="pt",
... )
>>> outputs = model(**encoded_inputs)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> relevance_logits = outputs.relevance_logits