Transformers documentation

TAPAS

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo se publicó en HF papers el 2020-04-05 y se contribuyó a Hugging Face Transformers el 2020-12-15.

TAPAS

Resumen

El modelo TAPAS se propuso en TAPAS: Weakly Supervised Table Parsing via Pre-training por Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno y Julian Martin Eisenschlos. Es un modelo basado en BERT diseñado específicamente (y preentrenado) para responder preguntas sobre datos tabulares. En comparación con BERT, TAPAS usa embeddings de posición relativa y tiene 7 tipos de tokens que codifican la estructura tabular. TAPAS se preentrena con el objetivo de modelado de lenguaje enmascarado (MLM) en un gran conjunto de datos que comprende millones de tablas de Wikipedia en inglés y los textos correspondientes.

Para la respuesta a preguntas, TAPAS tiene dos cabezas superiores: una cabeza de selección de celdas y una cabeza de agregación, para realizar (opcionalmente) agregaciones (como contar o sumar) entre las celdas seleccionadas. TAPAS se ha ajustado finamente en varios conjuntos de datos:

SQA (Sequential Question Answering de Microsoft)
WTQ (Wiki Table Questions de la Universidad de Stanford)
WikiSQL (de Salesforce).

Logra resultados de última generación tanto en SQA como en WTQ, con un rendimiento comparable al de SOTA en WikiSQL, pero con una arquitectura mucho más simple.

El resumen del artículo es el siguiente:

Responder a preguntas en lenguaje natural sobre tablas suele considerarse una tarea de análisis semántico. Para aliviar el coste de recopilar formas lógicas completas, un enfoque popular se centra en la supervisión débil que consiste en denotaciones en lugar de formas lógicas. Sin embargo, entrenar analizadores semánticos a partir de supervisión débil plantea dificultades, y además, las formas lógicas generadas solo se utilizan como un paso intermedio antes de recuperar la denotación. En este artículo, presentamos TAPAS, un enfoque para responder preguntas sobre tablas sin generar formas lógicas. TAPAS se entrena a partir de supervisión débil y predice la denotación seleccionando celdas de la tabla y aplicando opcionalmente un operador de agregación correspondiente a dicha selección. TAPAS extiende la arquitectura de BERT para codificar tablas como entrada, se inicializa a partir de un preentrenamiento conjunto eficaz de segmentos de texto y tablas obtenidos de Wikipedia, y se entrena de extremo a extremo. Experimentamos con tres conjuntos de datos de análisis semántico diferentes y encontramos que TAPAS supera o iguala a los modelos de análisis semántico al mejorar la precisión del estado del arte en SQA de 55.1 a 67.2 y al obtener resultados equivalentes al estado del arte en WIKISQL y WIKITQ, pero con una arquitectura de modelo más simple. Además, encontramos que el aprendizaje por transferencia, que es trivial en nuestro contexto, de WIKISQL a WIKITQ, produce una precisión de 48.7, 4.2 puntos por encima del estado del arte.

Además, los autores han pre-entrenado TAPAS para reconocer entailment de tablas, creando un conjunto de datos equilibrado con millones de ejemplos de entrenamiento generados automáticamente, que se aprenden en un paso intermedio antes del ajuste fino. Los autores de TAPAS llaman a este pre-entrenamiento adicional pre-entrenamiento intermedio (ya que TAPAS se pre-entrena primero en MLM y luego en otro conjunto de datos). Descubrieron que el pre-entrenamiento intermedio mejora aún más el rendimiento en SQA, logrando un nuevo estado del arte, así como el estado del arte en TabFact, un conjunto de datos a gran escala con 16k tablas de Wikipedia para el entailment de tablas (una tarea de clasificación binaria). Para más detalles, consulte su artículo de seguimiento: Understanding tables with intermediate pre-training de Julian Martin Eisenschlos, Syrine Krichene y Thomas Müller.

TAPAS architecture. Taken from the original blog post.

Este modelo fue aportado por nielsr. El código original se puede encontrar aquí.

Consejos de uso

TAPAS es un modelo que utiliza por defecto embeddings de posición relativa (reiniciando los embeddings de posición en cada celda de la tabla). Tenga en cuenta que esto es algo que se añadió después de la publicación del artículo original de TAPAS. Según los autores, esto suele dar lugar a un rendimiento ligeramente mejor y permite codificar secuencias más largas sin agotar los embeddings. Esto se refleja en el parámetro reset_position_index_per_cell de TapasConfig, que se establece en True por defecto. Las versiones predeterminadas de los modelos disponibles en el hub utilizan todos embeddings de posición relativa. Aún puede utilizar los que tienen embeddings de posición absoluta pasando un argumento adicional revision="no_reset" al llamar al método from_pretrained(). Tenga en cuenta que generalmente se recomienda rellenar las entradas a la derecha en lugar de a la izquierda.
TAPAS se basa en BERT, por lo que, por ejemplo, TAPAS-base corresponde a una arquitectura BERT-base. Por supuesto, TAPAS-large ofrecerá el mejor rendimiento (los resultados reportados en el artículo provienen de TAPAS-large). Los resultados de los modelos de diferentes tamaños se muestran en el repositorio original de GitHub.
TAPAS tiene puntos de control ajustados en SQA, que son capaces de responder preguntas relacionadas con una tabla en un entorno conversacional. Esto significa que puedes hacer preguntas de seguimiento, como “¿cuál es su edad?”, relacionadas con la pregunta anterior. Ten en cuenta que el paso hacia adelante de TAPAS es un poco diferente en el caso de un entorno conversacional: en ese caso, debes alimentar al modelo cada par tabla-pregunta uno por uno, de modo que los ids de tipo de token prev_labels puedan ser sobrescritos por las labels predichas por el modelo para la pregunta anterior. Consulta la sección “Uso” para más información.
TAPAS es similar a BERT y, por lo tanto, se basa en el objetivo de modelado de lenguaje enmascarado (MLM). En consecuencia, es eficiente para predecir tokens enmascarados y para el NLU en general, pero no es óptimo para la generación de texto. Los modelos entrenados con un objetivo de modelado de lenguaje causal (CLM) son mejores en ese aspecto. Tenga en cuenta que TAPAS puede usarse como codificador en el marco EncoderDecoderModel, para combinarlo con un decodificador de texto autoregresivo como GPT-2.

