dstklib 1.0.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

dstk/geometric_distance.py

@@ -1,107 +0,0 @@
-from sklearn.neighbors import NearestNeighbors
-import pandas as pd
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-from .workflow_tools import requires, workflow, WorkflowManager
-
-from .lib_types import ndarray, Series, DataFrame
-
-STAGES = [
-    "start", # The embeddings array
-    "end" # After a distance has been applied
-]
-
-class GeometricDistance(WorkflowManager):
-    """
-    Provides a set of methods to calculate the distance between the embeddings of words, such as Euclidean distance, Manhattan distance, Cosine similarity, Nearest neighbors, etc.
-    """
-
-    def __init__(self, embeddings: DataFrame | None = None):
-        """
-        Initializes GeometricDistance with given attributes.
-
-        :param embeddings: A matrix of word embeddings.
-        :param vocab: Sequence of words representing the vocabulary aligned with the embeddings.
-        """
-
-        super().__init__()
-
-        self._set_workflow(input_arg=embeddings)
-
-    @requires(stages=["start", "end"], multiple_calls=True)
-    @workflow(input_arg="embeddings", input_process="_start", output_process="_end", next_stage="end") # It would be interesting if you could select a set of distances as then result return all of them for comparision. Or you could call different words and return an array wit the result of all of them.
-    def euclidean_distance(self, *, embeddings: DataFrame, first_word: str, second_word: str) -> float:
-        """
-        Computes the Euclidean distance between the embeddings of two words.
-
-        :param embeddings: A dataframe containing the word embeddings.
-        :param first_word: The first word in the pair.
-        :param second_word: The second word in the pair. 
-        """
-
-        first_word_vector: Series = embeddings.loc[first_word]
-        second_word_vector: Series = embeddings.loc[second_word]
-
-        return float(np.linalg.norm(first_word_vector - second_word_vector))
-
-    @requires(stages=["start", "end"], multiple_calls=True)
-    @workflow(input_arg="embeddings", input_process="_start", output_process="_end", next_stage="end")
-    def manhattan_distance(self, *, embeddings: DataFrame, first_word: str, second_word: str) -> float:
-        """
-        Computes the Manhattan distance between the embeddings of two words.
-
-        :param embeddings: A dataframe containing the word embeddings.
-        :param first_word: The first word in the pair.
-        :param second_word: The second word in the pair. 
-        """
-
-        first_word_vector: Series = embeddings.loc[first_word]
-        second_word_vector: Series = embeddings.loc[second_word]
-
-        return np.sum(np.abs(first_word_vector - second_word_vector))
-
-    @requires(stages=["start", "end"], multiple_calls=True)
-    @workflow(input_arg="embeddings", input_process="_start", output_process="_end", next_stage="end")
-    def cos_similarity(self, *, embeddings: DataFrame, first_word: str, second_word: str) -> float:
-        """
-        Computes the cosine similarity between the embeddings of two words.
-
-        :param embeddings: A dataframe containing the word embeddings.
-        :param first_word: The first word in the pair.
-        :param second_word: The second word in the pair. 
-        """
-
-        first_word_vector: ndarray = np.array(embeddings.loc[first_word]).reshape(1, -1)
-        second_word_vector: ndarray = np.array(embeddings.loc[second_word]).reshape(1, -1)
-
-        cos_sim: ndarray = cosine_similarity(first_word_vector, second_word_vector)
-
-        return cos_sim[0][0]
-
-    @requires(stages=["start", "end"], multiple_calls=True)
-    @workflow(input_arg="embeddings", input_process="_start", output_process="_end", next_stage="end")
-    def nearest_neighbors(self, *, embeddings: DataFrame, word: str, metric: str, n_words: int = 5, **kwargs) -> list[tuple[str, float]]:
-        """
-        Returns the top N most semantically similar words to a given target word, based on the specified distance or similarity metric.
-
-        :param embeddings: A dataframe containing the word embeddings.
-        :param word: The target word to find neighbors for.
-        :param metric: The distance or similarity metric to use (e.g., 'cosine', 'euclidean').
-        :param n_words: Number of nearest neighbors to return. Defaults to 5.
-        :param kwargs: Additional keyword arguments to pass to sklearn's NearestNeighbors. For more information check: https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NearestNeighbors.html
-        """
-
-        neighbors: NearestNeighbors = NearestNeighbors(n_neighbors=n_words, algorithm="auto", metric=metric, **kwargs)
-        neighbors.fit(embeddings.to_numpy())
-
-        word_vector: Series = embeddings.loc[word]
-
-        distances: ndarray
-        indices: ndarray
-        distances, indices = neighbors.kneighbors([word_vector], n_neighbors=n_words + 1)
-
-        neighbor_tuples = zip(indices[0], distances[0])
-
-        results: list[tuple[str, float]] = [(embeddings.index[index], 1 - distance) for index, distance in neighbor_tuples if embeddings.index[index] != word]
-
-        return results

