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

dstklib-2.0.0.dist-info/METADATA

@@ -0,0 +1,377 @@
+Metadata-Version: 2.1
+Name: dstklib
+Version: 2.0.0
+Requires-Python: <3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: spacy
+Requires-Dist: plotly
+Requires-Dist: scikit-learn
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: gensim
+Requires-Dist: fasttext
+Requires-Dist: kneed
+Requires-Dist: umap-learn
+
+# Distributional Semantics Toolkit
+
+This library is based on the book *Distributional Semantics* by Alessandro Lenci and Magnus Sahlgren. It attempts to incorporate some of the algorithms described in the book, commonly used in distributional semantics.
+
+## Table of Contents
+
+1. [Documentation](#documentation)
+2. [Installation](#installation)
+3. [Usage](#usage)
+5. [Contributing](#contributing)
+6. [License](#license)
+
+## Documentation
+
+You can find the (temporal) basic documentation [here](https://distributional-semantics-toolkit-30269b.gitlab.io/index.html).
+
+## Installation
+
+To install it just run the command:
+
+```bash
+pip install dstklib
+```
+
+DSTK requires python <3.12 to work.
+
+# Usage
+
+The library can be used in three modes:
+
+## Standalone mode
+
+In standalone mode you can use the methods individually. Just import the method you want to use from its repective module in the `dstk.modules` folder:
+
+```python
+from dstk.modules.text_processor import to_lower
+
+words = ["The", "Quick", "Brown", "Fox", "Jumps", "Over", "The", "Lazy", "Dog"]
+
+lower_tokens = to_lower(words=words)
+
+print(lower_tokens)
+
+# Output: ["the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]
+```
+
+## Workflow mode
+
+If there is a specific workflow you use multiple times, you can automate it by using WorkflowBuilder. Just input the name of the methods (in the correct order) you want to use and their corresponding arguments as a list of dictionaries, along with the name of the module you are importing them from:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+model = "my_spacy_model"
+
+TokenizerWorkflow = WorkflowBuilder(
+    name="TokenizerWorkflow",
+    module_name="tokenizer"
+    workflow=[
+        {"apply_model": {"model": model}},
+        {"get_tokens": {}},
+        {"remove_stop_words": {}}
+    ]
+)
+
+# Pass as an argument the input data:
+tokens = TokenizerWorkflow(input_data=text)
+
+print(tokens)
+
+# Output: [quick, brown, fox, jumps, lazy, dog, sun, sets, behind, hills]
+```
+
+You can also get specic results in the workflow or even all of them by using `return_methods` and `return all`:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+model = "my_spacy_model"
+
+TokenizerWorkflow = WorkflowBuilder(
+    name="TokenizerWorkflow",
+    module_name="tokenizer"
+    workflow=[
+        {"apply_model": {"model": model}},
+        {"get_tokens": {}},
+        {"remove_stop_words": {}}
+    ]
+)
+
+model, filtered_tokens = TokenizerWorkflow(
+    input_data=text,
+    return_methods=["apply_model", "remove_stop_words"]
+)
+
+print(model)
+print(filtered_tokens)
+
+# Output: 
+# The quick brown fox jumps over the lazy dog while the sun sets behind the hills.
+# [quick, brown, fox, jumps, lazy, dog, sun, sets, behind, hills]
+```
+
+If you choose to return all of the results, the workflow will return a generator with a tuple containing the name of the method and its result:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+model = "my_spacy_model"
+
+TokenizerWorkflow = WorkflowBuilder(
+    name="TokenizerWorkflow",
+    module_name="tokenizer"
+    workflow=[
+        {"apply_model": {"model": model}},
+        {"get_tokens": {}},
+        {"remove_stop_words": {}}
+    ]
+)
+
+result = TokenizerWorkflow(
+    input_data=text,
+    return_all=True
+)
+
+print(next(result))
+print(next(result))
+print(next(result))
+
+# Output: 
+# ("apply_model", The quick brown fox jumps over the lazy dog while the sun sets behind the hills.)
+# ("get_tokens", [The, quick, brown, fox, jumps, over, the, lazy, dog, while, the, sun, sets, behind, the, hills])
+# ("remove_stop_words", [quick, brown, fox, jumps, lazy, dog, sun, sets, behind, hills])
+```
+
+You can also make a workflow return a Wrapper class containing methods you might want to used multiple times. For example, if you wish to calculat the `cos_similarity` of different words in the same embeddings, you can do:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+
+GeometricDistance = WorkflowBuilder(
+    name="GeometricDistance",
+    module_name="geometric_distance",
+    workflow=[
+        {"cos_similarity": {}}, # The methods should NOT have args
+    ],
+    wrapper=True
+)
+
+result = GeometricDistance(input_data=embeddings) # In this example 'embeddings' is a pandas DataFrame containing word embeddings
+
+print(result.cos_similarity(first_word="word1", second_word="word2"))
+print(result.cos_similarity(first_word="word3", second_word="word4"))
+
+# Output: 
+# 0.999999
+# 0.854456
+```
+
+### Templates
+
+Workflows can use templates. Templates are a way to enforce certain rules on the workflow, such as method invocation order or restricting certain methods after others have been called, in order to achieve type safety and minimize errors. To use them just import the template of your respective module and pass it during workflow definition:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+from dstk.templates import TokenizerTemplate
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+model = "my_spacy_model"
+
+TokenizerWorkflow = WorkflowBuilder(
+    name="TokenizerWorkflow",
+    module_name="tokenizer",
+    template=TokenizerTemplate,
+    workflow=[
+        {"get_tokens": {}},
+        {"apply_model": {"model": model}}, # Wrong order. 'apply_model' should go first
+        {"remove_stop_words": {}}
+    ]
+)
+
+tokens = TokenizerWorkflow(input_data=text)
+
+# Output: RuntimeError: The method on step select_model must be ['apply_model']. Instead, got method get_tokens
+```
+
+### Stage workflows
+
+Some common tasks in distributional semantics require the use of more than one module, such as text pre-processing (tokenization, text procesing and ngram extraction) or plotting embeddings (clustering and drawing the plot). Stage workflows exist to address that problem. They come with predefined templates about which modules should be used, their order and the methods that can be used (or not) after certain choices have been made. In order to use them just import the desired stage workflow and pass a StageWorkflow, which is a dictionary that includes the name of the modules to be used and its respective workflows:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+model = "my_spacy_model"
+
+TextProcessorWorkflow = TextProcessing(
+    name="TextProcessorWorkflow",
+    workflows={
+        "tokenizer": [
+            {"apply_model": {"model": model}},
+            {"get_tokens": {}},
+            {"remove_stop_words": {"custom_stop_words": stops}},
+        ],
+        "ngrams": [
+            {"extract_ngrams": {"window_size": 3}}
+        ],
+        "text_processor": [
+            {"tokens_to_text": {"lemmatize": True}},
+            {"to_lower": {}},
+            {"join": {}}
+        ]
+        
+    }
+)
+
+tokens = TokenizerWorkflow(input_data=text)
+
+
+# Output: ['the quick brown', 'quick brown fox', 'brown fox jumps', 'fox jumps over', 'jumps over the', 'over the lazy', 'the lazy dog', 'lazy dog while', 'dog while the', 'while the sun', 'the sun set', 'sun set behind', 'set behind the', 'behind the hills']
+```
+
+Just like in the case of WorkflowBuilder, you can also return the result of specific modules or all of them. You just need to pass a list with the names of the modules you want to return to `return_modules` or `True` to `return_all`. In the last case, it will return a generator with tuples containing the name of the module and its respective result.
+
+## Models
+
+A model is just a set of workflows running one after another. If there are a lot of workflows that you constantly use, you can automate the process by using ModelBuilder. Just pass your workflows as a list:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+from dstk.models.model_tools import ModelBuilder
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+
+TokenizerWorkflow = WorkflowBuilder(
+    name="TokenizerWorkflow",
+    module_name="tokenizer",
+    workflow=[
+        {"apply_model": {"model": model}},
+        {"get_tokens": {}},
+        {"remove_stop_words": {}}
+    ]
+)
+
+TextWorkflow = WorkflowBuilder(
+    name="TextWorkflow",
+    module_name="text_processor",
+    workflow=[
+        {"tokens_to_text": {}}
+        {"to_lower": {}}
+    ]
+)
+
+CustomModel = ModelBuilder(
+    workflows=[
+        TokenizerWorkflow,
+        TextWorkflow
+    ]
+)
+
+# Pass as an argument your input data
+result = CustomModel(input_data=text)
+
+print(result)
+
+# Output: ["quick", "brown", "fox", "jumps", "lazy", "dog", "sun", "sets", "behind", "hills"]
+```
+
+Just like in the case of WorkflowBuilder and StageWorkflows, you can also return the result of specific workflows or all of them. You just need to pass a list with the names of the workflows (or hooks) you want to return to `return_workflows` or `True` to `return_all`. In the last case, it will return a generator with tuples containing the name of the workflows and its respective result.
+
+### Hooks
+
+You can add hooks (functions with custom logic) to a pipeline. You must only follow two rules: 
+
+1. The function must accept only one input and return one output
+2. The type of its input must be the same as the one returned from the previous workflow. Also, the type it returns must match the input of the next workflow.
+
+Following these rules you can insert your custom hooks this way:
+
+```python
+from dstk.workflows.workflow_tools import WorkflowBuilder
+from dstk.models.model_tools import ModelBuilder
+from dstk.hooks.hook_tools import Hook
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+
+TokenizerWorkflow = WorkflowBuilder(
+    name="TokenizerWorkflow",
+    module_name="tokenizer",
+    workflow=[
+        {"apply_model": {"model": model}},
+        {"get_tokens": {}},
+        {"remove_stop_words": {}}
+    ]
+)
+
+TextWorkflow = WorkflowBuilder(
+    name="TextWorkflow",
+    module_name="text_processor",
+    workflow=[
+        {"tokens_to_text": {}}
+        {"to_lower": {}}
+    ]
+)
+
+def custom_hook(words): 
+    return [word + "_hook" for word in words]
+
+CustomHook = Hook(name="CustomHook", method=custom_hook)
+
+CustomModel = ModelBuilder(
+    workflows=[
+        TokenizerWorkflow,
+        TextWorkflow,
+        CustomHook
+    ]
+)
+
+result = CustomPipeline(input_data=text)
+
+print(result)
+
+# Output: ["quick_hook", "brown_hook", "fox_hook", "jumps_hook", "lazy_hook", "dog_hook", "sun_hook", "sets_hook", "behind_hook", "hills_hook"]
+```
+
+### Predefined Models
+
+DSTK has some models included that already cover most of the frequent tasks in distributional semantics:
+
+- *StandardModel*: 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.
+
+- *SGNSModel*:  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.
+
+In order to use them just do:
+
+```python
+from dstk.models.models import StandardModel
+
+text = "The quick brown fox jumps over the lazy dog while the sun sets behind the hills."
+
+result = StandardModel(text=text, model=model, n_components=13)
+
+print(result.cos_similarity(first_word="brown", second_word="fox")) # It returns a wrapper with the methods 'cos_similarity' and 'nearest_neighbors' included.
+
+# Output: 0.5858588775335568
+```
+
+# Contributing
+
+I welcome contributions to improve this toolkit. If you have ideas or fixes, feel free to fork the repository and submit a pull request. Here are some ways you can help:
+
+* Report bugs or issues.
+
+* Suggest new features or algorithms to add.
+
+# License
+
+This project is licensed under the GPL-3 License - see the [LICENSE](https://gitlab.com/CesarACabrera/distributional-semantics-toolkit/-/blob/master/LICENSE?ref_type=heads) file for details.

dstklib-2.0.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+dstk/__init__.py,sha256=zxRGhDnwApMqeLfJ3-ljlliJl3Nve_f2JYOXVw5hx_A,168
+dstk/method_index.py,sha256=7UoUPn_PZ3U10WkXFciqEp_XN5xEy4Wy4Wyxe6a__WQ,791
+dstk/adaptors/__init__.py,sha256=b6asMMPwGZlgFdvrjwlTqbkItB00_4FFdh63-tRMQjs,49
+dstk/adaptors/adaptors.py,sha256=t-BbxHYtHyB9-hxtbQTcMLrYmZ_Kov4WwSoGcilZMmE,4057
+dstk/adaptors/typeguards.py,sha256=Ev5Z_dppKRlgNVho07QMfCkmxY800uL2auxrfGRubd4,4589
+dstk/hooks/__init__.py,sha256=Z8rT2WV-hlhbEUGrPfO71sdpWPf69qu8tSgF6MEhVZo,56
+dstk/hooks/hook_tools.py,sha256=H0pJ5ADJeLtGTacNK39WABO5Hr65HfhTFLzFjtI-3R0,3275
+dstk/hooks/type_conversion.py,sha256=OKyAiCiOGecboy5FGLT43HmnltpAYtDY_LpOPcx5S2k,1395
+dstk/lib_types/__init__.py,sha256=L64qlAbqNavw6fopO467i6r0jOJGSL1d0VsGm35lPWU,222
+dstk/lib_types/dstk_types.py,sha256=vqqvec3eSKO8ozg-aDM8aiWWPXt0qQxuhGXiZzm2RHE,6750
+dstk/lib_types/fasttext_types.py,sha256=5LXE77kgCPJHRx0zXlLTs7wRIQOGZiz30Pq0trIXcBA,51
+dstk/lib_types/gensim_types.py,sha256=tg3OASG_EWuqFQw_pKM4HNjRk1yrMnmlBqdKm-orxag,34
+dstk/lib_types/numpy_types.py,sha256=zxgVrHcRJ-_NGO3LE1aba0d4JQDLYN26us5ljlhIq7E,64
+dstk/lib_types/pandas_types.py,sha256=bR27h-xyZ3FccROIHxqYpVvqMNoi1bvIzpq25cf8kkg,43
+dstk/lib_types/plotly_types.py,sha256=44_qvw7RNhYqq-BvdBALGR_sWTwQRSip7HjM--fkPGQ,39
+dstk/lib_types/sklearn_types.py,sha256=W59yIEkZM_E_tW061x1bY-LpRC2aCzLgtYmXANNSN3Q,47
+dstk/lib_types/spacy_types.py,sha256=hUiaw4AywSW8o42h5lp3t6a4yosG_GasdJX2RCKgW7o,125
+dstk/models/__init__.py,sha256=27_6lGFl0BAZp3rgXnbazEX_uxK9jQ0lf3RkjomzICA,48
+dstk/models/model_tools.py,sha256=IYTG4I1oNhnW3JX4bzXxgBa8phhvO7l0haTxeVMeYhM,3279
+dstk/models/models.py,sha256=wLd_BOP4hxWnCg7PCDOO-ZZ3Yx8jY3MqTLbvbhQqx2M,8152
+dstk/modules/__init__.py,sha256=NKI_C2D86x25lUmcM2r6e0M31rV1-8FZBFHRP2oXF2Q,267
+dstk/modules/count_models.py,sha256=VY8YRao78pmh_3WBX8zWQ94B13J1cSL6Pg91c3qUUyg,4288
+dstk/modules/geometric_distance.py,sha256=Zj9O0p6glJOqcNGkdjP_qucj_en-QeejbbQ8Hr5oUVM,4621
+dstk/modules/ngrams.py,sha256=WZ8Nr05KeBnOH_AnPLfUrBQJkcz1hJxJRwVuIU_qviI,6730
+dstk/modules/predict_models.py,sha256=6Wz75nG7JqtI4fCvidDrYQmEEuQyZ3aQxLv66zq0mI4,3987
+dstk/modules/text_matrix_builder.py,sha256=jAla8fKiKZ8cPHUmdW9V0B1MRGU488JKl4s9h45zLBc,2318
+dstk/modules/text_processor.py,sha256=v-T8qPQwRgXIeZ5eJxRO3e7J-zD6UPzbpb-sRf94Vrs,3600
+dstk/modules/tokenizer.py,sha256=bkALslqlUHzD83tjsI57U0joUIVRLZCdUlFi5TPaMb8,4323
+dstk/modules/weight_matrix.py,sha256=-nP-2VY2YFjOoExeojajWA0fkxtj8GdgJU5QQHBQFyo,2694
+dstk/modules/data_visualization/__init__.py,sha256=OSogy0-_DE7t89KS8Q6n1RNGToqoq2LnmKfLc6cjGOA,52
+dstk/modules/data_visualization/clustering.py,sha256=tyUQtFayH7Jh4uisheaeWkIEn9X3fvBYT-sblfgpVws,4982
+dstk/modules/data_visualization/embeddings.py,sha256=8lPMUB-saog0c3PWiHvuz1sC5YYkqFjn5wCJilnyBfQ,4237
+dstk/templates/__init__.py,sha256=t7R-RKxq-EZukHV7U9zj7dbIrbxGKTIJyRzh-Tm1PiM,45
+dstk/templates/rules.py,sha256=Rg8uUBwWlG0b6P-ObnahImb-ZOphMkXB5COWLRQgZSg,1757
+dstk/templates/templates.py,sha256=i-RV0FJfGpeh1Ja8PxLJetYh2cXH7l-jsV-bmJcdOIU,6447
+dstk/workflows/__init__.py,sha256=sP8X_nwRIquC4NHSyUZ5L8DbxZfUCtD8qBekykcBuW8,61
+dstk/workflows/stage_workflows.py,sha256=LkNRgEHRLmpCNIXJJiUERu45trS3zGv2zC7hcIxUl_s,2639
+dstk/workflows/workflow_tools.py,sha256=M1wcJ5UGeEKf6TSE0-Z2AA2CetmFUrgCGdV5Z4LvD4Y,16101
+dstklib-2.0.0.dist-info/LICENSE,sha256=LpSgNPBfwn5F4CVhnTbhpiX2f0YgRMzGWQ7Sphuuwuc,35139
+dstklib-2.0.0.dist-info/METADATA,sha256=gF35KRqRuMZTZRBJ_05rq8eUwameiBjX2sEafpi4WBU,12863
+dstklib-2.0.0.dist-info/WHEEL,sha256=VyG4dJCdJcxE1baiVBm9NET3Nj7Wne1lZZq7UFNxRpg,97
+dstklib-2.0.0.dist-info/top_level.txt,sha256=b_MNmKso0-ra2M7snsy5fZBW-l9MItjrwMYBd-tiOYo,5
+dstklib-2.0.0.dist-info/RECORD,,

dstk/collocations.py

@@ -1,121 +0,0 @@
-from collections import Counter
-from dataclasses import dataclass
-import matplotlib.pyplot as plt
-from .workflow_tools import workflow, requires, WorkflowManager
-
-from .lib_types import BarContainer, Collocate
-
-STAGES = [
-    "start", # Before any processing
-    "collocates", # Manipulation of collocates 
-    "count", # Operations dealing with the counts of the words appearing around the target word
-    "end" # End of the workflow. After this stage the user must necessarily call result to continue with the analysis
-]
-
-@dataclass
-class Ngrams:
-    collocates: list[tuple[str, ...]]
-    bigrams: list[Collocate]
-
-class Collocations(WorkflowManager):
-    """
-    Extracts n-grams for a target word by a context window (both directed or undirected). Counts and plots the terms that co-occur with the target
-
-    :param tokens: A list of tokenized words (e.g. from a text or corpus) in which to search for the target word and its collocates.
-    
-    """
-
-    _start: list[str]
-    _end: BarContainer
-
-    def __init__(self, tokens: list[str] | None = None):
-        """
-        Initializes TargetCollocations with given attributes.
-        """
-
-        super().__init__()
-        
-        # Stages
-
-        self._collocates: Ngrams
-        self._count: Counter[str]
-
-        self._set_workflow(input_arg=tokens)
-    
-    @requires(stages=["start"])
-    @workflow(input_arg="tokens", input_process="_start", output_process="_collocates", next_stage="collocates")
-    def extract_ngrams(self, *, tokens: list[str], target_word: str, window_size: tuple[int, int], directed: bool = False) -> Ngrams:
-        """
-        Extracts both the context words of the target collocation, returned as tuples whose lenght corresponds to the specified window_size, and the collocations of the target word, in either directed or undirected manner.
-
-        :param tokens: A list of tokenized words (e.g. from a text or corpus) in which to search for the target word and its collocates.
-        :param target_word: Target word whose collocation are to be identified.
-        :param window_size: Context window represented as a tuple (left, right) of the number of words to be included to left and right of the target word.
-        :param directed: If True, the position of collocates relative to the target word is considered (i.e., direction matters); if False, direction is ignored. Defaults to False. 
-        """
-
-        collocates: list[tuple[str, ...]] = []
-        bigrams: list[Collocate] = []
-
-        for index, word in enumerate(tokens):
-            if word == target_word:
-                start: int = max(0, index - window_size[0])
-                end: int = min(len(tokens), index + window_size[1] + 1)
-
-                left_context: list[str] = tokens[start:index]
-                right_context: list[str] = tokens[index + 1:end]
-
-                context: list[str] = left_context + right_context 
-
-                collocates.append(tuple(context))
-                
-                if directed == True:
-                    bigrams.extend([(word, ("L", target_word)) for word in left_context] + [(word, ("R", target_word)) for word in right_context])
-                else:
-                    bigrams.extend([(word, target_word) for word in context])
-        
-        return Ngrams(collocates, bigrams)
-    
-    @requires(stages=["collocates"])
-    @workflow(input_arg="collocates", input_attrs={"collocates": "collocates"}, input_process="_collocates", output_process="_count", next_stage="count")
-    def count_collocates(self, *, collocates: list[tuple[str, ...]]) -> Counter[str]:
-        """
-        Counts the collocates of the target word.
-
-        :param collocates: A list of collocates to count. 
-        """
-
-        all_words: list[str] = [word for collocation in collocates for word in collocation]
-        word_counts: Counter[str] = Counter(all_words)
-        
-        return word_counts
-
-    @requires(stages=["count"])
-    @workflow(input_arg="word_counts", input_process="_count", output_process="_end", next_stage="end")
-    def plot(self, *, word_counts: Counter[str], size: int = 10, show: bool = True, path: str | None = None) -> BarContainer:
-        """
-        Plots the count of the collocates.
-
-        :param word_counts: A Counter object with the counts of each word. Defaults to None.
-        :param size: The number of the most common collocates to plot. Defaults to 10. 
-        :param show: If True, shows the plot. Defaults to True.
-        :param path: If provided, saves the plot in the specified path. Defaults to None.
-        """
-
-        counts: list[tuple[str, int]] = word_counts.most_common(size)
-        
-        words: tuple[str, ...]
-        values: tuple[int, ...]
-        words, values = zip(*counts)
-
-        fig: BarContainer = plt.bar(words, values)
-        plt.xlabel("Palabras")
-        plt.ylabel("Cuentas")
-        
-        if path:
-            plt.savefig(path)
-        
-        if show:
-            plt.show()
-
-        return fig

dstk/count_models.py

@@ -1,112 +0,0 @@
-from sklearn.preprocessing import StandardScaler
-from sklearn.decomposition import PCA, TruncatedSVD
-from .workflow_tools import requires, workflow, WorkflowManager
-from .matrix_base import MatrixRepresentation, accept_matrix_representation, matrix_to_dataframe
-
-from .lib_types import ndarray, DataFrame
-
-STAGES = [
-    "start", # Before any transformation to the Co-Matrixis applied
-    "embeddings", # Result of the embeddings
-    "end" # Embeddings transformed to dataframe
-]
-
-class CountModels(WorkflowManager):
-    """
-    Generates word embeddings using dimensionality reduction techniques on a co-occurrence matrix, such as SVD and PCA.
-
-    :param co_ocurrence_matrix: A Co-ocurrence matrix from which embeddings will be generated.
-    """
-
-    _start: ndarray | DataFrame
-    _end: DataFrame
-
-    def __init__(self, co_ocurrence_matrix: DataFrame | None = None):
-        """
-        Initializes CountModels with given attributes.
-        """
-        super().__init__()
-
-        self._embeddings: MatrixRepresentation
-
-        self._set_workflow(input_arg=co_ocurrence_matrix)
-
-    @requires(stages=["start"])
-    @workflow(input_arg="matrix", input_process="_start", output_process="_embeddings", next_stage="embeddings")
-    @accept_matrix_representation()
-    def scale_matrix(self, *, matrix: ndarray | DataFrame, **kwargs) -> MatrixRepresentation:
-        """
-        Scales the input matrix to have zero mean and unit variance for each feature.
-
-        This method applies standardization using scikit-learn's StandardScaler, which transforms the data such that each colum (feature) has a mean of 0 and a standard deviation of 1.
-
-        :param matrix: The input data to scale.
-        :param kwargs: Additional keyword arguments to pass to sklearn's StandardScaler. For more information check: https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html
-
-        This method supports different matrix forms due to decorator-based preprocessing:
-            - matrix: ndarray or Dataframe
-            - matrix representation: MatrixRepresentation
-        """
-        
-        scaler: StandardScaler = StandardScaler(**kwargs)
-        scaled_matrix: ndarray = scaler.fit_transform(matrix)
-
-        return MatrixRepresentation(scaled_matrix, matrix.index if isinstance(matrix, DataFrame) else None, matrix.columns if isinstance(matrix, DataFrame) else None)
-
-    @requires(stages=["embeddings"])
-    @workflow(input_arg="matrix", input_process="_embeddings", output_process="_embeddings")
-    @accept_matrix_representation(override=("columns", None))
-    def svd_embeddings(self, *, matrix: ndarray | DataFrame, **kwargs) -> MatrixRepresentation:
-        """
-        Generates word embeddings using truncated Single Value Descomposition (SVD).
-
-        :param matrix: A Co-occurrence matrix from which embeddings will be generated.
-        :param kwargs: Additional keyword arguments to pass to sklearn's TruncatedSVD.
-            Common options include:
-                - n_components: Specifies the number of dimensions to reduce the Co-ocurrence matrix to. 
-            For more information check: https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.TruncatedSVD.html
-
-        This method supports different matrix forms due to decorator-based preprocessing:
-            - matrix: ndarray or Dataframe
-            - matrix representation: MatrixRepresentation
-        """
-
-        svd: TruncatedSVD = TruncatedSVD(**kwargs)
-        embeddings: ndarray = svd.fit_transform(matrix)
-
-        return MatrixRepresentation(embeddings, matrix.index if isinstance(matrix, DataFrame) else None, None)
-
-    @requires(stages=["embeddings"])
-    @workflow(input_arg="matrix", input_process="_embeddings", output_process="_embeddings")
-    @accept_matrix_representation(override=("columns", None))
-    def pca_embeddings(self, *, matrix: ndarray | DataFrame, **kwargs) -> MatrixRepresentation:
-        """
-        Generates word embeddings using Principal Component Analysis (PCA).
-
-        :param matrix: A Co-occurrence matrix from which embeddings will be generated.
-        :param kwargs: Additional keyword arguments to pass to sklearn's PCA.
-            Common options include:
-                - n_components: If an integer, specifies the number of dimensions to reduce the Co-ocurrence matrix to. If a float, the amount of variance to preserve during PCA.
-            For more information check: https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html
-
-        This method supports different matrix forms due to decorator-based preprocessing:
-            - matrix: ndarray or Dataframe
-            - matrix representation: MatrixRepresentation
-        """
-
-        pca: PCA = PCA(**kwargs)
-        embeddings: ndarray = pca.fit_transform(matrix)
-
-        return MatrixRepresentation(embeddings, matrix.index if isinstance(matrix, DataFrame) else None, None)
-
-    @requires(stages=["embeddings"])
-    @workflow(input_arg="matrix", input_process="_embeddings", output_process="_end", next_stage="end")
-    def to_dataframe(self, *, matrix: MatrixRepresentation, **kwargs) -> DataFrame:
-        """
-        Creates a dataframe from a matrix representation.
-
-        :param matrix: An matrix represenation from which to create a dataframe.
-        :param kwargs: Additional keyword arguments to pass to sklearn's pandas' DataFrame.
-        """
-
-        return matrix_to_dataframe(matrix=matrix, **kwargs)