DaSPi 2.1.0__tar.gz → 2.2.0__tar.gz

{daspi-2.1.0 → daspi-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DaSPi
-Version: 2.1.0
+Version: 2.2.0
 Summary: Visualize and analyze your data with DaSPi. This package is designed for users who want to find relevant influencing factors in processes and validate improvements.
 Author-Email: =?utf-8?q?Reto_J=C3=A4ggli?= <reto@jaeggli.email>
 License: MIT

{daspi-2.1.0 → daspi-2.2.0}/daspi/anova/model.py

@@ -76,7 +76,8 @@ import itertools
 import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Generator
-from typing import Any, Literal, LiteralString, Self
+from functools import lru_cache
+from typing import Any, Literal, LiteralString, Self, overload
 
 import numpy as np
 import pandas as pd
@@ -110,19 +111,61 @@ __all__ = [
     'GageStudyModel',
     'GeneralizedLinearModel',
     'LinearModel',
-    'get_order',
     'hierarchical',
-    'is_main_parameter',]
+    'interaction_order',
+    'is_main_parameter',
+]
 
 
+@overload
+def _drop_intercept(data: DataFrame) -> DataFrame: ...
+@overload
+def _drop_intercept(data: Series) -> Series: ...
+def _drop_intercept(data: DataFrame | Series) -> DataFrame | Series:
+    """Drop the intercept index from a DataFrame or Series if it exists.
+
+    Parameters
+    ----------
+    data : DataFrame or Series
+        The input data from which to drop the intercept.
+
+    Returns
+    -------
+    DataFrame or Series
+        The input data with the intercept dropped, if it was present.
+    """
+    mask = ~data.index.str.contains(ANOVA.INTERCEPT, regex=False)
+    if isinstance(data, Series):
+        data = data[mask]
+    else:
+        data = data.loc[mask, :]
+    return data.copy()
+
 def is_main_parameter(parameter: str) -> bool:
     """Check if given parameter is a main parameter (intercept is 
     excluded)."""
     return parameter != ANOVA.INTERCEPT and ANOVA.SEP not in parameter
 
-def get_order(parameter: str) -> int:
+def interaction_order(parameter: str) -> int:
     """Get the order of a parameter (i.e., how many interactions it
-    contains)."""
+    contains).
+    
+    Parameters
+    ----------
+    parameter : str
+        The parameter name to check.
+        
+    Returns
+    -------
+    int
+        The interaction order of the parameter.
+        
+    Examples
+    --------
+    ```python
+    interaction_order('x1')  # Returns 1
+    interaction_order('x1:x2')  # Returns 2
+    ```"""
     return parameter.count(ANOVA.SEP) + 1
 
 def hierarchical(parameters: list[str]) -> list[str]:
@@ -139,21 +182,28 @@ def hierarchical(parameters: list[str]) -> list[str]:
     -------
     h_parameters : list of str
         Sorted factors for hierarchical model"""
-
+    return list(_hierarchical_cached(tuple(parameters)))
+
+@lru_cache(maxsize=128)
+def _hierarchical_cached(parameters: tuple[str, ...]) -> tuple[str, ...]:
+    """Cached implementation of `hierarchical`. Repeated calls with the
+    same (unchanged) set of terms, e.g. from `is_hierarchical` during a
+    single fit, are then resolved without recomputing all interaction
+    subsets."""
     h_parameters = set(parameters)
     for parameter in parameters:
         split = parameter.split(ANOVA.SEP)
-        n_splits = len(split)
-        for s in split:
-            h_parameters.add(s)
-        if n_splits <= ANOVA.SMALLEST_INTERACTION:
+        _order = len(split)
+        h_parameters.update(split)
+        if _order <= ANOVA.SMALLEST_INTERACTION_ORDER:
             continue
 
-        for i in range(ANOVA.SMALLEST_INTERACTION, n_splits):
-            for combo in map(ANOVA.SEP.join, itertools.combinations(split, i)):
-                h_parameters.add(combo)
+        h_parameters.update(
+            ANOVA.SEP.join(combo)
+            for i in range(ANOVA.SMALLEST_INTERACTION_ORDER, _order)
+            for combo in itertools.combinations(split, i))
 
-    return sorted(sorted(h_parameters), key=get_order)
+    return tuple(sorted(h_parameters, key=lambda p: (interaction_order(p), p)))
 
 
 class BaseHTMLReprModel(ABC):
@@ -671,21 +721,55 @@ class LinearModel(BaseHTMLReprModel):
         """Check if current fitted model is hierarchical."""
         return all(term in self.terms for term in hierarchical(self.terms))
     
