Transformers documentation
DPR
Ce modèle a été publié dans HF papers le 2020-04-10 et ajouté à Hugging Face Transformers le 2020-11-16.
DPR
Aperçu
Dense Passage Retrieval (DPR) est un ensemble d’outils et de modèles pour la recherche de pointe en Q&A à domaine ouvert. Il a été introduit dans Dense Passage Retrieval for Open-Domain Question Answering par Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, Wen-tau Yih.
L'abstract de l'article est le suivant :
La réponse à des questions en domaine ouvert repose sur une récupération efficace de passages pour sélectionner des contextes candidats, où les modèles traditionnels d’espace vectoriel creux, tels que TF-IDF ou BM25, sont la méthode de fait. Dans ce travail, nous montrons que la récupération peut être mise en œuvre de manière pratique en utilisant uniquement des représentations denses, où les plongements sont appris à partir d’un petit nombre de questions et de passages par un simple cadre à double encodeur. Évalué sur une large gamme de jeux de données de QA en domaine ouvert, notre récupérateur dense surpasse un système Lucene-BM25 robuste, avec une amélioration absolue de 9 % à 19 % en termes de précision de récupération des 20 meilleurs passages, et aide notre système de QA de bout en bout à établir de nouveaux états de l’art sur plusieurs benchmarks de QA en domaine ouvert.
Ce modèle a été contribué par lhoestq. Le code d'origine peut être trouvé ici.
Conseils d'utilisation
DPR se compose de trois modèles :
- Encodeur de questions : encode les questions sous forme de vecteurs
- Encodeur de contexte : encode les contextes sous forme de vecteurs
- Lecteur : extrait la réponse aux questions présentes dans les contextes récupérés, accompagnée d'un score de pertinence (élevé si l'inférence de l'extraire répond réellement à la question).
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 )
Paramètres
- vocab_size (
int, facultatif, par défaut30522) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - intermediate_size (
int, facultatif, par défaut3072) — Dimension des représentations du MLP. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], facultatif, par défaut0.1) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler. - attention_probs_dropout_prob (
Union[float, int], facultatif, par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - max_position_embeddings (
int, facultatif, par défaut512) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - type_vocab_size (
int, facultatif, par défaut2) — La taille du vocabulaire destoken_type_ids. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - layer_norm_eps (
float, facultatif, valeur par défaut1e-12) — L'épsilon utilisé par les couches de normalisation de couche. - pad_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - projection_dim (
int, facultatif, par défaut0) — Dimension des couches de projection du texte et de la vision. - is_decoder (
bool, facultatif, par défautFalse) — Indique si le modèle est utilisé comme décodeur ou non. SiFalse, le modèle est utilisé comme encodeur. - add_cross_attention (
bool, facultatif, valeur par défautFalse) — Indique si des couches d'attention croisée doivent être ajoutées au modèle.
Ceci est la classe de configuration destinée à stocker la configuration d'un DPRQuestionEncoder. Elle est utilisée pour instancier un modèle Dpr en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de facebook/dpr-ctx_encoder-single-nq-base
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> from transformers import 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
Construisez un tokenizer DPRContextEncoder.
DPRContextEncoderTokenizer est identique à BertTokenizer et exécute la tokenisation de bout en bout : séparation de la ponctuation et wordpiece.
Reportez-vous à la superclasse BertTokenizer pour des exemples d'utilisation et la documentation concernant les paramètres.
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 )
Construire un tokenizer « rapide » DPRContextEncoder (basé sur la bibliothèque tokenizers de HuggingFace).
DPRContextEncoderTokenizerFast est identique à BertTokenizer et exécute la tokenisation de bout en bout : séparation de la ponctuation et wordpiece.
Reportez-vous à la superclasse BertTokenizer pour des exemples d'utilisation et la documentation concernant les paramètres.
DPRQuestionEncoderTokenizer
Construit un tokenizer DPRQuestionEncoder.
DPRQuestionEncoderTokenizer est identique à BertTokenizer et exécute la tokenisation de bout en bout : séparation de la ponctuation et wordpiece.
Reportez-vous à la superclasse BertTokenizer pour des exemples d'utilisation et la documentation concernant les paramètres.
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 )
Construit un tokenizer « rapide » DPRQuestionEncoder (basé sur la bibliothèque tokenizers de HuggingFace).
DPRQuestionEncoderTokenizerFast est identique à BertTokenizer et exécute la tokenisation de bout en bout : séparation de la ponctuation et wordpiece.
Reportez-vous à la superclasse BertTokenizer pour des exemples d'utilisation et la documentation concernant les paramètres.
DPRReaderTokenizer
classe transformers.DPRReaderTokenizer
< source >( *argsdo_lower_case = False**kwargs ) → dict[str, list[list[int]]]
Paramètres
- questions (
stroulist[str]) — Les questions à encoder. Vous pouvez spécifier une seule question pour de nombreux passages. Dans ce cas, la question sera dupliquée comme[questions] * n_passages. Sinon, vous devez spécifier autant de questions que danstitlesoutexts. - titles (
stroulist[str]) — Les titres des passages à encoder. Il peut s’agir d’une chaîne de caractères ou d’une liste de chaînes de caractères s’il y a plusieurs passages. - texts (
stroulist[str]) — Les textes des passages à encoder. Il peut s’agir d’une chaîne de caractères ou d’une liste de chaînes de caractères s’il y a plusieurs passages. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni. Le tronquage s’effectue jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.'only_first': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.'only_second': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets Numpynp.ndarray.
- return_attention_mask (
bool, facultatif) — Indique s'il faut renvoyer le masque d'attention. Si non défini, le masque d'attention est renvoyé selon la valeur par défaut du tokenizer spécifique, définie par l'attributreturn_outputs.
Retourne
dict[str, list[list[int]]]
Un dictionnaire avec les clés suivantes :
input_ids: Liste des identifiants de jetons à fournir à un modèle.attention_mask: Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention.
Construisez un tokenizer DPRReader.
DPRReaderTokenizer est quasi identique à BertTokenizer et exécute la tokenisation de bout en bout : séparation de la ponctuation et wordpiece. La différence est qu’il possède trois chaînes d’entrée : question, titles et texts, qui sont combinées pour être transmises au modèle DPRReader.
Reportez-vous à la superclasse BertTokenizer pour des exemples d'utilisation et la documentation concernant les paramètres.
Retourne un dictionnaire contenant les identifiants de jetons des chaînes d’entrée ainsi que d’autres informations à transmettre à .decode_best_spans.
Il convertit les chaînes d’une question et de différents passages (titre et texte) en une séquence d’identifiants (entiers),
en utilisant le tokeniseur et le vocabulaire. Le input_ids résultant est une matrice de taille (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]]]
Paramètres
- questions (
stroulist[str]) — Les questions à encoder. Vous pouvez spécifier une seule question pour de nombreux passages. Dans ce cas, la question sera dupliquée comme[questions] * n_passages. Sinon, vous devez spécifier autant de questions que danstitlesoutexts. - titles (
stroulist[str]) — Les titres des passages à encoder. Il peut s’agir d’une chaîne de caractères ou d’une liste de chaînes de caractères s’il y a plusieurs passages. - texts (
stroulist[str]) — Les textes des passages à encoder. Il peut s’agir d’une chaîne de caractères ou d’une liste de chaînes de caractères s’il y a plusieurs passages. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni. Le tronquage s’effectue jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.'only_first': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.'only_second': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets Numpynp.ndarray.
- return_attention_mask (
bool, facultatif) — Indique s'il faut renvoyer le masque d'attention. Si non défini, le masque d'attention est renvoyé selon la valeur par défaut du tokenizer spécifique, définie par l'attributreturn_outputs.
Retourne
dict[str, list[list[int]]]
Un dictionnaire avec les clés suivantes :
input_ids: Liste des identifiants de jetons à fournir à un modèle.attention_mask: Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention.
Construit un tokenizer « rapide » DPRReader (basé sur la bibliothèque tokenizers de HuggingFace).
DPRReaderTokenizerFast est quasi identique à BertTokenizer et exécute la tokenisation de bout en bout : séparation de la ponctuation et wordpiece. La différence est qu'il possède trois chaînes d'entrée : question, titles et texts qui sont combinées pour être fournies au modèle DPRReader.
Reportez-vous à la superclasse BertTokenizer pour des exemples d'utilisation et la documentation concernant les paramètres.
Retourne un dictionnaire contenant les identifiants de jetons des chaînes d’entrée ainsi que d’autres informations à transmettre à .decode_best_spans.
Il convertit les chaînes d’une question et de différents passages (titre et texte) en une séquence d’identifiants (entiers),
en utilisant le tokeniseur et le vocabulaire. Le input_ids résultant est une matrice de taille (n_passages, sequence_length) au format suivant :
[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>
Sorties spécifiques à DPR
classe transformers.models.dpr.modeling_dpr.DPRContextEncoderOutput
< source >( pooler_output: Tensorhidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- pooler_output (
torch.Tensorde forme(batch_size, embeddings_size)) — L’encodeur DPR renvoie le pooler_output qui correspond à la représentation du contexte. État caché de la dernière couche du premier jeton de la séquence (jeton de classification), traité ensuite par une couche Linear. Cette sortie est destinée à intégrer les contextes pour des requêtes de plus proches voisins avec les embeddings des questions. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Classe pour les sorties de DPRQuestionEncoder.
classe transformers.models.dpr.modeling_dpr.DPRQuestionEncoderOutput
< source >( pooler_output: Tensorhidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )
Paramètres
- pooler_output (
torch.Tensorde forme(batch_size, embeddings_size)) — L’encodeur DPR renvoie le pooler_output qui correspond à la représentation de la question. État caché de la dernière couche du premier jeton de la séquence (jeton de classification), traité ensuite par une couche Linear. Cette sortie est destinée à intégrer les questions pour des requêtes de plus proches voisins avec les intégrations de contexte. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Classe pour les sorties 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 )
Paramètres
- start_logits (
torch.Tensorde forme(n_passages, sequence_length)) — Logits de l'indice de début de la portée pour chaque passage. - end_logits (
torch.Tensorde forme(n_passages, sequence_length)) — Logits de l'indice de fin de l'intervalle pour chaque passage. - relevance_logits (
torch.Tensorde forme(n_passages, )) — Sorties du classifieur QA du DPRReader, correspondant aux scores de chaque passage pour répondre à la question, par rapport à tous les autres passages. - hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Classe pour les sorties de DPRQuestionEncoder.
DPRContextEncoder
classe transformers.DPRContextEncoder
< source >( config: DPRConfig )
Paramètres
- config (DPRConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le transformateur DPRContextEncoder brut, qui produit des sorties de pooler en tant que représentations de contexte.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Pour correspondre à la préformation, la séquence d'entrée DPR doit être formatée avec les jetons [CLS] et [SEP] comme suit :(a) Pour des paires de séquences (par exemple, une paire titre + texte) :
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
DPRContextEncoderOutput ou tuple(torch.Tensor)
Un DPRContextEncoderOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DPRConfig) et des entrées.
La méthode forward de DPRContextEncoder redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
pooler_output (
torch.Tensorde forme(batch_size, embeddings_size)) — L’encodeur DPR renvoie le pooler_output qui correspond à la représentation du contexte. État caché de la dernière couche du premier jeton de la séquence (jeton de classification), traité ensuite par une couche linéaire. Cette sortie est destinée à intégrer les contextes pour des requêtes de plus proches voisins avec les intégrations des questions.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
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) Pour des séquences uniques (par exemple, pour une question) :
tokens: [CLS] the dog is hairy . [SEP]
token_type_ids: 0 0 0 0 0 0 0DPR est un modèle avec des embeddings de position absolus, il est donc généralement conseillé de compléter les entrées à droite plutôt qu’à gauche.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Exemples :
>>> 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 )
Paramètres
- config (DPRConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le transformateur DPRQuestionEncoder brut, qui produit des sorties de pooler en tant que représentations de questions.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Pour correspondre à la préformation, la séquence d'entrée DPR doit être formatée avec les jetons [CLS] et [SEP] comme suit :(a) Pour des paires de séquences (par exemple, une paire titre + texte) :
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
DPRQuestionEncoderOutput ou tuple(torch.Tensor)
Un DPRQuestionEncoderOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DPRConfig) et des entrées.
La méthode forward de DPRQuestionEncoder redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
pooler_output (
torch.Tensorde forme(batch_size, embeddings_size)) — L’encodeur DPR renvoie le pooler_output qui correspond à la représentation de la question. État caché de la dernière couche du premier jeton de la séquence (jeton de classification), traité ensuite par une couche linéaire. Cette sortie est destinée à intégrer les questions pour des requêtes de plus proches voisins avec les intégrations de contexte.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
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) Pour des séquences uniques (par exemple, pour une question) :
tokens: [CLS] the dog is hairy . [SEP]
token_type_ids: 0 0 0 0 0 0 0DPR est un modèle avec des embeddings de position absolus, il est donc généralement conseillé de compléter les entrées à droite plutôt qu’à gauche.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Exemples :
>>> 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 )
Paramètres
- config (DPRConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le transformateur DPRReader brut produisant des prédictions d'intervalles.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- input_ids (
tuple[torch.LongTensor]de formes(n_passages, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Il doit s'agir d'un triplet de séquences composé de 1) la question, 2) les titres des passages et 3) les textes des passages. Pour correspondre au pré-entraînement, la séquenceinput_idsdoit être formatée avec [CLS] et [SEP] selon le format : [CLS] <identifiants des jetons de la question> [SEP] <identifiants des titres> [SEP] <identifiants des textes>. DPR est un modèle avec des embeddings de position absolus, il est donc généralement conseillé de compléter les entrées à droite plutôt qu'à gauche. Les indices peuvent être obtenus à l'aide de DPRReaderTokenizer. Consultez la documentation de cette classe pour plus de détails. Que sont les identifiants d'entrée ?[CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>DPR est un modèle avec des embeddings de position absolus, il est donc généralement conseillé de compléter les entrées à droite plutôt qu’à gauche.
Les indices peuvent être obtenus à l'aide de DPRReaderTokenizer. Consultez la documentation de cette classe pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- inputs_embeds (
torch.Tensorde forme(n_passages, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
DPRReaderOutput ou tuple(torch.Tensor)
Un DPRReaderOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DPRConfig) et des entrées.
La méthode forward de DPRReader redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
start_logits (
torch.Tensorde forme(n_passages, sequence_length)) — Logits de l'indice de début de la portée pour chaque passage.end_logits (
torch.Tensorde forme(n_passages, sequence_length)) — Logits de l'indice de fin de l'intervalle pour chaque passage.relevance_logits (
torch.Tensorde forme(n_passages, )) — Sorties du classifieur QA du DPRReader, correspondant aux scores de chaque passage pour répondre à la question, par rapport à tous les autres passages.hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> 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