dstk/lib_types/matplotlib_types.py

@@ -1,4 +0,0 @@
-from matplotlib.collections import PathCollection
-from matplotlib.pyplot import Axes
-from matplotlib.container import BarContainer
-from mpl_toolkits.mplot3d.axes3d import Axes3D

dstk/lib_types/nltk_types.py

@@ -1 +0,0 @@
-from nltk import Text

dstk/matrix_base.py

@@ -1,113 +0,0 @@
-from dataclasses import dataclass, field
-import pandas as pd
-from .lib_types import Matrix, Labels, ndarray, DataFrame, csr_matrix, csc_matrix
-from .workflow_tools import accepts_generic
-
-from typing import Any, cast, Callable
-
-@dataclass
-class MatrixRepresentation:
-    """
-    Container for a matrix and its associated row and column labels, with optional metadata.
-
-    :param matrix: The core matrix data, typically a NumPy array.
-    :param rows: Optional row labels.
-    :param columns: Optional column labels.
-    :param meta: Optional dictionary to store additional metadata.
-    """
-
-    matrix: Matrix
-    rows: Labels = None
-    columns: Labels = None
-    meta: dict[str, Any] = field(default_factory=dict)
-
-def accept_matrix_representation(accepts: bool = True, custom_error_message: str = "", intercept: bool = True, meta: str | None = None, override: tuple[str, Any] | None = None) -> Callable:
-    """
-    Decorator that allows a method to accept a MatrixRepresentation object as input.
-
-    Extracts the underlying matrix for processing and optionally reattaches metadata, labels, or captures non-matrix outputs into metadata.
-
-    :param accepts: Whether to accept MatrixRepresentation inputs.
-    :param custom_error_message: Optional error message if input type is not accepted.
-    :param intercept: Whether to intercept the input and repackage the output.
-    :param meta: Optional metadata key to store non-matrix outputs in the result.
-
-    :return: A decorated method that supports MatrixRepresentation as input.
-    """
-
-    def is_matrix_representation(matrix: Any) -> bool:
-        """
-        If matrix is an instance of MatrixRepresentation, returns True. Else, returns False.
-
-        :param matrix: A matrix to check its instance.
-        """
-
-        return True if isinstance(matrix, MatrixRepresentation) else False
-        
-    def intercept_matrix(self, input_value: MatrixRepresentation, method: Callable, *args, **kwargs) -> MatrixRepresentation:
-        result: MatrixRepresentation | Any = method(self, *args, matrix=input_value.matrix, **kwargs)
-
-        matrix: MatrixRepresentation
-
-        if isinstance(result, MatrixRepresentation):
-            matrix = result
-
-            matrix.rows = input_value.rows
-            matrix.columns = input_value.columns
-
-            if override:
-                attr, value = override
-                setattr(matrix, attr, value) 
-        else:
-            if isinstance(result, ndarray):
-                matrix = MatrixRepresentation(result, input_value.rows, input_value.columns)
-            elif not isinstance(result, ndarray) and meta:
-                matrix = MatrixRepresentation(input_value.matrix, input_value.rows, input_value.columns)
-                matrix.meta[meta] = result
-
-        return matrix
-    
-    return accepts_generic(
-        type_checker=is_matrix_representation,
-        input_arg="matrix",
-        accepts=accepts,
-        intercept=intercept,
-        interceptor=lambda self, input_value, method, *args, **kwargs: intercept_matrix(self, input_value, method, *args, **kwargs),
-        input_type=MatrixRepresentation,
-        custom_error_message=custom_error_message
-    )
-
-def matrix_to_dataframe(matrix: MatrixRepresentation, **kwargs):
-    """
-    Converts a MatrixRepresentation to a pandas DataFrame.
-
-    :param matrix: A MatrixRepresentation instance.
-    :param kwargs: Additional keyword arguments to pass to sklearn's pandas' DataFrame.
-
-    :return: A pandas DataFrame with corresponding data and labels.
-    """
-
-    if isinstance(matrix.matrix, csr_matrix) or isinstance(matrix.matrix, csc_matrix):
-        matrix.matrix = matrix.matrix.toarray()
-
-    return pd.DataFrame(
-        matrix.matrix,
-        index=matrix.rows,
-        columns=matrix.columns,
-        **kwargs
-    )
-
-def dataframe_to_matrix(dataframe: DataFrame):
-    """
-    Converts a pandas DataFrame to a MatrixRepresentation.
-
-    :param dataframe: A pandas DataFrame.
-
-    :return: A MatrixRepresentation with matrix data and index/column labels.
-    """
-
-    return MatrixRepresentation(
-        matrix=dataframe.to_numpy(),
-        rows=list(dataframe.index),
-        columns=list(dataframe.columns)
-    )

