Transformers documentation
LUKE
Este modelo se publicó en HF papers el 2020-10-02 y se contribuyó a Hugging Face Transformers el 2021-05-03.
LUKE
Resumen
El modelo LUKE se propuso en LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention por Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda y Yuji Matsumoto. Se basa en RoBERTa y añade embeddings de entidades, así como un mecanismo de autoatención consciente de entidades, lo que ayuda a mejorar el rendimiento en diversas tareas de nivel inferior que implican razonamiento sobre entidades, como el reconocimiento de entidades nombradas, la respuesta a preguntas extractiva y de estilo cloze, la tipificación de entidades y la clasificación de relaciones.
El resumen del artículo es el siguiente:
Las representaciones de entidades son útiles en tareas de lenguaje natural que involucran entidades. En este artículo, proponemos nuevas representaciones contextualizadas preentrenadas de palabras y entidades basadas en el transformador bidireccional. El modelo propuesto trata las palabras y las entidades de un texto dado como tokens independientes y genera representaciones contextualizadas de estos. Nuestro modelo se entrena utilizando una nueva tarea de preentrenamiento basada en el modelo de lenguaje enmascarado de BERT. La tarea consiste en predecir palabras y entidades enmascaradas aleatoriamente en un gran corpus anotado con entidades recuperado de Wikipedia. También proponemos un mecanismo de autoatención consciente de entidades, que es una extensión del mecanismo de autoatención del transformador y que considera los tipos de tokens (palabras o entidades) al calcular las puntuaciones de atención. El modelo propuesto logra un rendimiento empírico impresionante en una amplia gama de tareas relacionadas con entidades. En particular, obtiene resultados de estado del arte en cinco conjuntos de datos bien conocidos: Open Entity (tipificación de entidades), TACRED (clasificación de relaciones), CoNLL-2003 (reconocimiento de entidades nombradas), ReCoRD (respuesta a preguntas de estilo cloze) y SQuAD 1.1 (respuesta a preguntas extractiva).
Este modelo fue aportado por ikuyamada y nielsr. El código original se puede encontrar aquí.
Consejos de uso
Esta implementación es la misma que RobertaModel con la adición de embeddings de entidades, así como un mecanismo de autoatención consciente de las entidades, que mejora el rendimiento en tareas que implican razonamiento sobre entidades.
LUKE trata las entidades como tokens de entrada; por lo tanto, toma
entity_ids,entity_attention_mask,entity_token_type_idsyentity_position_idscomo entrada adicional. Puedes obtenerlos usando LukeTokenizer.LukeTokenizer toma
entitiesyentity_spans(posiciones de inicio y fin basadas en caracteres de las entidades en el texto de entrada) como entrada adicional.entitiessuele consistir en entidades [MASK] o entidades de Wikipedia. La breve descripción al ingresar estas entidades es la siguiente:- Introducir entidades [MASK] para calcular representaciones de entidades: la entidad [MASK] se utiliza para enmascarar las entidades que se deben predecir durante el preentrenamiento. Cuando LUKE recibe la entidad [MASK], intenta predecir la entidad original recopilando información sobre la entidad a partir del texto de entrada. Por lo tanto, la entidad [MASK] puede utilizarse para abordar tareas de nivel inferior que requieren información sobre las entidades en el texto, como la tipificación de entidades, la clasificación de relaciones y el reconocimiento de entidades nombradas.
- Introducir entidades de Wikipedia para calcular representaciones de tokens enriquecidas con conocimiento: LUKE aprende información rica (o conocimiento) sobre las entidades de Wikipedia durante el preentrenamiento y almacena esa información en su embedding de entidad. Al utilizar las entidades de Wikipedia como tokens de entrada, LUKE genera representaciones de tokens enriquecidas con la información almacenada en los embeddings de estas entidades. Esto resulta especialmente eficaz para tareas que requieren conocimiento del mundo real, como la respuesta a preguntas.
Hay tres modelos de cabeza para el caso de uso anterior:
- LukeForEntityClassification, para tareas de clasificación de una única entidad en un texto de entrada, como la tipificación de entidades, p. ej. el conjunto de datos Open Entity. Este modelo coloca una capa lineal sobre la representación de salida de la entidad.
- LukeForEntityPairClassification, para tareas de clasificación de la relación entre dos entidades, como la clasificación de relaciones, p. ej. el conjunto de datos TACRED. Este modelo coloca una capa lineal sobre la representación de salida concatenada del par de entidades dadas.
- LukeForEntitySpanClassification, para tareas de clasificación de secuencias de tramos de entidades, como el reconocimiento de entidades nombradas (NER). Este modelo coloca una cabeza lineal sobre las representaciones de salida de las entidades. Puedes abordar el NER con este modelo introduciendo en el modelo todos los tramos de entidades posibles en el texto.
LukeTokenizer tiene un argumento
taskque te permite crear fácilmente una entrada para estos modelos de cabeza especificandotask="entity_classification",task="entity_pair_classification"otask="entity_span_classification". Consulta el código de ejemplo de cada modelo de cabeza.
Ejemplo de uso:
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer
model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"
text = "Beyoncé lives in Los Angeles."
entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations
entities = [
"Beyoncé",
"Los Angeles",
] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model
model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])Recursos
- Un cuaderno de demostración sobre cómo ajustar [LukeForEntityPairClassification](/docs/transformers/main/en/model_doc/luke#transformers.LukeForEntityPairClassification) para la clasificación de relaciones
- Notebooks que muestran cómo reproducir los resultados reportados en el artículo con la implementación de LUKE de HuggingFace
- Guía de la tarea de clasificación de texto
- Guía de la tarea de clasificación de tokens
- Guía de la tarea de respuesta a preguntas
- Guía de la tarea de modelado de lenguaje enmascarado
- Guía de tareas de selección múltiple
LukeConfig
clase transformers.LukeConfig
< 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 = 50267entity_vocab_size: int = 500000hidden_size: int = 768entity_emb_size: int = 256num_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-12use_entity_aware_attention: bool = Trueclassifier_dropout: float | int | None = Nonepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
Parámetros
- vocab_size (
int, opcional, valor predeterminado50267) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - entity_vocab_size (
int, opcional, valor predeterminado 500000) — Tamaño del vocabulario de entidades del modelo LUKE. Define el número de entidades diferentes que pueden representarse mediante losentity_idspasados al llamar a LukeModel. - hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - entity_emb_size (
int, opcional, valor predeterminado 256) — El número de dimensiones del embedding de entidad. - num_hidden_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - intermediate_size (
int, opcional, valor predeterminado3072) — Dimensión de las representaciones del MLP. - hidden_act (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], opcional, valor predeterminado0.1) — La probabilidad de dropout para todas las capas totalmente conectadas en las incrustaciones, el codificador y el pooler. - attention_probs_dropout_prob (
Union[float, int], opcional, valor predeterminado0.1) — La proporción de dropout para las probabilidades de atención. - max_position_embeddings (
int, opcional, valor predeterminado512) — La longitud máxima de secuencia con la que se podría utilizar este modelo. - type_vocab_size (
int, opcional, valor predeterminado2) — El tamaño del vocabulario detoken_type_ids. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - layer_norm_eps (
float, opcional, valor predeterminado1e-12) — El epsilon utilizado por las capas de normalización de capa. - use_entity_aware_attention (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe o no utilizar el mecanismo de autoatención consciente de entidades propuesto en LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.). - classifier_dropout (
Union[float, int], opcional) — La proporción de dropout para el clasificador. - pad_token_id (
int, opcional, valor predeterminado1) — Id del token utilizado para el relleno en el vocabulario. - bos_token_id (
int, opcional, valor predeterminado0) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional, valor predeterminado2) — Identificador de token utilizado para el fin de secuencia en el vocabulario. - tie_word_embeddings (
bool, opcional, valor predeterminadoTrue) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo.
Esta es la clase de configuración para almacenar la configuración de un LukeModel. Se utiliza para instanciar un modelo Luke según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de studio-ousia/luke-base
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
LukeTokenizer
clase transformers.LukeTokenizer
< source >( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneentity_vocab: str | dict | list | None = Noneerrors = 'replace'bos_token = '<s>'eos_token = '</s>'sep_token = '</s>'cls_token = '<s>'unk_token = '<unk>'pad_token = '<pad>'mask_token = '<mask>'add_prefix_space = Falsetask = Nonemax_entity_length = 32max_mention_length = 30entity_1_token = '<ent>'entity_2_token = '<ent2>'entity_unk_token = '[UNK]'entity_pad_token = '[PAD]'entity_mask_token = '[MASK]'entity_mask2_token = '[MASK2]'**kwargs )
Parámetros
- vocab_file (
str) — Ruta al archivo de vocabulario. - merges_file (
str) — Ruta al archivo de fusiones. - vocab (
strodict[str, int], opcional) — Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desdevocab_file. - merges (
strolist[str], opcional) — Lista de fusiones personalizada. Si no se proporciona, las fusiones se cargan desdemerges_file. - entity_vocab_file (
str) — Ruta al archivo de vocabulario de entidades. - task (
str, opcional) — Tarea para la que deseas preparar las secuencias. Una de"entity_classification","entity_pair_classification"o"entity_span_classification". Si especificas este argumento, la secuencia de entidades se crea automáticamente en función del o los tramos de entidad dados. - max_entity_length (
int, opcional, valor predeterminado 32) — La longitud máxima deentity_ids. - max_mention_length (
int, opcional, valor predeterminado 30) — El número máximo de tokens dentro de un tramo de entidad. - entity_1_token (
str, opcional, valor predeterminado<ent>) — El token especial utilizado para representar un tramo de entidad en una secuencia de tokens de palabras. Este token solo se utiliza cuandotaskestá establecido en"entity_classification"o"entity_pair_classification". - entity_2_token (
str, opcional, valor predeterminado<ent2>) — El token especial utilizado para representar un tramo de entidad en una secuencia de tokens de palabras. Este token solo se utiliza cuandotaskestá establecido en"entity_pair_classification". - errors (
str, opcional, valor predeterminado"replace") — Paradigma a seguir al decodificar bytes a UTF-8. Consulte bytes.decode para obtener más información. - bos_token (
str, opcional, por defecto"<s>") — El token de inicio de secuencia que se utilizó durante el preentrenamiento. Puede usarse como token de clasificador de secuencias. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el inicio de la secuencia. El token que se utiliza es cls_token.Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el inicio de la secuencia. El token que se utiliza es
cls_token. - eos_token (
str, opcional, por defecto es"</s>") — El token de fin de secuencia. Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el fin de la secuencia. El token que se utiliza es sep_token.Al construir una secuencia con tokens especiales, este no es el token que se utiliza para el final de la secuencia. El token que se utiliza es
sep_token. - sep_token (
str, opcional, valor predeterminado"</s>") — El token separador, que se utiliza al construir una secuencia a partir de varias secuencias, por ejemplo, dos secuencias para la clasificación de secuencias o un texto y una pregunta para la respuesta a preguntas. También se utiliza como el último token de una secuencia construida con tokens especiales. - cls_token (
str, opcional, valor predeterminado"<s>") — El token clasificador que se utiliza al realizar clasificación de secuencias (clasificación de la secuencia completa en lugar de clasificación por token). Es el primer token de la secuencia cuando se construye con tokens especiales. - unk_token (
str, opcional, valor predeterminado"<unk>") — El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar. - pad_token (
str, opcional, valor predeterminado"<pad>") — El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes. - mask_token (
str, opcional, valor predeterminado"<mask>") — El token utilizado para enmascarar valores. Este es el token que se emplea al entrenar este modelo con modelado de lenguaje enmascarado. Es el token que el modelo intentará predecir. - add_prefix_space (
bool, opcional, valor predeterminadoFalse) — Indica si se debe añadir un espacio inicial a la entrada. Esto permite tratar la palabra inicial como cualquier otra palabra. (El tokenizador LUKE detecta el inicio de las palabras mediante el espacio que las precede).
Construye un tokenizador LUKE, derivado del tokenizador GPT-2, que utiliza Byte-Pair-Encoding a nivel de bytes.
Este tokenizador se ha entrenado para tratar los espacios como partes de los tokens (un poco como sentencepiece), por lo que una palabra
se codifica de manera diferente si se encuentra al principio de la oración (sin espacio) o no:
>>> from transformers import LukeTokenizer
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]Puede evitar ese comportamiento pasando add_prefix_space=True al instanciar este tokenizer o al llamarlo sobre algún texto, pero dado que el modelo no se preentrenó de esa manera, podría provocar una disminución en el rendimiento.
Cuando se usa con
is_split_into_words=True, este tokenizador añadirá un espacio antes de cada palabra (incluso la primera).
Este tokenizador hereda de PreTrainedTokenizer, que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos. También crea secuencias de entidades, a saber, entity_ids, entity_attention_mask, entity_token_type_ids y entity_position_ids, para ser utilizadas por el modelo LUKE.
__call__
< source >( text: str | list[str]text_pair: str | list[str] | None = Noneentity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentities: list[str] | list[list[str]] | None = Noneentities_pair: list[str] | list[list[str]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonemax_entity_length: int | None = Nonestride: int = 0is_split_into_words: bool | None = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs ) → BatchEncoding
Devuelve
Un BatchEncoding con los siguientes campos:
-
input_ids — Lista de ids de tokens que se enviarán a un modelo.
-
token_type_ids — Lista de ids de tipo de token que se enviarán a un modelo (cuando
return_token_type_ids=Trueo si “token_type_ids” está enself.model_input_names). -
attention_mask — Lista de índices que especifica qué tokens deben ser atendidos por el modelo (cuando
return_attention_mask=Trueo si “attention_mask” está enself.model_input_names). -
entity_ids — Lista de ids de entidades que se enviarán a un modelo.
-
entity_position_ids — Lista de posiciones de entidades en la secuencia de entrada que se enviará a un modelo.
-
entity_token_type_ids — Lista de ids de tipo de token de entidad que se enviarán a un modelo (cuando
return_token_type_ids=Trueo si “entity_token_type_ids” está enself.model_input_names). -
entity_attention_mask — Lista de índices que especifica a qué entidades debe prestar atención el modelo (cuando
return_attention_mask=Trueo si “entity_attention_mask” está enself.model_input_names). -
entity_start_positions — Lista de las posiciones de inicio de las entidades en la secuencia de tokens de palabras (cuando
task="entity_span_classification"). -
entity_end_positions — Lista de las posiciones finales de las entidades en la secuencia de tokens de palabras (cuando
task="entity_span_classification"). -
overflowing_tokens — Lista de secuencias de tokens que exceden el límite (cuando se especifica un
max_lengthyreturn_overflowing_tokens=True). -
num_truncated_tokens — Número de tokens truncados (cuando se especifica un
max_lengthyreturn_overflowing_tokens=True). -
special_tokens_mask — Lista de 0 y 1, donde 1 especifica los tokens especiales añadidos y 0 especifica los tokens regulares de la secuencia (cuando
add_special_tokens=Trueyreturn_special_tokens_mask=True). -
length — La longitud de las entradas (cuando
return_length=True)
add_special_tokens (bool, opcional, valor predeterminado True):
Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente PretrainedTokenizerBase.build_inputs_with_special_tokens, que define qué tokens se
añaden automáticamente a los ids de entrada. Esto es útil si se desea añadir tokens bos o eos
automáticamente.
padding (bool, str o PaddingStrategy, opcional, valor predeterminado False):
Activa y controla el relleno. Acepta los siguientes valores:
Trueo'longest': Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia).'max_length': Rellena hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes). truncation (bool,stro TruncationStrategy, opcional, predeterminado enFalse): Activa y controla la truncación. Acepta los siguientes valores:Trueo'longest_first': Trunca hasta una longitud máxima especificada con el argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token a token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas).'only_first': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de un par si se proporciona un par de secuencias (o un lote de pares).'only_second': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de un par si se proporciona un par de secuencias (o un lote de pares).Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia superiores al tamaño máximo de entrada admisible por el modelo). max_length (int, opcional): Controla la longitud máxima que debe utilizar uno de los parámetros de truncamiento/relleno.
Si se deja sin establecer o se establece en None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud de entrada máxima específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.
stride (int, opcional, valor predeterminado 0):
Si se establece en un número junto con max_length, los tokens sobrantes devueltos cuando return_overflowing_tokens=True contendrán algunos tokens del final de la secuencia truncada devuelta para proporcionar cierta superposición entre las secuencias truncadas y las sobrantes. El valor de este argumento define el número de tokens superpuestos.
is_split_into_words (bool, opcional, valor predeterminado False):
Indica si la entrada ya está pre-tokenizada (p. ej., dividida en palabras). Si se establece en True, el tokenizador asume que la entrada ya está dividida en palabras (por ejemplo, dividiéndola por espacios en blanco) y la tokenizará. Esto es útil para NER o clasificación de tokens.
pad_to_multiple_of (int, opcional):
Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que padding esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo >= 7.5 (Volta).
padding_side (str, opcional):
El lado en el que el modelo debe tener relleno aplicado. Debe seleccionarse entre [‘right’, ‘left’].
El valor predeterminado se elige del atributo de clase con el mismo nombre.
return_tensors (str o TensorType, opcional):
Si se establece, devolverá tensores en lugar de una lista de enteros de python. Los valores aceptables son:
'pt': Devuelve objetostorch.Tensorde PyTorch.'np': Devuelve objetos Numpynp.ndarray.
return_token_type_ids (bool, opcional):
Si se deben devolver los IDs de tipo de token. Si se deja en el valor predeterminado, se devolverán los IDs de tipo de token según el valor predeterminado del tokenizador específico, definido por el atributo return_outputs.
¿Qué son los IDs de tipo de token? return_attention_mask (bool, opcional):
Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del tokenizador específico, definido por el atributo return_outputs.
¿Qué son las máscaras de atención? return_overflowing_tokens (bool, opcional, valor predeterminado False):
Indica si se deben devolver las secuencias de tokens que exceden el límite. Si se proporciona un par de secuencias de ids de entrada (o un lote de pares) con truncation_strategy = longest_first o True, se genera un error en lugar de devolver los tokens que exceden el límite.
return_special_tokens_mask (bool, opcional, valor predeterminado False):
Indica si se debe devolver la información de la máscara de tokens especiales.
return_offsets_mapping (bool, opcional, valor predeterminado False):
Indica si se debe devolver (char_start, char_end) para cada token.
Esto solo está disponible en los tokenizadores rápidos que heredan de PreTrainedTokenizerFast; si se utiliza el tokenizador de Python, este método lanzará NotImplementedError.
return_length (bool, opcional, valor predeterminado False):
Indica si se deben devolver las longitudes de las entradas codificadas.
verbose (bool, opcional, valor predeterminado True):
Indica si se debe imprimir más información y advertencias.
**kwargs: se pasan al método self.tokenize()
LukeModel
clase transformers.LukeModel
< source >( config: LukeConfigadd_pooling_layer: bool = True )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
- add_pooling_layer (
bool, opcional, valor predeterminadoTrue) — Si se debe añadir una capa de pooling
La salida del transformador del modelo LUKE básico, que emite estados ocultos crudos tanto para los tokens de palabras como para las entidades, sin
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseLukeModelOutputWithPooling or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
BaseLukeModelOutputWithPooling o tuple(torch.FloatTensor)
Un BaseLukeModelOutputWithPooling o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeModel sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
last_hidden_state (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.FloatTensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación), procesado adicionalmente por una capa Linear y una función de activación Tanh.hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
entity_last_hidden_state (
torch.FloatTensorde forma(batch_size, entity_length, hidden_size)) — Secuencia de estados ocultos de entidades en la salida de la última capa del modelo.entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.
Ejemplos:
>>> from transformers import AutoTokenizer, LukeModel
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens
>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
... "Beyoncé",
... "Los Angeles",
... ] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> encoding = tokenizer(
... text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_stateLukeForMaskedLM
clase transformers.LukeForMaskedLM
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo LUKE con una cabeza de modelado de lenguaje y una cabeza de predicción de entidades en la parte superior para el modelado de lenguaje enmascarado y la predicción de entidades enmascaradas.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneentity_labels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMaskedLMOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size]. - entity_labels (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size] - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
LukeMaskedLMOutput o tuple(torch.FloatTensor)
Un LukeMaskedLMOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForMaskedLM sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — La suma de la pérdida de modelado de lenguaje enmascarado (MLM) y la pérdida de predicción de entidades.mlm_loss (
torch.FloatTensorde forma(1,), opcional, devuelto cuando se proporcionalabels) — Pérdida de modelado de lenguaje enmascarado (MLM).mep_loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de predicción de entidades con máscara (MEP).logits (
torch.FloatTensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).entity_logits (
torch.FloatTensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de predicción de entidades (puntuaciones para cada token del vocabulario de entidades antes del SoftMax).hidden_states (
tuple[torch.FloatTensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, LukeForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...LukeForEntityClassification
clase transformers.LukeForEntityClassification
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo LUKE con una cabeza de clasificación en la parte superior (una capa lineal sobre el estado oculto del primer token de entidad) para tareas de clasificación de entidades, como Open Entity.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityClassificationOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,)o(batch_size, num_labels), opcional) — Etiquetas para calcular la pérdida de clasificación. Si la forma es(batch_size,), se utiliza la pérdida de entropía cruzada para la clasificación de una sola etiqueta. En este caso, las etiquetas deben contener los índices que deben estar en[0, ..., config.num_labels - 1]. Si la forma es(batch_size, num_labels), se utiliza la pérdida de entropía cruzada binaria para la clasificación de múltiples etiquetas. En este caso, las etiquetas solo deben contener[0, 1], donde 0 y 1 indican falso y verdadero, respectivamente. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
EntityClassificationOutput o tuple(torch.FloatTensor)
Un EntityClassificationOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForEntityClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.FloatTensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> from transformers import AutoTokenizer, LukeForEntityClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: personLukeForEntityPairClassification
clase transformers.LukeForEntityPairClassification
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo LUKE con una cabeza de clasificación en la parte superior (una capa lineal sobre los estados ocultos de los dos tokens de entidad) para tareas de clasificación de pares de entidades, como TACRED.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityPairClassificationOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,)o(batch_size, num_labels), opcional) — Etiquetas para calcular la pérdida de clasificación. Si la forma es(batch_size,), se utiliza la pérdida de entropía cruzada para la clasificación de una sola etiqueta. En este caso, las etiquetas deben contener los índices que deben estar en[0, ..., config.num_labels - 1]. Si la forma es(batch_size, num_labels), se utiliza la pérdida de entropía cruzada binaria para la clasificación de múltiples etiquetas. En este caso, las etiquetas solo deben contener[0, 1], donde 0 y 1 indican falso y verdadero, respectivamente. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
EntityPairClassificationOutput o tuple(torch.FloatTensor)
Un EntityPairClassificationOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForEntityPairClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.FloatTensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> from transformers import AutoTokenizer, LukeForEntityPairClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residenceLukeForEntitySpanClassification
clase transformers.LukeForEntitySpanClassification
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo LUKE con una cabeza de clasificación de tramos en la parte superior (una capa lineal sobre la salida de los estados ocultos) para tareas como el reconocimiento de entidades nombradas.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneentity_start_positions: typing.Optional[torch.LongTensor] = Noneentity_end_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntitySpanClassificationOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - entity_start_positions (
torch.LongTensor, opcional) — Las posiciones de inicio de las entidades en la secuencia de tokens de palabras. - entity_end_positions (
torch.LongTensor, opcional) — Las posiciones finales de las entidades en la secuencia de tokens de palabras. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, entity_length)o(batch_size, entity_length, num_labels), opcional) — Etiquetas para calcular la pérdida de clasificación. Si la forma es(batch_size, entity_length), se utiliza la pérdida de entropía cruzada para la clasificación de una sola etiqueta. En este caso, las etiquetas deben contener los índices que deben estar en[0, ..., config.num_labels - 1]. Si la forma es(batch_size, entity_length, num_labels), se utiliza la pérdida de entropía cruzada binaria para la clasificación de múltiples etiquetas. En este caso, las etiquetas solo deben contener[0, 1], donde 0 y 1 indican falso y verdadero, respectivamente. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
EntitySpanClassificationOutput o tuple(torch.FloatTensor)
Un EntitySpanClassificationOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForEntitySpanClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.FloatTensorde forma(batch_size, entity_length, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplos:
>>> from transformers import AutoTokenizer, LukeForEntitySpanClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text
>>> word_start_positions = [0, 8, 14, 17, 21] # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28] # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
... for end_pos in word_end_positions[i:]:
... entity_spans.append((start_pos, end_pos))
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
... if predicted_class_idx != 0:
... print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOCLukeForSequenceClassification
clase transformers.LukeForSequenceClassification
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El transformador del modelo LUKE con una cabeza de clasificación/regresión de secuencias en la parte superior (una capa lineal sobre la salida agrupada), por ejemplo, para tareas de GLUE.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeSequenceClassifierOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada). - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
LukeSequenceClassifierOutput o tuple(torch.FloatTensor)
Un LukeSequenceClassifierOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForSequenceClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.FloatTensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo de clasificación de una sola etiqueta:
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base")
>>> 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 = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Ejemplo de clasificación multietiqueta:
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", 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 = LukeForSequenceClassification.from_pretrained(
... "studio-ousia/luke-base", 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).lossLukeForMultipleChoice
clase transformers.LukeForMultipleChoice
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Luke con una cabeza de clasificación de opción múltiple en la parte superior (una capa lineal sobre la salida agrupada y un softmax), por ejemplo, para las tareas RocStories/SWAG.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMultipleChoiceModelOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, num_choices, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación de opción múltiple. Los índices deben estar en[0, ..., num_choices-1], dondenum_choiceses el tamaño de la segunda dimensión de los tensores de entrada. (Véaseinput_idsarriba) - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
LukeMultipleChoiceModelOutput o tuple(torch.FloatTensor)
Un LukeMultipleChoiceModelOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForMultipleChoice sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma (1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.FloatTensorde forma(batch_size, num_choices)) — num_choices es la segunda dimensión de los tensores de entrada. (ver input_ids arriba).Puntuaciones de clasificación (antes de SoftMax).
hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, LukeForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-base")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsLukeForTokenClassification
clase transformers.LukeForTokenClassification
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo LUKE con una cabeza de clasificación de tokens en la parte superior (una capa lineal sobre la salida de los estados ocultos). Para
resolver la tarea de reconocimiento de entidades nombradas (NER) con LUKE, LukeForEntitySpanClassification es más adecuado que esta
clase.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeTokenClassifierOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación de opción múltiple. Los índices deben estar en[0, ..., num_choices-1], dondenum_choiceses el tamaño de la segunda dimensión de los tensores de entrada. (Véaseinput_idsarriba) - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
LukeTokenClassifierOutput o tuple(torch.FloatTensor)
Un LukeTokenClassifierOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForTokenClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.FloatTensorde forma(batch_size, sequence_length, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, LukeForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...LukeForQuestionAnswering
clase transformers.LukeForQuestionAnswering
< source >( config: LukeConfig )
Parámetros
- config (LukeConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El transformador Luke con una cabeza de clasificación de tramos en la parte superior para tareas de respuesta a preguntas extractivas como
SQuAD (una capa lineal sobre la salida de los estados ocultos para calcular span start logits y span end logits).
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.FloatTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.FloatTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- position_ids (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - entity_ids (
torch.LongTensorde forma(batch_size, entity_length)) — Índices de los tokens de entidad en el vocabulario de entidades.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- entity_attention_mask (
torch.FloatTensorde forma(batch_size, entity_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de entidad de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens de entidad que no están enmascarados,
- 0 para los tokens de entidad que están enmascarados.
- entity_token_type_ids (
torch.LongTensorde forma(batch_size, entity_length), opcional) — Índices de tokens de segmento para indicar las porciones primera y segunda de los tokens de entidad de entrada. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de entidad de porción A,
- 1 corresponde a un token de entidad de porción B.
- entity_position_ids (
torch.LongTensorde forma(batch_size, entity_length, max_mention_length), opcional) — Índices de las posiciones de cada entidad de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.FloatTensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - start_positions (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para la posición (índice) del inicio del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (sequence_length). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida. - end_positions (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para la posición (índice) del final del tramo etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (sequence_length). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida. - output_attentions (
bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulteattentionsen los tensores devueltos para obtener más detalles. - output_hidden_states (
bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consultehidden_statesen los tensores devueltos para obtener más detalles. - return_dict (
bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.
Devuelve
LukeQuestionAnsweringModelOutput o tuple(torch.FloatTensor)
Un LukeQuestionAnsweringModelOutput o una tupla de
torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (LukeConfig) y las entradas.
El método forward de LukeForQuestionAnswering sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.FloatTensorde forma(1,), opcional, devuelta cuando se proporcionalabels) — La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin.start_logits (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Puntuaciones de inicio de tramo (antes de SoftMax).end_logits (
torch.FloatTensorde forma(batch_size, sequence_length), opcional) — Puntuaciones de fin de tramo (antes de SoftMax).hidden_states (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
entity_hidden_states (
tuple(torch.FloatTensor), opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.FloatTensor(una para la salida de los embeddings + una para la salida de cada capa) de forma(batch_size, entity_length, hidden_size). Estados ocultos de las entidades del modelo en la salida de cada capa más las salidas iniciales de los embeddings de entidades.attentions (
tuple[torch.FloatTensor, ...], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.FloatTensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, LukeForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-base")
>>> 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)
...