Upload 17 files

README.md

@@ -1,12 +1,13 @@
----
-title: TAPASxHF2
-emoji: 🚀
-colorFrom: yellow
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.26.0
-app_file: app.py
-pinned: false
----
+Here are the main classes, functions, and methods that will be implemented:
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+1. `CSVLoader`: This class will have methods for uploading CSV files and converting them into pandas dataframes with the required structure.
+2. `EmbeddingGenerator`: This class will have a method for generating embeddings for the data using the SentenceTransformer model.
+3. `ChromaDBIndexer`: This class will have methods for creating a chroma db index and uploading the generated embeddings to the index.
+4. `QuestionAnswerer`: This class will have methods for processing user's queries, querying the chroma db for the relevant table, and running the table and query through the TAPAS pipeline for answering.
+5. `AnswerPresenter`: This class will have methods for presenting the answers returned from TAPAS in the UI and executing any suggested aggregator functions.
+6. `run.sh`: This is the entrypoint of the program. It will start the application and handle any command line arguments.
+7. `requirements.txt`: This file will list all the Python package dependencies for the application.
+
+Now, let's implement the code for each file.
+
+run.sh

answer_presenter.py

@@ -0,0 +1,4 @@
+class AnswerPresenter:
+    def present_answer(self, answer):
+        # Implement the logic to present the answer in the UI
+        pass

app.py

@@ -0,0 +1,30 @@
+import streamlit as st
+from csv_loader import CSVLoader
+from embedding_generator import EmbeddingGenerator
+from chroma_db_indexer import ChromaDBIndexer
+from question_answerer import QuestionAnswerer
+from answer_presenter import AnswerPresenter
+
+def main():
+    st.title("TAPAS LLM Application")
+    
+    csv_loader = CSVLoader()
+    embedding_generator = EmbeddingGenerator()
+    chroma_db_indexer = ChromaDBIndexer()
+    question_answerer = QuestionAnswerer()
+    answer_presenter = AnswerPresenter()
+    
+    uploaded_files = st.file_uploader("Upload CSV", type='csv', accept_multiple_files=True)
+    if uploaded_files:
+        dataframes = csv_loader.load_csvs(uploaded_files)
+        embeddings = embedding_generator.generate_embeddings(dataframes)
+        chroma_db_indexer.create_index(embeddings)
+        
+        query = st.text_input("Enter your question")
+        if query:
+            table = question_answerer.query_table(query)
+            answer = question_answerer.answer_question(query, table)
+            answer_presenter.present_answer(answer)
+
+if __name__ == "__main__":
+    main()

chroma_db_indexer.py

@@ -0,0 +1,9 @@
+from chroma_db import ChromaDB
+
+class ChromaDBIndexer:
+    def __init__(self):
+        self.db = ChromaDB()
+
+    def create_index(self, embeddings):
+        for embedding in embeddings:
+            self.db.insert(embedding)

csv_loader.py

@@ -0,0 +1,9 @@
+import pandas as pd
+
+class CSVLoader:
+    def load_csvs(self, files):
+        dataframes = []
+        for file in files:
+            df = pd.read_csv(file)
+            dataframes.append(df)
+        return dataframes

embedding_generator.py

@@ -0,0 +1,16 @@
+from transformers import AutoTokenizer, AutoModel
+import torch
+
+class EmbeddingGenerator:
+    def __init__(self):
+        self.model_name = "deepset/all-mpnet-base-v2-table"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModel.from_pretrained(self.model_name)
+
+    def generate_embeddings(self, dataframes):
+        embeddings = []
+        for df in dataframes:
+            inputs = self.tokenizer(df.to_string(index=False), return_tensors='pt', truncation=True, padding=True)
+            outputs = self.model(**inputs)
+            embeddings.append(outputs.last_hidden_state.mean(dim=1).detach().numpy())
+        return embeddings

question_answerer.py

@@ -0,0 +1,16 @@
+from transformers import TapasTokenizer, TapasForQuestionAnswering, pipeline
+
+class QuestionAnswerer:
+    def __init__(self):
+        self.model_name = "google/tapas-large-finetuned-wtq"
+        self.tokenizer = TapasTokenizer.from_pretrained(self.model_name)
+        self.model = TapasForQuestionAnswering.from_pretrained(self.model_name)
+        self.pipe = pipeline("table-question-answering", model=self.model, tokenizer=self.tokenizer)
+
+    def query_table(self, query):
+        # Implement the logic to query the chroma db for the relevant table
+        pass
+
+    def answer_question(self, query, table):
+        inputs = self.pipe(table, query)
+        return inputs

requirements.txt

@@ -0,0 +1,5 @@
+streamlit==0.88.0
+pandas==1.3.3
+transformers==4.10.2
+gradio==2.3.0
+sentence-transformers==2.0.0

run.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+# Entry point for the TAPAS LLM Application
+streamlit run app.py

setup_instructions.md

@@ -0,0 +1,21 @@
+# Setup Instructions for the TAPAS LLM Application
+
+1. Install the necessary dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+2. Setup the required services (e.g., chroma db):
+
+```bash
+# Add the appropriate commands here
+```
+
+3. Run the application:
+
+```bash
+./run.sh
+```
+
+If you encounter any issues during setup, please refer to the [Troubleshooting Guide](troubleshooting.md).

tapas_application_specification.txt

