tmplot 0.3.0__tar.gz → 0.4.0__tar.gz

{tmplot-0.3.0 → tmplot-0.4.0}/MANIFEST.in

@@ -1,3 +1,4 @@
 include LICENSE
 include README.md
+include CHANGELOG.md
 recursive-exclude tests *

{tmplot-0.3.0/src/tmplot.egg-info → tmplot-0.4.0}/PKG-INFO

@@ -1,56 +1,35 @@
 Metadata-Version: 2.4
 Name: tmplot
-Version: 0.3.0
+Version: 0.4.0
 Summary: Visualization of Topic Modeling Results
 Author-email: Maksim Terpilovskii <maximtrp@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2021 Maksim Terpilowski
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: homepage, https://github.com/maximtrp/tmplot
 Project-URL: documentation, https://tmplot.readthedocs.io/
 Keywords: data science,data analytics
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Text Processing :: General
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: seaborn
-Requires-Dist: pandas
-Requires-Dist: scikit-learn
-Requires-Dist: scipy
-Requires-Dist: altair
-Requires-Dist: ipywidgets
-Requires-Dist: tqdm
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scikit-learn>=1.4
+Requires-Dist: scipy>=1.9
+Requires-Dist: altair>=5
+Requires-Dist: ipywidgets>=8
+Requires-Dist: IPython>=8
+Requires-Dist: tqdm>=4.64
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"
+Requires-Dist: build; extra == "test"
+Requires-Dist: twine; extra == "test"
 Provides-Extra: models
 Requires-Dist: tomotopy>=0.8.0; extra == "models"
 Requires-Dist: gensim; extra == "models"
@@ -170,7 +149,7 @@ saliency = tmp.get_salient_terms(phi, theta)
 
 ```python
 # Create topic distance matrix with different metrics
-topic_dists = tmp.get_topics_dist(phi, method='jensen-shannon')
+topic_dists = tmp.get_topics_dist(phi, method='jsd')
 
 # Generate coordinates with custom algorithm
 coords = tmp.get_topics_scatter(topic_dists, theta, method='tsne')
@@ -181,7 +160,7 @@ tmp.plot_scatter_topics(coords, topic=3)  # Highlight topic 3
 
 - [Complete Tutorial](https://tmplot.readthedocs.io/en/latest/tutorial.html) - Step-by-step guide
 - [API Reference](https://tmplot.readthedocs.io/) - Full documentation
-- [Example Notebooks](https://github.com/maximtrp/tmplot/tree/main/examples) - Jupyter examples
+- [Tutorial Notebook](docs/source/tutorial.ipynb) - Jupyter walkthrough
 
 ## Requirements
 

{tmplot-0.3.0 → tmplot-0.4.0}/README.md

@@ -111,7 +111,7 @@ saliency = tmp.get_salient_terms(phi, theta)
 
 ```python
 # Create topic distance matrix with different metrics
-topic_dists = tmp.get_topics_dist(phi, method='jensen-shannon')
+topic_dists = tmp.get_topics_dist(phi, method='jsd')
 
 # Generate coordinates with custom algorithm
 coords = tmp.get_topics_scatter(topic_dists, theta, method='tsne')
