instructor

app.py

@@ -1,9 +1,11 @@
 
 import streamlit as st
-import pandas as pd
 
+import pandas as pd
 from sentence_transformers import SentenceTransformer, util
 
+from transformers import AutoTokenizer, pipeline
+import numpy as np
 
 def sentence_sim(sentence1, sentence2):
     #model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
@@ -16,9 +18,69 @@ def sentence_sim(sentence1, sentence2):
     cos_scores = util.pytorch_cos_sim(embedding1, embedding2).cpu().numpy()
     return cos_scores[0][0]
 
+
+def dot_product(v1, v2):
+    return round(np.dot(v1, v2), 3)
+    
 st.title('Similarity Computations')
 
 
+if st.button('Sentence Transformer'):
+    model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
+    sentencetriplets = ["record the play", "play the record", "play the game"]
+    embedding_vec = {}
+    embedding_vec[0] = model.encode(sentencetriplets[0])
+    embedding_vec[1] = model.encode(sentencetriplets[1])
+
+if st.button('Context Sim Bert'):
+    model = 'bert-base-uncased'
+    framework = 'tf'
+    tokenizer = AutoTokenizer.from_pretrained(model)
+    feature_extractor = pipeline(
+            model=model,
+            framework=framework,
+            tokenizer=tokenizer,
+            task="feature-extraction",
+        )
+    
+    sentencetriplets = ["record the play", "play the record", "play the game"]
+    index = 0
+    #sentence = sentencetriplets[index]
+    test_word = 'play'
+    test_word_vector = {}
+    for index, sentence in enumerate(sentencetriplets):
+        tokens = tokenizer.tokenize(sentence)
+        vectors = feature_extractor(sentence, return_tensors=True).numpy()
+        test_word_location = [i for i in range(len(tokens)) if test_word == tokens[i]][0]
+        test_word_vector[index] = vectors[0, test_word_location + 1, :]  # 0 is '[CLS]'
+        magnitude = np.linalg.norm(test_word_vector[index])
+        test_word_vector[index] = test_word_vector[index] / magnitude
+
+    dot_product(test_word_vector[0], test_word_vector[1])
+    dot_product(test_word_vector[1], test_word_vector[2])
+    dot_product(test_word_vector[0], test_word_vector[2])
+
+if st.button('Instructor'):
+    from InstructorEmbedding import INSTRUCTOR
+    model = INSTRUCTOR('hkunlp/instructor-large')
+    sentence = "3D ActionSLAM: wearable person tracking in multi-floor environments"
+    instruction = "Represent the Science title:"
+    embeddings = model.encode([[instruction,sentence]])
+    st.write(instruction)
+    st.write(embeddings)
+
+    from sklearn.metrics.pairwise import cosine_similarity
+    sentences_a = [['Represent the Science sentence: ','Parton energy loss in QCD matter'], 
+                ['Represent the Financial statement: ','The Federal Reserve on Wednesday raised its benchmark interest rate.']]
+    sentences_b = [['Represent the Science sentence: ','The Chiral Phase Transition in Dissipative Dynamics'],
+                ['Represent the Financial statement: ','The funds rose less than 0.5 per cent on Friday']]
+    embeddings_a = model.encode(sentences_a)
+    embeddings_b = model.encode(sentences_b)
+    similarities = cosine_similarity(embeddings_a,embeddings_b)
+    st.write(sentences_a)
+    st.write(sentences_b)
+    st.write(similarities)
+
 if st.button('Cos Sim MiniLM'):
     #title = "I Tried Using ChatGPT To Earn $6,147 In Just 1 Week"
     #summary = "Unveiling the Reality: The Perils of Using ChatGPT for Content Generation and Monetization"

context.py

@@ -0,0 +1,84 @@
+import json
+from typing import Any
+
+import numpy as np
+from transformers import AutoTokenizer, pipeline
+
+__all__ = ["ContextAwareWordVectors", "print_results"]
+
+
+class NumpyFloatValuesEncoder(json.JSONEncoder):
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, np.float32):
+            return round(float(obj), 3)
+        return json.JSONEncoder.default(self, obj)
+
+
+def print_results():
+    with open("sentences.json", encoding="utf-8") as fp:
+        samples = json.load(fp)
+        context_aware_word_vectors = ContextAwareWordVectors(model="bert-base-uncased")
+        results = context_aware_word_vectors.run(samples)
+        print(json.dumps(results, indent=2, cls=NumpyFloatValuesEncoder))
+
+
+class ContextAwareWordVectors:
+    def __init__(self, model: str, framework: str = "tf") -> None:
+        self.framework = framework
+        self.model = model
+        self.tokenizer = AutoTokenizer.from_pretrained(model)
+        self.feature_extractor = pipeline(
+            model=model,
+            framework=framework,
+            tokenizer=self.tokenizer,
+            task="feature-extraction",
+        )
+
+    def dot_product(self, v1: Any, v2: Any) -> Any:
+        return round(np.dot(v1, v2), 3)
+
+    def euclidean_distance(self, v1: Any, v2: Any) -> Any:
+        return round(np.linalg.norm(v1 - v2), 3)
+
+    def manhattan_distance(self, v1: Any, v2: Any) -> Any:
+        return round(np.linalg.norm(v1 - v2, ord=1), 3)
+
+    def run(self, samples: dict[str, dict[str, str]]) -> dict[str, dict[str, Any]]:
+        test_word_vector: dict[str, Any]
+        results: dict[str, dict[str, Any]] = {}
+
+        for test_word, sample in samples.items():
+            results[test_word] = {}
+            test_word_vector = {}
+            for index, sentence in sample.items():
+                tokens = self.tokenizer.tokenize(sentence)
+                vectors = self.feature_extractor(sentence, return_tensors=True).numpy()
+                test_word_location = [
+                    i for i in range(len(tokens)) if test_word == tokens[i]
+                ][0]
+                test_word_vector[index] = vectors[
+                    0, test_word_location + 1, :
+                ]  # 0 is '[CLS]'
+                magnitude = np.linalg.norm(test_word_vector[index])
+                test_word_vector[index] = test_word_vector[index] / magnitude
+            results[test_word]["sentences"] = sample
+            results[test_word]["dot_product"] = [
+                self.dot_product(test_word_vector["1"], test_word_vector["2"]),
+                self.dot_product(test_word_vector["2"], test_word_vector["3"]),
+                self.dot_product(test_word_vector["3"], test_word_vector["1"]),
+            ]
+            results[test_word]["euclidean_distance"] = [
+                self.euclidean_distance(test_word_vector["1"], test_word_vector["2"]),
+                self.euclidean_distance(test_word_vector["2"], test_word_vector["3"]),
+                self.euclidean_distance(test_word_vector["3"], test_word_vector["1"]),
+            ]
+            results[test_word]["manhattan_distance"] = [
+                self.manhattan_distance(test_word_vector["1"], test_word_vector["2"]),
+                self.manhattan_distance(test_word_vector["2"], test_word_vector["3"]),
+                self.manhattan_distance(test_word_vector["3"], test_word_vector["1"]),
+            ]
+        return results
+
+
+if __name__ == "__main__":
+    print_results()