Upload 191 files

Transcripts/AMZN/2019-Apr-25-AMZN.txt

@@ -69,7 +69,7 @@ With that, we will move to Q&A. Operator, please remind our listeners how to ini
 
 ================================================================================
 Questions and Answers
-================================================================================s
+================================================================================
 --------------------------------------------------------------------------------
 Operator    [1]
 --------------------------------------------------------------------------------

app.py

@@ -1,29 +1,31 @@
+import openai
+import streamlit_scrollable_textbox as stx
+
 import pinecone
 import streamlit as st
-
-st.set_page_config(layout="wide")
-
-import streamlit_scrollable_textbox as stx
-import openai
 from utils import (
+    create_dense_embeddings,
+    create_sparse_embeddings,
+    format_query,
+    generate_prompt,
     get_data,
+    get_flan_t5_model,
     get_mpnet_embedding_model,
     get_sgpt_embedding_model,
-    get_flan_t5_model,
+    get_splade_sparse_embedding_model,
     get_t5_model,
-    save_key,
-)
-
-from utils import (
-    retrieve_transcript,
+    gpt_model,
+    hybrid_score_norm,
     query_pinecone,
-    format_query,
+    query_pinecone_sparse,
+    retrieve_transcript,
+    save_key,
     sentence_id_combine,
     text_lookup,
-    generate_prompt,
-    gpt_model,
 )
 
+st.set_page_config(layout="wide")
+
 
 st.title("Abstractive Question Answering")
 
@@ -73,12 +75,14 @@ with st.sidebar:
     st.subheader("Select Options:")
 
 with st.sidebar:
-    num_results = int(st.number_input("Number of Results to query", 1, 15, value=6))
+    num_results = int(
+        st.number_input("Number of Results to query", 1, 15, value=6)
+    )
 
 
 # Choose encoder model
 
-encoder_models_choice = ["MPNET", "SGPT"]
+encoder_models_choice = ["MPNET", "SGPT", "Hybrid MPNET - SPLADE"]
 with st.sidebar:
     encoder_model = st.selectbox("Select Encoder Model", encoder_models_choice)
 
@@ -97,18 +101,34 @@ with st.sidebar:
 
 if encoder_model == "MPNET":
     # Connect to pinecone environment
-    pinecone.init(api_key=st.secrets["pinecone_mpnet"], environment="us-east1-gcp")
+    pinecone.init(
+        api_key=st.secrets["pinecone_mpnet"], environment="us-east1-gcp"
+    )
     pinecone_index_name = "week2-all-mpnet-base"
     pinecone_index = pinecone.Index(pinecone_index_name)
     retriever_model = get_mpnet_embedding_model()
 
 elif encoder_model == "SGPT":
     # Connect to pinecone environment
-    pinecone.init(api_key=st.secrets["pinecone_sgpt"], environment="us-east1-gcp")
+    pinecone.init(
+        api_key=st.secrets["pinecone_sgpt"], environment="us-east1-gcp"
+    )
     pinecone_index_name = "week2-sgpt-125m"
     pinecone_index = pinecone.Index(pinecone_index_name)
     retriever_model = get_sgpt_embedding_model()
 
+elif encoder_model == "Hybrid MPNET - SPLADE":
+    pinecone.init(
+        api_key=st.secrets["pinecone_hybrid_splade_mpnet"],
+        environment="us-central1-gcp",
+    )
+    pinecone_index_name = "splade-mpnet"
+    pinecone_index = pinecone.Index(pinecone_index_name)
+    retriever_model = get_mpnet_embedding_model()
+    (
+        sparse_retriever_model,
+        sparse_retriever_tokenizer,
+    ) = get_splade_sparse_embedding_model()
 
 with st.sidebar:
     window = int(st.number_input("Sentence Window Size", 0, 10, value=1))
@@ -116,23 +136,52 @@ with st.sidebar:
 with st.sidebar:
     threshold = float(
         st.number_input(
-            label="Similarity Score Threshold", step=0.05, format="%.2f", value=0.25
+            label="Similarity Score Threshold",
+            step=0.05,
+            format="%.2f",
+            value=0.25,
         )
     )
 
 data = get_data()
 
-query_results = query_pinecone(
-    query_text,
-    num_results,
-    retriever_model,
-    pinecone_index,
-    year,
-    quarter,
-    ticker,
-    participant_type,
-    threshold,
-)
+if encoder_model == "Hybrid SGPT - SPLADE":
+    dense_query_embedding = create_dense_embeddings(
+        query_text, retriever_model
+    )
+    sparse_query_embedding = create_sparse_embeddings(
+        query_text, sparse_retriever_model, sparse_retriever_tokenizer
+    )
+    dense_query_embedding, sparse_query_embedding = hybrid_score_norm(
+        dense_query_embedding, sparse_query_embedding, 0
+    )
+    query_results = query_pinecone_sparse(
+        dense_query_embedding,
+        sparse_query_embedding,
+        num_results,
+        pinecone_index,
+        year,
+        quarter,
+        ticker,
+        participant_type,
+        threshold,
+    )
+
+else:
+    dense_query_embedding = create_dense_embeddings(
+        query_text, retriever_model
+    )
+    query_results = query_pinecone(
+        dense_query_embedding,
+        num_results,
+        pinecone_index,
+        year,
+        quarter,
+        ticker,
+        participant_type,
+        threshold,
+    )
+
 
 if threshold <= 0.90:
     context_list = sentence_id_combine(data, query_results, lag=window)