dstk/pipeline_tools.py

@@ -1,27 +0,0 @@
-from .workflow_tools import WorkflowBuilder, WorkflowManager
-
-from typing import Any, Callable
-
-class PipelineBuilder:
-    """
-    Automates the execution of a sequence of workflows on a WorkflowBuilder or Callable subclass.
-
-    :param workflows: A subclass of WorkflowBuilder representing the workflow to execute or a function to hook in the pipeline.
-    """
-
-    def __init__(self, workflows: list[WorkflowBuilder | Callable]):
-        """
-        Initializes WorkflowBuilder with given attributes.
-        """
-
-        self.workflows: list[WorkflowBuilder | Callable] = workflows
-
-    def __call__(self, **kwargs) -> Any:
-            workflows: list[WorkflowBuilder | Callable] = self.workflows
-            entry_workflow: WorkflowBuilder | Callable = workflows.pop(0)
-            result: Any = entry_workflow(**kwargs)
-
-            for workflow in workflows:
-                result = workflow(result)
-
-            return result

dstk/pipelines.py

@@ -1,114 +0,0 @@
-from .workflow_tools import WorkflowBuilder
-from .pipeline_tools import PipelineBuilder
-from dstk.lib_types import Language, DataFrame
-
-from .text_processor import TextProcessor
-from .text_matrix_builder import TextMatrixBuilder
-from .weight_matrix import WeightMatrix
-from .count_models import CountModels
-from .geometric_distance import GeometricDistance
-from .predict_models import PredictModels
-
-def StandardModel(text: str, model: str | Language, window_size: int = 2, components: int = 100) -> DataFrame:
-    """
-    This pipeline generates word embeddings using the standard model as defined by (Lenci & Sahlgren 97). It preprocesses the text by removing stop words, lowering the words and segmenting the text using a context window. The co-occurrence matrix is weighted with PPMI and reduced with truncated SVD. 
-
-    :param text: The text to extract the embeddings from.
-    :param model: The spaCy NLP model to tokenize the text.
-    :param window_size: The size of the context window to segment the text. Defaults to 2.
-    :param components: The number of dimensions of the embeddings. Defaults to 100.
-    """
-
-    StandardTextWorkflow: WorkflowBuilder = WorkflowBuilder(
-        work_class=TextProcessor, 
-        method_representation={
-            "set_model": {"model": model},
-            "get_tokens": {},
-            "remove_stop_words": {},
-            "get_text": {"lemmatize": True},
-            "to_lower": {},
-            "corpus_by_context_window": {"window_size": window_size}
-        }
-    )
-
-    StandardMatrix: WorkflowBuilder = WorkflowBuilder(
-        work_class=TextMatrixBuilder,
-        method_representation={
-            "create_dtm": {},
-            "create_co_occurrence_matrix": {},
-            "to_dataframe": {}
-        }
-    )
-
-    StandardWeightMatrix: WorkflowBuilder = WorkflowBuilder(
-        work_class=WeightMatrix,
-        method_representation={
-            "pmi": {"positive": True}
-        }
-    )
-
-    StandardCountModels: WorkflowBuilder = WorkflowBuilder(
-        work_class=CountModels,
-        method_representation={
-            "scale_matrix": {},
-            "svd_embeddings": {"n_components": components},
-            "to_dataframe": {}
-        }
-    )
-
-    Model: PipelineBuilder = PipelineBuilder([
-        StandardTextWorkflow,
-        StandardMatrix,
-        StandardWeightMatrix,
-        StandardCountModels
-    ])
-
-    return Model(text=text)
-
-def SGNSModel(text: str, model: str | Language, path: str, **kwargs) -> PredictModels:
-    """
-    This pipeline generates word embeddings using Skip-Gram with Negative Sampling (SGNS) as defined by (Lenci & Sahlgren 162). It preprocesses the text by extracting the sentences, removing stop words and lowering them. The embeddings are extracted by using word2vec to do SGNS. Returns an instance of PredictModels.
-
-    :param text: The text to extract the embeddings from.
-    :param model: The spaCy NLP model to tokenize the text.
-    :param path: The path to save the processed senteces.
-    :param kwargs:  Additional keyword arguments to pass to gensim.models.Word2Vec. Common options include:
-            - vector_size: Size of the word embedding vectors.
-            - workers: Number of CPU cores to be used during the training process.
-            - negative: Specifies how many "noise words" to sample for each positive example during training. Typical values range from 5 to 20. Higher values make training slower but can improve embedding quality.
-            - window (int): Maximum distance between the current and predicted word.
-            - min_count (int): Ignores all words with total frequency lower than this.
-
-            For more information check: https://radimrehurek.com/gensim/models/word2vec.html
-    """
-
-    SGNSTextWorkflow: WorkflowBuilder = WorkflowBuilder(
-        work_class=TextProcessor,
-        method_representation={
-            "set_model": {"model": model},
-            "get_sentences": {},
-            "remove_stop_words": {},
-            "get_text": {"lemmatize": True},
-            "to_lower": {},
-            "join": {},
-            "save_to_file": {"path": path}
-        }
-    )
-
-    SGNSPredictWorkflow: WorkflowBuilder = WorkflowBuilder(
-        work_class=PredictModels,
-        method_representation={
-            "word2vec": {
-                "sg": 1,
-                **kwargs
-            }
-        },
-        result=False
-    )
-
-    Model: PipelineBuilder = PipelineBuilder([
-        SGNSTextWorkflow,
-        SGNSPredictWorkflow
-    ])
-
-    return Model(text=text)

