# %load miniproject1_part4-2-1.py import streamlit as st import numpy as np import numpy.linalg as la import pickle import os import gdown from sentence_transformers import SentenceTransformer import matplotlib.pyplot as plt import math # Compute Cosine Similarity def cosine_similarity(x, y): """ Exponentiated cosine similarity 1. Compute cosine similarity 2. Exponentiate cosine similarity 3. Return exponentiated cosine similarity (20 pts) """ # Compute cosine similarity dot_product = np.dot(x, y) norm_x = np.linalg.norm(x) norm_y = np.linalg.norm(y) cosine_sim = dot_product / (norm_x * norm_y) # Exponentiate cosine similarity exp_cosine_sim = np.exp(cosine_sim) # Return exponentiated cosine similarity return exp_cosine_sim # 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_50d_temp.npy" # embeddings_temp = "embeddings_" + str(model_type) + "_temp.npy" # 修改的 word_index_temp = "word_index_dict_50d_temp.pkl" # 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() 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])) 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) """ words = sentence.split() # Step 1: Split sentence into words embedding_sum = np.zeros(int(model_type.split("d")[0])) valid_word_count = 0 for word in words: # Step 2: Get embeddings for each word word_embedding = get_glove_embeddings(word, word_index_dict, embeddings, model_type) if np.any(word_embedding): # Only consider valid embeddings embedding_sum += word_embedding valid_word_count += 1 if valid_word_count > 0: # Step 4: Divide by number of words averaged_embedding = embedding_sum / valid_word_count else: averaged_embedding = np.zeros(int(model_type.split("d")[0])) return averaged_embedding # Step 5: Return averaged embeddings def get_category_embeddings(embeddings_metadata): """ 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] = {} 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 Steps: 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 (50 pts) """ categories = st.session_state.categories.split(" ") cosine_sim = {} 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) for category in categories: # Get embedding for category category_embedding = averaged_glove_embeddings_gdrive(category, word_index_dict, embeddings, model_type) # Compute cosine similarity cos_sim = cosine_similarity(input_embedding, category_embedding) cosine_sim[category] = cos_sim 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 category in categories: # Update category embeddings if category not found if category not in category_embeddings: update_category_embeddings(embeddings_metadata) category_embeddings = st.session_state["cat_embed_" + model_name] # Compute cosine similarity category_embedding = category_embeddings[category] cos_sim = cosine_similarity(input_embedding, category_embedding) cosine_sim[category] = cos_sim # Sort the cosine similarities sorted_cosine_sim = dict(sorted(cosine_sim.items(), key=lambda item: item[1], reverse=True)) return sorted_cosine_sim # # 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(list(sorted_cosine_scores_items.values())) categories_sorted = list(sorted_cosine_scores_items.keys()) 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 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: # modified figs[model] = plot_piechart_helper(sorted_cosine_scores_models[model]) for index in range(len(tabs)): with tabs[index]: st.pyplot(figs[models[index]]) ### 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*. """ ) if 'categories' not in st.session_state: st.session_state['categories'] = "Flowers Colors Cars Weather Food" if 'text_search' not in st.session_state: st.session_state['text_search'] = "Roses are red, trucks are blue, and Seattle is grey right now" 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." ) # 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" # ) # categories of user input user_categories = st.text_input( label="Categories", value=st.session_state.categories ) st.session_state.categories = user_categories # st.text_input( # label="Categories", key="categories", value="Flowers Colors Cars Weather Food" # ) # Categories = st.session_state.get('categories', "Flowers Colors Cars Weather Food") print(st.session_state.get("categories")) # print(st.session_state["categories"]) print(type(st.session_state.get("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") user_text_search = st.text_input( label="Input your sentence", value=st.session_state.text_search, ) st.session_state.text_search = user_text_search # st.session_state.text_search = text_search # 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, "text_search": st.session_state.text_search } with st.spinner("Obtaining Cosine similarity for Glove..."): sorted_cosine_sim_glove = get_sorted_cosine_similarity( embeddings_metadata ) # Sentence transformer embeddings print("Sentence Transformer Embedding") embeddings_metadata = {"embedding_model": "transformers", "model_name": "", "text_search": st.session_state.text_search } with st.spinner("Obtaining Cosine similarity for 384d sentence transformer..."): sorted_cosine_sim_transformer = get_sorted_cosine_similarity( 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) st.write(f"Closest category using GloVe embeddings : {list(sorted_cosine_sim_glove.keys())[0]}") st.write( f"Closest category using Sentence Transformer embeddings : {list(sorted_cosine_sim_transformer.keys())[0]}") plot_alatirchart( { "glove_" + str(model_type): sorted_cosine_sim_glove, "sentence_transformer_384": sorted_cosine_sim_transformer, } ) st.write("") st.write( "Demo developed by [V50](https://huggingface.co/spaces/ericlkc/V50)" )