-    def effects(self) -> Series:
+    def effects(self, include_intercept: bool = True) -> Series:
         """Calculates the impact of each term on the target. The
         effects are described as absolute number of the parameter 
-        coefficients devided by its standard error."""
+        coefficients devided by its standard error.
+        
+        Parameters
+        ----------
+        include_intercept : bool, optional
+            If False, the intercept is dropped from the returned
+            Series, by default True.
+
+        Returns
+        -------
+        Series
+            A Pandas Series containing the effects of each term on the 
+            target variable. The index of the Series corresponds to the 
+            term names, and the values represent the calculated effects.
+        """
         if self._effects.empty:
             self._effects = terms_effect(self.model)
         effects = self._effects.copy().rename(index=self.term_map)
+        if not include_intercept:
+            effects = _drop_intercept(effects)
         return effects
 
-    def p_values(self) -> 'Series[float]':
+    def p_values(self, include_intercept: bool = True) -> 'Series[float]':
         """Get P-value for significance of adding model terms using 
-        anova typ III table for current model."""
+        anova typ III table for current model.
+        
+        Parameters
+        ----------
+        include_intercept : bool, optional
+            If False, the intercept is dropped from the returned
+            Series, by default True.
+        
+        Returns
+        -------
+        Series
+            A Pandas Series containing the p-values of each term on the 
+            target variable. The index of the Series corresponds to the 
+            term names, and the values represent the calculated 
+            p-values.
+        """
         if self._p_values.empty:
             self._p_values = terms_probability(self.model)
-        return self._p_values.copy().rename(index=self.term_map)
+        p_values = self._p_values.copy().rename(index=self.term_map)
+        if not include_intercept:
+            p_values = _drop_intercept(p_values)
+        return p_values
 
     def least_parameter(self) -> str:
         """Get the parameter name with the least effect or the least 
@@ -706,20 +790,15 @@ class LinearModel(BaseHTMLReprModel):
         the term name with the least p-value for the F-stats coming from
         current ANOVA table.
         """
-        p_values = self.p_values().copy()
-        has_intercept = ANOVA.INTERCEPT in p_values.index
+        include_intercept = not self.skip_intercept_as_least
+        p_values = self.p_values(include_intercept)
         if any(p_values.isna()):
-            effects = self.effects().copy()
-            if has_intercept and self.skip_intercept_as_least:
-                effects = effects.drop(ANOVA.INTERCEPT)
-            if any(effects.isna()):
-                leasts = effects[effects.isna()]
-            else:
-                leasts = effects[effects == effects.min()]
-            least = max(leasts.index, key=get_order)
+            effects = self.effects(include_intercept).copy()
+            effect_mask = effects.isna()
+            if not any(effect_mask):
+                effect_mask = effects == effects.min()
+            least = max(effects[effect_mask].index, key=interaction_order )
         else:
-            if has_intercept and self.skip_intercept_as_least:
-                p_values = p_values.drop(ANOVA.INTERCEPT)
             least = p_values.iloc[::-1].idxmax()
         return str(least)
     
@@ -945,7 +1024,8 @@ class LinearModel(BaseHTMLReprModel):
             get_term_name(self.feature_map.get(x, x))
             for x in parameter.split(ANOVA.SEP))
         assert term in self.terms, (
-            f'Given term {term} is not in model')
+            f'Given term {term} (or "{parameter}") is not in model, '
+            f'got: {self.terms}')
         
         self.excluded.add(term)
         return self
@@ -985,7 +1065,7 @@ class LinearModel(BaseHTMLReprModel):
                 UserWarning)
         self.excluded.discard(term)
         return self
