app_orig.py

# -*- coding: utf-8 -*-
"""P4_Russel_ThursAM.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/1dVe0kyDXjRC5Or8m8qgqRT3VG7Waq6PQ
"""

## THIS CODE BLOCK -- plotting functions & Cosine Similarity (exponential)

def plot_piechart(sorted_cosine_scores_items):
    sorted_cosine_scores = np.array([
            sorted_cosine_scores_items[index][1]
            for index in range(len(sorted_cosine_scores_items))
        ]
    )
    categories = st.session_state.categories.split(" ")
    categories_sorted = [
        categories[sorted_cosine_scores_items[index][0]]
        for index in range(len(sorted_cosine_scores_items))
    ]
    fig, ax = plt.subplots()
    ax.pie(sorted_cosine_scores, labels=categories_sorted, autopct="%1.1f%%")
    st.pyplot(fig)  # Figure


def plot_piechart_helper(sorted_cosine_scores_items):
    sorted_cosine_scores = np.array(
        [
            sorted_cosine_scores_items[index][1]
            for index in range(len(sorted_cosine_scores_items))
        ]
    )
    categories = st.session_state.categories.split(" ")
    categories_sorted = [
        categories[sorted_cosine_scores_items[index][0]]
        for index in range(len(sorted_cosine_scores_items))
    ]
    fig, ax = plt.subplots(figsize=(3, 3))
    my_explode = np.zeros(len(categories_sorted))
    my_explode[0] = 0.2
    if len(categories_sorted) == 3:
        my_explode[1] = 0.1  # explode this by 0.2
    elif len(categories_sorted) > 3:
        my_explode[2] = 0.05
    ax.pie(
        sorted_cosine_scores,
        labels=categories_sorted,
        autopct="%1.1f%%",
        explode=my_explode,
    )

    return fig

def plot_piecharts(sorted_cosine_scores_models):
    scores_list = []
    categories = st.session_state.categories.split(" ")
    index = 0
    for model in sorted_cosine_scores_models:
        scores_list.append(sorted_cosine_scores_models[model])
        # scores_list[index] = np.array([scores_list[index][ind2][1] for ind2 in range(len(scores_list[index]))])
        index += 1

    if len(sorted_cosine_scores_models) == 2:
        fig, (ax1, ax2) = plt.subplots(2)

        categories_sorted = [
            categories[scores_list[0][index][0]] for index in range(len(scores_list[0]))
        ]
        sorted_scores = np.array(
            [scores_list[0][index][1] for index in range(len(scores_list[0]))]
        )
        ax1.pie(sorted_scores, labels=categories_sorted, autopct="%1.1f%%")

        categories_sorted = [
            categories[scores_list[1][index][0]] for index in range(len(scores_list[1]))
        ]
        sorted_scores = np.array(
            [scores_list[1][index][1] for index in range(len(scores_list[1]))]
        )
        ax2.pie(sorted_scores, labels=categories_sorted, autopct="%1.1f%%")

    st.pyplot(fig)

def plot_alatirchart(sorted_cosine_scores_models):
    models = list(sorted_cosine_scores_models.keys())
    tabs = st.tabs(models)
    figs = {}
    for model in models:
        figs[model] = plot_piechart_helper(sorted_cosine_scores_models[model])

    for index in range(len(tabs)):
        with tabs[index]:
            st.pyplot(figs[models[index]])

# Compute Cosine Similarity
def cosine_similarity(x, y):
    """
    Exponentiated cosine similarity, (20 pts)
    1. Compute cosine similarity, 2. Exponentiate cosine similarity, 3. Return exponentiated cosine similarity
    """
    ##################################
    ### TODO: Add code here ##########
    ##################################
    if len(x) != len(y):
        raise ValueError("The dimensions of the two vectors must be the same.")

    dot_product = np.dot(x, y)

    norm_x = la.norm(x)
    norm_y = la.norm(y)

    cs = dot_product / (norm_x * norm_y)
    return np.exp(cs)

