model-diagnostics 1.4.1__tar.gz → 1.4.3__tar.gz

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: model-diagnostics
-Version: 1.4.1
+Version: 1.4.3
 Summary: Tools for diagnostics and assessment of (machine learning) models
 Project-URL: Homepage, https://lorentzenchr.github.io/model-diagnostics/
 Project-URL: Source, https://github.com/lorentzenchr/model-diagnostics
@@ -27,6 +27,7 @@ License: MIT License
         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-File: LICENSE
 Keywords: calibration,machine learning,model diagnostics
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Hatch
@@ -34,13 +35,13 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.9
-Requires-Dist: matplotlib>=3.6.1
-Requires-Dist: numpy>=1.22
+Requires-Python: >=3.11
+Requires-Dist: matplotlib>=3.8.4
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: packaging>=23.1
-Requires-Dist: polars>=1.0.0
-Requires-Dist: scikit-learn>=1.2.0
-Requires-Dist: scipy>=1.10
+Requires-Dist: polars>=1.1.0
+Requires-Dist: scikit-learn>=1.4.2
+Requires-Dist: scipy>=1.13.1
 Description-Content-Type: text/markdown
 
 # model-diagnostics

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/mkdocs.yml

@@ -53,6 +53,8 @@ nav:
 
 watch:
   - src/model_diagnostics/
+  - docs/development.md
+  - docs/index.md
 
 plugins:
   # Built-in

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 description = "Tools for diagnostics and assessment of (machine learning) models"
 readme = "README.md"
 license = { file="LICENSE" }
-requires-python = ">=3.9"
+requires-python = ">=3.11"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Framework :: Hatch",
@@ -21,12 +21,12 @@ classifiers = [
 ]
 keywords = ["machine learning", "model diagnostics", "calibration"]
 dependencies = [
-  "matplotlib>=3.6.1",
-  "numpy>=1.22",  # type annotations and method arg in quantile
+  "matplotlib>=3.8.4",  # numpy 2 support
+  "numpy>=2.0.0",
   "packaging>=23.1",
-  "polars>=1.0.0",
-  "scikit-learn>=1.2.0",  # We rely on the set_output API.
-  "scipy>=1.10",  # scipy.stats.expectile
+  "polars>=1.1.0",  # numpy 2 support
+  "scikit-learn>=1.4.2",  # numpy 2 support
+  "scipy>=1.13.1",  # numpy 2 support
 ]
 dynamic = ["version"]
 
@@ -122,7 +122,6 @@ lint.isort.known-first-party = ["model_diagnostics"]
 # disallow_untyped_defs = false
 # follow_imports = "normal"
 ignore_missing_imports = true
-plugins = "numpy.typing.mypy_plugin"
 pretty = true
 # show_column_numbers = true
 # warn_no_return = false
@@ -150,9 +149,10 @@ exclude = [
 ]
 
 [tool.hatch.envs.default]