@@ -122,7 +122,7 @@ tmp.plot_scatter_topics(coords, topic=3)  # Highlight topic 3
 
 - [Complete Tutorial](https://tmplot.readthedocs.io/en/latest/tutorial.html) - Step-by-step guide
 - [API Reference](https://tmplot.readthedocs.io/) - Full documentation
-- [Example Notebooks](https://github.com/maximtrp/tmplot/tree/main/examples) - Jupyter examples
+- [Tutorial Notebook](docs/source/tutorial.ipynb) - Jupyter walkthrough
 
 ## Requirements
 

{tmplot-0.3.0 → tmplot-0.4.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel"]
+requires = ["setuptools>=77.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -7,8 +7,9 @@ name = "tmplot"
 dynamic = ["version"]
 description = "Visualization of Topic Modeling Results"
 readme = "README.md"
-requires-python = ">=3.8"
-license.file = "LICENSE"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
 authors = [
   { name = "Maksim Terpilovskii", email = "maximtrp@gmail.com" },
 ]
@@ -17,9 +18,7 @@ keywords = [
     "data analytics"
 ]
 classifiers = [
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -31,18 +30,18 @@ urls.homepage = "https://github.com/maximtrp/tmplot"
 urls.documentation = "https://tmplot.readthedocs.io/"
 
 dependencies = [
-    "numpy",
-    "seaborn",
-    "pandas",
-    "scikit-learn",
-    "scipy",
-    "altair",
-    "ipywidgets",
-    "tqdm",
+    "numpy>=1.23",
+    "pandas>=1.5",
+    "scikit-learn>=1.4",
+    "scipy>=1.9",
+    "altair>=5",
+    "ipywidgets>=8",
+    "IPython>=8",
+    "tqdm>=4.64",
 ]
 
 [project.optional-dependencies]
-test = ["pytest", "coverage"]
+test = ["pytest", "coverage", "build", "twine"]
 models = ["tomotopy>=0.8.0", "gensim", "bitermplus"]
 
 [tool.setuptools.dynamic]

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/__init__.py

@@ -5,4 +5,4 @@ from ._stability import *  # noqa: F401, F403
 from ._vis import *  # noqa: F401, F403
 from ._metrics import *  # noqa: F401, F403
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/_distance.py

@@ -1,5 +1,6 @@
 __all__ = ["get_topics_dist", "get_topics_scatter", "get_top_topic_words"]
 from typing import Optional, Union, List
+from inspect import signature
 from itertools import combinations
 from pandas import DataFrame, Index
 import numpy as np
@@ -15,14 +16,22 @@ from sklearn.manifold import (
 from ._helpers import calc_topics_marg_probs
 
 
+EPSILON = 1e-64
+
+
+def _positive_probabilities(values: np.ndarray) -> np.ndarray:
+    values = np.clip(np.asarray(values, dtype=float), EPSILON, None)
+    return values / values.sum()
+
+
 def _dist_klb(a1: np.ndarray, a2: np.ndarray):
-    dist = kl_div(a1, a2)
-    return dist[np.isfinite(dist)].sum()
+    return kl_div(_positive_probabilities(a1), _positive_probabilities(a2)).sum()
 
 
 def _dist_sklb(a1: np.ndarray, a2: np.ndarray):
-    dist = kl_div(a1, a2) + kl_div(a2, a1)
-    return dist[np.isfinite(dist)].sum()
+    a1_safe = _positive_probabilities(a1)
+    a2_safe = _positive_probabilities(a2)
+    return (kl_div(a1_safe, a2_safe) + kl_div(a2_safe, a1_safe)).sum()
 
 
 def _dist_jsd(a1: np.ndarray, a2: np.ndarray):
@@ -32,13 +41,9 @@ def _dist_jsd(a1: np.ndarray, a2: np.ndarray):
 
 
 def _dist_jef(a1: np.ndarray, a2: np.ndarray):
-    vals = (a1 - a2) * (np.log(a1) - np.log(a2))
-    vals[(vals <= 0) | ~np.isfinite(vals)] = 0.0
-    return vals.sum()
-
-
-# Small value for numerical stability
-EPSILON = 1e-64
+    a1_safe = _positive_probabilities(a1)
+    a2_safe = _positive_probabilities(a2)
+    return ((a1_safe - a2_safe) * (np.log(a1_safe) - np.log(a2_safe))).sum()
 
 
 def _dist_hel(a1: np.ndarray, a2: np.ndarray):
@@ -124,8 +129,12 @@ def get_topics_dist(
         "jac": _dist_jac,
     }
 
+    if method not in dist_funcs:
+        raise ValueError(
+            f"Unknown distance method {method!r}; choose from {sorted(dist_funcs)}"
+        )
+    _dist_func = dist_funcs[method]
     for i, j in topics_pairs:
-        _dist_func = dist_funcs.get(method, "sklb")
         topics_dists[((i, j), (j, i))] = _dist_func(
             phi_copy[:, i], phi_copy[:, j], **kwargs
         )
@@ -133,6 +142,17 @@ def get_topics_dist(
     return topics_dists
 
 
+def _classical_mds(distances: np.ndarray) -> np.ndarray:
+    count = distances.shape[0]
+    centering = np.eye(count) - np.ones((count, count)) / count
+    gram = -0.5 * centering @ (distances**2) @ centering
+    eigenvalues, eigenvectors = np.linalg.eigh(gram)
+    positive = eigenvalues > np.finfo(float).eps
+    if not positive.any():
+        return np.zeros((count, 1))
+    return eigenvectors[:, positive] * np.sqrt(eigenvalues[positive])
+
+
 def get_topics_scatter(
     topic_dists: np.ndarray,
     theta: np.ndarray,
@@ -164,11 +184,39 @@ def get_topics_scatter(
     DataFrame
         Topics scatter coordinates.
     """
-    if not method_kws:
-        method_kws = {"n_components": 2}
+    topic_dists = np.asarray(topic_dists, dtype=float)
+    theta = np.asarray(theta, dtype=float)
+    if topic_dists.ndim != 2 or topic_dists.shape[0] != topic_dists.shape[1]:
+        raise ValueError("topic_dists must be a square 2D matrix")
+    if not np.isfinite(topic_dists).all():
+        raise ValueError("topic_dists must contain only finite values")
+    if not np.allclose(topic_dists, topic_dists.T):
+        raise ValueError("topic_dists must be symmetric")
+    if theta.ndim != 2 or theta.shape[0] != topic_dists.shape[0]:
+        raise ValueError("theta topics dimension must match topic_dists")
+    if topic_dists.shape[0] < 2:
+        raise ValueError("at least two topics are required for scatter coordinates")
+
+    valid_methods = ["tsne", "sem", "mds", "lle", "ltsa", "isomap"]
+    if method not in valid_methods:
+        raise ValueError(
+            f"Unknown scatter method {method!r}; choose from {valid_methods}"
+        )
+
+    if topic_dists.shape[0] == 2:
+        half_distance = topic_dists[0, 1] / 2
+        coords = np.array([[-half_distance, 0.0], [half_distance, 0.0]])
+        topics_xy = DataFrame(coords, columns=Index(["x", "y"]))
+        topics_xy["topic"] = topics_xy.index.astype(int)
+        topics_xy["size"] = calc_topics_marg_probs(theta) * 100
+        return topics_xy
+
+    method_kws = dict(method_kws or {})
+    method_kws.setdefault("n_components", 2)
 
     if method == "tsne":
-        method_kws.setdefault("init", "pca")
+        method_kws.setdefault("metric", "precomputed")
+        method_kws.setdefault("init", "random")
         method_kws.setdefault("learning_rate", "auto")
         method_kws.setdefault("perplexity", min(50, max(topic_dists.shape[0] // 2, 1)))
         transformer = TSNE(**method_kws)
@@ -176,25 +224,46 @@ def get_topics_scatter(
     elif method == "sem":
         method_kws.setdefault("affinity", "precomputed")
         transformer = SpectralEmbedding(**method_kws)
+        nonzero = topic_dists[topic_dists > 0]
+        scale = np.median(nonzero) if nonzero.size else 1.0
+        transform_input = np.exp(-((topic_dists / scale) ** 2))
+        np.fill_diagonal(transform_input, 1.0)
 
     elif method == "mds":
-        method_kws.setdefault("dissimilarity", "precomputed")
+        mds_params = signature(MDS.__init__).parameters
+        if "metric_mds" in mds_params:
+            # scikit-learn >= 1.9 deprecated `dissimilarity` in favor of `metric`
+            method_kws.setdefault("metric", "precomputed")
+        else:
+            method_kws.setdefault("dissimilarity", "precomputed")
         method_kws.setdefault("normalized_stress", "auto")
         method_kws.setdefault("n_init", 1)
+        if "init" in mds_params:
+            # `init` is a constructor argument only since scikit-learn 1.9
+            method_kws.setdefault("init", "random")
         transformer = MDS(**method_kws)
 
     elif method == "lle":
         method_kws["method"] = "standard"
+        method_kws.setdefault("n_neighbors", min(5, topic_dists.shape[0] - 1))
         transformer = LocallyLinearEmbedding(**method_kws)
+        transform_input = _classical_mds(topic_dists)
 
     elif method == "ltsa":
         method_kws["method"] = "ltsa"
+        method_kws.setdefault("n_neighbors", min(5, topic_dists.shape[0] - 1))
         transformer = LocallyLinearEmbedding(**method_kws)
+        transform_input = _classical_mds(topic_dists)
 
     elif method == "isomap":
+        method_kws.setdefault("metric", "precomputed")
+        method_kws.setdefault("n_neighbors", min(5, topic_dists.shape[0] - 1))
         transformer = Isomap(**method_kws)
 
-    coords = transformer.fit_transform(topic_dists)
+    else:
+        raise AssertionError("validated scatter method was not handled")
+
+    coords = transformer.fit_transform(locals().get("transform_input", topic_dists))
 
     topics_xy = DataFrame(coords, columns=Index(["x", "y"]))
     topics_xy["topic"] = topics_xy.index.astype(int)
@@ -229,6 +298,7 @@ def get_top_topic_words(
     DataFrame
         Words with highest probabilities in all (or selected) topics.
     """
-    return phi.loc[:, topics_idx or phi.columns].apply(
+    selected_topics = phi.columns if topics_idx is None else topics_idx
+    return phi.loc[:, selected_topics].apply(
         lambda x: x.sort_values(ascending=False).head(words_num).index, axis=0
     )

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/_helpers.py

@@ -9,43 +9,65 @@ __all__ = [
     "calc_topics_marg_probs",
     "calc_terms_probs_ratio",
 ]
-from warnings import warn
 from importlib.util import find_spec
+from warnings import warn
 from typing import Union, Optional, Sequence, List
 from functools import partial
-from math import log
-from numpy import ndarray, zeros, argsort, array, arange, vstack
+from numpy import ndarray, zeros, array, arange, vstack
 from numpy import log as nplog
+import numpy as np
 from pandas import concat, Series, DataFrame
 
 tomotopy_installed = find_spec("tomotopy")
 if tomotopy_installed:
-    from tomotopy import (
-        LDAModel as tomotopyLDA,
-        LLDAModel as tomotopyLLDA,
-        CTModel as tomotopyCT,
-        DMRModel as tomotopyDMR,
-        HDPModel as tomotopyHDP,
-        PTModel as tomotopyPT,
-        SLDAModel as tomotopySLDA,
-        GDMRModel as tomotopyGDMR,
-    )
+    try:
+        from tomotopy import (
+            LDAModel as tomotopyLDA,
+            LLDAModel as tomotopyLLDA,
+            CTModel as tomotopyCT,
+            DMRModel as tomotopyDMR,
+            HDPModel as tomotopyHDP,
+            PTModel as tomotopyPT,
+            SLDAModel as tomotopySLDA,
+            GDMRModel as tomotopyGDMR,
+        )
+    except (ImportError, OSError):
+        tomotopy_installed = None
 
 gensim_installed = find_spec("gensim")
 if gensim_installed:
-    from gensim.models.ldamodel import LdaModel as gensimLDA
-    from gensim.models.ldamulticore import LdaMulticore as gensimLDAMC
+    try:
+        from gensim.models.ldamodel import LdaModel as gensimLDA
+        from gensim.models.ldamulticore import LdaMulticore as gensimLDAMC
+    except (ImportError, OSError):
+        gensim_installed = None
 
 bitermplus_installed = find_spec("bitermplus")
 if bitermplus_installed:
-    from bitermplus._btm import BTM
-
-
-def __warn_package_installation(package_name: str):
-    warn(
-        f'Please install "{package_name}" package to analyze its models.\n'
-        f"Run `pip install {package_name}` in the console."
-    )
+    try:
+        from bitermplus._btm import BTM
+    except (ImportError, OSError):
+        bitermplus_installed = None
+
+
+def _warn_missing_model_packages() -> None:
+    missing = [
+        name
+        for name, installed in (
+            ("tomotopy", tomotopy_installed),
+            ("gensim", gensim_installed),
+            ("bitermplus", bitermplus_installed),
+        )
+        if not installed
+    ]
+    if missing:
+        packages = ", ".join(missing)
+        warn(
+            f"Optional model adapter packages are not installed: {packages}. "
+            f"Install the required adapter to analyze its models.",
+            UserWarning,
+            stacklevel=2,
+        )
 
 
 def get_phi(model: object, vocabulary: Optional[Sequence] = None) -> DataFrame:
@@ -81,7 +103,9 @@ def get_phi(model: object, vocabulary: Optional[Sequence] = None) -> DataFrame:
 
     elif _is_gensim(model):
         phi = DataFrame(model.get_topics().T)
-        if vocabulary:
+        if vocabulary is not None:
+            if len(vocabulary) != phi.shape[0]:
+                raise ValueError("vocabulary length must match the number of words")
             phi.index = vocabulary
 
     elif _is_btmplus(model):
@@ -91,6 +115,9 @@ def get_phi(model: object, vocabulary: Optional[Sequence] = None) -> DataFrame:
         phi.index.name = "words"
         phi.columns.name = "topics"
 
+    if phi is None:
+        _warn_missing_model_packages()
+        raise ValueError(f"Unsupported model type: {type(model)}")
     return phi
 
 
@@ -108,7 +135,6 @@ def _is_tomotopy(model: object) -> bool:
         ]
         return any(map(partial(isinstance, model), tomotopy_models))
 
-    __warn_package_installation("tomotopy")
     return False
 
 
@@ -117,7 +143,6 @@ def _is_gensim(model: object) -> bool:
         gensim_models = [gensimLDA, gensimLDAMC]
         return any(map(partial(isinstance, model), gensim_models))
 
-    __warn_package_installation("gensim")
     return False
 
 
@@ -125,7 +150,6 @@ def _is_btmplus(model: object) -> bool:
     if bitermplus_installed:
         return isinstance(model, BTM)
 
-    __warn_package_installation("bitermplus")
     return False
 
 
@@ -159,15 +183,16 @@ def get_theta(model: object, corpus: Optional[List] = None) -> Optional[DataFram
         if len(corpus) == 0:
             raise ValueError("corpus cannot be empty")
         tdd = list(map(model.get_document_topics, corpus))
-        theta = DataFrame(zeros((len(tdd), model.num_topics)))
+        theta_values = zeros((len(tdd), model.num_topics))
         for doc_id, doc_topic in enumerate(tdd):
             for topic_id, topic_prob in doc_topic:
-                theta.loc[doc_id, topic_id] = topic_prob
-        theta = theta.T
+                theta_values[doc_id, topic_id] = topic_prob
+        theta = DataFrame(theta_values.T)
 
     elif _is_btmplus(model):
         theta = DataFrame(model.matrix_topics_docs_)
     else:
+        _warn_missing_model_packages()
         raise ValueError(f"Unsupported model type: {type(model)}")
 
     if isinstance(theta, DataFrame):
@@ -236,12 +261,22 @@ def get_top_docs(
     if all([model is None, theta is None]):
         raise ValueError("Please pass a model or a theta matrix to function")
 
-    if model and theta is not None:
+    if theta is None:
         theta = get_theta(model, corpus=corpus).values
 
+    theta = array(theta)
+    if theta.ndim != 2:
+        raise ValueError("theta must be a 2D topics x documents matrix")
+    if len(docs) != theta.shape[1]:
+        raise ValueError("docs length must match theta documents dimension")
+    if docs_num <= 0:
+        raise ValueError("docs_num must be positive")
+
     def _select_docs(docs, theta, topic_id: int):
         probs = theta[topic_id, :]
-        idx = argsort(probs)[: -docs_num - 1 : -1]
+        count = min(docs_num, probs.size)
+        idx = np.argpartition(probs, -count)[-count:]
+        idx = idx[np.argsort(probs[idx])[::-1]]
         result = Series(list(map(lambda x: docs[x], idx)))
         result.name = f"topic{topic_id}"
         return result
@@ -271,10 +306,14 @@ def calc_topics_marg_probs(
     theta_arr = array(theta)
     if theta_arr.size == 0:
         raise ValueError("theta matrix cannot be empty")
+    if theta_arr.ndim != 2:
+        raise ValueError("theta matrix must be a 2D array")
+    if not np.isfinite(theta_arr).all() or np.any(theta_arr < 0):
+        raise ValueError("theta matrix must contain finite non-negative values")
 
     p_t = theta_arr.sum(axis=1)
     total_sum = p_t.sum()
-    if total_sum == 0:
+    if total_sum <= 0:
         raise ValueError("theta matrix contains all zeros - cannot normalize")
 
     p_t /= total_sum
@@ -311,12 +350,25 @@ def calc_terms_marg_probs(
 
     if phi_arr.size == 0:
         raise ValueError("phi matrix cannot be empty")
+    if phi_arr.ndim != 2:
+        raise ValueError("phi matrix must be a 2D array")
     if p_t_arr.size == 0:
         raise ValueError("p_t array cannot be empty")
+    if p_t_arr.ndim != 1:
+        raise ValueError("p_t array must be a 1D array")
+    if not np.isfinite(phi_arr).all() or np.any(phi_arr < 0):
+        raise ValueError("phi matrix must contain finite non-negative values")
+    if not np.isfinite(p_t_arr).all() or np.any(p_t_arr < 0):
+        raise ValueError("p_t must contain finite non-negative values")
     if phi_arr.shape[1] != p_t_arr.shape[0]:
-        raise ValueError(f"phi topics dimension {phi_arr.shape[1]} must match p_t length {p_t_arr.shape[0]}")
+        raise ValueError(
+            f"phi topics dimension {phi_arr.shape[1]} must match p_t length {p_t_arr.shape[0]}"
+        )
 
-    p_w = (phi_arr * p_t_arr).sum(axis=1)
+    p_t_sum = p_t_arr.sum()
+    if p_t_sum <= 0:
+        raise ValueError("p_t must have positive total probability")
+    p_w = (phi_arr * (p_t_arr / p_t_sum)).sum(axis=1)
     if word_id is not None:
         if word_id < 0 or word_id >= len(p_w):
             raise IndexError(f"word_id {word_id} out of bounds for {len(p_w)} words")
@@ -343,33 +395,34 @@ def get_salient_terms(phi: ndarray, theta: ndarray) -> ndarray:
     numpy.ndarray
         Terms saliency values.
     """
+    phi = array(phi, dtype=float)
+    theta = array(theta, dtype=float)
     if phi.size == 0 or theta.size == 0:
         raise ValueError("phi and theta matrices cannot be empty")
     if phi.shape[1] != theta.shape[0]:
-        raise ValueError(f"phi topics dimension {phi.shape[1]} must match theta topics dimension {theta.shape[0]}")
+        raise ValueError(
+            f"phi topics dimension {phi.shape[1]} must match theta topics dimension {theta.shape[0]}"
+        )
 
     p_t = calc_topics_marg_probs(theta)
     p_w = calc_terms_marg_probs(phi, p_t)
 
-    def _p_tw(phi, w, t):
-        if p_w[w] == 0:
-            return 0  # Avoid division by zero
-        return array(phi)[w, t] * p_t[t] / p_w[w]
-
-    saliency = array(
-        [
-            p_w[w]
-            * sum(
-                (
-                    _p_tw(phi, w, t) * log(_p_tw(phi, w, t) / p_t[t])
-                    if _p_tw(phi, w, t) > 0 and p_t[t] > 0
-                    else 0  # Handle log(0) cases
-                    for t in range(phi.shape[1])
-                )
-            )
-            for w in range(phi.shape[0])
-        ]
+    p_tw = np.divide(
+        phi * p_t,
+        p_w[:, None],
+        out=np.zeros_like(phi, dtype=float),
+        where=p_w[:, None] > 0,
+    )
+    ratio = np.divide(
+        p_tw,
+        p_t,
+        out=np.ones_like(p_tw),
+        where=p_t > 0,
     )
+    contributions = np.zeros_like(p_tw)
+    positive = p_tw > 0
+    contributions[positive] = p_tw[positive] * np.log(ratio[positive])
+    saliency = p_w * contributions.sum(axis=1)
     # saliency(term w) = frequency(w)
     # * [sum_t p(t | w) * log(p(t | w)/p(t))] for topics t
     # p(t | w) = p(w | t) * p(t) / p(w)
@@ -377,7 +430,11 @@ def get_salient_terms(phi: ndarray, theta: ndarray) -> ndarray:
 
 
 def calc_terms_probs_ratio(
-    phi: DataFrame, topic: int, terms_num: int = 30, lambda_: float = 0.6
+    phi: DataFrame,
+    topic: int,
+    terms_num: int = 30,
+    lambda_: float = 0.6,
+    p_t: Optional[ndarray] = None,
 ) -> DataFrame:
     """Get terms conditional and marginal probabilities.
 
@@ -406,6 +463,8 @@ def calc_terms_probs_ratio(
     pandas.DataFrame
         Words conditional and marginal probabilities.
     """
+    if not 0 <= lambda_ <= 1:
+        raise ValueError("lambda_ must be between 0 and 1")
     p_cond_name = "Conditional term probability, p(w | t)"
     p_cond = (
         phi.iloc[:, topic].rename(p_cond_name)
@@ -414,29 +473,31 @@ def calc_terms_probs_ratio(
     )
 
     p_marg_name = "Marginal term probability, p(w)"
-    p_marg = (
-        phi.sum(axis=1).rename(p_marg_name)
-        if isinstance(phi, DataFrame)
-        else Series(phi[:, topic], name=p_marg_name)
-    )
+    topic_probs = np.full(phi.shape[1], 1 / phi.shape[1]) if p_t is None else array(p_t)
+    marginal = calc_terms_marg_probs(phi, topic_probs)
+    index = phi.index if isinstance(phi, DataFrame) else None
+    p_marg = Series(marginal, index=index, name=p_marg_name)
 
     terms_probs = concat((p_marg, p_cond), axis=1)
-    relevant_idx = get_relevant_terms(phi, topic, lambda_).index
+    relevant_idx = get_relevant_terms(phi, topic, lambda_, p_t=p_t).index
     terms_probs_slice = terms_probs.loc[relevant_idx].head(terms_num)
 
     return (
-        terms_probs_slice.reset_index(drop=False)
+        terms_probs_slice.rename_axis("Terms")
+        .reset_index(drop=False)
         .melt(
-            id_vars=[terms_probs_slice.index.name],
+            id_vars=["Terms"],
             var_name="Type",
             value_name="Probability",
         )
-        .rename(columns={terms_probs_slice.index.name: "Terms"})
     )
 
 
 def get_relevant_terms(
-    phi: Union[ndarray, DataFrame], topic: int, lambda_: float = 0.6
+    phi: Union[ndarray, DataFrame],
+    topic: int,
+    lambda_: float = 0.6,
+    p_t: Optional[ndarray] = None,
 ) -> Series:
     """Select relevant terms.
 
@@ -463,10 +524,30 @@ def get_relevant_terms(
     pandas.Series
         Terms sorted by relevance (descendingly).
     """
-    phi_topic = phi.iloc[:, topic] if isinstance(phi, DataFrame) else phi[:, topic]
+    if not 0 <= lambda_ <= 1:
+        raise ValueError("lambda_ must be between 0 and 1")
+    phi_arr = array(phi, dtype=float)
+    if phi_arr.ndim != 2:
+        raise ValueError("phi must be a 2D words x topics matrix")
+    if not 0 <= topic < phi_arr.shape[1]:
+        raise IndexError("topic is out of bounds")
+    topic_probs = (
+        np.full(phi_arr.shape[1], 1 / phi_arr.shape[1])
+        if p_t is None
+        else array(p_t, dtype=float)
+    )
+    if topic_probs.ndim != 1 or topic_probs.shape[0] != phi_arr.shape[1]:
+        raise ValueError("p_t length must match the number of topics")
+    p_marg = calc_terms_marg_probs(phi_arr, topic_probs)
+    phi_topic = phi_arr[:, topic]
 
     # relevance = lambda * log(p(w | t)) + (1 - lambda) * log(p(w | t) / p(w))
-    relevance = lambda_ * nplog(phi_topic) + (1 - lambda_) * nplog(
-        phi_topic / phi.sum(axis=1)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        relevance = lambda_ * nplog(phi_topic) + (1 - lambda_) * nplog(
+            np.divide(phi_topic, p_marg, out=np.zeros_like(phi_topic), where=p_marg > 0)
+        )
+    relevance = Series(
+        relevance,
+        index=phi.index if isinstance(phi, DataFrame) else None,
     )
     return relevance.sort_values(ascending=False)

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/_metrics.py

@@ -1,7 +1,9 @@
 """Metrics module"""
+
 from math import log
 import numpy as np
-__all__ = ['entropy']
+
+__all__ = ["entropy"]
 
 
 def entropy(phi: np.ndarray, max_probs: bool = False):
@@ -40,6 +42,12 @@ def entropy(phi: np.ndarray, max_probs: bool = False):
     >>> # Entropy calculation
     >>> entropy = tmp.entropy(phi)
     """
+    phi = np.asarray(phi, dtype=float)
+    if phi.ndim != 2 or 0 in phi.shape:
+        raise ValueError("phi must be a non-empty 2D topics x words matrix")
+    if not np.isfinite(phi).all() or np.any(phi < 0):
+        raise ValueError("phi must contain finite non-negative probabilities")
+
     # Terms number
     words_num = phi.shape[1]
     # Topics number
@@ -53,14 +61,18 @@ def entropy(phi: np.ndarray, max_probs: bool = False):
         p_max = np.max(phi, axis=0)
 
         # Select the probabilities larger than thresh
-        p_max_mask = p_max > thresh
+        p_max_mask = p_max >= thresh
         word_ratio = p_max_mask.sum()
         sum_prob = p_max[p_max_mask].sum()
 
     else:
         # Select the probabilities larger than thresh
-        sum_prob = np.nansum(phi[phi > thresh])
-        word_ratio = np.count_nonzero(phi > thresh)
+        mask = phi >= thresh
+        sum_prob = phi[mask].sum()
+        word_ratio = np.count_nonzero(mask)
+
+    if word_ratio == 0 or sum_prob <= 0:
+        raise ValueError("phi does not contain probabilities at or above the threshold")
 
     # Shannon entropy
     shannon = log(word_ratio / (words_num * topics_num))
@@ -75,6 +87,6 @@ def entropy(phi: np.ndarray, max_probs: bool = False):
     if topics_num == 1:
         renyi = free_energy / topics_num
     else:
-        renyi = free_energy / (topics_num-1)
+        renyi = free_energy / (topics_num - 1)
 
     return renyi

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/_report.py

@@ -1,5 +1,4 @@
 __all__ = ["prepare_coords", "report"]
-import warnings
 from typing import Dict, Optional, Sequence, List
 from copy import deepcopy
 from IPython.display import display
@@ -7,10 +6,13 @@ from ipywidgets import widgets as wdg
 from pandas import DataFrame
 from ._distance import get_topics_dist, get_topics_scatter
 from ._vis import plot_scatter_topics, plot_terms, plot_docs
-from ._helpers import calc_terms_probs_ratio, get_phi, get_theta, get_top_docs
-
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
+from ._helpers import (
+    calc_terms_probs_ratio,
+    calc_topics_marg_probs,
+    get_phi,
+    get_theta,
+    get_top_docs,
+)
 
 
 def prepare_coords(
@@ -44,7 +46,10 @@ def prepare_coords(
     theta = get_theta(model, corpus=corpus)
     topics_dists = get_topics_dist(phi, **dist_kws)
     topics_coords = get_topics_scatter(topics_dists, theta, **scatter_kws)
-    topics_coords["label"] = labels or theta.index
+    selected_labels = theta.index if labels is None else labels
+    if len(selected_labels) != len(topics_coords):
+        raise ValueError("labels length must match the number of topics")
+    topics_coords["label"] = selected_labels
     return topics_coords
 
 
@@ -114,7 +119,9 @@ def report(
         if not topics_kws
         else deepcopy(topics_kws)
     )
-    _coords_kws = {"corpus": corpus} if not coords_kws else deepcopy(coords_kws)
+    _coords_kws = {"corpus": corpus}
+    if coords_kws:
+        _coords_kws.update(deepcopy(coords_kws))
     _words_kws = (
         {"chart_kws": {"height": height, "width": width}}
         if not words_kws
@@ -154,7 +161,7 @@ def report(
     # Children widgets list init
     children = []
 
-    if "topics_coords" not in _topics_kws:
+    if show_topics and "topics_coords" not in _topics_kws:
         topics_coords = prepare_coords(model, **_coords_kws)
         _topics_kws.update(
             {
@@ -165,51 +172,60 @@ def report(
             }
         )
 
-    # Cache phi matrix to avoid repeated calls
     phi = get_phi(model)
+    theta = None
+    p_t = None
 
-    if "terms_probs" not in _words_kws:
-        terms_probs = calc_terms_probs_ratio(phi, topic=0)
-        _words_kws.update({"terms_probs": terms_probs})
+    if show_words:
+        theta = get_theta(model, corpus=corpus)
+        p_t = calc_topics_marg_probs(theta)
+        if "terms_probs" not in _words_kws:
+            terms_probs = calc_terms_probs_ratio(phi, topic=0, p_t=p_t)
+            _words_kws.update({"terms_probs": terms_probs})
 
-    if "docs" not in _docs_kws:
-        theta = get_theta(model, corpus=corpus).values
-        _top_docs_kws.update(
-            {"docs": docs, "theta": theta, "topics": [0], "docs_num": 2}
-        )
-        top_docs = get_top_docs(**_top_docs_kws)
-        top_docs.columns = [""]
-        _docs_kws.update({"docs": top_docs})
+    if show_docs:
+        theta = get_theta(model, corpus=corpus) if theta is None else theta
+        _top_docs_kws.setdefault("docs", docs)
+        _top_docs_kws.setdefault("theta", theta.values)
+        _top_docs_kws.setdefault("topics", [0])
+        _top_docs_kws.setdefault("docs_num", 2)
+        if "docs" not in _docs_kws:
+            top_docs = get_top_docs(**_top_docs_kws)
+            top_docs.columns = [""]
+            _docs_kws.update({"docs": top_docs})
 
     # Topic selection
     def _on_select_topic(sel):
-        topic = sel['new']
+        topic = sel["new"]
 
         if show_words:
             words_plot_output.clear_output(wait=False)
             with words_plot_output:
                 terms_probs = calc_terms_probs_ratio(
-                    phi, topic=topic, lambda_=lambda_slider.value)
-                _words_kws.update({'terms_probs': terms_probs})
+                    phi, topic=topic, lambda_=lambda_slider.value, p_t=p_t
+                )
+                _words_kws.update({"terms_probs": terms_probs})
                 display(plot_terms(**_words_kws))
 
         if show_topics:
             topics_plot_output.clear_output(wait=False)
             with topics_plot_output:
-                _topics_kws.update({'topic': topic})
+                _topics_kws.update({"topic": topic})
                 display(plot_scatter_topics(**_topics_kws))
 
         if show_docs:
             docs_plot_output.clear_output(wait=False)
             with docs_plot_output:
-                _top_docs_kws.update({'topics': [sel['new']]})
+                _top_docs_kws.update({"topics": [sel["new"]]})
                 top_docs = get_top_docs(**_top_docs_kws)
-                top_docs.columns = ['']
-                _docs_kws.update({'docs': top_docs})
+                top_docs.columns = [""]
+                _docs_kws.update({"docs": top_docs})
                 display(plot_docs(**_docs_kws))
 
-    topics_ids = list(range(len(_topics_kws["topics_coords"])))
-    topics_labels = topics_labels or topics_ids
+    topics_ids = list(range(phi.shape[1]))
+    if topics_labels is not None and len(topics_labels) != len(topics_ids):
+        raise ValueError("topics_labels length must match the number of topics")
+    topics_labels = topics_ids if topics_labels is None else topics_labels
     select_topic = wdg.Dropdown(options=list(zip(topics_labels, topics_ids)), value=0)
     select_topic.observe(_on_select_topic, names="value")
     select_topic_header = wdg.HTML("<b>Select a topic</b>:")
@@ -219,11 +235,24 @@ def report(
     )
 
     # Topics scatter
+    scatter_cache = {}
+
     def _on_select_topics_method(names):
         topics_plot_output.clear_output(wait=False)
         with topics_plot_output:
-            _coords_kws.update({"scatter_kws": {"method": names["new"]}})
-            topics_coords = prepare_coords(model, **_coords_kws)
+            if not scatter_cache:
+                scatter_theta = get_theta(model, corpus=_coords_kws.get("corpus"))
+                scatter_cache["theta"] = scatter_theta
+                scatter_cache["distances"] = get_topics_dist(
+                    phi, **_coords_kws.get("dist_kws", {})
+                )
+            scatter_kws = dict(_coords_kws.get("scatter_kws", {}))
+            scatter_kws["method"] = names["new"]
+            topics_coords = get_topics_scatter(
+                scatter_cache["distances"], scatter_cache["theta"], **scatter_kws
+            )
+            labels = _coords_kws.get("labels", scatter_cache["theta"].index)
+            topics_coords["label"] = labels
             _topics_kws.update(
                 {"topics_coords": topics_coords, "topic": select_topic.value}
             )
@@ -243,7 +272,7 @@ def report(
         topics_method = wdg.Dropdown(
             options=options_methods,
             value="tsne",
-            layout=wdg.Layout(width=f"{width/1.25}px"),
+            layout=wdg.Layout(width=f"{width / 1.25}px"),
         )
         topics_method_widget = wdg.HBox([topics_method_header, topics_method])
         topics_method.observe(_on_select_topics_method, names="value")
@@ -262,7 +291,9 @@ def report(
             lambda_ = lambda_slider.value
             words_plot_output.clear_output(wait=False)
             with words_plot_output:
-                terms_probs = calc_terms_probs_ratio(phi, topic=topic, lambda_=lambda_)
+                terms_probs = calc_terms_probs_ratio(
+                    phi, topic=topic, lambda_=lambda_, p_t=p_t
+                )
                 _words_kws.update({"terms_probs": terms_probs})
                 display(plot_terms(**_words_kws))
 
@@ -276,7 +307,7 @@ def report(
             orientation="horizontal",
             readout=True,
             readout_format=".2f",
-            layout=wdg.Layout(width=f"{width/1.25}px"),
+            layout=wdg.Layout(width=f"{width / 1.25}px"),
         )
         lambda_slider.observe(_on_select_lambda, names="value")
         lambda_slider_header = wdg.HTML("Lambda value:")
@@ -307,14 +338,14 @@ def report(
                 display(plot_docs(**_docs_kws))
 
         docs_num_slider = wdg.IntSlider(
-            value=2,
+            value=_top_docs_kws["docs_num"],
             min=1,
             max=100,
             continuous_update=False,
             orientation="horizontal",
             readout=True,
             readout_format="d",
-            layout=wdg.Layout(width=f"{width/1.25}px"),
+            layout=wdg.Layout(width=f"{width / 1.25}px"),
         )
         docs_num_slider.observe(_on_select_docs_num, names="value")
         docs_num_slider_header = wdg.HTML("Documents number:")

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/_stability.py

@@ -91,8 +91,11 @@ def get_closest_topics(
     closest_topics = np.zeros(shape=(topics_num, models_num), dtype=int)
     closest_topics[:, ref] = np.arange(topics_num)
 
-    # Distance function selection
-    dist_func = dist_funcs.get(method, "sklb")
+    if method not in dist_funcs:
+        raise ValueError(
+            f"Unknown distance method {method!r}; choose from {sorted(dist_funcs)}"
+        )
+    dist_func = dist_funcs[method]
 
     # Distance values
     dist_vals = np.zeros(shape=(topics_num, models_num), dtype=float)
@@ -109,23 +112,33 @@ def get_closest_topics(
         # Get phi matrix for current model
         current_phi = get_phi(model)
 
+        shared_words = model_ref_phi.index.intersection(current_phi.index)
+        if shared_words.empty:
+            raise ValueError("models do not have any vocabulary terms in common")
+        ref_phi = model_ref_phi.loc[shared_words]
+        current_phi = current_phi.loc[shared_words]
+        ref_sums = ref_phi.sum(axis=0)
+        current_sums = current_phi.sum(axis=0)
+        if (ref_sums <= 0).any() or (current_sums <= 0).any():
+            raise ValueError("shared vocabulary has zero probability mass for a topic")
+        ref_phi = ref_phi / ref_sums
+        current_phi = current_phi / current_sums
+        current_topics_num = current_phi.shape[1]
+
         # Distance matrix for all topic pairs
-        all_vs_all_dists = np.zeros((topics_num, topics_num))
+        all_vs_all_dists = np.zeros((topics_num, current_topics_num))
 
         # Iterating over all topic pairs
         for t_ref in range(topics_num):
-            for t in range(topics_num):
+            for t in range(current_topics_num):
+                kwargs = {"top_words": top_words} if method == "jac" else {}
                 all_vs_all_dists[t_ref, t] = dist_func(
-                    model_ref_phi.iloc[:, t_ref], current_phi.iloc[:, t]
+                    ref_phi.iloc[:, t_ref], current_phi.iloc[:, t], **kwargs
                 )
 
         # Creating two arrays for the closest topics ids and distance values
-        if method == "jac":
-            closest_topics[:, mid] = np.argmax(all_vs_all_dists, axis=1)
-            dist_vals[:, mid] = np.max(all_vs_all_dists, axis=1)
-        else:
-            closest_topics[:, mid] = np.argmin(all_vs_all_dists, axis=1)
-            dist_vals[:, mid] = np.min(all_vs_all_dists, axis=1)
+        closest_topics[:, mid] = np.argmin(all_vs_all_dists, axis=1)
+        dist_vals[:, mid] = np.min(all_vs_all_dists, axis=1)
 
     return closest_topics, dist_vals
 
@@ -190,7 +203,8 @@ def get_stable_topics(
     ...     closest_topics, kldiv)
     """
     dist_arr = np.asarray(dist)
-    dist_ready = dist_arr / dist_arr.max() if norm else dist_arr.copy()
+    max_dist = dist_arr.max()
+    dist_ready = dist_arr / max_dist if norm and max_dist > 0 else dist_arr.copy()
     dist_ready = inverse_factor - dist_ready if inverse else dist_ready
     mask = np.sum(np.delete(dist_ready, ref, axis=1) >= thres, axis=1) >= thres_models
     return closest_topics[mask], dist_ready[mask]

{tmplot-0.3.0 → tmplot-0.4.0}/src/tmplot/_vis.py

@@ -109,15 +109,6 @@ def plot_scatter_topics(
             "scale": Scale(range=[0, 3000]),
         }
 
-    if not circle_enc_kws:
-        circle_enc_kws = {
-            "x": X(**x_kws),
-            "y": Y(**y_kws),
-            "size": Size(size_col, **size_kws)
-            if size_col and not topics_coords[size_col].isna().any()
-            else value(500),
-        }
-
     if not text_kws:
         text_kws = {"align": "center", "baseline": "middle"}
 
@@ -138,6 +129,20 @@ def plot_scatter_topics(
             raise ValueError("topics_coords DataFrame cannot be empty")
         data = topics_coords.copy()
 
+    if size_col and size_col not in data:
+        raise ValueError(f"size column {size_col!r} is missing")
+    if label_col and label_col not in data:
+        raise ValueError(f"label column {label_col!r} is missing")
+
+    if not circle_enc_kws:
+        circle_enc_kws = {
+            "x": X(**x_kws),
+            "y": Y(**y_kws),
+            "size": Size(size_col, **size_kws)
+            if size_col and not data[size_col].isna().any()
+            else value(500),
+        }
+
     if not topic_col:
         topic_col = "topic"
         data = data.assign(**{topic_col: range(len(topics_coords))})

{tmplot-0.3.0 → tmplot-0.4.0/src/tmplot.egg-info}/PKG-INFO

@@ -1,56 +1,35 @@
 Metadata-Version: 2.4
 Name: tmplot
-Version: 0.3.0
+Version: 0.4.0
 Summary: Visualization of Topic Modeling Results
 Author-email: Maksim Terpilovskii <maximtrp@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2021 Maksim Terpilowski
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: homepage, https://github.com/maximtrp/tmplot
 Project-URL: documentation, https://tmplot.readthedocs.io/
 Keywords: data science,data analytics
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Text Processing :: General
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: seaborn
-Requires-Dist: pandas
-Requires-Dist: scikit-learn
-Requires-Dist: scipy
-Requires-Dist: altair
-Requires-Dist: ipywidgets
-Requires-Dist: tqdm
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scikit-learn>=1.4
+Requires-Dist: scipy>=1.9
+Requires-Dist: altair>=5
+Requires-Dist: ipywidgets>=8
+Requires-Dist: IPython>=8
+Requires-Dist: tqdm>=4.64
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: coverage; extra == "test"
+Requires-Dist: build; extra == "test"
+Requires-Dist: twine; extra == "test"
 Provides-Extra: models
 Requires-Dist: tomotopy>=0.8.0; extra == "models"
 Requires-Dist: gensim; extra == "models"
@@ -170,7 +149,7 @@ saliency = tmp.get_salient_terms(phi, theta)
 
 ```python
 # Create topic distance matrix with different metrics
-topic_dists = tmp.get_topics_dist(phi, method='jensen-shannon')
+topic_dists = tmp.get_topics_dist(phi, method='jsd')
 
 # Generate coordinates with custom algorithm
 coords = tmp.get_topics_scatter(topic_dists, theta, method='tsne')
@@ -181,7 +160,7 @@ tmp.plot_scatter_topics(coords, topic=3)  # Highlight topic 3
 
 - [Complete Tutorial](https://tmplot.readthedocs.io/en/latest/tutorial.html) - Step-by-step guide
 - [API Reference](https://tmplot.readthedocs.io/) - Full documentation
-- [Example Notebooks](https://github.com/maximtrp/tmplot/tree/main/examples) - Jupyter examples
+- [Tutorial Notebook](docs/source/tutorial.ipynb) - Jupyter walkthrough
 
 ## Requirements
 

tmplot-0.4.0/src/tmplot.egg-info/requires.txt

@@ -0,0 +1,19 @@
+numpy>=1.23
+pandas>=1.5
+scikit-learn>=1.4
+scipy>=1.9
+altair>=5
+ipywidgets>=8
+IPython>=8
+tqdm>=4.64
+
+[models]
+tomotopy>=0.8.0
+gensim
+bitermplus
+
+[test]
+pytest
+coverage
+build
+twine

tmplot-0.3.0/src/tmplot.egg-info/requires.txt

@@ -1,17 +0,0 @@
-numpy
-seaborn
-pandas
-scikit-learn
-scipy
-altair
-ipywidgets
-tqdm
-
-[models]
-tomotopy>=0.8.0
-gensim
-bitermplus
-
-[test]
-pytest
-coverage