## THIS CODE BLOCK -- Has a set of functions that have no To Do's
## generally having utility functions for downloading and loading glove embeddings
## also contains functions for loading sentence transformer model and loading those embeddings

# Function to Load Glove Embeddings
def load_glove_embeddings(glove_path="Data/embeddings.pkl"):
    with open(glove_path, "rb") as f:
        embeddings_dict = pickle.load(f, encoding="latin1")

    return embeddings_dict

def get_model_id_gdrive(model_type):
    if model_type == "25d":
        word_index_id = "13qMXs3-oB9C6kfSRMwbAtzda9xuAUtt8"
        embeddings_id = "1-RXcfBvWyE-Av3ZHLcyJVsps0RYRRr_2"
    elif model_type == "50d":
        embeddings_id = "1DBaVpJsitQ1qxtUvV1Kz7ThDc3az16kZ"
        word_index_id = "1rB4ksHyHZ9skes-fJHMa2Z8J1Qa7awQ9"
    elif model_type == "100d":
        word_index_id = "1-oWV0LqG3fmrozRZ7WB1jzeTJHRUI3mq"
        embeddings_id = "1SRHfX130_6Znz7zbdfqboKosz-PfNvNp"

    return word_index_id, embeddings_id


def download_glove_embeddings_gdrive(model_type):
    # Get glove embeddings from google drive
    word_index_id, embeddings_id = get_model_id_gdrive(model_type)

    # Use gdown to get files from google drive
    embeddings_temp = "embeddings_" + str(model_type) + "_temp.npy"
    word_index_temp = "word_index_dict_" + str(model_type) + "_temp.pkl"

    # Download word_index pickle file
    print("Downloading word index dictionary....\n")
    gdown.download(id=word_index_id, output=word_index_temp, quiet=False)

    # Download embeddings numpy file
    print("Donwloading embedings...\n\n")
    gdown.download(id=embeddings_id, output=embeddings_temp, quiet=False)


@st.cache_data() # -- should this be uncommented so that data is generated everytime fn is called?
def load_glove_embeddings_gdrive(model_type):
    word_index_temp = "word_index_dict_" + str(model_type) + "_temp.pkl"
    embeddings_temp = "embeddings_" + str(model_type) + "_temp.npy"

    # Load word index dictionary
    word_index_dict = pickle.load(open(word_index_temp, "rb"), encoding="latin")

    # Load embeddings numpy
    embeddings = np.load(embeddings_temp)

    return word_index_dict, embeddings

@st.cache_resource()
def load_sentence_transformer_model(model_name):
    sentenceTransformer = SentenceTransformer(model_name)
    return sentenceTransformer

def get_sentence_transformer_embeddings(sentence, model_name="all-MiniLM-L6-v2"):
    """
    Get sentence transformer embeddings for a sentence
    """
    # 384 dimensional embedding
    # Default model: https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2

    sentenceTransformer = load_sentence_transformer_model(model_name)

    try:
        return sentenceTransformer.encode(sentence)
    except:
        if model_name == "all-MiniLM-L6-v2":
            return np.zeros(384)
        else:
            return np.zeros(512)

def get_glove_embeddings(word, word_index_dict, embeddings, model_type):
    """
    Get glove embedding for a single word
    """
    if word.lower() in word_index_dict:
        return embeddings[word_index_dict[word.lower()]]
    else:
        return np.zeros(int(model_type.split("d")[0]))

## THIS CODE BLOCK -- Has a set of functions that have To Do's