Uso: ajuste fino

Aquí explicamos cómo puedes realizar el ajuste fino de TapasForQuestionAnswering en tu propio conjunto de datos.

PASO 1: Elige una de las 3 formas en las que puedes usar TAPAS, o experimenta

Básicamente, hay 3 formas diferentes de realizar el ajuste fino de TapasForQuestionAnswering, que corresponden a los distintos conjuntos de datos en los que se ajustó Tapas:

SQA: si te interesa hacer preguntas de seguimiento relacionadas con una tabla, en un entorno conversacional. Por ejemplo, si primero preguntas «¿cuál es el nombre del primer actor?», luego puedes hacer una pregunta de seguimiento como «¿cuántos años tiene?». Aquí, las preguntas no implican ninguna agregación (todas las preguntas son de selección de celdas).
WTQ: si no te interesa hacer preguntas en un entorno conversacional, sino más bien hacer preguntas relacionadas con una tabla, que pueden implicar agregación, como contar un número de filas, sumar valores de celdas o promediar valores de celdas. Entonces, por ejemplo, puedes preguntar “¿cuál es el número total de goles que hizo Cristiano Ronaldo en su carrera?”. Este caso también se llama supervisión débil, ya que el propio modelo debe aprender el operador de agregación apropiado (SUM/COUNT/AVERAGE/NONE) dado solo la respuesta a la pregunta como supervisión.
WikiSQL-supervised: este conjunto de datos se basa en WikiSQL, donde el modelo recibe el operador de agregación correcto durante el entrenamiento. Esto también se denomina supervisión fuerte. Aquí, aprender el operador de agregación adecuado es mucho más fácil.

Para resumir:

Tarea	Conjunto de datos de ejemplo	Descripción
Conversacional	SQA	Conversacional, solo preguntas de selección de celdas
Supervisión débil para la agregación	WTQ	Las preguntas pueden implicar agregación, y el modelo debe aprender esto dado únicamente la respuesta como supervisión
Supervisión fuerte para la agregación	Supervisado con WikiSQL	Las preguntas pueden implicar agregación, y el modelo debe aprender esto dado el operador de agregación de referencia

La inicialización de un modelo con una base preentrenada y cabezas de clasificación inicializadas aleatoriamente desde el hub se puede realizar como se muestra a continuación.

from transformers import TapasConfig, TapasForQuestionAnswering


# for example, the base sized model with default SQA configuration
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto")

# or, the base sized model with WTQ configuration
config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")

# or, the base sized model with WikiSQL configuration
config = TapasConfig("google-base-finetuned-wikisql-supervised")
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")

Por supuesto, no es necesario seguir necesariamente una de estas tres formas en las que se ajustó TAPAS. También puedes experimentar definiendo los hiperparámetros que desees al inicializar TapasConfig y, a continuación, crear un TapasForQuestionAnswering basado en esa configuración. Por ejemplo, si tienes un conjunto de datos que contiene tanto preguntas conversacionales como preguntas que podrían implicar agregación, puedes hacerlo de esta manera. Aquí tienes un ejemplo:

from transformers import TapasConfig, TapasForQuestionAnswering


# you can initialize the classification heads any way you want (see docs of TapasConfig)
config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
# initializing the pre-trained base sized model with our custom classification heads
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")

También puede comenzar desde un punto de control ya afinado. Cabe señalar que el punto de control ya afinado en WTQ presenta algunos problemas debido a la pérdida L2, que es algo frágil. Consulte aquí para obtener más información.

Para obtener una lista de todos los puntos de control de TAPAS preentrenados y afinados disponibles en el hub de HuggingFace, consulte aquí.

PASO 2: Prepara tus datos en el formato SQA

En segundo lugar, sin importar lo que hayas elegido anteriormente, debes preparar tu conjunto de datos en el formato SQA. Este formato es un archivo TSV/CSV con las siguientes columnas:

id: opcional, id de la pareja tabla-pregunta, con fines de registro.
annotator: opcional, id de la persona que anotó el par tabla-pregunta, con fines de registro.
position: entero que indica si la pregunta es la primera, la segunda, la tercera, en relación con la tabla. Solo es obligatorio en el caso de una configuración conversacional (SQA). No necesitas esta columna si vas a usar WTQ/WikiSQL-supervised.
question: string
table_file: string, nombre de un archivo csv que contiene los datos tabulares
answer_coordinates: lista de una o más tuplas (cada tupla es una coordenada de celda, es decir, un par de fila y columna que forma parte de la respuesta)
answer_text: lista de una o más cadenas (cada cadena es un valor de celda que forma parte de la respuesta)
aggregation_label: índice del operador de agregación. Solo es necesario en el caso de supervisión fuerte para la agregación (el caso supervisado por WikiSQL)
float_answer: la respuesta en formato float a la pregunta, si la hay (np.nan si no la hay). Solo es obligatorio en caso de supervisión débil para la agregación (como WTQ y WikiSQL)

Las tablas en sí deben estar presentes en una carpeta, siendo cada tabla un archivo csv separado. Tenga en cuenta que los autores del algoritmo TAPAS utilizaron scripts de conversión con cierta lógica automatizada para convertir otros conjuntos de datos (WTQ, WikiSQL) al formato SQA. El autor explica esto aquí. Se puede encontrar una conversión de este script que funciona con la implementación de HuggingFace aquí. Curiosamente, estos scripts de conversión no son perfectos (los campos answer_coordinates y float_answer se rellenan en función del answer_text), lo que significa que los resultados de WTQ y WikiSQL podrían mejorar en realidad.

