Table Question Answering Setup on Ubuntu

1. Install Python and Required Tools

First, ensure that Python is installed on your system. Use the following commands to install Python, pip, and venv for managing virtual environments:

sudo apt update
sudo apt install python3 python3-pip python3-venv

2. Create a Virtual Environment

It’s a best practice to use virtual environments to manage project dependencies. Run the following commands to create and activate a virtual environment:

python3 -m venv table-qa-env
source table-qa-env/bin/activate

3. Install Necessary Libraries

To implement Table Question Answering (Table QA), we will use Hugging Face's transformers library, pandas for table manipulation, and PyTorch for the deep learning backend:

pip install transformers pandas torch datasets

4. Load a Pre-trained Table Question Answering Model

Hugging Face provides pre-trained models for Table Question Answering, like TAPAS. Let's load the TAPAS model and tokenizer, which are designed for answering questions from tables:

from transformers import TapasTokenizer, TapasForQuestionAnswering
import pandas as pd

# Load the TAPAS tokenizer and model
tokenizer = TapasTokenizer.from_pretrained("google/tapas-large-finetuned-wtq")
model = TapasForQuestionAnswering.from_pretrained("google/tapas-large-finetuned-wtq")

5. Prepare Your Table Data

You need to format your table data as a pandas DataFrame before passing it to the model. For example:

# Sample table data
data = {
    "Player": ["Lionel Messi", "Cristiano Ronaldo", "Neymar Jr"],
    "Goals": [700, 750, 300],
    "Assists": [300, 250, 200]
}

# Convert the data to a pandas DataFrame
table = pd.DataFrame.from_dict(data)

6. Ask a Question About the Table

Once the table is prepared, you can ask questions about it. Tokenize the input question and table data, and then pass them to the TAPAS model:

# Define the question
questions = ["How many goals has Lionel Messi scored?"]

# Tokenize the input
inputs = tokenizer(table=table, queries=questions, padding="max_length", return_tensors="pt")

# Get model output
outputs = model(**inputs)

# Get the answer from the model
logits = outputs.logits
predicted_index = logits.argmax(-1).item()

# Decode the answer
answers = tokenizer.convert_logits_to_predictions(inputs, outputs.logits)
print(f"Answer: {answers[0]}")

7. Fine-tune the Model (Optional)

If you have a custom dataset and want to fine-tune the TAPAS model for your Table QA task, you can use Hugging Face’s Trainer API. To do so, first, prepare your dataset and load it using the datasets library. Then, fine-tune the model:

from datasets import load_dataset
from transformers import TrainingArguments, Trainer

# Load your dataset
dataset = load_dataset("path_to_your_dataset")

# Define training arguments
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    num_train_epochs=3,
    weight_decay=0.01,
)

# Initialize Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["validation"],
    tokenizer=tokenizer
)

# Fine-tune the model
trainer.train()

8. Save the Fine-tuned Model

Once you have fine-tuned your model, save it for later use:

# Save the model
trainer.save_model("./table_qa_model")

9. Run Inference on New Data

After fine-tuning or loading a pre-trained model, you can run inference on new tables and questions:

# New question and table data
new_table = pd.DataFrame.from_dict({
    "Player": ["Kylian Mbappe", "Robert Lewandowski"],
    "Goals": [300, 450],
    "Assists": [100, 120]
})

new_questions = ["How many goals has Robert Lewandowski scored?"]

# Tokenize the new input
new_inputs = tokenizer(table=new_table, queries=new_questions, padding="max_length", return_tensors="pt")

# Get model output
new_outputs = model(**new_inputs)

# Decode the answer
new_answers = tokenizer.convert_logits_to_predictions(new_inputs, new_outputs.logits)
print(f"Answer: {new_answers[0]}")

10. Serve the Model Using FastAPI (Optional)

If you want to serve the Table QA model as an API, you can use FastAPI and Uvicorn. First, install the required libraries:

pip install fastapi uvicorn

Here is an example FastAPI app that serves the Table QA model:

from fastapi import FastAPI
from transformers import TapasTokenizer, TapasForQuestionAnswering
import pandas as pd

app = FastAPI()

# Load the TAPAS tokenizer and model
tokenizer = TapasTokenizer.from_pretrained("google/tapas-large-finetuned-wtq")
model = TapasForQuestionAnswering.from_pretrained("google/tapas-large-finetuned-wtq")

@app.post("/table_qa")
def table_qa(table: dict, question: str):
    # Convert table dictionary to DataFrame
    table_df = pd.DataFrame.from_dict(table)

    # Tokenize the inputs
    inputs = tokenizer(table=table_df, queries=[question], padding="max_length", return_tensors="pt")

    # Get model output
    outputs = model(**inputs)

    # Decode the answer
    answers = tokenizer.convert_logits_to_predictions(inputs, outputs.logits)
    return {"answer": answers[0]}

# Run the server
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

You can run this API with the following command:

uvicorn app:app --reload

Summary

You’ve successfully set up Table Question Answering on Ubuntu using Python, Hugging Face's TAPAS model, and PyTorch. You can either use a pre-trained model or fine-tune it on custom data, and optionally serve it through an API using FastAPI.