dstk/plot_embeddings.py

@@ -1,240 +0,0 @@
-import matplotlib.pyplot as plt
-from sklearn.cluster import KMeans
-from sklearn.metrics import silhouette_score
-from kneed import KneeLocator
-from umap import UMAP
-from .workflow_tools import requires, workflow, WorkflowManager
-from .matrix_base import MatrixRepresentation, accept_matrix_representation
-
-from .lib_types import ndarray, PathCollection, Axes, Axes3D, Labels
-
-STAGES = [
-    "start", # The embeddings matrix representation
-    "clusters", # The ideal number of clusters to be plotted
-    "end" # The result of the plot
-]
-
-# Maybe return the interias and the highest score?
-class PlotEmbeddings(WorkflowManager):
-    """
-    Provides a set of methods to visualize word embeddings in both 2D and 3D.
-
-    :param embeddings: A matrix representation of word embeddings.
-    """
-
-    def __init__(self, embeddings: MatrixRepresentation | None = None):
-        """
-        Initializes PlotEmbeddings with given attributes.
-        """
-
-        super().__init__()
-
-        # Stages
-
-        self._clusters: tuple[int, float]
-
-        self._set_workflow(input_arg=embeddings)
-
-    @requires(stages=["start"])
-    @workflow(input_arg="matrix", input_process="_start", output_process="_clusters", next_stage="clusters")
-    @accept_matrix_representation(meta="n_clusters")
-    def elbow_analysis(self, *, matrix: ndarray, max_k: int, show: bool = False, path: str | None = None) -> int:
-        """
-        Generates an Elbow plot to help determine the optimal number of clusters for the word embeddings. Returns the best number of clusters.
-
-        :param matrix: An array to be clustered.
-        :param max_k: The maximum number of clusters to evaluate when applying the Elbow method.
-        :param show: If True, shows the plot. Defaults to False.
-        :param path: If provided, saves the plot in the specified path. Defaults to None.
-
-        This method supports different matrix forms due to decorator-based preprocessing:
-            - matrix: ndarray
-            - matrix representation: MatrixRepresentation
-        """
-        plt.clf() 
-        plt.close("all")
-
-        means: list[int] = []
-        inertias: list[float] = []
-
-        for k in range(1, max_k):
-            kmeans: KMeans = KMeans(n_clusters=k, random_state=42)
-            kmeans.fit(matrix)
-
-            means.append(k)
-            inertias.append(kmeans.inertia_)
-
-        elbow: KneeLocator = KneeLocator(means, inertias, curve="convex", direction="decreasing")
-
-        print(f"The best cluster is {elbow.knee} with an inertia of {elbow.knee_y}")
-
-        elbow.plot_knee()
-
-        if path:
-            plt.savefig(path)
-
-        if show:
-            plt.show()
-
-        return elbow.knee
-
-    @requires(stages=["start"])
-    @workflow(input_arg="matrix", input_process="_start", output_process="_clusters", next_stage="clusters")
-    @accept_matrix_representation(meta="n_clusters")
-    def extract_silhouette_score(self, *, matrix: ndarray, max_k: int, show: bool = False, path: str | None = None, **kwargs) -> int:
-        """
-        Extracts and plots the Silhouette score to help determine the optimal number of clusters for the word embeddings. Returns the best number of clusters based on the highest score.
-
-        :param matrix: An array to be clustered.
-        :param max_k: The maximum number of clusters to evaluate when computing the Silhouette score.
-        :param show: If True, shows the plot. Defaults to False.
-        :param path: If provided, saves the plot in the specified path. Defaults to None.
-        :param kwargs: Additional keyword arguments to pass to sklearn.metrics silhouette_score. For more information check: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.silhouette_score.html
-
-        This method supports different matrix forms due to decorator-based preprocessing:
-            - matrix: ndarray
-            - matrix representation: MatrixRepresentation
-        """
-        plt.clf() 
-        plt.close("all")
-
-        sil_scores: list[tuple[int, float]] = []
-
-        for k in range(2, max_k):
-            kmeans: KMeans = KMeans(n_clusters=k, random_state=42)
-            kmeans.fit(matrix)
-            sil_score: float = silhouette_score(matrix, kmeans.labels_)
-            sil_scores.append((k, sil_score), **kwargs)
-
-        highest_score: tuple[int, float] = max(sil_scores, key=lambda tup: tup[1])
-        print(f"The best cluster is {highest_score[0]} with a Silhouette score of {highest_score[1]}")
-
-        clusters, scores = zip(*sil_scores)
-        
-        plt.plot(clusters, scores, 'o-')
-
-        plt.xlabel("Number of Clusters")
-        plt.ylabel("Silhouette Scores")
-        plt.title("Silhouette Score Plot")
-        plt.grid(True)
-
-        if path:
-            plt.savefig(path)
-
-        if show:
-            plt.show()
-
-        return highest_score[0]
-
-    @requires(stages=["clusters"])
-    @workflow(input_arg="embeddings", input_attrs={"embeddings": None, "n_clusters": {"meta": "n_clusters"}}, input_process="_clusters", output_process="_end", next_stage="end") 
-    def plot_embeddings_2D(self, *, embeddings: MatrixRepresentation, n_clusters: int = 1, alpha: float = 0.8, font_size: int = 8, grid: bool = True, show: bool = True, path: str | None = None, umap_neighbors: int = 15, umap_metric: str = "cosine", umap_dist: float = 0.1) -> PathCollection:
-        """
-        Generates a 2D plot of the word embedddings using UMAP for dimensionality reduction.
-
-        :param embeddings: A matrix representation of word embeddings.
-        :param n_clusters: The number of clusters to form when grouping the word embeddings. Defaluts to 1.
-        :param alpha: The transparency level (alpha) of the plotted dots, between 0 (fully transparent) and 1 (fully opaque). Defaults to 0.8.
-        :param font_size: Specifies the font size for the labels of the plotted dots. Defaults to 8.
-        :param grid: If True, displays a grid on the plot; if False, hides it. Defaults to True.
-        :param show: If True, shows the plot. Defaults to True.
-        :param path: If provided, saves the plot in the specified path. Defaults to None.
-        :param umap_neighbors: Controls how UMAP balances local versus global structure. Higher values consider a broader context when reducing dimensions. Defaults to 15.
-        :param umap_metric: The distance metric UMAP uses to assess similarity between words (e.g., "cosine", "euclidean"). Defaults to "cosine", which is common for word embeddings.
-        :param umap_dist: Controls how tightly UMAP packs points together. Lower values keep similar words closer in the 2D space. Defaults to 0.1.
-
-        :return: A matplotlib PathCollection object representing the plotted points.
-        """
-
-        plt.clf()
-        plt.close("all")
-
-        embeddings_matrix: ndarray = embeddings.matrix
-        labels: Labels = embeddings.rows
-
-        reducer: UMAP = UMAP(n_components=2, n_neighbors=umap_neighbors, min_dist=umap_dist, metric=umap_metric)
-        umap_embeddings: ndarray = reducer.fit_transform(embeddings_matrix)
-
-        kmeans: KMeans = KMeans(n_clusters=n_clusters, random_state=42)
-        clusters: ndarray = kmeans.fit_predict(umap_embeddings)
-        scatter: PathCollection = plt.scatter(umap_embeddings[:, 0], umap_embeddings[:, 1], c=clusters, cmap='Spectral', alpha=alpha)
-
-        if labels is not None:
-            for index, label in enumerate(labels):
-                plt.annotate(label, (umap_embeddings[index, 0], umap_embeddings[index, 1]), fontsize=font_size, alpha=0.6)
-        else:
-            raise ValueError("Rows of embeddings are None. Make sure your matrix contains labeled rows.")
-
-        plt.xlabel("Axis 1")
-        plt.ylabel("Axis 2")
-        plt.title("Projection of word embeddings")
-        plt.colorbar(scatter, label="Cluster")
-        plt.grid(grid)
-        plt.tight_layout()
-
-        if path:
-            plt.savefig(path)
-
-        if show:
-            plt.show()
-        
-        return scatter
-
-    @requires(stages=["clusters"])
-    @workflow(input_arg="embeddings", input_attrs={"embeddings": None, "n_clusters": {"meta": "n_clusters"}}, input_process="_clusters", output_process="_end", next_stage="end") 
-    def plot_embeddings_3D(self, *, embeddings: MatrixRepresentation, n_clusters: int = 1, alpha: float = 0.8, font_size: int = 8, grid: bool = True, show: bool = True, path: str | None = None, umap_neighbors: int = 15, umap_metric: str = "cosine", umap_dist: float = 0.1) -> PathCollection:
-        """
-        Generates a 3D plot of the word embedddings.
-
-        :param embeddings: A matrix representation of word embeddings.
-        :param n_clusters: The number of clusters to form when grouping the word embeddings. Defaults to 1.
-        :param alpha: The transparency level (alpha) of the plotted dots, between 0 (fully transparent) and 1 (fully opaque). Defaults to 0.8.
-        :param font_size: Specifies the font size for the labels of the plotted dots. Defaults to 8.
-        :param grid: If True, displays a grid on the plot; if False, hides it. Defaults to True.
-        :param show: If True, shows the plot. Defaults to True.
-        :param path: If provided, saves the plot in the specified path. Defaults to None.
-        :param umap_neighbors: Controls how UMAP balances local versus global structure. Higher values consider a broader context when reducing dimensions. Defaults to 15.
-        :param umap_metric: The distance metric UMAP uses to assess similarity between words (e.g., "cosine", "euclidean"). Defaults to "cosine", which is common for word embeddings.
-        :param umap_dist: Controls how tightly UMAP packs points together. Lower values keep similar words closer in the 2D space. Defaults to 0.1.
-
-        :return: A matplotlib PathCollection object representing the plotted points.
-        """
-        plt.clf()
-        plt.close("all")
-
-        embeddings_matrix: ndarray = embeddings.matrix
-        labels: Labels = embeddings.rows
-
-        reducer: UMAP = UMAP(n_components=3, n_neighbors=umap_neighbors, min_dist=umap_dist, metric=umap_metric)
-        umap_embeddings: ndarray = reducer.fit_transform(embeddings_matrix)
-
-        kmeans: KMeans = KMeans(n_clusters=n_clusters, random_state=42)
-        clusters = kmeans.fit_predict(umap_embeddings)
-
-        ax: Axes3D = plt.axes(projection="3d")
-
-        scatter: PathCollection = ax.scatter(umap_embeddings
-        [:, 0], umap_embeddings[:, 1], umap_embeddings[:, 2], c=clusters, cmap="Spectral", alpha=alpha)
-
-        if labels is not None:
-            for index, label in enumerate(labels):
-                ax.text(umap_embeddings[index, 0], umap_embeddings[index, 1], umap_embeddings[index, 2], label, size=font_size, alpha=0.6)
-        else:
-            raise ValueError("Rows of embeddings are None. Make sure your matrix contains labeled rows.")
-
-        ax.set_xlabel("Axis 1")
-        ax.set_ylabel("Axis 2")
-        ax.set_zlabel("Axis 3")
-        ax.set_title("3D projection of word embeddings")
-
-        plt.colorbar(scatter, label="Cluster")
-        plt.grid(grid)
-        plt.tight_layout()
-  
-        if path:
-            plt.savefig(path)
-
-        if show:
-            plt.show()
-        
-        return scatter