PASO 3: Convierta sus datos en tensores usando TapasTokenizer

Tercero, dado que has preparado tus datos en este formato TSV/CSV (y los archivos CSV correspondientes que contienen los datos tabulares), puedes usar TapasTokenizer para convertir pares de tabla-pregunta en input_ids, attention_mask, token_type_ids y así sucesivamente. Nuevamente, en función de cuál de los tres casos elegiste arriba, TapasForQuestionAnswering requiere diferentes entradas para el ajuste fino:

Tarea	Entradas requeridas
Conversacional	`input_ids`, `attention_mask`, `token_type_ids`, `labels`
Supervisión débil para la agregación	`input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer`
Supervisión fuerte para la agregación	`input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels`

TapasTokenizer crea las labels, numeric_values y numeric_values_scale en función de las columnas answer_coordinates y answer_text del archivo TSV. Las float_answer y aggregation_labels ya están en el archivo TSV del paso 2. Aquí hay un ejemplo:

from transformers import TapasTokenizer
import pandas as pd

model_name = "google/tapas-base"
tokenizer = TapasTokenizer.from_pretrained(model_name)

data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
queries = [
    "What is the name of the first actor?",
    "How many movies has George Clooney played in?",
    "What is the total number of movies?",
]
answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
answer_text = [["Brad Pitt"], ["69"], ["209"]]
table = pd.DataFrame.from_dict(data)
inputs = tokenizer(
    table=table,
    queries=queries,
    answer_coordinates=answer_coordinates,
    answer_text=answer_text,
    padding="max_length",
    return_tensors="pt",
)
inputs
{'input_ids': tensor([[ ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ]]), 'numeric_values_scale: tensor([[ ]]), labels: tensor([[ ]])}

Tenga en cuenta que TapasTokenizer espera que los datos de la tabla sean solo texto. Puede usar .astype(str) en un dataframe para convertirlo en datos solo de texto. Por supuesto, esto solo muestra cómo codificar un único ejemplo de entrenamiento. Se recomienda crear un dataloader para iterar sobre lotes:

import pandas as pd
import torch


tsv_path = "your_path_to_the_tsv_file"
table_csv_path = "your_path_to_a_directory_containing_all_csv_files"


class TableDataset(torch.utils.data.Dataset):
    def __init__(self, data, tokenizer):
        self.data = data
        self.tokenizer = tokenizer

    def __getitem__(self, idx):
        item = data.iloc[idx]
        table = pd.read_csv(table_csv_path + item.table_file).astype(
            str
        )  # be sure to make your table data text only
        encoding = self.tokenizer(
            table=table,
            queries=item.question,
            answer_coordinates=item.answer_coordinates,
            answer_text=item.answer_text,
            truncation=True,
            padding="max_length",
            return_tensors="pt",
        )
        # remove the batch dimension which the tokenizer adds by default
        encoding = {key: val.squeeze(0) for key, val in encoding.items()}
        # add the float_answer which is also required (weak supervision for aggregation case)
        encoding["float_answer"] = torch.tensor(item.float_answer)
        return encoding

    def __len__(self):
        return len(self.data)


data = pd.read_csv(tsv_path, sep="\t")
train_dataset = TableDataset(data, tokenizer)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32)

Tenga en cuenta que aquí codificamos cada par de tabla-pregunta de forma independiente. Esto es adecuado siempre que su conjunto de datos no sea conversacional. En caso de que su conjunto de datos incluya preguntas conversacionales (como en SQA), primero debe agrupar las queries, answer_coordinates y answer_text por tabla (en el orden de su índice de position) y codificar por lotes cada tabla con sus preguntas. Esto asegurará que los tipos de token de prev_labels (consulte la documentación de TapasTokenizer) se establezcan correctamente. Consulte este cuaderno para obtener más información.

**PASO 4: Entrenar (ajustar) el modelo

A continuación, puede realizar el ajuste fino de TapasForQuestionAnswering de la siguiente manera (mostrado aquí para el caso de supervisión débil para agregación):

from transformers import AdamW, TapasConfig, TapasForQuestionAnswering


# this is the default WTQ configuration
config = TapasConfig(
    num_aggregation_labels=4,
    use_answer_as_supervision=True,
    answer_loss_cutoff=0.664694,
    cell_selection_preference=0.207951,
    huber_loss_delta=0.121194,
    init_cell_selection_weights_to_zero=True,
    select_one_column=True,
    allow_empty_column_selection=False,
    temperature=0.0352513,
)
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")

optimizer = AdamW(model.parameters(), lr=5e-5)

model.train()
for epoch in range(2):  # loop over the dataset multiple times
    for batch in train_dataloader:
        # get the inputs;
        input_ids = batch["input_ids"]
        attention_mask = batch["attention_mask"]
        token_type_ids = batch["token_type_ids"]
        labels = batch["labels"]
        numeric_values = batch["numeric_values"]
        numeric_values_scale = batch["numeric_values_scale"]
        float_answer = batch["float_answer"]

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            labels=labels,
            numeric_values=numeric_values,
            numeric_values_scale=numeric_values_scale,
            float_answer=float_answer,
        )
        loss = outputs.loss
        loss.backward()
        optimizer.step()

Uso: inferencia

Aquí explicamos cómo puede utilizar TapasForQuestionAnswering para inferencia (es decir, para realizar predicciones sobre nuevos datos). Para la inferencia, solo se deben proporcionar al modelo input_ids, attention_mask y token_type_ids (que puede obtener utilizando TapasTokenizer) para obtener los logits. A continuación, puede utilizar el práctico método ~models.tapas.tokenization_tapas.convert_logits_to_predictions para convertirlos en coordenadas predichas e índices de agregación opcionales.

