Upload 6 files

app.py

@@ -0,0 +1,425 @@
+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
+
+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 download 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("Downloading embeddings...\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 array
+    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 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(embeddings_metadata):
+    """
+    Update embeddings for each category
+    """
+    get_category_embeddings(embeddings_metadata)
+
+
+### Plotting utility functions
+    
+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)  # Display figure
+
+
+def plot_piechart_helper(sorted_cosine_scores_items):
+    # 使用seaborn的pastel调色板
+    colors = plt.cm.Pastel1.colors  
+    categories = st.session_state.categories.split(" ")
+    
+    # 创建子图并设置大小
+    fig, ax = plt.subplots(figsize=(6, 6))
+    
+    # 准备数据
+    labels = [categories[i] for i, _ in sorted_cosine_scores_items]
+    sizes = [score for _, score in sorted_cosine_scores_items]
+    explode = np.zeros(len(labels))
+    explode[0] = 0.1  # 突出显示最高分项
+    
+    # 绘制饼图
+    wedges, texts, autotexts = ax.pie(
+        sizes,
+        explode=explode,
+        labels=labels,
+        colors=colors,
+        autopct=lambda p: f'{p:.1f}%',
+        startangle=90,
+        shadow=True,        # 添加阴影
+        pctdistance=0.85,   # 调整百分比位置
+        wedgeprops={'edgecolor': 'white', 'linewidth': 1},  # 添加白色边界
+        textprops={'fontsize': 10}
+    )
+    
+    # 设置百分比文本样式
+    for autotext in autotexts:
+        autotext.set_color('black')
+        autotext.set_fontsize(10)
+        autotext.set_fontweight('bold')
+    
+    # 添加中心空白实现类3D效果
+    centre_circle = plt.Circle((0,0),0.42,fc='white')
+    ax.add_artist(centre_circle)
+    
+    # 设置标题
+    ax.set_title('Category Distribution', fontsize=14, pad=20)
+    
+    # 保证圆形比例
+    ax.axis('equal')  
+    
+    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])
+        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]])
+
+# Task I: 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)
+    """
+    dot_product = np.dot(x, y)
+    norm_x = la.norm(x)
+    norm_y = la.norm(y)
+    if norm_x == 0 or norm_y == 0:
+        return 0.0  # Handle zero vectors to avoid division by zero
+    cos_sim = dot_product / (norm_x * norm_y)
+    return np.exp(cos_sim)
+
+# Task II: Average Glove Embedding Calculation
+def averaged_glove_embeddings_gdrive(sentence, word_index_dict, embeddings, model_type):
+    """
+    Get averaged glove embeddings for a sentence
+    1. Split sentence into words
+    2. Get embeddings for each word
+    3. Sum embeddings for each word
+    4. Divide by number of words
+    5. Return averaged embeddings
+    (30 pts)
+    """
+    model_dim = int(model_type.split('d')[0])
+    words = sentence.split()
+    avg_embedding = np.zeros(model_dim)
+    if not words:
+        return avg_embedding
+    for word in words:
+        word_embed = get_glove_embeddings(word, word_index_dict, embeddings, model_type)
+        avg_embedding += word_embed
+    avg_embedding /= len(words)
+    return avg_embedding
+
+# Task III: Sort the cosine similarity
+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 (update if not found)
+    3. Compute cosine similarity between input and categories
+    4. Sort cosine similarities
+    5. Return sorted cosine similarities
+    (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
+        )
+        
+        # Compute cosine similarity for each category
+        for idx, category in enumerate(categories):
+            cat_embed = get_glove_embeddings(category, word_index_dict, embeddings, model_type)
+            sim = cosine_similarity(input_embedding, cat_embed)
+            cosine_sim[idx] = sim
+        
+    else:
+        model_name = embeddings_metadata.get("model_name", "")
+        if f"cat_embed_{model_name}" not in st.session_state:
+            get_category_embeddings(embeddings_metadata)
+        
+        category_embeddings = st.session_state[f"cat_embed_{model_name}"]
+        
+        input_embedding = get_sentence_transformer_embeddings(
+            st.session_state.text_search, model_name=model_name
+        )
+        
+        for idx, category in enumerate(categories):
+            if category not in category_embeddings:
+                # Update missing category embedding
+                category_embeddings[category] = get_sentence_transformer_embeddings(category, model_name=model_name)
+            cat_embed = category_embeddings[category]
+            sim = cosine_similarity(input_embedding, cat_embed)
+            cosine_sim[idx] = sim
+    
+    # Sort scores in descending order
+    sorted_scores = sorted(cosine_sim.items(), key=lambda x: x[1], reverse=True)
+    return sorted_scores
+
+
+if __name__ == "__main__":
+    # 侧边栏设置
+    st.sidebar.title("Model Configuration")
+    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*.
+    """
+    )
+    # Sentence Transformer模型选择
+    st_model = st.sidebar.selectbox(
+        "Sentence Transformer Model",
+        options=[
+            "all-MiniLM-L6-v2",
+            "all-mpnet-base-v2",
+            "multi-qa-mpnet-base-dot-v1",
+            "paraphrase-multilingual-mpnet-base-v2"
+        ],
+        index=0,
+        help="Select pretrained sentence transformer model"
+    )
+
+    # GloVe模型选择
+    model_type = st.sidebar.selectbox(
+        "GloVe Dimension", 
+        ("25d", "50d", "100d"), 
+        index=1,
+        help="Select dimension for GloVe embeddings"
+    )
+    
+    # 主界面设置
+    st.title("Semantic Search Demo")
+    
+    # 初始化session状态
+    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"
+
+    # 输入组件
+    st.subheader("Categories (space-separated)")
+    st.text_input(
+        label="Categories",
+        key="categories",
+        value=st.session_state.categories
+    )
+    
+    st.subheader("Input Sentence")
+    st.text_input(
+        label="Your input",
+        key="text_search",
+        value=st.session_state.text_search
+    )
+
+    # 下载GloVe嵌入
+    embeddings_path = f"embeddings_{model_type}_temp.npy"
+    word_index_dict_path = f"word_index_dict_{model_type}_temp.pkl"
+    if not os.path.isfile(embeddings_path) or not os.path.isfile(word_index_dict_path):
+        with st.spinner(f"Downloading GloVe-{model_type} embeddings..."):
+            download_glove_embeddings_gdrive(model_type)
+
+    # 加载嵌入模型
+    word_index_dict, embeddings = load_glove_embeddings_gdrive(model_type)
+
+    # 处理输入
+    if st.session_state.text_search.strip():
+        # GloVe处理流程
+        glove_metadata = {
+            "embedding_model": "glove",
+            "word_index_dict": word_index_dict,
+            "embeddings": embeddings,
+            "model_type": model_type,
+        }
+        
+        # Transformer处理流程
+        transformer_metadata = {
+            "embedding_model": "transformers", 
+            "model_name": st_model
+        }
+        
+        # 并行处理
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            with st.spinner(f"Processing GloVe-{model_type}..."):
+                sorted_glove = get_sorted_cosine_similarity(glove_metadata)
+        
+        with col2:
+            with st.spinner(f"Processing {st_model}..."):
+                sorted_transformer = get_sorted_cosine_similarity(transformer_metadata)
+
+        # 可视化结果
+        st.subheader(f"Results for: '{st.session_state.text_search}'")
+        plot_alatirchart({
+            f"Sentence Transformer ({st_model})": sorted_transformer,
+            f"GloVe-{model_type}": sorted_glove
+        })
+        
+        # 开发者信息
+        st.markdown("---")
+        st.caption("Developed by [Xinghao Chen](https://www.linkedin.com/in/cxh42/) | "
+                   "Model credits: [Sentence Transformers](https://www.sbert.net/) |"
+                   "[GloVe](https://nlp.stanford.edu/projects/glove/)")

embeddings_25d_temp.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5eec0acf13b5c7d7c3bd178c1c84332347b9c0d55a474e37f4313e5289aacde3
+size 238702880

embeddings_50d_temp.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e74f88cde3ff2e36c815d13955c67983cf6f81829d2582cb6789c10786e5ef66
+size 477405680

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+numpy
+gdown
+sentence_transformers
+matplotlib

word_index_dict_25d_temp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:674af352f703098ef122f6a8db7c5e08c5081829d49daea32e5aeac1fe582900
+size 60284151

word_index_dict_50d_temp.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:674af352f703098ef122f6a8db7c5e08c5081829d49daea32e5aeac1fe582900
+size 60284151