+installer = "uv"
 dependencies = [
-  "pandas>=1.5",
-  "pyarrow>=11.0.0",
+  "pandas>=2.2.2",  # numpy 2 support
+  "pyarrow>=16.0.0",  # numpy 2 support
   "pytest",
   "pytest-cov",
   "pytest-xdist",
@@ -172,9 +172,7 @@ dependencies = [
   "mkdocs-literate-nav>=0.6.1",
   "mkdocs-section-index>=0.3.9",
   "mkdocs-jupyter==0.24.7",  # https://github.com/danielfrg/mkdocs-jupyter/issues/212
-]
-extra-dependencies = [
-  "scikit-learn>=1.3.0",  # for Gamma deviance in HistGradientBoostingRegressor
+  "click<=8.2.1",  # https://github.com/mkdocs/mkdocs/issues/4032
 ]
 
 [tool.hatch.envs.docs.scripts]
@@ -185,7 +183,6 @@ ci-build = "mkdocs gh-deploy --force {args}"
 [tool.hatch.envs.jupyter]
 extra-dependencies = [
   "jupyterlab>=4.0.4",
-  "scikit-learn>=1.3.0",
   "plotly>=5.11.0",
 ]
 
@@ -195,7 +192,7 @@ lab = "jupyter lab"
 [tool.hatch.envs.format]
 detached = true
 dependencies = [
-  "numpy>=1.22",
+  "numpy>=2.3",
   "mypy>=1.14",
   "ruff==0.4.4",
 ]
@@ -241,36 +238,36 @@ dependencies = [
 ]
 
 [[tool.hatch.envs.test.matrix]]
-python = ["3.9", "3.10", "3.11", "3.12"]
+python = ["3.11", "3.12", "3.13", "3.14"]
 
 [tool.hatch.envs.test.overrides]
-# Minimal versions (partially inherited from scikit-learn 1.2.0)
+# Minimal versions
 # but including pandas and pyarrow
-name."py3.9".set-extra-dependencies = [
-  "numpy==1.22",
-  "polars==1.0.0",
-  "scipy==1.10",
-  "pandas==1.5.*",
-  "pyarrow==11.0.*"
+name."py3.11".set-extra-dependencies = [
+  "numpy==2.0.0",
+  "polars==1.1.0",
+  "scipy==1.13.1",
+  "pandas==2.2.2",  # numpy 2 support
+  "pyarrow==16.0.*" # numpy 2 support
 ]
 # Minimal versions without pandas and pyarrow 
-name."py3.10".set-extra-dependencies = [
-  "numpy==1.22",
-  "polars==1.0.0",
-  "scipy==1.10",
+name."py3.12".set-extra-dependencies = [
+  "numpy==2.0.0",
+  "polars==1.1.0",
+  "scipy==1.13.1",
 ]
 # Some intermediate versions, with pandads but without pyarrow
-name."py3.11".set-extra-dependencies = [
-  "numpy==1.26.*",
-  "polars==1.0.*",
-  "scipy==1.12.*",
-  "pandas==2.0.*",
+name."py3.13".set-extra-dependencies = [
+  "numpy==2.1.*",
+  "polars==1.10.*",
+  "scipy==1.14.*",
+  "pandas==2.3.*",
   "plotly",
 ]
 # Latest versions, with plotly
-name."py3.12".set-extra-dependencies = [
-  "numpy>=2.2.0",
-  "polars>=1.21.0",
+name."py3.14".set-extra-dependencies = [
+  "numpy>=2.3.0",
+  "polars>=1.31.0",
   "scipy",
   "pandas",
   "plotly",

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/__about__.py

@@ -14,4 +14,4 @@
 # Dev branch marker is: 'X.Y.dev' or 'X.Y.devN' where N is an integer.
 # 'X.Y.dev0' is the canonical version of 'X.Y.dev'
 #
-__version__ = "1.4.1"
+__version__ = "1.4.3"

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/_utils/binning.py

@@ -30,8 +30,8 @@ def bin_feature(
     feature_name: Optional[Union[int, str]],
     n_obs: int,
     n_bins: int = 10,
-    bin_method: str = "quantile",
-):
+    bin_method: str = "sturges",
+) -> tuple[pl.Series, int, pl.DataFrame]:
     """Helper function to bin features of different dtypes.
 
     Best call this function inside a `with pl.StringCache()` context manager.
@@ -45,11 +45,15 @@ def bin_feature(
     n_obs : int
         The expected length of the first dimention of feature.
     n_bins : int
-        The number of bins, at least 2, for numerical features and the maximal number
-        of (most frequent) categories shown for categorical features. Due to ties, the
-        effective number of bins might be smaller than `n_bins`. Null values are always
-        included in the output, accounting for one bin. NaN values are treated as null
-        values.
+        The number of bins, at least 2. For numerical features, `n_bins` only applies
+        when `bin_method` is set to `"quantile"` or `"uniform"`.
+        For string-like and categorical features, the most frequent values are taken.
+        Ties are dealt with by taking the first value in natural sorting order.
+        The remaining values are merged into `"other n"` with `n` indicating the unique
+        count.
+
+        I present, null values are always included in the output, accounting for one
+        bin. NaN values are treated as null values.
     bin_method : str
         The method to use for finding bin edges (boundaries). Options are:
 
@@ -115,7 +119,7 @@ def bin_feature(
     # The following statement, i.e. possibly the creation of a pl.Categorical,
     # MUST be under the StringCache context manager!
     try:
-        feature = pl.Series(name=feature_name, values=feature)
+        feature_out = pl.Series(name=feature_name, values=feature)
     except ImportError:
         # FIXME: pyarrow not installed
         # For non numpy-backed columns, pyarrow is needed. Here we handle the case
@@ -127,38 +131,38 @@ def bin_feature(
                 feature.dtype,  # type: ignore
                 pandas.CategoricalDtype,
             )
-            feature = pl.from_dataframe(
+            feature_out = pl.from_dataframe(
                 feature.to_frame(name=feature_name)  # type: ignore
             )[:, 0]
-            if is_pandas_categorical and isinstance(feature.dtype, pl.Enum):
+            if is_pandas_categorical and isinstance(feature_out.dtype, pl.Enum):
                 # Pandas categoricals usually get mapped to polars categoricals.
                 # But this code path gives pl.Enum.
-                feature = feature.cast(pl.Categorical)
+                feature_out = feature_out.cast(pl.Categorical)
         else:
             raise  # re-raises the ImportError
-    if length_of_first_dimension(feature) != n_obs:
+    if length_of_first_dimension(feature_out) != n_obs:
         msg = (
             f"The feature array {feature_name} does not have length {n_obs} of its"
             " first dimension."
         )
         raise ValueError(msg)
-    if feature.dtype == pl.Categorical:
+    if feature_out.dtype == pl.Categorical:
         is_categorical = True
-    elif feature.dtype == pl.Enum:
+    elif feature_out.dtype == pl.Enum:
         is_enum = True
-    elif feature.dtype in [pl.Utf8, pl.Object]:
+    elif feature_out.dtype in [pl.Utf8, pl.Object]:
         # We could convert strings to categoricals.
         is_string = True
-    elif feature.dtype.is_float():
+    elif feature_out.dtype.is_float():
         # We treat NaN as Null values, numpy will see a Null as a NaN.
-        feature = feature.fill_nan(None)
+        feature_out = feature_out.fill_nan(None)
     else:
         # integers
         pass
 
     # If we have Null values, we should reserve one bin for it and reduce
     # the effective number of bins by 1.
-    n_bins_ef = max(1, n_bins - feature.has_nulls())
+    n_bins_ef = max(1, n_bins - feature_out.has_nulls())
 
     if is_categorical or is_enum or is_string:
         # For categorical and string features, knowing the frequency table in
@@ -177,7 +181,7 @@ def bin_feature(
         # value_counts(sort=True) sorts ties by first occurence, we want
         # alphanumerical sorting order.
         value_counts = (
-            feature.drop_nulls()
+            feature_out.drop_nulls()
             .value_counts()
             .sort(by=["count", feature_name], descending=[True, False])
         )
@@ -185,18 +189,21 @@ def bin_feature(
         if n_bins_ef >= value_counts.shape[0]:
             # This also covers the case of only null values.
             n_bins_ef = value_counts.shape[0]
-            f_binned = pl.DataFrame({"bin": feature})
+            f_binned = pl.DataFrame({"bin": feature_out})
         else:
             # We keep the n_bins_ef - 1 most frequent values. Ties are resolved by
             # taking the first one of the sorted values (most often alpha-numerical).
-            if feature.has_nulls():
+            if feature_out.has_nulls():
                 # To ease adding the null value, we take one value more.
                 keep_values = value_counts[feature_name].head(n_bins_ef)
-                if is_categorical:
-                    # FIXME: Workaround for https://github.com/pola-rs/polars/issues/21175
+                if is_categorical or is_enum:
+                    # FIXME: categorical: Workaround for https://github.com/pola-rs/polars/issues/21175
+                    # FIXME: enum: Workaround for https://github.com/pola-rs/polars/pull/25245
+                    # to be released in polars 1.35.3 or 1.36.
+                    dtype = keep_values.dtype
                     keep_values = keep_values.cast(pl.String)
                     keep_values[-1] = None
-                    keep_values = keep_values.cast(pl.Categorical)
+                    keep_values = keep_values.cast(dtype)
                 else:
                     keep_values[-1] = None
             else:
@@ -205,14 +212,16 @@ def bin_feature(
             # n = n_remaining.
             n_remaining = value_counts.shape[0] - (n_bins_ef - 1)
             remaining_name = "other " + _format_integer(n_remaining)
-            while remaining_name in keep_values:
+            while remaining_name in keep_values.cast(pl.String):
                 remaining_name = "_" + remaining_name
-            return_dtype = feature.dtype
+            return_dtype = feature_out.dtype
             if is_enum:
                 return_dtype = pl.Enum(
-                    pl.concat([feature.dtype.categories, pl.Series([remaining_name])])
+                    pl.concat(
+                        [feature_out.dtype.categories, pl.Series([remaining_name])]
+                    )
                 )
-            f_binned = feature.replace_strict(
+            f_binned = feature_out.replace_strict(
                 old=keep_values,
                 new=keep_values,
                 default=remaining_name,
@@ -222,13 +231,13 @@ def bin_feature(
     else:
         # Binning a numerical feature
         # We will need min and max anyway.
-        feature_min, feature_max = feature.min(), feature.max()
+        feature_min, feature_max = feature_out.min(), feature_out.max()
         if feature_min == -np.inf:
-            finite_min = feature.filter(feature > -np.inf).min()
+            finite_min = feature_out.filter(feature_out > -np.inf).min()
         else:
             finite_min = feature_min
         if feature_max == np.inf:
-            finite_max = feature.filter(feature < np.inf).max()
+            finite_max = feature_out.filter(feature_out < np.inf).max()
         else:
             finite_max = feature_max
         f_range = finite_max - finite_min
@@ -237,7 +246,7 @@ def bin_feature(
             # We use method="inverted_cdf" instead of the default "linear" because
             # "linear" produces as many unique values as before.
             q = np.nanquantile(
-                feature,
+                feature_out,
                 # Improved rounding errors by using integers and dividing at the
                 # end as opposed to np.linspace with 1/n_bins step size.
                 q=np.arange(1, n_bins_ef) / n_bins_ef,
@@ -248,11 +257,11 @@ def bin_feature(
             bin_edges = finite_min + f_range * np.arange(1, n_bins_ef) / n_bins_ef
         else:
             # numpy histogram bin methods
-            a = feature.filter(feature.is_finite() & feature.is_not_null())
+            a = feature_out.filter(feature_out.is_finite() & feature_out.is_not_null())
             bin_edges = np.histogram_bin_edges(a, bins=bin_method)[1:-1]
             n_bins_ef = bin_edges.shape[0] + 1
         # We want: bins[i-1] < x <= bins[i]
-        f_binned = np.digitize(feature, bins=bin_edges, right=True)
+        f_binned = np.digitize(feature_out, bins=bin_edges, right=True)
         # The full bin edges also include min and max of the feature.
         if bin_edges.size == 0:
             bin_edges = np.r_[feature_min, feature_max]
@@ -268,8 +277,8 @@ def bin_feature(
         f_binned = (
             pl.LazyFrame(
                 [
-                    feature,
-                    pl.Series("__f_binned", f_binned, dtype=feature.dtype),
+                    feature_out,
+                    pl.Series("__f_binned", f_binned, dtype=feature_out.dtype),
                     pl.Series(
                         "__bin_edges",
                         bin_edges[f_binned],
@@ -289,4 +298,4 @@ def bin_feature(
             )
             .collect()
         )
-    return feature, n_bins_ef + feature.has_nulls(), f_binned
+    return feature_out, n_bins_ef + feature_out.has_nulls(), f_binned

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/_utils/partial_dependence.py

@@ -93,7 +93,7 @@ def compute_partial_dependence(
     pd_values = np.average(
         y_pred.reshape(n_grid, y_pred.shape[0] // n_grid),
         axis=1,
-        weights=weights,
+        weights=weights,  # type: ignore
     )
 
     return pd_values

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/_utils/tests/test_binning.py

@@ -146,7 +146,7 @@ def test_binning_numerical(bin_method, with_inf, with_null, feature_type):
 
 
 def test_binning_auto():
-    """ "Test auto bin method"""
+    """Test auto bin method"""
     n_bins = 5
     feature = pl.Series(name="my_feature", values=[0, 1, 1, 2])
     n_obs = len(feature)

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/_utils/tests/test_isotonic.py

@@ -236,7 +236,7 @@ def test_gpava_simple(y, fun_lower, x_lower, fun_upper, x_upper):
         tol=1e-12,
     )
 
-    assert result.fun == pytest.approx(loss_lower, rel=1e-8)
+    assert result.fun == pytest.approx(loss_lower, rel=1e-7)
 
     # Check that it is the boundary of solutions.
     eps = 1e-8 * np.mean(np.abs(xl))

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/_utils/tests/test_partial_dependence.py

@@ -6,7 +6,7 @@ import polars as pl
 import pytest
 from numpy.testing import assert_allclose, assert_equal
 from polars.testing import assert_frame_equal
-from sklearn.base import RegressorMixin
+from sklearn.base import BaseEstimator, RegressorMixin
 from sklearn.inspection import partial_dependence
 
 from model_diagnostics._utils.array import (
@@ -82,21 +82,15 @@ def test_compute_partial_dependence(n_max, weights, feature_type, data_container
                     "b": X["b"].to_numpy(),
                 }
             )
-        elif feature_type == "string":
-            # TODO: With pandas 2.0.3, this does not work for strings. Get
-            # AssertionError from polars in string_column_to_ndarray.
-            # X_skl = pandas.api.interchange.from_dataframe(X). So we do it manually.
-            X_skl = pandas.DataFrame(
-                {
-                    "a": X["a"].to_numpy(),
-                    "b": X["b"].to_numpy(),
-                }
-            )
         else:
             X_skl = pandas.api.interchange.from_dataframe(X)
     else:
         X_skl = X.to_pandas()
 
+    if feature_type == "numeric" and pandas is not None:
+        # scikit-learn does not like integers in partial dependence
+        X_skl["a"] = 1.0 * X_skl["a"]
+
     grid = X.get_column("a").unique().sort()
     # Make sure grid is the same data container as X.
     if data_container == "list":
@@ -143,7 +137,7 @@ def test_compute_partial_dependence(n_max, weights, feature_type, data_container
         rng=rng,
     )
 
-    class ModelWrapPredict(RegressorMixin):
+    class ModelWrapPredict(RegressorMixin, BaseEstimator):
         def fit(self, X):
             self.is_fitted_ = True
             return self

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/calibration/identification.py

@@ -60,6 +60,7 @@ def identification_function(
     Notes
     -----
     [](){#notes}
+
     The function \(V(y, z)\) for observation \(y=y_{pred}\) and prediction
     \(z=y_{pred}\) is a strict identification function for the functional \(T\), or
     induces the functional \(T\) as:
@@ -130,7 +131,7 @@ def compute_bias(
     functional: str = "mean",
     level: float = 0.5,
     n_bins: int = 10,
-    bin_method: str = "auto",
+    bin_method: str = "sturges",
 ):
     r"""Compute generalised bias conditional on a feature.
 
@@ -172,10 +173,15 @@ def compute_bias(
         `level=0.5` and `functional="expectile"` gives the mean.
         `level=0.5` and `functional="quantile"` gives the median.
     n_bins : int
-        The number of bins for numerical features and the maximal number of (most
-        frequent) categories shown for categorical features. Due to ties, the effective
-        number of bins might be smaller than `n_bins`. Null values are always included
-        in the output, accounting for one bin. NaN values are treated as null values.
+        The number of bins, at least 2. For numerical features, `n_bins` only applies
+        when `bin_method` is set to `"quantile"` or `"uniform"`.
+        For string-like and categorical features, the most frequent values are taken.
+        Ties are dealt with by taking the first value in natural sorting order.
+        The remaining values are merged into `"other n"` with `n` indicating the unique
+        count.
+
+        I present, null values are always included in the output, accounting for one
+        bin. NaN values are treated as null values.
     bin_method : str
         The method for finding bin edges (boundaries). Options using `n_bins` are:
 
@@ -230,6 +236,7 @@ def compute_bias(
     Notes
     -----
     [](){#notes}
+
     A model \(m(X)\) is conditionally calibrated iff
     \(\mathbb{E}(V(m(X), Y)|X)=0\) almost surely with canonical identification
     function \(V\).
@@ -306,20 +313,21 @@ def compute_bias(
     with pl.StringCache():
         feature_name = None
         if feature is not None:
-            feature, n_bins, f_binned = bin_feature(
+            feature_series, n_bins, f_binned = bin_feature(
                 feature=feature,
                 feature_name=None,
                 n_obs=n_obs,
                 n_bins=n_bins,
                 bin_method=bin_method,
             )
-            feature_name = feature.name
-            is_cat_or_string = feature.dtype in [
+            feature_name = feature_series.name
+            is_cat_or_string = feature_series.dtype in [
                 pl.Categorical,
                 pl.Enum,
                 pl.Utf8,
                 pl.Object,
             ]
+            feature = feature_series
 
         for i in range(len(pred_names)):
             # Loop over columns of y_pred.
@@ -483,7 +491,7 @@ def compute_marginal(
     weights: Optional[npt.ArrayLike] = None,
     *,
     n_bins: int = 10,
-    bin_method: str = "auto",
+    bin_method: str = "sturges",
     n_max: int = 1000,
     rng: Optional[Union[np.random.Generator, int]] = None,
 ):
@@ -512,10 +520,15 @@ def compute_marginal(
         Case weights. If given, the bias is calculated as weighted average of the
         identification function with these weights.
     n_bins : int
-        The number of bins for numerical features and the maximal number of (most
-        frequent) categories shown for categorical features. Due to ties, the effective
-        number of bins might be smaller than `n_bins`. Null values are always included
-        in the output, accounting for one bin. NaN values are treated as null values.
+        The number of bins, at least 2. For numerical features, `n_bins` only applies
+        when `bin_method` is set to `"quantile"` or `"uniform"`.
+        For string-like and categorical features, the most frequent values are taken.
+        Ties are dealt with by taking the first value in natural sorting order.
+        The remaining values are merged into `"other n"` with `n` indicating the unique
+        count.
+
+        I present, null values are always included in the output, accounting for one
+        bin. NaN values are treated as null values.
     bin_method : str
         The method for finding bin edges (boundaries). Options using `n_bins` are:
 

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/calibration/plots.py

@@ -93,6 +93,7 @@ def plot_reliability_diagram(
     Notes
     -----
     [](){#notes}
+
     The expectation conditional on the predictions is \(E(Y|y_{pred})\). This object is
     estimated by the pool-adjacent violator (PAV) algorithm, which has very desirable
     properties:
@@ -319,7 +320,7 @@ def plot_bias(
     functional: str = "mean",
     level: float = 0.5,
     n_bins: int = 10,
-    bin_method: str = "auto",
+    bin_method: str = "sturges",
     confidence_level: float = 0.9,
     ax: Optional[mpl.axes.Axes] = None,
 ):
@@ -365,10 +366,15 @@ def plot_bias(
         `level=0.5` and `functional="expectile"` gives the mean.
         `level=0.5` and `functional="quantile"` gives the median.
     n_bins : int
-        The number of bins for numerical features and the maximal number of (most
-        frequent) categories shown for categorical features. Due to ties, the effective
-        number of bins might be smaller than `n_bins`. Null values are always included
-        in the output, accounting for one bin. NaN values are treated as null values.
+        The number of bins, at least 2. For numerical features, `n_bins` only applies
+        when `bin_method` is set to `"quantile"` or `"uniform"`.
+        For string-like and categorical features, the most frequent values are taken.
+        Ties are dealt with by taking the first value in natural sorting order.
+        The remaining values are merged into `"other n"` with `n` indicating the unique
+        count.
+
+        I present, null values are always included in the output, accounting for one
+        bin. NaN values are treated as null values.
     bin_method : str
         The method for finding bin edges (boundaries). Options using `n_bins` are:
 
@@ -420,6 +426,7 @@ def plot_bias(
     Notes
     -----
     [](){#notes}
+
     A model \(m(X)\) is conditionally calibrated iff \(E(V(m(X), Y))=0\) a.s. The
     empirical version, given some data, reads \(\frac{1}{n}\sum_i V(m(x_i), y_i)\).
     See `[FLM2022]`.
@@ -742,7 +749,7 @@ def plot_marginal(
     weights: Optional[npt.ArrayLike] = None,
     *,
     n_bins: int = 10,
-    bin_method: str = "auto",
+    bin_method: str = "sturges",
     n_max: int = 1000,
     rng: Optional[Union[np.random.Generator, int]] = None,
     ax: Optional[mpl.axes.Axes] = None,
@@ -773,10 +780,15 @@ def plot_marginal(
         Case weights. If given, the bias is calculated as weighted average of the
         identification function with these weights.
     n_bins : int
-        The number of bins for numerical features and the maximal number of (most
-        frequent) categories shown for categorical features. Due to ties, the effective
-        number of bins might be smaller than `n_bins`. Null values are always included
-        in the output, accounting for one bin. NaN values are treated as null values.
+        The number of bins, at least 2. For numerical features, `n_bins` only applies
+        when `bin_method` is set to `"quantile"` or `"uniform"`.
+        For string-like and categorical features, the most frequent values are taken.
+        Ties are dealt with by taking the first value in natural sorting order.
+        The remaining values are merged into `"other n"` with `n` indicating the unique
+        count.
+
+        I present, null values are always included in the output, accounting for one
+        bin. NaN values are treated as null values.
     bin_method : str
         The method for finding bin edges (boundaries). Options using `n_bins` are:
 

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/calibration/tests/test_identification.py

@@ -296,7 +296,10 @@ def test_compute_bias_n_bins_string_like_feature(feature_type):
     if feature_type == "cat":
         dtype = pl.Categorical
     elif feature_type == "cat_physical":
-        dtype = pl.Categorical(ordering="physical")
+        if Version(pl.__version__) < Version("1.32.0"):
+            dtype = pl.Categorical(ordering="lexical")
+        else:
+            dtype = pl.Categorical()
     elif feature_type == "enum":
         dtype = pl.Enum(categories=["b", "a", "c"])
     else:
@@ -824,7 +827,10 @@ def test_compute_marginal_n_bins_string_like_feature(feature_type):
     if feature_type == "cat":
         dtype = pl.Categorical
     elif feature_type == "cat_physical":
-        dtype = pl.Categorical(ordering="physical")
+        if Version(pl.__version__) < Version("1.32.0"):
+            dtype = pl.Categorical(ordering="lexical")
+        else:
+            dtype = pl.Categorical()
     elif feature_type == "enum":
         dtype = pl.Enum(categories=["b", "a", "c"])
     else:

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/calibration/tests/test_plots.py

@@ -5,6 +5,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import polars as pl
 import pytest
+from packaging.version import Version
 from sklearn.base import BaseEstimator, TransformerMixin
 from sklearn.compose import ColumnTransformer
 from sklearn.datasets import make_classification
@@ -305,7 +306,7 @@ def test_plot_bias(
         random_state=42,
     )
     X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
-    clf = LogisticRegression(solver="lbfgs")
+    clf = LogisticRegression(solver="newton-cg")
     clf.fit(X_train, y_train)
     feature = X_test[:, 0]
     if feature_type != "num":
@@ -319,7 +320,10 @@ def test_plot_bias(
         elif feature_type == "cat":
             dtype = pl.Categorical
         elif feature_type == "cat_physical":
-            dtype = pl.Categorical(ordering="physical")
+            if Version(pl.__version__) < Version("1.32.0"):
+                dtype = pl.Categorical(ordering="lexical")
+            else:
+                dtype = pl.Categorical()
         elif feature_type == "enum":
             dtype = pl.Enum(categories=np.unique(feature))
         else:
@@ -527,7 +531,10 @@ def test_plot_marginal(with_null_values, feature_type, bin_method, ax, plot_back
         elif feature_type == "cat":
             dtype = pl.Categorical
         elif feature_type == "cat_physical":
-            dtype = pl.Categorical(ordering="physical")
+            if Version(pl.__version__) < Version("1.32.0"):
+                dtype = pl.Categorical(ordering="lexical")
+            else:
+                dtype = pl.Categorical()
         elif feature_type == "enum":
             dtype = pl.Enum(categories=np.unique(feature))
         else:
@@ -576,7 +583,7 @@ def test_plot_marginal(with_null_values, feature_type, bin_method, ax, plot_back
 
     clf = make_pipeline(
         ColumnTransformer([("ohe", safe_ohe, [0])], remainder="passthrough"),
-        LogisticRegression(solver="lbfgs"),
+        LogisticRegression(solver="newton-cg"),
     )
     clf.fit(X, y)
 

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/scoring/plots.py

@@ -75,6 +75,7 @@ def plot_murphy_diagram(
     Notes
     -----
     [](){#notes}
+
     For details, refer to `[Ehm2015]`.
 
     References

{model_diagnostics-1.4.1 → model_diagnostics-1.4.3}/src/model_diagnostics/scoring/scoring.py

@@ -60,7 +60,10 @@ class _BaseScoringFunction(ABC):
         score : float
             The average score.
         """
-        return np.average(self.score_per_obs(y_obs, y_pred), weights=weights)
+        return np.average(
+            self.score_per_obs(y_obs, y_pred),
+            weights=weights,  # type: ignore
+        )
 
     @abstractmethod
     def score_per_obs(
@@ -142,9 +145,9 @@ class HomogeneousExpectileScore(_BaseScoringFunction):
     Examples
     --------
     >>> hes = HomogeneousExpectileScore(degree=2, level=0.1)
-    >>> hes(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])  # doctest: +SKIP
-    0.95
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> hes(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])
+    np.float64(0.95)
+    """
 
     def __init__(self, degree: float = 2, level: float = 0.5) -> None:
         self.degree = degree
@@ -268,9 +271,9 @@ class SquaredError(HomogeneousExpectileScore):
     Examples
     --------
     >>> se = SquaredError()
-    >>> se(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])  # doctest: +SKIP
-    0.75
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> se(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])
+    np.float64(0.75)
+    """
 
     def __init__(self) -> None:
         super().__init__(degree=2, level=0.5)
@@ -296,9 +299,9 @@ class PoissonDeviance(HomogeneousExpectileScore):
     Examples
     --------
     >>> pd = PoissonDeviance()
-    >>> pd(y_obs=[0, 0, 1, 1], y_pred=[2, 1, 1 , 2])  # doctest: +SKIP
-    1.6534264097200273
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> pd(y_obs=[0, 0, 1, 1], y_pred=[2, 1, 1 , 2])
+    np.float64(1.6534264097200273)
+    """
 
     def __init__(self) -> None:
         super().__init__(degree=1, level=0.5)
@@ -325,9 +328,9 @@ class GammaDeviance(HomogeneousExpectileScore):
     Examples
     --------
     >>> gd = GammaDeviance()
-    >>> gd(y_obs=[3, 2, 1, 1], y_pred=[2, 1, 1 , 2])  # doctest: +SKIP
-    0.2972674459459178
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> gd(y_obs=[3, 2, 1, 1], y_pred=[2, 1, 1 , 2])
+    np.float64(0.2972674459459178)
+    """
 
     def __init__(self) -> None:
         super().__init__(degree=0, level=0.5)
@@ -366,11 +369,9 @@ class LogLoss(_BaseScoringFunction):
     Examples
     --------
     >>> ll = LogLoss()
-    >>> ll(y_obs=[0, 0.5, 1, 1], y_pred=[0.1, 0.2, 0.8 , 0.9], weights=[1, 2, 1, 1])  # doctest: +SKIP
-    0.17603033705165635
-    """  # noqa: E501
-
-    # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> ll(y_obs=[0, 0.5, 1, 1], y_pred=[0.1, 0.2, 0.8 , 0.9], weights=[1, 2, 1, 1])
+    np.float64(0.17603033705165635)
+    """
 
     @property
     def functional(self):
@@ -466,9 +467,9 @@ class HomogeneousQuantileScore(_BaseScoringFunction):
     Examples
     --------
     >>> hqs = HomogeneousQuantileScore(degree=3, level=0.1)
-    >>> hqs(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])  # doctest: +SKIP
-    0.6083333333333334
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> hqs(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])
+    np.float64(0.6083333333333334)
+    """
 
     def __init__(self, degree: float = 2, level: float = 0.5) -> None:
         self.degree = degree
@@ -569,9 +570,9 @@ class PinballLoss(HomogeneousQuantileScore):
     Examples
     --------
     >>> pl = PinballLoss(level=0.9)
-    >>> pl(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])  # doctest: +SKIP
-    0.275
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> pl(y_obs=[0, 0, 1, 1], y_pred=[-1, 1, 1 , 2])
+    np.float64(0.275)
+    """
 
     def __init__(self, level: float = 0.5) -> None:
         super().__init__(degree=1, level=level)
@@ -606,6 +607,7 @@ class ElementaryScore(_BaseScoringFunction):
     Notes
     -----
     [](){#notes}
+
     The elementary scoring or loss function is given by
 
     \[
@@ -644,9 +646,9 @@ class ElementaryScore(_BaseScoringFunction):
     Examples
     --------
     >>> el_score = ElementaryScore(eta=2, functional="mean")
-    >>> el_score(y_obs=[1, 2, 2, 1], y_pred=[4, 1, 2, 3])  # doctest: +SKIP
-    0.5
-    """  # FIXME: numpy 2.0.0, doctest skip should not be necessary.
+    >>> el_score(y_obs=[1, 2, 2, 1], y_pred=[4, 1, 2, 3])
+    np.float64(0.5)
+    """
 
     def __init__(
         self, eta: float, functional: str = "mean", level: float = 0.5