Sin embargo, ten en cuenta que la inferencia es distinta dependiendo de si la configuración es conversacional o no. En una configuración no conversacional, la inferencia se puede realizar en paralelo para todos los pares de tabla-pregunta de un lote. Aquí tienes un ejemplo:

from transformers import TapasTokenizer, TapasForQuestionAnswering
import pandas as pd

model_name = "google/tapas-base-finetuned-wtq"
model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto")
tokenizer = TapasTokenizer.from_pretrained(model_name)

data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
queries = [
    "What is the name of the first actor?",
    "How many movies has George Clooney played in?",
    "What is the total number of movies?",
]
table = pd.DataFrame.from_dict(data)
inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt").to(model.device)
outputs = model(**inputs)
predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
    inputs, outputs.logits.detach(), outputs.logits_aggregation.detach()
)

# let's print out the results:
id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]

answers = []
for coordinates in predicted_answer_coordinates:
    if len(coordinates) == 1:
        # only a single cell:
        answers.append(table.iat[coordinates[0]])
    else:
        # multiple cells
        cell_values = []
        for coordinate in coordinates:
            cell_values.append(table.iat[coordinate])
        answers.append(", ".join(cell_values))

display(table)
print("")
for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
    print(query)
    if predicted_agg == "NONE":
        print("Predicted answer: " + answer)
    else:
        print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69

En el caso de una configuración conversacional, cada par tabla-pregunta debe proporcionarse al modelo de forma secuencial, de modo que los tipos de token prev_labels puedan ser sobrescritos por las labels predichas del par tabla-pregunta anterior. Nuevamente, más información puede encontrarse en este cuaderno.

Recursos

Salidas específicas de TAPAS

clase transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonelogits_aggregation: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = None )

Parámetros

loss (torch.Tensor de forma (1,), opcional, devuelto cuando se proporcionan labels (y posiblemente answer, aggregation_labels, numeric_values y numeric_values_scale)) — Pérdida total como la suma de la pérdida de verosimilitud logarítmica de selección jerárquica de celdas y (opcionalmente) la pérdida de regresión semisupervisada y (opcionalmente) la pérdida supervisada para agregaciones.
logits (torch.Tensor de forma (batch_size, sequence_length)) — Puntuaciones de predicción de la cabeza de selección de celdas, para cada token.
logits_aggregation (torch.Tensor, opcional, de forma (batch_size, num_aggregation_labels)) — Puntuaciones de predicción de la cabeza de agregación, para cada operador de agregación.
hidden_states (tuple[torch.Tensor], opcional, se devuelve cuando output_hidden_states=True se pasa o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno 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.Tensor], opcional, se devuelve cuando output_attentions=True se pasa o cuando config.output_attentions=True) — Tupla de torch.Tensor (uno por cada capa) con 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.

Tipo de salida de TapasForQuestionAnswering.

TapasConfig

clase transformers.TapasConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 1024type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10)initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0bos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonepositive_label_weight: float = 10.0num_aggregation_labels: int = 0aggregation_loss_weight: float = 1.0use_answer_as_supervision: bool | None = Noneanswer_loss_importance: float = 1.0use_normalized_answer_loss: bool = Falsehuber_loss_delta: float | None = Nonetemperature: float = 1.0aggregation_temperature: float = 1.0use_gumbel_for_cells: bool = Falseuse_gumbel_for_aggregation: bool = Falseaverage_approximation_function: str = 'ratio'cell_selection_preference: float | None = Noneanswer_loss_cutoff: float | int | None = Nonemax_num_rows: int = 64max_num_columns: int = 32average_logits_per_cell: bool = Falseselect_one_column: bool = Trueallow_empty_column_selection: bool = Falseinit_cell_selection_weights_to_zero: bool = Falsereset_position_index_per_cell: bool = Truedisable_per_token_loss: bool = Falseaggregation_labels: dict | None = Noneno_aggregation_label_index: int | None = Noneis_decoder: bool = Falseadd_cross_attention: bool = Falsetie_word_embeddings: bool = True )

Parámetros