-
+    
     def recursive_elimination(
             self,
             rsquared_max: float = 0.99,

{daspi-2.1.0 → daspi-2.2.0}/daspi/anova/tables.py

@@ -97,9 +97,23 @@ def terms_effect(model: RegressionResultsWrapper) -> Series:
     Series
         A pandas Series containing the effects of each factor
         on the target variable.
+
+    Notes
+    -----
+    The effect size is calculated as the absolute value of the parameter
+    coefficient divided by its standard error. This is a measure of the
+    strength of the relationship between the predictor and the target
+    variable, with larger values indicating a stronger effect.
+
+    The index of the returned Series corresponds to the factor names in
+    the model, and the values represent the calculated effect sizes. 
+
+    Only terms that are present in the model are included in the output,
+    which is determined by filtering the effects based on the unique 
+    factor names derived from the model's design information.
     """
     params: Series = model.params
-    se: Series = model.scale
+    terms = model.model.data.design_info.term_names
     names_map = {n: get_term_name(n) for n in params.index}
     se = (model.bse
         .rename(index=names_map)
@@ -112,7 +126,7 @@ def terms_effect(model: RegressionResultsWrapper) -> Series:
         .groupby(level=0)
         .sum())
     effects = params.abs() / se
-    effects = effects[uniques(names_map.values())]
+    effects = effects[uniques(n for n in names_map.values() if n in terms)] # Filter out terms that are not in the model (this can happen when the model is imbalanced and some terms are dropped)
     effects.name = ANOVA.EFFECTS
     effects.index.name = ANOVA.FACTORS
     return effects

{daspi-2.1.0 → daspi-2.2.0}/daspi/constants.py

@@ -549,7 +549,7 @@ class _Anova_:
     """"Default name for source used in ANOVA table."""
     VIF: Literal['VIF'] = 'VIF'
     """"Default column name for VIF values in ANOVA table."""
-    SMALLEST_INTERACTION: int = 2
+    SMALLEST_INTERACTION_ORDER: int = 2
     """Smallest possible interaction"""
     RESIDUAL: Literal['Residual'] = 'Residual'
     """Name in anova table for residual (not explained) values."""

{daspi-2.1.0 → daspi-2.2.0}/daspi/plotlib/plotter.py

@@ -2088,7 +2088,7 @@ class TransformPlotter(Plotter):
         self.skip_na = skip_na
         
         df =  pd.concat(
-            [self.transform(f, t) for f, t in self.feature_grouped(source)],
+            (self.transform(f, t) for f, t in self.feature_grouped(source)),
             axis=0,
             ignore_index=True)
 
@@ -2120,24 +2120,29 @@ class TransformPlotter(Plotter):
         target_data : pandas Series
             feature grouped target data used for transformation.
         """
+        feature_data = self._f_base
         if self.feature and self.feature != PLOTTER.TRANSFORMED_FEATURE:
-            for i, (f_value, group) in enumerate(
-                    source.groupby(self.feature, sort=True, observed=True),
-                    start=DEFAULT.FEATURE_BASE):
+            use_feature_value = any((
+                pd.api.types.is_numeric_dtype(source[self.feature]),
+                pd.api.types.is_datetime64_dtype(source[self.feature]),
+                pd.api.types.is_timedelta64_dtype(source[self.feature])))
+
+            grouped = source.groupby(self.feature, sort=True, observed=True)
+            for feature_value, group in grouped:
                 target_data = group[self.target]
                 if self.skip_na and getattr(target_data.isna(), self.skip_na)():
                     continue
                 
-                self._original_f_values = self._original_f_values + (f_value, )
-                if isinstance(f_value, (float, int, pd.Timestamp)):
-                    feature_data = f_value
+                self._original_f_values += (feature_value,)
+                if use_feature_value:
+                    yield feature_value, target_data
                 else:
-                    feature_data = i
-                yield feature_data, target_data
+                    yield feature_data, target_data
+                    feature_data += 1
+                
         else:
             self.feature = PLOTTER.TRANSFORMED_FEATURE
             self._original_f_values = (self._f_base, )
-            feature_data = self._f_base
             target_data = source[self.target]
             yield feature_data, target_data
 
@@ -4294,6 +4299,13 @@ class GaussianKDE(SpreadOpacity, TransformPlotter):
         plot.
     target : str
         Column name of the target variable for the plot.
+    feature : str, optional
+        Column name of the feature variable for the plot, by default ''.
+        Please note that this class is designed for univariate plots, so
+        by default, all curves will be drawn on the same feature axis. 
+        If you want to draw curves on different feature axes, change the
+        "ignore_feature" parameter to False and provide a feature column 
+        in the source DataFrame.
     stretch : float, optional
         Factor by which the curve was stretched in height,
         by default 1.
@@ -4446,10 +4458,11 @@ class GaussianKDE(SpreadOpacity, TransformPlotter):
             self,
             source: DataFrame,
             target: str,
+            feature: str = '',
             stretch: float = 1,
             height: float | None = None,
             skip_na: Literal['all', 'any'] | None = None,
-            ignore_feature: bool = True,
+            ignore_feature: bool = True, # TODO: This option seems not to work at all: fix it
             margin: float = 0,
             fill: bool = True,
             agreements: tuple[float, ...] | tuple[int, ...] = DEFAULT.AGREEMENTS,
@@ -4467,15 +4480,16 @@ class GaussianKDE(SpreadOpacity, TransformPlotter):
         self.n_points = n_points
         self.margin = margin
         self.fill = fill
-        if not ignore_feature and kwds.get('feature', False):
+        if feature and not ignore_feature:
             height = height if height else CATEGORY.FEATURE_SPACE
         else:
-            kwds['feature'] = PLOTTER.TRANSFORMED_FEATURE
+            feature = PLOTTER.TRANSFORMED_FEATURE
         self._height = height
         f_base = kwds.pop('f_base', DEFAULT.FEATURE_BASE)
         super().__init__(
             source=source,
             target=target,
+            feature=feature,
             f_base=f_base,
             skip_na=skip_na,
             target_on_y=target_on_y,

{daspi-2.1.0 → daspi-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "DaSPi"
-version = "2.1.0"
+version = "2.2.0"
 description = "Visualize and analyze your data with DaSPi. This package is designed for users who want to find relevant influencing factors in processes and validate improvements."
 authors = [
     { name = "Reto Jäggli", email = "reto@jaeggli.email" },

{daspi-2.1.0 → daspi-2.2.0}/tests/anova_model_test.py

@@ -216,6 +216,26 @@ class TestLinearModel:
         assert p_values.max() > 0.05
         assert lm.least_parameter() == 'A'
 
+    def test_effects_include_intercept(self, lm: LinearModel) -> None:
+        lm.fit()
+        effects = lm.effects()
+        assert 'Intercept' in effects.index
+        effects_no_intercept = lm.effects(include_intercept=False)
+        assert 'Intercept' not in effects_no_intercept.index
+        assert len(effects_no_intercept) == len(effects) - 1
+        pd.testing.assert_series_equal(
+            effects_no_intercept, effects.drop('Intercept'))
+
+    def test_p_values_include_intercept(self, lm: LinearModel) -> None:
+        lm.fit()
+        p_values = lm.p_values()
+        assert 'Intercept' in p_values.index
+        p_values_no_intercept = lm.p_values(include_intercept=False)
+        assert 'Intercept' not in p_values_no_intercept.index
+        assert len(p_values_no_intercept) == len(p_values) - 1
+        pd.testing.assert_series_equal(
+            p_values_no_intercept, p_values.drop('Intercept'))
+
     def test_main_parameters_property(self, lm2: LinearModel) -> None:
         lm2.fit()
         assert lm2.main_parameters == ['A', 'B', 'C', 'bad']
@@ -367,10 +387,10 @@ class TestLinearModel:
 
     def test_eliminate_invalid_term(self, lm3: LinearModel) -> None:
         lm3.fit()
-        with pytest.raises(AssertionError, match=r'Given term Q is not in model'):
+        with pytest.raises(AssertionError, match=r'Given term Q .* is not in model'):
             lm3.eliminate('Q')
 
-        with pytest.raises(AssertionError, match=r'Given term x0:x1:x2 is not in model'):
+        with pytest.raises(AssertionError, match=r'Given term x0:x1:x2 .* is not in model'):
             lm3.eliminate('A:B:C')
 
     def test_eliminate_encoded_term(self, lm3: LinearModel) -> None:

{daspi-2.1.0 → daspi-2.2.0}/tests/plotlib_visual_test.py

@@ -677,6 +677,38 @@ class TestSingleChart:
         assert STR.today in info_msg
         assert STR.username in info_msg
         assert self.info_msg not in info_msg
+
+        self.kind = 'ridge'
+        chart = SingleChart(
+                source=df_painkillers,
+                target=self.target,
+                feature=self.cat1,
+                target_on_y=True
+            ).plot(
+                GaussianKDE,
+                visible_spines='target',
+                hide_axis='feature',
+                agreements=(),
+                ignore_feature=False,
+            ).label(
+                fig_title=self.fig_title,
+                sub_title=self.sub_title,
+                feature_label=True,
+                target_label=True, 
+                info=True
+            ).save(self.file_name
+            ).close()
+        texts = get_texts(chart)
+        info_msg = texts[-1].get_text()
+        assert self.file_name.is_file()
+        assert len(texts) == 5
+        assert texts[0].get_text() == self.fig_title
+        assert texts[1].get_text() == self.sub_title
+        assert texts[2].get_text() == self.target
+        assert texts[3].get_text() == self.cat1
+        assert STR.today in info_msg
+        assert STR.username in info_msg
+        assert self.info_msg not in info_msg
     
     def test_beeswarm_plot(self) -> None:
         self.base = f'{self.fig_title}_beeswarm'