@@ -145,7 +194,9 @@ prompt = generate_prompt(query_text, context_list)
 if decoder_model == "GPT3 - (text-davinci-003)":
     with col2:
         with st.form("my_form"):
-            edited_prompt = st.text_area(label="Model Prompt", value=prompt, height=270)
+            edited_prompt = st.text_area(
+                label="Model Prompt", value=prompt, height=270
+            )
 
             openai_key = st.text_input(
                 "Enter OpenAI key",
@@ -166,20 +217,20 @@ elif decoder_model == "T5":
     output_text = []
     for context_text in context_list:
         output_text.append(t5_pipeline(context_text)[0]["summary_text"])
-    generated_text = ". ".join(output_text)
     with col2:
         st.subheader("Answer:")
-        st.write(t5_pipeline(generated_text)[0]["summary_text"])
+        for text in output_text:
+            st.markdown(f"- {text}")
 
 elif decoder_model == "FLAN-T5":
     flan_t5_pipeline = get_flan_t5_model()
     output_text = []
     for context_text in context_list:
         output_text.append(flan_t5_pipeline(context_text)[0]["summary_text"])
-    generated_text = ". ".join(output_text)
     with col2:
         st.subheader("Answer:")
-        st.write(flan_t5_pipeline(generated_text)[0]["summary_text"])
+        for text in output_text:
+            st.markdown(f"- {text}")
 
 with col1:
     with st.expander("See Retrieved Text"):

utils.py

@@ -1,18 +1,18 @@
-import streamlit as st
-import pandas as pd
+import openai
 import pandas as pd
-from tqdm import tqdm
-import pinecone
+import streamlit_scrollable_textbox as stx
 import torch
 from sentence_transformers import SentenceTransformer
+from tqdm import tqdm
 from transformers import (
-    pipeline,
-    AutoTokenizer,
-    AutoModelForCausalLM,
+    AutoModelForMaskedLM,
     AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    pipeline,
 )
-import openai
-import streamlit_scrollable_textbox as stx
+
+import pinecone
+import streamlit as st
 
 
 @st.experimental_singleton
@@ -32,7 +32,11 @@ def get_t5_model():
 @st.experimental_singleton
 def get_flan_t5_model():
     return pipeline(
-        "summarization", model="google/flan-t5-small", tokenizer="google/flan-t5-small"
+        "summarization",
+        model="google/flan-t5-small",
+        tokenizer="google/flan-t5-small",
+        max_length=512,
+        # length_penalty = 0
     )
 
 
@@ -46,6 +50,18 @@ def get_mpnet_embedding_model():
     return model
 
 
+@st.experimental_singleton
+def get_splade_sparse_embedding_model():
+    model_sparse = "naver/splade-cocondenser-ensembledistil"
+    # check device
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    tokenizer = AutoTokenizer.from_pretrained(model_sparse)
+    model_sparse = AutoModelForMaskedLM.from_pretrained(model_sparse)
+    # move to gpu if available
+    model_sparse.to(device)
+    return model_sparse, tokenizer
+
+
 @st.experimental_singleton
 def get_sgpt_embedding_model():
     device = "cuda" if torch.cuda.is_available() else "cpu"
@@ -61,20 +77,152 @@ def save_key(api_key):
     return api_key
 
 
+def create_dense_embeddings(query, model):
+    dense_emb = model.encode([query]).tolist()
+    return dense_emb
+
+
+def create_sparse_embeddings(query, model, tokenizer):
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    inputs = tokenizer(query, return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        logits = model(**inputs).logits
+
+    inter = torch.log1p(torch.relu(logits[0]))
+    token_max = torch.max(inter, dim=0)  # sum over input tokens
+    nz_tokens = torch.where(token_max.values > 0)[0]
+    nz_weights = token_max.values[nz_tokens]
+
+    order = torch.sort(nz_weights, descending=True)
+    nz_weights = nz_weights[order[1]]
+    nz_tokens = nz_tokens[order[1]]
+    return {
+        "indices": nz_tokens.cpu().numpy().tolist(),
+        "values": nz_weights.cpu().numpy().tolist(),
+    }
+
+
+def hybrid_score_norm(dense, sparse, alpha: float):
+    """Hybrid score using a convex combination
+
+    alpha * dense + (1 - alpha) * sparse
+
+    Args:
+        dense: Array of floats representing
+        sparse: a dict of `indices` and `values`
+        alpha: scale between 0 and 1
+    """
+    if alpha < 0 or alpha > 1:
+        raise ValueError("Alpha must be between 0 and 1")
+    hs = {
+        "indices": sparse["indices"],
+        "values": [v * (1 - alpha) for v in sparse["values"]],
+    }
+    return [v * alpha for v in dense], hs
+
+
+def query_pinecone_sparse(
+    dense_vec,
+    sparse_vec,
+    top_k,
+    index,
+    year,
+    quarter,
+    ticker,
+    participant_type,
+    threshold=0.25,
+):
+    if participant_type == "Company Speaker":
+        participant = "Answer"
+    else:
+        participant = "Question"
+
+    if year == "All":
+        if quarter == "All":
+            xc = index.query(
+                vector=dense_vec,
+                sparse_vector=sparse_vec,
+                top_k=top_k,
+                filter={
+                    "Year": {
+                        "$in": [
+                            int("2020"),
+                            int("2019"),
+                            int("2018"),
+                            int("2017"),
+                            int("2016"),
+                        ]
+                    },
+                    "Quarter": {"$in": ["Q1", "Q2", "Q3", "Q4"]},
+                    "Ticker": {"$eq": ticker},
+                    "QA_Flag": {"$eq": participant},
+                },
+                include_metadata=True,
+            )
+        else:
+            xc = index.query(
+                vector=dense_vec,
+                sparse_vector=sparse_vec,
+                top_k=top_k,
+                filter={
+                    "Year": {
+                        "$in": [
+                            int("2020"),
+                            int("2019"),
+                            int("2018"),
+                            int("2017"),
+                            int("2016"),
+                        ]
+                    },
+                    "Quarter": {"$eq": quarter},
+                    "Ticker": {"$eq": ticker},
+                    "QA_Flag": {"$eq": participant},
+                },
+                include_metadata=True,
+            )
+    else:
+        # search pinecone index for context passage with the answer
+        xc = index.query(
+            vector=dense_vec,
+            sparse_vector=sparse_vec,
+            top_k=top_k,
+            filter={
+                "Year": int(year),
+                "Quarter": {"$eq": quarter},
+                "Ticker": {"$eq": ticker},
+                "QA_Flag": {"$eq": participant},
+            },
+            include_metadata=True,
+        )
+    # filter the context passages based on the score threshold
+    filtered_matches = []
+    for match in xc["matches"]:
+        if match["score"] >= threshold:
+            filtered_matches.append(match)
+    xc["matches"] = filtered_matches
+    return xc
+
+
 def query_pinecone(
-    query, top_k, model, index, year, quarter, ticker, participant_type, threshold=0.25
+    dense_vec,
+    top_k,
+    index,
+    year,
+    quarter,
+    ticker,
+    participant_type,
+    threshold=0.25,
 ):
     if participant_type == "Company Speaker":
         participant = "Answer"
     else:
         participant = "Question"
-    # generate embeddings for the query
-    xq = model.encode([query]).tolist()
 
     if year == "All":
         if quarter == "All":
             xc = index.query(
-                xq,
+                vector=dense_vec,
                 top_k=top_k,
                 filter={
                     "Year": {
@@ -94,7 +242,7 @@ def query_pinecone(
             )
         else:
             xc = index.query(
-                xq,
+                vector=dense_vec,
                 top_k=top_k,
                 filter={
                     "Year": {
@@ -115,7 +263,7 @@ def query_pinecone(
     else:
         # search pinecone index for context passage with the answer
         xc = index.query(
-            xq,
+            vector=dense_vec,
             top_k=top_k,
             filter={
                 "Year": int(year),
@@ -136,24 +284,33 @@ def query_pinecone(
 
 def format_query(query_results):
     # extract passage_text from Pinecone search result
-    context = [result["metadata"]["Text"] for result in query_results["matches"]]
+    context = [
+        result["metadata"]["Text"] for result in query_results["matches"]
+    ]
     return context
 
 
 def sentence_id_combine(data, query_results, lag=1):
     # Extract sentence IDs from query results
-    ids = [result["metadata"]["Sentence_id"] for result in query_results["matches"]]
+    ids = [
+        result["metadata"]["Sentence_id"]
+        for result in query_results["matches"]
+    ]
     # Generate new IDs by adding a lag value to the original IDs
     new_ids = [id + i for id in ids for i in range(-lag, lag + 1)]
     # Remove duplicates and sort the new IDs
     new_ids = sorted(set(new_ids))
     # Create a list of lookup IDs by grouping the new IDs in groups of lag*2+1
     lookup_ids = [
-        new_ids[i : i + (lag * 2 + 1)] for i in range(0, len(new_ids), lag * 2 + 1)
+        new_ids[i : i + (lag * 2 + 1)]
+        for i in range(0, len(new_ids), lag * 2 + 1)
     ]
     # Create a list of context sentences by joining the sentences corresponding to the lookup IDs
     context_list = [
-        " ".join(data.Text.iloc[lookup_id].to_list()) for lookup_id in lookup_ids
+        " ".join(
+            data.loc[data["Sentence_id"].isin(lookup_id), "Text"].to_list()
+        )
+        for lookup_id in lookup_ids
     ]
     return context_list