@@ -0,0 +1,30 @@
+Specification for TAPAS LLM Application
+
+1. Overview:
+The application will be a web-based application hosted on HuggingFace "Space" using either streamlit or gradio UI. It will allow users to upload CSV files and ask questions about the data in the files. The application will use Google's TAPAS LLM model to answer these questions.
+
+2. Core Classes and Functions:
+   - `CSVLoader`: This class will handle the uploading and loading of CSV files. It will convert the CSV files into pandas dataframes with the required structure for the SentenceTransformer retriever.
+   - `EmbeddingGenerator`: This class will generate embeddings for the data using the SentenceTransformer model "deepset/all-mpnet-base-v2-table".
+   - `ChromaDBIndexer`: This class will create a chroma db index and upload the generated embeddings to the index.
+   - `QuestionAnswerer`: This class will handle the processing of user's queries, querying the chroma db for the relevant table, and running the table and query through the TAPAS pipeline for answering.
+   - `AnswerPresenter`: This class will handle the presentation of the answers returned from TAPAS in the UI. It will also handle the execution of any suggested aggregator functions.
+
+3. Non-Standard Dependencies:
+   - pandas: For handling CSV files and data manipulation.
+   - HuggingFace Transformers: For the TAPAS model, tokenizer, pipeline, and SentenceTransformer model.
+   - streamlit or gradio: For the UI of the application.
+   - chroma db: For creating the index and querying for relevant tables.
+
+4. Detailed Functionality:
+   - The application will start with a UI where users can upload one or more CSV files. The `CSVLoader` will handle the uploading and loading of these files, converting them into pandas dataframes with the required structure.
+   - The `EmbeddingGenerator` will then generate embeddings for the data using the SentenceTransformer model "deepset/all-mpnet-base-v2-table".
+   - The `ChromaDBIndexer` will create a chroma db index with a metric type of "cosine" and a dimension of "768", and upload the generated embeddings to the index.
+   - The user will be able to input a query in natural language. The `QuestionAnswerer` will take this query, generate embeddings for it, and query the chroma db for the relevant table that should contain the answer.
+   - The `QuestionAnswerer` will then run the relevant table and the query through the TAPAS pipeline for answering. The TAPAS model, tokenizer, and pipeline will be loaded from HuggingFace.
+   - The `AnswerPresenter` will take the answer returned from TAPAS and present it neatly in the UI. If the TAPAS answer includes an aggregator, the `AnswerPresenter` will first execute the aggregator function on the cell values before presenting the answer.
+
+5. Additional Considerations:
+   - Error handling should be implemented to handle cases where the CSV file cannot be loaded, the embeddings cannot be generated, the chroma db index cannot be created, or the TAPAS pipeline cannot answer the question.
+   - The UI should be user-friendly and intuitive, with clear instructions on how to upload CSV files and input queries.
+   - The application should be designed with scalability in mind, as the number of CSV files and queries could potentially be large.

test_answer_presenter.py

@@ -0,0 +1,14 @@
+from answer_presenter import AnswerPresenter
+
+def test_answer_presenter():
+    answer_presenter = AnswerPresenter()
+    
+    # Test presenting answer without aggregator
+    answer = {"answer": "Test", "aggregator": "NONE"}
+    presented_answer = answer_presenter.present(answer)
+    assert presented_answer == "Test"
+    
+    # Test presenting answer with aggregator
+    answer = {"answer": "SUM > 1, 2", "cells": ["1", "2"], "aggregator": "SUM"}
+    presented_answer = answer_presenter.present(answer)
+    assert presented_answer == "3"

test_application.py

@@ -0,0 +1,12 @@
+from application import Application
+
+def test_application():
+    app = Application()
+    
+    # Test uploading CSV file
+    app.upload_csv("test.csv")
+    assert app.csv_loader.loaded_files == ["test.csv"]
+    
+    # Test asking question
+    answer = app.ask_question("What is the sum?")
+    assert isinstance(answer, str)

test_chroma_db_indexer.py

@@ -0,0 +1,14 @@
+from chroma_db_indexer import ChromaDBIndexer
+
+def test_chroma_db_indexer():
+    chroma_db_indexer = ChromaDBIndexer()
+    
+    # Test creating index
+    index = chroma_db_indexer.create_index()
+    assert index.metric_type == "cosine"
+    assert index.dim == 768
+    
+    # Test uploading embeddings
+    embeddings = [0]*768
+    chroma_db_indexer.upload_embeddings(embeddings, index)
+    assert len(index.search(embeddings, 1)) == 1

test_csv_loader.py

@@ -0,0 +1,14 @@
+import pandas as pd
+from csv_loader import CSVLoader
+
+def test_csv_loader():
+    csv_loader = CSVLoader()
+    
+    # Test loading a CSV file
+    df = csv_loader.load("test.csv")
+    assert isinstance(df, pd.DataFrame)
+    
+    # Test converting to required structure
+    structured_df = csv_loader.convert_to_required_structure(df)
+    assert isinstance(structured_df, pd.DataFrame)
+    assert "\n" in structured_df.to_string(index=False)

test_embedding_generator.py

@@ -0,0 +1,9 @@
+from embedding_generator import EmbeddingGenerator
+
+def test_embedding_generator():
+    embedding_generator = EmbeddingGenerator()
+    
+    # Test generating embeddings
+    embeddings = embedding_generator.generate("test query")
+    assert isinstance(embeddings, list)
+    assert len(embeddings) == 768

test_question_answerer.py

@@ -0,0 +1,17 @@
+from question_answerer import QuestionAnswerer
+
+def test_question_answerer():
+    question_answerer = QuestionAnswerer()
+    
+    # Test processing query
+    processed_query = question_answerer.process_query("test query")
+    assert isinstance(processed_query, list)
+    
+    # Test querying chroma db
+    table = question_answerer.query_chroma_db(processed_query)
+    assert isinstance(table, pd.DataFrame)
+    
+    # Test running TAPAS pipeline
+    answer = question_answerer.run_tapas_pipeline(processed_query, table)
+    assert isinstance(answer, dict)
+    assert "answer" in answer