added similarity score calc

.gitignore

@@ -1 +1,2 @@
-.idea
+.idea
+venv

app.py

@@ -1,4 +1,23 @@
 import streamlit as st
+from battleground_tab import BattlegroundTab
 
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)
+
+def main():
+    st.title("Embedding Arena")
+    tab1, tab2, tab3 = st.tabs(["Battleground", "Leaderboard", "About"])
+
+    with tab1:
+        BattlegroundTab().ui()
+
+    with tab2:
+        st.header("Leaderboard")
+        st.write("#TODO")
+
+    with tab3:
+        st.header("About")
+        st.write("#TODO")
+
+
+# Run the main function when the app is executed
+if __name__ == "__main__":
+    main()

battleground_tab.py

@@ -0,0 +1,51 @@
+import streamlit as st
+from embedding_models.registry import registry as embedding
+from similarity_models.registry import registry as similarity
+import pandas as pd
+
+
+def calculate_similarity(text_1, text_2):
+    # TODO: pick any N random embedding models
+    similarity_scores = []
+
+    # TODO: pick any random similarity model
+    similarity_model = similarity.models()["cosine"]
+    for name, model in embedding.models().items():
+        embedding_1 = model.embed(text_1)
+        embedding_2 = model.embed(text_2)
+
+        similarity_scores.append((name, similarity_model.score(embedding_1, embedding_2)))
+    return similarity_scores
+
+
+class BattlegroundTab:
+
+    def __init__(self):
+        pass
+
+    def ui(self):
+        st.header("Battleground")
+        st.write("Battle embedding models with each other! May the best win!")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            text_1 = st.text_input("Enter first text here!")
+
+        with col2:
+            text_2 = st.text_input("Enter second text here!")
+
+        expected_sc = st.slider(
+            'How similar do feel these words are',
+            min_value=1, max_value=10, step=1, value=5) / 10
+        st.write('Expected Similarity Score = ', expected_sc)
+
+        if st.button("Calculate Similarity Score"):
+            similarity_scores = calculate_similarity(text_1, text_2)
+            df = pd.DataFrame(similarity_scores, columns=['Model', 'Score'])
+            df['Loss'] = abs(df['Score'] - expected_sc)
+            winner_model = df.loc[df['Loss'].idxmin(), 'Model']
+            df['Winner'] = ''
+            df.loc[df['Model'] == winner_model, 'Winner'] = '👑'
+            df = df.drop(columns=['Loss'])
+            markdown_table = df.to_markdown(index=False)
+            st.markdown(markdown_table)

embedding_models/open_ai.py

@@ -0,0 +1,29 @@
+from openai import OpenAI
+
+class OpenAIAda002():
+
+    def name(self):
+        return "OpenAI/text-embedding-ada-002"
+
+    def embed(self, text):
+        client = OpenAI()
+        resp = client.embeddings.create(
+            input=[text],
+            model="text-embedding-ada-002"
+        )
+        embedding = resp.data[0].embedding
+        return embedding
+
+class OpenAI3Large():
+
+    def name(self):
+        return "OpenAI/text-embedding-3-large"
+
+    def embed(self, text):
+        client = OpenAI()
+        resp = client.embeddings.create(
+            input=[text],
+            model="text-embedding-3-large"
+        )
+        embedding = resp.data[0].embedding
+        return embedding

embedding_models/registry.py

@@ -0,0 +1,15 @@
+from embedding_models import open_ai
+class _Registry:
+    def __init__(self):
+        pass
+
+    def _models(self):
+        return [
+            open_ai.OpenAIAda002(),
+            open_ai.OpenAI3Large()
+        ]
+
+    def models(self):
+        return {m.name(): m for m in self._models()}
+
+registry = _Registry()

requirements.txt

@@ -0,0 +1,4 @@
+streamlit
+scikit-learn
+openai
+tabulate

similarity_models/cosine_similarity.py

@@ -0,0 +1,15 @@
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+class CosineSimilarity:
+    def __init__(self):
+        pass
+
+    def name(self):
+        return "cosine"
+
+    def score(self,embedding_1, embedding_2):
+        embedding_1 = np.array([embedding_1])
+        embedding_2 = np.array([embedding_2])
+        similarity_score = cosine_similarity(embedding_1, embedding_2)
+        return similarity_score[0][0]

similarity_models/registry.py

@@ -0,0 +1,15 @@
+from similarity_models.cosine_similarity import CosineSimilarity
+
+class _Registry:
+    def __init__(self):
+        pass
+
+    def _models(self):
+        return [
+            CosineSimilarity()
+        ]
+
+    def models(self):
+        return {m.name(): m for m in self._models()}
+
+registry = _Registry()