def averaged_glove_embeddings_gdrive(sentence, word_index_dict, embeddings, model_type=50):
    """
    Get averaged glove embeddings for a sentence
    1. Split sentence into words, 2. Get embeddings for each word, 3. Add embeddings for each word
    4. Divide by number of words, 5. Return averaged embeddings
    (30 pts)
    """
    embedding = np.zeros(int(model_type.split("d")[0]))
    ##################################
    ##### TODO: Add code here ######## -- returns a sentence embedding (averaged glove word embeddings)
    ##################################

    words = sentence.split()
    for word in words:
      embedding.append(get_glove_embeddings(word, word_index_dict, embeddings, model_type))

    sentence_embedding = []
    if embedding:
      sentence_embedding = np.sum(embedding)/len(embedding)
    else:
      # Handle cases where no words have GloVe embeddings
      sentence_embedding = np.zeros(len(embeddings['a']))

    return sentence_embedding

def get_category_embeddings(embeddings_metadata):
    """ NOTE: All this code came from the assignment
    Get embeddings for each category
    1. Split categories into words
    2. Get embeddings for each word
    """

    model_name = embeddings_metadata["model_name"]

    st.session_state["cat_embed_" + model_name] = {} # referenced by cat_embed + model_name and set = to {}

    for category in st.session_state.categories.split(" "):
        if model_name:
            if not category in st.session_state["cat_embed_" + model_name]:
                st.session_state["cat_embed_" + model_name][category] = get_sentence_transformer_embeddings(category, model_name=model_name)
        else:
            if not category in st.session_state["cat_embed_" + model_name]:
                st.session_state["cat_embed_" + model_name][category] = get_sentence_transformer_embeddings(category)


def update_category_embeddings(embedings_metadata):
    """
    Update embeddings for each category
    """
    get_category_embeddings(embeddings_metadata)


def get_sorted_cosine_similarity(embeddings_metadata):
    """
    Get sorted cosine similarity between input sentence and categories, (50 pts)
    1. Get embeddings for input sentence
    2. Get embeddings for categories (if not found, update category embeddings)
    3. Compute cosine similarity between input sentence and categories
    4. Sort cosine similarity, 5. Return sorted cosine similarity
    """
    categories = st.session_state.categories.split(" ")
    category_embeddings = []
    category_rank = {}

    if embeddings_metadata["embedding_model"] == "glove":
        word_index_dict = embeddings_metadata["word_index_dict"]
        embeddings = embeddings_metadata["embeddings"]
        model_type = embeddings_metadata["model_type"]

        input_embedding = averaged_glove_embeddings_gdrive(st.session_state.text_search,
                                                            word_index_dict,
                                                            embeddings, model_type)

        ##########################################
        ## TODO: Get embeddings for categories ###
        ##########################################

        for category in enumerate(categories):
          category_embeddings.append(averaged_glove_embeddings_gdrive(category,
                                                                word_index_dict,
                                                                embeddings, model_type))
    else:
        model_name = embeddings_metadata["model_name"]
        if not "cat_embed_" + model_name in st.session_state:
            get_category_embeddings(embeddings_metadata)
        category_embeddings = st.session_state["cat_embed_" + model_name]
        print("text_search = ", st.session_state.text_search)
        if model_name:
            input_embedding = get_sentence_transformer_embeddings(st.session_state.text_search, model_name=model_name)
        else:
            input_embedding = get_sentence_transformer_embeddings(st.session_state.text_search)

        for index in range(len(categories)):
            ##########################################
            # TODO: Compute cosine similarity between input sentence and categories
            # TODO: Update category embeddings if category not found    --- ** NOT SURE ABOUT THIS AT ALL ** --
            ##########################################

            category_rank[categories[index]] = cosine_similarity(input_embedding, category_embeddings) # or
            cos_sim.append(cosine_similarity(input_embedding, category_embeddings))

    return sorted(cos_sim, reverse=True) # or sorted(category_rank, key=lambda x: x[1], reverse=True)

averaged_glove_embeddings_gdrive("The quick brown fox.")

