Merge remote-tracking branch 'origin/master'

        self.cosine_scores = self.get_cosine_scores(self.embeddings1, self.embeddings2)

        self.preds = self.get_preds()

    def sentence_clusters(self):

        """

        This method prints out clusters of sentences with high similarity.

        """

        corpus = self.sentences1 + self.sentences2

        corpus_embeddings = self.get_embeddings(corpus)

        # Normalize the embeddings to unit length

        corpus_embeddings = corpus_embeddings / np.linalg.norm(corpus_embeddings, axis=1, keepdims=True)

        # Perform kmean clustering

        clustering_model = AgglomerativeClustering(n_clusters=None, distance_threshold=1.5) #, affinity='cosine', linkage='average', distance_threshold=0.4)

        clustering_model.fit(corpus_embeddings)

        cluster_assignment = clustering_model.labels_

        clustered_sentences = {}

        for sentence_id, cluster_id in enumerate(cluster_assignment):

            if cluster_id not in clustered_sentences:

                clustered_sentences[cluster_id] = []

            clustered_sentences[cluster_id].append(corpus[sentence_id])

        for i, cluster in clustered_sentences.items():

            print("Cluster ", i+1)

            print(cluster)

            print("")

    def visualize_embeddings(self, sentences, highlights=[], figsize=(80, 200)):

        """

        Parameters

            size of the final image. The default is set to (80,200),

            which is 8000x20000 pixels and is appropriate for

            the stsb test dataset (2757 data points).

        An example of how the method can be used is provided 

        in sentence_similarity.py.

        Due to long loading times of the model, it is recommended 

        to use this method in the interactive mode: 

        python -i sentence_similarity.py

        """

        plt.figure(figsize=figsize)

        t1 = time.time()

        #Convert into list if it is a string

        if isinstance(highlights, str):

            highlights = [highlights]

        if len(highlights) == 1:

            highlights_embs = self.get_embeddings(highlights).reshape(1, -1)

            highlights_embs = self.get_embeddings(highlights).reshape(1, -1).cpu()

        elif len(highlights) > 1:

            highlights_embs = self.get_embeddings(highlights)

        embs = self.get_embeddings(sentences)

        umap_model = umap.UMAP(n_neighbors=15, n_components=2, min_dist=0.5, spread=2, metric='cosine', random_state=42).fit(embs)

            highlights_embs = self.get_embeddings(highlights).cpu()

        embs = self.get_embeddings(sentences).cpu()

        umap_model = umap.UMAP(n_neighbors=15, n_components=2, min_dist=2, spread=20, metric='cosine', random_state=42).fit(embs)

        umap_data_transformed = umap_model.transform(embs)

        plt.figure(figsize=(80,200))

        folder = "outputs"

        plot_name = f"plot-{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.png"

        plot_path = os.path.join(folder,plot_name)

            for i, (x, y) in enumerate(umap_data_transformed):

                name = sentences[i]

                reader.write(f"{i}: {name} ({x:.2f},{y:.2f})\n")

                label = i

                plt.plot(x, y, 'bo')

                plt.text(x, y, label)

                plt.plot(x, y, 'bo', alpha=0.3)

            if highlights:

                highlights_transformed = umap_model.transform(highlights_embs)

                for i, (x, y) in enumerate(highlights_transformed):

                    name = highlights[i]

                    label = f"{i}: {name}\n({x:.2f},{y:.2f})"

                    label = f"{i}: {name}"

                    reader.write(f"Highlights: {i}: {name} ({x:.2f},{y:.2f})\n")

                    plt.plot(x, y, 'ro', markersize=30)

                    plt.text(x, y, label)

                    plt.plot(x, y, 'ro', markersize=20)

                    plt.text(x, y, label , backgroundcolor="white", alpha=0.4)

        plt.savefig(plot_path)

        t2 = time.time()

        print(f"Plot saved to {plot_path}. Time it took to generate: {t2-t1:.2f} seconds")

dataset = STSB_Dataset('../data/stsbenchmark/sts-test.csv').as_dataframe

#zero_model = SBERT_Model("Zero Model", 'models/nli-bert-large/', dataset)

ft_model = SBERT_Model("Fine-tuned Model", '../models/stsb-bert-large/', dataset)

zero_model = SBERT_Model("nli-bert-large", 'models/nli-bert-large/', dataset)

ft_model = SBERT_Model("stsb-bert-large", '../models/stsb-bert-large/', dataset)

paws_model = SBERT_Model("paws-stsb-bert-large", '../models/stsb-bert-large/', dataset)

#zero_model.print_statistics()

#ft_model.print_statistics()

zero_model.print_statistics()

ft_model.print_statistics()

paws_model.print_statistics()

#ft_model.visualize_embeddings(ft_model.sentences1+ft_model.sentences2, ["A cat is on the mat","A [MASK] is on the mat"])

#Make a list with sentence pairs for the heatmap

sentence_pairs = []

for i in range(2):

    sentence_pairs.append((ft_model.sentences1[i],ft_model.sentences2[i]))

#sentence_pairs = []

#for i in range(2):

#    sentence_pairs.append((ft_model.sentences1[i],ft_model.sentences2[i]))

#generate the heatmap with default mask == "[MASK]"

ft_model.get_html_word_importance(sentence_pairs)

 No newline at end of file

#ft_model.get_html_word_importance(sentence_pairs)