# TAPAS ## Resumen El modelo TAPAS se propuso en [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) 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 utiliza 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](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Sequential Question Answering de Microsoft) - [WTQ](https://github.com/ppasupat/WikiTableQuestions) (Wiki Table Questions de la Universidad de Stanford) - [WikiSQL](https://github.com/salesforce/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, opcionalmente, aplicando 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 igualar el 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](https://github.com/wenhuchen/Table-Fact-Checking), 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](https://www.aclweb.org/anthology/2020.findings-emnlp.27/) de Julian Martin Eisenschlos, Syrine Krichene y Thomas Müller. drawing Arquitectura de TAPAS. Tomado del artículo de blog original. Este modelo fue aportado por [nielsr](https://huggingface.co/nielsr). El código original se puede encontrar [aquí](https://github.com/google-research/tapas). ## 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 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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig), que se establece en `True` por defecto. Las versiones por defecto de los modelos disponibles en el [hub](https://huggingface.co/models?search=tapas) utilizan todos embeddings de posición relativa. Aún puede utilizar los que emplean 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](https://github.com/google-research/tapas). - TAPAS tiene puntos de control ajustados en SQA, 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 "Usage" 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](/docs/transformers/main/es/model_doc/tapas#transformers.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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasForQuestionAnswering), que corresponden a los distintos conjuntos de datos en los que se ajustó Tapas: 1. 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). 2. WTQ: si no te interesa hacer preguntas en un entorno conversacional, sino más bien hacer preguntas relacionadas con una tabla, que pueden implicar agregaciones, 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 denomina **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. 3. 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. ```python 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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig) y, a continuación, crear un [TapasForQuestionAnswering](/docs/transformers/main/es/model_doc/tapas#transformers.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: ```python 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í](https://github.com/google-research/tapas/issues/91#issuecomment-735719340) 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í](https://huggingface.co/models?search=tapas). **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](https://www.microsoft.com/en-us/download/details.aspx?id=54253). 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 propias tablas 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í](https://github.com/google-research/tapas/issues/50#issuecomment-705465960). Una conversión de este script que funciona con la implementación de HuggingFace se puede encontrar [aquí](https://github.com/NielsRogge/tapas_utils). Curiosamente, estos scripts de conversión no son perfectos (los campos `answer_coordinates` y `float_answer` se rellenan en función de `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** En tercer lugar, dado que has preparado tus datos en este formato TSV/CSV (y los archivos CSV correspondientes que contienen los datos tabulares), puedes usar [TapasTokenizer](/docs/transformers/main/es/model_doc/tapas#transformers.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 anteriormente, [TapasForQuestionAnswering](/docs/transformers/main/es/model_doc/tapas#transformers.TapasForQuestionAnswering) requiere entradas diferentes 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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasTokenizer) crea `labels`, `numeric_values` y `numeric_values_scale` en función de las columnas `answer_coordinates` y `answer_text` del archivo TSV. `float_answer` y `aggregation_labels` ya están en el archivo TSV del paso 2. A continuación, un ejemplo: ```py 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](/docs/transformers/main/es/model_doc/tapas#transformers.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: ```python 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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasTokenizer)) se establezcan correctamente. Consulte [este cuaderno](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) para obtener más información. **PASO 4: Entrenar (ajustar) el modelo A continuación, puede realizar el ajuste fino de [TapasForQuestionAnswering](/docs/transformers/main/es/model_doc/tapas#transformers.TapasForQuestionAnswering) de la siguiente manera (mostrado aquí para el caso de supervisión débil para agregación): ```python 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](/docs/transformers/main/es/model_doc/tapas#transformers.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](/docs/transformers/main/es/model_doc/tapas#transformers.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 **diferente** según 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: ```py 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](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb). ## Recursos - [Guía de la tarea de clasificación de texto](../tasks/sequence_classification) - [Guía de la tarea de modelado de lenguaje enmascarado](../tasks/masked_language_modeling) ## Salidas específicas de TAPAS[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] #### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] ```python transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L49) **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 se pasa `output_hidden_states=True` 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 de embedding iniciales opcionales. attentions (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Tipo de salida de [TapasForQuestionAnswering](/docs/transformers/main/es/model_doc/tapas#transformers.TapasForQuestionAnswering). ## TapasConfig[[transformers.TapasConfig]] #### transformers.TapasConfig[[transformers.TapasConfig]] ```python transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/configuration_tapas.py#L32) **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 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 los embeddings, 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 del vocabulario de los `token_type_ids` pasados al llamar a [TapasModel](/docs/transformers/main/es/model_doc/tapas#transformers.TapasModel). initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de 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 capas. pad_token_id (`int`, *opcional*, valor predeterminado `0`) : Id de token utilizado para el relleno en el vocabulario. bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario. eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la 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*) : Indica si se debe usar la respuesta como ú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 debe normalizar 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`) : Indica si se debe aplicar 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 aplicable en 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, se predice la agregación para un ejemplo. answer_loss_cutoff (`float`, *opcional*) : Ignorar 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 "Sin 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. 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`) : Indica si se deben vincular las incrustaciones de pesos 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](https://huggingface.co/google/tapas-base-finetuned-sqa) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> 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[[transformers.TapasTokenizer]] #### transformers.TapasTokenizer[[transformers.TapasTokenizer]] ```python transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L149) **Parámetros:** vocab_file (`str`) : Archivo que contiene el vocabulario. do_lower_case (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe convertir la entrada en 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`) : Indica si se deben tokenizar los caracteres chinos. Probablemente debería desactivarse para el japonés (véase esta [incidencia](https://github.com/huggingface/transformers/issues/328)). 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 la 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*) : Id 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 utilizado por los modelos TAPAS. Este tokenizador hereda de [PreTrainedTokenizer](/docs/transformers/main/es/main_classes/tokenizer#transformers.PythonBackend), 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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasTokenizer) crea varios token type ids para codificar la estructura tabular. Para ser más precisos, añade 7 token type ids, 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 pregunta, tokens especiales y relleno. - row_ids: indica a qué fila de la tabla pertenece un token (comenzando desde 1). Es 0 para todos los tokens de la pregunta, los tokens especiales y el padding. 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 "número de películas" 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 con respecto a 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, los tokens especiales y el padding. [TapasTokenizer](/docs/transformers/main/es/model_doc/tapas#transformers.TapasTokenizer) realiza la tokenización de extremo a extremo en una tabla y sus oraciones asociadas: división de puntuación y wordpiece. #### __llamada__[[transformers.TapasTokenizer.__call__]] ```python __call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L518) **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á. Ten 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 respuesta de cada par tabla-pregunta del lote. Si solo se proporciona un par tabla-pregunta, answer_text debe ser una única lista de una o más cadenas de caracteres. Cada cadena debe ser el texto de respuesta de una coordenada de respuesta correspondiente. Si se proporciona un lote de pares tabla-pregunta, 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`) : Indica si se deben codificar las secuencias con los tokens especiales relativos a su modelo. padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. 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 longitudes diferentes). truncation (`bool`, `str` o `TapasTruncationStrategy`, *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores: - `True` o `'drop_rows_to_fit'`: Trunca 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. Esto truncará fila por fila, eliminando filas de la tabla. - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño de entrada máximo admisible del modelo). max_length (`int`, *opcional*) : Controla la longitud máxima que debe usar uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se usará 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á. 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 procederá a tokenizarla. 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. Esto resulta 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](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy. Método principal para tokenizar y preparar para el modelo una o varias secuencias relacionadas con una tabla. #### convert_logits_to_predictions[[transformers.TapasTokenizer.convert_logits_to_predictions]] ```python convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L1885) **Parámetros:** data (`dict`) : Diccionario que mapea las características a sus valores reales. Debe crearse usando [TapasTokenizer](/docs/transformers/main/es/model_doc/tapas#transformers.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 solo 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 del operador de agregación predichos por la cabeza de agregación. Convierte los logits de [TapasForQuestionAnswering](/docs/transformers/main/es/model_doc/tapas#transformers.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í](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288). #### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L386) ## TapasModel[[transformers.TapasModel]] #### transformers.TapasModel[[transformers.TapasModel]] ```python transformers.TapasModel(config: TapasConfig, add_pooling_layer = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L510) **Parámetros:** config ([TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L543) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte esta clase para obtener más información. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig) se establece en `True`, se utilizarán incrustaciones de posición relativa. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) 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 tokens que **no están enmascarados**, - 0 para 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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig)) y las entradas. El método forward de [TapasModel](/docs/transformers/main/es/model_doc/tapas#transformers.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 preprocesamiento y posprocesamiento, 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*, 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 los embeddings, si el modelo tiene una capa de embedding, + 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: ```python >>> 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[[transformers.TapasForMaskedLM]] #### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]] ```python transformers.TapasForMaskedLM(config: TapasConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L660) **Parámetros:** config ([TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Tapas con una cabeza de `language modeling` en la parte superior." Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L684) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte esta clase para obtener más información. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig) se establece en `True`, se utilizarán incrustaciones de posición relativa. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) 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 tokens que **no están enmascarados**, - 0 para 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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **Devuelve:** [MaskedLMOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) o `tuple(torch.Tensor)` Un [MaskedLMOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig)) y las entradas. El método forward de [TapasForMaskedLM](/docs/transformers/main/es/model_doc/tapas#transformers.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 preprocesamiento y posprocesamiento, 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*, 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 los embeddings, si el modelo tiene una capa de embedding, + 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: ```python >>> 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[[transformers.TapasForSequenceClassification]] #### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] ```python transformers.TapasForSequenceClassification(config: TapasConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1119) **Parámetros:** config ([TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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 implicación de tablas, como TabFact (Chen et al., 2020). Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1131) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte esta clase para obtener más información. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig) se establece en `True`, se utilizarán incrustaciones de posición relativa. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) 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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **Devuelve:** [SequenceClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) o `tuple(torch.Tensor)` Un [SequenceClassifierOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig)) y las entradas. El método forward de [TapasForSequenceClassification](/docs/transformers/main/es/model_doc/tapas#transformers.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 preprocesamiento y posprocesamiento, 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*, 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 los embeddings, si el modelo tiene una capa de embedding, + 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: ```python >>> 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[[transformers.TapasForQuestionAnswering]] #### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] ```python transformers.TapasForQuestionAnswering(config: TapasConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L781) **Parámetros:** config ([TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L804) **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 mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) 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 la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) 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](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte esta clase para obtener más información. [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig) se establece en `True`, se utilizarán incrustaciones de posición relativa. Seleccionados en el rango `[0, config.max_position_embeddings - 1]`. [¿Qué son los IDs de posición?](../glossary#position-ids) 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 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](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). - 1 para los tokens que son **parte de la respuesta**, - 0 para los tokens que **no son 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, utilizado para calcular la pérdida de agregación. Los índices deben estar en `[0, ..., config.num_aggregation_labels - 1]`. Solo es necesario en el caso de supervisión fuerte para la agregación (supervisado por WikiSQL). float_answer (`torch.Tensor` de forma `(batch_size, )`, *opcional*) : Respuesta en formato float 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 puede obtener usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.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 usando [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Solo es necesario en 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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **Devuelve:** [TableQuestionAnsweringOutput](/docs/transformers/main/es/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) o `tuple(torch.Tensor)` Un [TableQuestionAnsweringOutput](/docs/transformers/main/es/model_doc/tapas#transformers.models.tapas.modeling_tapas.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](/docs/transformers/main/es/model_doc/tapas#transformers.TapasConfig)) y las entradas. El método forward de [TapasForQuestionAnswering](/docs/transformers/main/es/model_doc/tapas#transformers.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 preprocesamiento y posprocesamiento, 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: ```python >>> 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 ```