### Text Search ###
st.sidebar.title("GloVe Twitter")
st.sidebar.markdown(
    """
GloVe is an unsupervised learning algorithm for obtaining vector representations for words. Pretrained on
2 billion tweets with vocabulary size of 1.2 million. Download from [Stanford NLP](http://nlp.stanford.edu/data/glove.twitter.27B.zip).

Jeffrey Pennington, Richard Socher, and Christopher D. Manning. 2014. *GloVe: Global Vectors for Word Representation*.
"""
)

model_type = st.sidebar.selectbox("Choose the model", ("25d", "50d"), index=1)

st.title("Search Based Retrieval Demo")
st.subheader(
    "Pass in space separated categories you want this search demo to be about."
)
# the following 4 lines of code were commented out in the original .py file
#st.selectbox(label="Pick the categories you want this search demo to be about...",
#options=("Flowers Colors Cars Weather Food", "Chocolate Milk", "Anger Joy Sad Frustration Worry Happiness", "Positive Negative"),
#key="categories"
#)
# above 4 lines can be read like this: st.selectbox(label="..", options=("..", ".."), key="categories")
# perhaps the line below is a default being used by this code to feed in the text_input as label=, key=, value= w/o having to
# use the selectbox
st.text_input(
    label="Categories", key="categories", value="Flowers Colors Cars Weather Food"
)

print(st.session_state["categories"])
print(type(st.session_state["categories"]))
# print("Categories = ", categories)
# st.session_state.categories = categories

st.subheader("Pass in an input word or even a sentence")
text_search = st.text_input(
    label="Input your sentence",
    key="text_search",
    value="Roses are red, trucks are blue, and Seattle is grey right now",
)
# st.session_state.text_search = text_search  # -- why is this commented out?

# Download glove embeddings if it doesn't exist
embeddings_path = "embeddings_" + str(model_type) + "_temp.npy"
word_index_dict_path = "word_index_dict_" + str(model_type) + "_temp.pkl"

if not os.path.isfile(embeddings_path) or not os.path.isfile(word_index_dict_path):
    print("Model type = ", model_type)
    glove_path = "Data/glove_" + str(model_type) + ".pkl"
    print("glove_path = ", glove_path)

    # Download embeddings from google drive
    with st.spinner("Downloading glove embeddings..."):
        download_glove_embeddings_gdrive(model_type)


# Load glove embeddings
word_index_dict, embeddings = load_glove_embeddings_gdrive(model_type)


# Find closest word to an input word
if st.session_state.text_search:
    # Glove embeddings
    print("Glove Embedding")
    embeddings_metadata = {
        "embedding_model": "glove",
        "word_index_dict": word_index_dict,
        "embeddings": embeddings,
        "model_type": model_type,
    }
    with st.spinner("Obtaining Cosine similarity for Glove..."):
        sorted_cosine_sim_glove = get_sorted_cosine_similarity(
            st.session_state.text_search, embeddings_metadata
        )

    # Sentence transformer embeddings
    print("Sentence Transformer Embedding")
    embeddings_metadata = {"embedding_model": "transformers", "model_name": ""}
    with st.spinner("Obtaining Cosine similarity for 384d sentence transformer..."):
        sorted_cosine_sim_transformer = get_sorted_cosine_similarity(
            st.session_state.text_search, embeddings_metadata
        )

    # Results and Plot Pie Chart for Glove
    print("Categories are: ", st.session_state.categories)
    st.subheader(
        "Closest word I have between: "
        + st.session_state.categories
        + " as per different Embeddings"
    )

    print(sorted_cosine_sim_glove)
    print(sorted_cosine_sim_transformer)
    # print(sorted_distilbert)
    # Altair Chart for all models
    plot_alatirchart(
        {
            "glove_" + str(model_type): sorted_cosine_sim_glove,
            "sentence_transformer_384": sorted_cosine_sim_transformer,
        }
    )
    # "distilbert_512": sorted_distilbert})

    st.write("")
    st.write(
        "Demo developed by [Dr. Karthik Mohan](https://www.linkedin.com/in/karthik-mohan-72a4b323/)"
    )