vocab_size (int, opcional, valor predeterminado 30522) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante input_ids.
hidden_size (int, opcional, valor predeterminado 768) — Dimensión de las representaciones ocultas.
num_hidden_layers (int, opcional, valor predeterminado 12) — Número de capas ocultas en el decodificador del Transformer.
num_attention_heads (int, opcional, valor predeterminado 12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
intermediate_size (int, opcional, valor predeterminado 3072) — Dimensión de las representaciones del MLP.
hidden_act (str, opcional, valor predeterminado gelu) — 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 predeterminado 0.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 predeterminado 0.1) — La proporción de dropout para las probabilidades de atención.
max_position_embeddings (int, opcional, valor predeterminado 1024) — La longitud máxima de secuencia con la que se podría utilizar este modelo.
type_vocab_sizes (list[int], opcional, valor predeterminado [3, 256, 256, 2, 256, 256, 10]) — Los tamaños de vocabulario de los token_type_ids pasados al llamar a TapasModel.
initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
layer_norm_eps (float, opcional, valor predeterminado 1e-12) — El epsilon utilizado por las capas de normalización de capa.
pad_token_id (int, opcional, valor predeterminado 0) — Id del token utilizado para el relleno en el vocabulario.
bos_token_id (int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario.
eos_token_id (Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario.
positive_label_weight (float, opcional, valor predeterminado 10.0) — Peso para las etiquetas positivas.
num_aggregation_labels (int, opcional, valor predeterminado 0) — El número de operadores de agregación a predecir.
aggregation_loss_weight (float, opcional, valor predeterminado 1.0) — Peso de importancia para la pérdida de agregación.
use_answer_as_supervision (bool, opcional) — Si se debe usar la respuesta como la única supervisión para los ejemplos de agregación.
answer_loss_importance (float, opcional, valor predeterminado 1.0) — Peso de importancia para la pérdida de regresión.
use_normalized_answer_loss (bool, opcional, valor predeterminado False) — Si se normaliza la pérdida de la respuesta por el máximo entre el valor predicho y el valor esperado.
huber_loss_delta (float, opcional) — Parámetro delta utilizado para calcular la pérdida de regresión.
temperature (float, opcional, valor predeterminado 1.0) — Valor utilizado para controlar (o cambiar) la asimetría de las probabilidades de logits de las celdas.
aggregation_temperature (float, opcional, valor predeterminado 1.0) — Escala los logits de agregación para controlar la asimetría de las probabilidades.
use_gumbel_for_cells (bool, opcional, valor predeterminado False) — Si se aplica Gumbel-Softmax a la selección de celdas.
use_gumbel_for_aggregation (bool, opcional, valor predeterminado False) — Si se aplica Gumbel-Softmax a la selección de agregación.
average_approximation_function (string, opcional, valor predeterminado "ratio") — Método para calcular la media esperada de las celdas en el caso de supervisión débil. Uno de "ratio", "first_order" o "second_order".
cell_selection_preference (float, opcional) — Preferencia para la selección de celdas en casos ambiguos. Solo es aplicable en el caso de supervisión débil para la agregación (WTQ, WikiSQL). Si la masa total de las probabilidades de agregación (excluyendo el operador “NONE”) es mayor que este hiperparámetro, entonces se predice la agregación para un ejemplo.
answer_loss_cutoff (float, opcional) — Ignora los ejemplos cuya pérdida de respuesta sea mayor que el umbral.
max_num_rows (int, opcional, valor predeterminado 64) — Número máximo de filas.
max_num_columns (int, opcional, valor predeterminado 32) — Número máximo de columnas.
average_logits_per_cell (bool, opcional, valor predeterminado False) — Si se promedian los logits por celda.
select_one_column (bool, opcional, valor predeterminado True) — Si se debe restringir el modelo para que solo seleccione celdas de una única columna.
allow_empty_column_selection (bool, opcional, valor predeterminado False) — Si se permite no seleccionar ninguna columna.
init_cell_selection_weights_to_zero (bool, opcional, valor predeterminado False) — Si se inicializan los pesos de selección de celdas en 0 para que las probabilidades iniciales sean del 50%.
reset_position_index_per_cell (bool, opcional, valor predeterminado True) — Si se reinician los índices de posición en cada celda (es decir, si se usan incrustaciones de posición relativa).
disable_per_token_loss (bool, opcional, valor predeterminado False) — Si se deshabilita cualquier supervisión (fuerte o débil) en las celdas.
aggregation_labels (dict[int, label], opcional) — Las etiquetas de agregación utilizadas para agregar los resultados. Por ejemplo, los modelos WTQ tienen las siguientes etiquetas de agregación: {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
no_aggregation_label_index (int, opcional) — Si las etiquetas de agregación están definidas y una de ellas representa “No agregación”, este valor debe establecerse en su índice. Por ejemplo, los modelos WTQ tienen la etiqueta de agregación “NONE” en el índice 0, por lo que ese valor debe establecerse en 0 para estos modelos.
is_decoder (bool, opcional, valor predeterminado False) — Indica si el modelo se utiliza como decodificador o no. Si es False, el modelo se utiliza como codificador.
add_cross_attention (bool, opcional, valor predeterminado False) — Si se deben añadir capas de atención cruzada al modelo.
tie_word_embeddings (bool, opcional, valor predeterminado True) — Si se deben vincular las matrices de pesos de embeddings según el mapeo tied_weights_keys del modelo.

Esta es la clase de configuración para almacenar la configuración de un TapasModel. Se utiliza para instanciar un modelo Tapas 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 google/tapas-base-finetuned-sqa

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.

Ejemplo:

>>> from transformers import TapasModel, TapasConfig

>>> # Initializing a default (SQA) Tapas configuration
>>> configuration = TapasConfig()
>>> # Initializing a model from the configuration
>>> model = TapasModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

TapasTokenizer

clase transformers.TapasTokenizer

< source >

( vocab_filedo_lower_case = Truedo_basic_tokenize = Truenever_split = Noneunk_token = '[UNK]'sep_token = '[SEP]'pad_token = '[PAD]'cls_token = '[CLS]'mask_token = '[MASK]'empty_token = '[EMPTY]'tokenize_chinese_chars = Truestrip_accents = Nonecell_trim_length: int = -1max_column_id: int | None = Nonemax_row_id: int | None = Nonestrip_column_names: bool = Falseupdate_answer_coordinates: bool = Falsemin_question_length = Nonemax_question_length = Nonemodel_max_length: int = 512additional_special_tokens: list[str] | None = Noneclean_up_tokenization_spaces = True**kwargs )

Parámetros

vocab_file (str) — Archivo que contiene el vocabulario.
do_lower_case (bool, opcional, valor predeterminado True) — Si se debe convertir la entrada a minúsculas al tokenizar.
do_basic_tokenize (bool, opcional, valor predeterminado True) — Indica si se debe realizar una tokenización básica antes de WordPiece.
never_split (Iterable, opcional) — Colección de tokens que nunca se dividirán durante la tokenización. Solo tiene efecto cuando do_basic_tokenize=True
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.
sep_token (str, opcional, valor predeterminado "[SEP]") — 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.
pad_token (str, opcional, valor predeterminado "[PAD]") — El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.
cls_token (str, opcional, valor predeterminado "[CLS]") — 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.
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.
empty_token (str, opcional, valor predeterminado "[EMPTY]") — El token utilizado para los valores de celdas vacías en una tabla. Los valores de celdas vacías incluyen "", “n/a”, “nan” y ”?“.
tokenize_chinese_chars (bool, opcional, valor predeterminado True) — Si se tokenizan o no los caracteres chinos. Probablemente debería desactivarse para el japonés (ver este issue).
strip_accents (bool, opcional) — Indica si se deben eliminar todas las tildes. Si no se especifica esta opción, se determinará en función del valor de lowercase (como en BERT original).
cell_trim_length (int, opcional, valor predeterminado -1) — Si > 0: Recorta las celdas para que su longitud sea <= este valor. También desactiva el recorte adicional de celdas, por lo que debe usarse con truncation establecido en True.
max_column_id (int, opcional) — Identificador de columna máximo a extraer.
max_row_id (int, opcional) — Identificador de fila máximo a extraer.
strip_column_names (bool, opcional, valor predeterminado False) — Si se deben añadir cadenas vacías en lugar de los nombres de las columnas.
update_answer_coordinates (bool, opcional, valor predeterminado False) — Si se deben recalcular las coordenadas de la respuesta a partir del texto de la respuesta.
min_question_length (int, opcional) — Longitud mínima de cada pregunta en términos de tokens (se omitirá en caso contrario).
max_question_length (int, opcional) — Longitud máxima de cada pregunta en términos de tokens (se omitirá en caso contrario).
clean_up_tokenization_spaces (bool, opcional, valor predeterminado True) — Indica si se deben limpiar los espacios tras la decodificación. La limpieza consiste en eliminar posibles artefactos, como espacios adicionales.

Construye un tokenizador TAPAS. Basado en WordPiece. Aplana una tabla y una o más frases relacionadas para ser utilizadas por los modelos TAPAS.

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. TapasTokenizer crea varios ids de tipo de token para codificar la estructura tabular. Para ser más precisos, añade 7 ids de tipo de token, en el siguiente orden: segment_ids, column_ids, row_ids, prev_labels, column_ranks, inv_column_ranks y numeric_relations:

segment_ids: indica si un token pertenece a la pregunta (0) o a la tabla (1). 0 para tokens especiales y relleno.
column_ids: indica a qué columna de la tabla pertenece un token (comenzando desde 1). Es 0 para todos los tokens de la pregunta, los tokens especiales y el padding.
row_ids: indica a qué fila de la tabla pertenece un token (comenzando desde 1). Es 0 para todos los tokens de la pregunta, tokens especiales y relleno. Los tokens de las cabeceras de columna también son 0.
prev_labels: indica si un token formaba parte de la respuesta a la pregunta anterior (1) o no (0). Útil en un entorno conversacional (como SQA).
column_ranks: indica el rango de un token de tabla en relación con una columna, si es aplicable. Por ejemplo, si tienes una columna “number of movies” con los valores 87, 53 y 69, entonces los rangos de columna de estos tokens son 3, 1 y 2, respectivamente. 0 para todos los tokens de pregunta, tokens especiales y relleno.
inv_column_ranks: indica el rango inverso de un token de tabla en relación con una columna, si es aplicable. Por ejemplo, si tienes una columna “number of movies” con los valores 87, 53 y 69, entonces los rangos inversos de columna de estos tokens son 1, 3 y 2, respectivamente. 0 para todos los tokens de pregunta, tokens especiales y relleno.
numeric_relations: indica las relaciones numéricas entre la pregunta y los tokens de la tabla. 0 para todos los tokens de la pregunta, tokens especiales y padding.

TapasTokenizer ejecuta la tokenización de extremo a extremo en una tabla y sus oraciones asociadas: división de puntuación y wordpiece.

call

< source >

Parámetros

table (pd.DataFrame o str o list[str]) — Tabla que contiene datos tabulares. Tenga en cuenta que todos los valores de las celdas deben ser texto. Use .astype(str) en un dataframe de Pandas para convertirlo a cadena de caracteres. Al pasar una cadena de caracteres o una lista de cadenas de caracteres, estas se interpretarán como consultas con una tabla vacía (para soportar pruebas genéricas de tokenizadores).
queries (str o list[str]) — Pregunta o lote de preguntas relacionadas con una tabla que se codificará. Tenga en cuenta que, en el caso de un lote, todas las preguntas deben referirse a la misma tabla.
answer_coordinates (list[Tuple] o list[list[Tuple]], opcional) — Coordenadas de la respuesta de cada par tabla-pregunta del lote. Si solo se proporciona un par tabla-pregunta, entonces answer_coordinates debe ser una única lista de una o más tuplas. Cada tupla debe ser un par (row_index, column_index). La primera fila de datos (no la fila de encabezado de columnas) tiene índice 0. La primera columna tiene índice 0. Si se proporciona un lote de pares tabla-pregunta, entonces answer_coordinates debe ser una lista de listas de tuplas (cada lista correspondiente a un único par tabla-pregunta).
answer_text (list[str] o list[list[str]], opcional) — Texto de la respuesta de cada par tabla-pregunta del lote. Si solo se proporciona un par tabla-pregunta, entonces answer_text debe ser una única lista de uno o más cadenas de caracteres. Cada cadena de caracteres debe ser el texto de la respuesta de una coordenada de respuesta correspondiente. Si se proporciona un lote de pares tabla-pregunta, entonces answer_coordinates debe ser una lista de listas de cadenas de caracteres (cada lista correspondiente a un único par tabla-pregunta).
add_special_tokens (bool, opcional, valor predeterminado True) — Si se codifican o no las secuencias con los tokens especiales relativos a su modelo.
padding (bool, str o PaddingStrategy, opcional, el valor predeterminado es False) — Activa y controla el padding. Acepta los siguientes valores:
- True o '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 argumento max_length o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.
- False o 'do_not_pad' (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
truncation (bool, str o TapasTruncationStrategy, opcional, por defecto False) — Activa y controla la truncación. Acepta los siguientes valores:
- True o 'drop_rows_to_fit': Trunca a una longitud máxima especificada con el argumento max_length o a la longitud de entrada máxima aceptable para el modelo si no se proporciona ese argumento. Esto truncará fila por fila, eliminando filas de la tabla.
- False o 'do_not_truncate' (predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
max_length (int, opcional) — Controla la longitud máxima que se utilizará mediante uno de los parámetros de truncamiento/relleno.
Si se deja sin definir o se establece en None, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno lo requiere. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.
is_split_into_words (bool, opcional, valor predeterminado False) — Indica si la entrada ya está pretokenizada (por ejemplo, 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 las tokenizará. Esto es útil para NER o clasificación de tokens.
pad_to_multiple_of (int, opcional) — Si se establece, se rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo >= 7.5 (Volta).
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 objetos torch.Tensor de PyTorch.
- 'np': Devuelve objetos Numpy np.ndarray.

Método principal para tokenizar y preparar para el modelo una o varias secuencias relacionadas con una tabla.

convert_logits_to_predictions

< source >

( datalogitslogits_agg = Nonecell_classification_threshold = 0.5 ) → tuple comprising various elements depending on the inputs

Parámetros

data (dict) — Diccionario que mapea las características a sus valores reales. Debe crearse usando TapasTokenizer.
logits (torch.Tensor de forma (batch_size, sequence_length)) — Tensor que contiene los logits a nivel de token.
logits_agg (torch.Tensor de forma (batch_size, num_aggregation_labels), opcional) — Tensor que contiene los logits de agregación.
cell_classification_threshold (float, opcional, valor predeterminado 0.5) — Umbral que se utilizará para la selección de celdas. Se seleccionarán todas las celdas de la tabla cuya probabilidad sea mayor que este umbral.

Devuelve

tuple que comprende varios elementos según las entradas

predicted_answer_coordinates (list[list[[tuple]] de longitud batch_size): Coordenadas de la respuesta predicha como una lista de listas de tuplas. Cada elemento de la lista contiene las coordenadas de la respuesta predicha de un único ejemplo del lote, como una lista de tuplas. Cada tupla es una celda, es decir, (índice de fila, índice de columna).
predicted_aggregation_indices (list[int]de longitud batch_size, opcional, se devuelve cuando se proporciona logits_aggregation): Índices de los operadores de agregación predichos por la cabeza de agregación.

Convierte los logits de TapasForQuestionAnswering en coordenadas de respuesta predichas y, opcionalmente, en índices de agregación.

La implementación original, en la que se basa esta función, se puede encontrar aquí.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

clase transformers.TapasModel

< source >

( config: TapasConfigadd_pooling_layer = True )

Parámetros

config (TapasConfig) — 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 predeterminado True) — Si se debe añadir una capa de pooling

El modelo Tapas básico que emite estados ocultos sin ninguna cabeza específica en la parte superior.

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.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor de 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.

¿Qué son los IDs de entrada?
attention_mask (torch.Tensor de 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.
¿Qué son las máscaras de atención?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codifican la estructura tabular. Los índices se pueden obtener usando AutoTokenizer. Consulta esta class para obtener más información.
¿Qué son los IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Si reset_position_index_per_cell de TapasConfig se establece en True, se utilizarán embeddings de posición relativos. Seleccionados en el rango [0, config.max_position_embeddings - 1].
¿Qué son los IDs de posición?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador.
encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno de la entrada del codificador. Esta máscara se utiliza en la atención cruzada si el modelo está configurado como decodificador. 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.
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en 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. Consulte hidden_states en 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

BaseModelOutputWithPooling o tuple(torch.Tensor)

Un BaseModelOutputWithPooling o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (TapasConfig) y las entradas.

El método forward de TapasModel 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 Module despué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.Tensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.
pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (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.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (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, TapasModel
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasModel.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

TapasForMaskedLM

clase transformers.TapasForMaskedLM

< source >

( config: TapasConfig )

Parámetros

config (TapasConfig) — 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 Tapas con una cabeza de language modeling en la parte superior.”

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor de 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.

¿Qué son los IDs de entrada?
attention_mask (torch.Tensor de 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.
¿Qué son las máscaras de atención?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codifican la estructura tabular. Los índices se pueden obtener usando AutoTokenizer. Consulta esta class para obtener más información.
¿Qué son los IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Si reset_position_index_per_cell de TapasConfig se establece en True, se utilizarán embeddings de posición relativos. Seleccionados en el rango [0, config.max_position_embeddings - 1].
¿Qué son los IDs de posición?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador.
encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno de la entrada del codificador. Esta máscara se utiliza en la atención cruzada si el modelo está configurado como decodificador. 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.
labels (torch.LongTensor de 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 de input_ids). Los tokens con índices establecidos en -100 se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en [0, ..., config.vocab_size].
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en 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. Consulte hidden_states en 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

MaskedLMOutput o tuple(torch.Tensor)

Un MaskedLMOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (TapasConfig) y las entradas.

El método forward de TapasForMaskedLM 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 Module despué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.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de modelado de lenguaje enmascarado (MLM).
logits (torch.Tensor de 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).
hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (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.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (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, TapasForMaskedLM
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasForMaskedLM.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)

>>> inputs = tokenizer(
...     table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt"
... )
>>> labels = tokenizer(
...     table=table, queries="How many movies has George Clooney played in?", return_tensors="pt"
... )["input_ids"]

>>> outputs = model(**inputs, labels=labels)
>>> logits = outputs.logits

TapasForSequenceClassification

clase transformers.TapasForSequenceClassification

< source >

( config: TapasConfig )

Parámetros

config (TapasConfig) — 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.

Modelo Tapas con una cabeza de clasificación de secuencias en la parte superior (una capa lineal sobre la salida agrupada), por ejemplo, para tareas de inferencia en tablas, como TabFact (Chen et al., 2020).

forward

< source >

Parámetros

input_ids (torch.LongTensor de 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.

¿Qué son los IDs de entrada?
attention_mask (torch.Tensor de 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.
¿Qué son las máscaras de atención?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codifican la estructura tabular. Los índices se pueden obtener usando AutoTokenizer. Consulta esta class para obtener más información.
¿Qué son los IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Si reset_position_index_per_cell de TapasConfig se establece en True, se utilizarán embeddings de posición relativos. Seleccionados en el rango [0, config.max_position_embeddings - 1].
¿Qué son los IDs de posición?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
labels (torch.LongTensor de 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]. Si config.num_labels == 1 se calcula una pérdida de regresión (pérdida de error cuadrático medio), si config.num_labels > 1 se calcula una pérdida de clasificación (entropía cruzada). Nota: en la implementación original se denomina “classification_class_index”.
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en 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. Consulte hidden_states en 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

SequenceClassifierOutput o tuple(torch.Tensor)

Un SequenceClassifierOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (TapasConfig) y las entradas.

El método forward de TapasForSequenceClassification 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 Module despué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.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación (o de regresión si config.num_labels==1).
logits (torch.Tensor de 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.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (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.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (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, TapasForSequenceClassification
>>> import torch
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact")
>>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = [
...     "There is only one actor who is 45 years old",
...     "There are 3 actors which played in more than 60 movies",
... ]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> labels = torch.tensor([1, 0])  # 1 means entailed, 0 means refuted

>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits

TapasForQuestionAnswering

clase transformers.TapasForQuestionAnswering

< source >

( config: TapasConfig )

Parámetros

config (TapasConfig) — 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.

Modelo Tapas con una cabeza de selección de celdas y una cabeza de agregación opcional en la parte superior para tareas de respuesta a preguntas sobre tablas (capas lineales sobre la salida de estados ocultos para calcular logits y logits_aggregation opcionales), por ejemplo, para tareas supervisadas de SQA, WTQ o WikiSQL.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonetable_mask: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneaggregation_labels: typing.Optional[torch.LongTensor] = Nonefloat_answer: typing.Optional[torch.Tensor] = Nonenumeric_values: typing.Optional[torch.Tensor] = Nonenumeric_values_scale: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → TableQuestionAnsweringOutput or tuple(torch.Tensor)

Parámetros

input_ids (torch.LongTensor de 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.

¿Qué son los IDs de entrada?
attention_mask (torch.Tensor de 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.
¿Qué son las máscaras de atención?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codifican la estructura tabular. Los índices se pueden obtener usando AutoTokenizer. Consulta esta class para obtener más información.
¿Qué son los IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Si reset_position_index_per_cell de TapasConfig se establece en True, se utilizarán embeddings de posición relativos. Seleccionados en el rango [0, config.max_position_embeddings - 1].
¿Qué son los IDs de posición?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasar input_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de input_ids en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.
table_mask (torch.LongTensor de forma (batch_size, seq_length), opcional) — Máscara para la tabla. Indica qué tokens pertenecen a la tabla (1). Los tokens de la pregunta, las cabeceras de la tabla y el relleno son 0.
labels (torch.LongTensor de forma (batch_size, seq_length), opcional) — Etiquetas por token para calcular la pérdida de selección jerárquica de celdas. Esto codifica las posiciones de la respuesta que aparece en la tabla. Se puede obtener usando AutoTokenizer.
- 1 para los tokens que son parte de la respuesta,
- 0 para los tokens que no forman parte de la respuesta.
aggregation_labels (torch.LongTensor de forma (batch_size, ), opcional) — Índice de la función de agregación para cada ejemplo del lote para calcular la pérdida de agregación. Los índices deben estar en [0, ..., config.num_aggregation_labels - 1]. Solo es necesario en caso de supervisión fuerte para la agregación (supervisado por WikiSQL).
float_answer (torch.Tensor de forma (batch_size, ), opcional) — Respuesta en coma flotante para cada ejemplo del lote. Establecer en float(‘nan’) para preguntas de selección de celdas. Solo es obligatorio en el caso de supervisión débil (WTQ) para calcular la máscara agregada y la pérdida de regresión.
numeric_values (torch.Tensor de forma (batch_size, seq_length), opcional) — Valores numéricos de cada token, NaN para los tokens que no son valores numéricos. Se pueden obtener usando AutoTokenizer. Solo es necesario en el caso de supervisión débil para la agregación (WTQ) para calcular la pérdida de regresión.
numeric_values_scale (torch.Tensor de forma (batch_size, seq_length), opcional) — Escala de los valores numéricos de cada token. Se puede obtener mediante AutoTokenizer. Solo es necesario en el caso de supervisión débil para la agregación (WTQ) para calcular la pérdida de regresión.
output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en 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. Consulte hidden_states en 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

TableQuestionAnsweringOutput o tuple(torch.Tensor)

Un TableQuestionAnsweringOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (TapasConfig) y las entradas.

El método forward de TapasForQuestionAnswering 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 Module despué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.Tensor de forma (1,), opcional, devuelto cuando se proporcionan labels (y posiblemente answer, aggregation_labels, numeric_values y numeric_values_scale)) — Pérdida total como la suma de la pérdida de verosimilitud logarítmica de selección jerárquica de celdas y (opcionalmente) la pérdida de regresión semisupervisada y (opcionalmente) la pérdida supervisada para agregaciones.
logits (torch.Tensor de forma (batch_size, sequence_length)) — Puntuaciones de predicción de la cabeza de selección de celdas, para cada token.
logits_aggregation (torch.Tensor, opcional, de forma (batch_size, num_aggregation_labels)) — Puntuaciones de predicción de la cabeza de agregación, para cada operador de agregación.
hidden_states (tuple[torch.Tensor], opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (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.Tensor], opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (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, TapasForQuestionAnswering
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> logits_aggregation = outputs.logits_aggregation

Update on GitHub

←Modelos de codificador-decodificador de voz TIPSv2→