liesel-gam 0.0.4__py3-none-any.whl

liesel_gam/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.0.4"

liesel_gam/__init__.py

@@ -0,0 +1,9 @@
+from .__about__ import __version__ as __version__
+from .dist import MultivariateNormalSingular as MultivariateNormalSingular
+from .kernel import init_star_ig_gibbs as init_star_ig_gibbs
+from .kernel import star_ig_gibbs as star_ig_gibbs
+from .predictor import AdditivePredictor as AdditivePredictor
+from .var import Basis as Basis
+from .var import Intercept as Intercept
+from .var import LinearTerm as LinearTerm
+from .var import SmoothTerm as SmoothTerm

liesel_gam/dist.py

@@ -0,0 +1,100 @@
+from functools import cached_property
+
+import jax
+import jax.numpy as jnp
+import tensorflow_probability.substrates.jax.distributions as tfd
+from tensorflow_probability.substrates.jax import tf2jax as tf
+from tensorflow_probability.substrates.jax.internal.parameter_properties import (
+    ParameterProperties,
+)
+
+Array = jax.typing.ArrayLike
+
+
+class MultivariateNormalSingular(tfd.Distribution):
+    def __init__(
+        self,
+        loc: Array,
+        scale: Array,
+        penalty: Array,
+        penalty_rank: Array,
+        validate_args: bool = False,
+        allow_nan_stats: bool = True,
+        name: str = "MultivariateNormalSingular",
+    ):
+        parameters = dict(locals())
+
+        self._loc = jnp.asarray(loc)
+        self._scale = jnp.asarray(scale)
+        self._penalty = jnp.asarray(penalty)
+        self._penalty_rank = jnp.asarray(penalty_rank)
+
+        super().__init__(
+            dtype=self._loc.dtype,
+            reparameterization_type=tfd.FULLY_REPARAMETERIZED,
+            validate_args=validate_args,
+            allow_nan_stats=allow_nan_stats,
+            parameters=parameters,
+            name=name,
+        )
+
+    @classmethod
+    def _parameter_properties(cls, dtype=jnp.float32, num_classes=None):
+        return dict(
+            loc=ParameterProperties(event_ndims=1),
+            scale=ParameterProperties(event_ndims=0),
+            penalty=ParameterProperties(event_ndims=2),
+            penalty_rank=ParameterProperties(event_ndims=0),
+        )
+
+    def _event_shape(self):
+        return tf.TensorShape((jnp.shape(self._penalty)[-1],))
+
+    def _event_shape_tensor(self):
+        return jnp.array((jnp.shape(self._penalty)[-1],), dtype=self._penalty.dtype)
+
+    def _log_prob(self, x: Array) -> Array:
+        x_centered = x - self._loc
+
+        # The following lines illustrate what the jnp.einsum call is conceptually
+        # doing.
+        # xt = jnp.expand_dims(x, axis=-2) # [batch_dims, 1, event_dim]
+        # x = jnp.swapaxes(xt, -2, -1) # [batch_dims, event_dim, 1]
+        # quad_form = jnp.squeeze((xt @ self._penalty @ x))
+        quad_form = jnp.einsum(
+            "...i,...ij,...j->...", x_centered, self._penalty, x_centered
+        )
+
+        neg_kernel = 0.5 * quad_form * jnp.power(self._scale, -2.0)
+
+        return -(jnp.log(self._scale) * self._penalty_rank + neg_kernel)
+
+    def _sample_n(self, n, seed=None) -> Array:
+        shape = [n] + self.batch_shape + self.event_shape
+
+        # The added dimension at the end here makes sure that matrix multiplication
+        # with the "sqrt pcov" matrices works out correctly.
+        z = jax.random.normal(key=seed, shape=shape + [1])
+
+        # Add a dimension at 0 for the sample size.
+        sqrt_cov = jnp.expand_dims(self._sqrt_cov, 0)
+        centered_samples = jnp.reshape(sqrt_cov @ z, shape)
+
+        # Add a dimension at 0 for the sample size.
+        loc = jnp.expand_dims(self._loc, 0)
+        scale = jnp.expand_dims(self._scale, 0)
+
+        return scale * centered_samples + loc
+
+    @cached_property
+    def _sqrt_cov(self) -> Array:
+        eigenvalues, evecs = jnp.linalg.eigh(self._penalty)
+        sqrt_eval = jnp.sqrt(1 / eigenvalues)
+        sqrt_eval = sqrt_eval.at[: -self._penalty_rank].set(0.0)
+
+        event_shape = sqrt_eval.shape[-1]
+        shape = sqrt_eval.shape + (event_shape,)
+
+        r = tuple(range(event_shape))
+        diags = jnp.zeros(shape).at[..., r, r].set(sqrt_eval)
+        return evecs @ diags

liesel_gam/kernel.py

@@ -0,0 +1,48 @@
+from collections.abc import Sequence
+
+import jax
+import jax.numpy as jnp
+import liesel.goose as gs
+import liesel.model as lsl
+
+
+def star_ig_gibbs(coef: lsl.Var) -> gs.GibbsKernel:
+    variance_var = coef.dist_node["scale"].value_node[0]  # type: ignore
+    a_value = variance_var.dist_node["concentration"].value  # type: ignore
+    b_value = variance_var.dist_node["scale"].value  # type: ignore
+
+    penalty_value = coef.dist_node["penalty"].value  # type: ignore
+    rank_value = jnp.linalg.matrix_rank(penalty_value)
+
+    model = coef.model
+    if model is None:
+        raise ValueError("The model must be set in the coefficient variable.")
+
+    name = variance_var.name
+
+    def transition(prng_key, model_state):
+        pos = model.extract_position([coef.name], model_state)
+
+        coef_value = pos[coef.name].squeeze()
+
+        a_gibbs = jnp.squeeze(a_value + 0.5 * rank_value)
+        b_gibbs = jnp.squeeze(b_value + 0.5 * (coef_value @ penalty_value @ coef_value))
+
+        draw = b_gibbs / jax.random.gamma(prng_key, a_gibbs)
+
+        return {name: draw}
+
+    return gs.GibbsKernel([name], transition)
+
+
+def init_star_ig_gibbs(position_keys: Sequence[str], coef: lsl.Var) -> gs.GibbsKernel:
+    if len(position_keys) != 1:
+        raise ValueError("The position keys must be a single key.")
+
+    variance_var = coef.dist_node["scale"].value_node[0]  # type: ignore
+    name = variance_var.name
+
+    if position_keys[0] != name:
+        raise ValueError(f"The position key must be {name}.")
+
+    return star_ig_gibbs(coef)  # type: ignore

liesel_gam/predictor.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Self, cast
+
+import liesel.model as lsl
+
+Array = Any
+
+
+class AdditivePredictor(lsl.Var):
+    def __init__(
+        self, name: str, inv_link: Callable[[Array], Array] | None = None
+    ) -> None:
+        if inv_link is None:
+
+            def _sum(*args, **kwargs):
+                # the + 0. implicitly ensures correct dtype also for empty predictors
+                return sum(args) + sum(kwargs.values()) + 0.0
+        else:
+
+            def _sum(*args, **kwargs):
+                # the + 0. implicitly ensures correct dtype also for empty predictors
+                return inv_link(sum(args) + sum(kwargs.values()) + 0.0)
+
+        super().__init__(lsl.Calc(_sum), name=name)
+        self.update()
+        self.terms: dict[str, lsl.Var] = {}
+        """Dictionary of terms in this predictor."""
+
+    def update(self) -> Self:
+        return cast(Self, super().update())
+
+    def __add__(self, other: lsl.Var) -> Self:
+        self.value_node.add_inputs(other)
+        self.terms[other.name] = other
+        return self.update()
+
+    def __iadd__(self, other: lsl.Var) -> Self:
+        self.value_node.add_inputs(other)
+        self.terms[other.name] = other
+        return self.update()
+
+    def __getitem__(self, name) -> lsl.Var:
+        return self.terms[name]
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.name=}, {len(self.terms)} terms)"

liesel_gam/roles.py

@@ -0,0 +1,9 @@
+class Roles:
+    basis: str = "gam_basis"
+    coef_smooth: str = "gam_coef_smooth"
+    coef_linear: str = "gam_coef_linear"
+    variance_smooth: str = "gam_variance_smooth"
+    scale_smooth: str = "gam_scale_smooth"
+    term_smooth: str = "gam_term_smooth"
+    term_linear: str = "gam_term_linear"
+    intercept: str = "gam_intercept"

liesel_gam/var.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Self
+
+import jax
+import jax.numpy as jnp
+import liesel.goose as gs
+import liesel.model as lsl
+import tensorflow_probability.substrates.jax.distributions as tfd
+
+from .dist import MultivariateNormalSingular
+from .kernel import init_star_ig_gibbs
+from .roles import Roles
+
+InferenceTypes = Any
+Array = Any
+
+
+class SmoothTerm(lsl.Var):
+    def __init__(
+        self,
+        basis: Basis | lsl.Var,
+        penalty: lsl.Var | Array,
+        scale: lsl.Var,
+        name: str,
+        inference: InferenceTypes = None,
+        coef_name: str | None = None,
+    ):
+        coef_name = f"{name}_coef" if coef_name is None else coef_name
+
+        if not jnp.asarray(basis.value).ndim == 2:
+            raise ValueError(f"basis must have 2 dimensions, got {basis.value.ndim}.")
+
+        nbases = jnp.shape(basis.value)[-1]
+
+        prior = lsl.Dist(
+            MultivariateNormalSingular,
+            loc=0.0,
+            scale=scale,
+            penalty=penalty,
+            penalty_rank=jnp.linalg.matrix_rank(penalty),
+        )
+
+        self.scale = scale
+        self.nbases = nbases
+        self.basis = basis
+        self.coef = lsl.Var.new_param(
+            jnp.zeros(nbases), prior, inference=inference, name=coef_name
+        )
+        calc = lsl.Calc(jnp.dot, basis, self.coef)
+
+        super().__init__(calc, name=name)
+        self.coef.update()
+        self.update()
+        self.coef.role = Roles.coef_smooth
+        self.role = Roles.term_smooth
+
+    @classmethod
+    def new_ig(
+        cls,
+        basis: Basis | lsl.Var,
+        penalty: Array,
+        name: str,
+        ig_concentration: float = 0.01,
+        ig_scale: float = 0.01,
+        inference: InferenceTypes = None,
+        variance_value: float | None = None,
+        variance_name: str | None = None,
+        variance_jitter_dist: tfd.Distribution | None = None,
+        coef_name: str | None = None,
+    ) -> Self:
+        variance_name = f"{name}_variance" if variance_name is None else variance_name
+
+        variance = lsl.Var.new_param(
+            value=1.0,
+            distribution=lsl.Dist(
+                tfd.InverseGamma,
+                concentration=ig_concentration,
+                scale=ig_scale,
+            ),
+            name=variance_name,
+        )
+        variance.role = Roles.variance_smooth
+
+        scale = lsl.Var.new_calc(jnp.sqrt, variance, name=f"{variance_name}_root")
+        scale.role = Roles.scale_smooth
+
+        if variance_value is None:
+            ig_median = variance.dist_node.init_dist().quantile(0.5)  # type: ignore
+            variance.value = min(ig_median, 10.0)
+        else:
+            variance.value = variance_value
+
+        term = cls(
+            basis=basis,
+            scale=scale,
+            penalty=penalty,
+            inference=inference,
+            name=name,
+            coef_name=coef_name,
+        )
+
+        variance.inference = gs.MCMCSpec(
+            init_star_ig_gibbs,
+            kernel_kwargs={"coef": term.coef},
+            jitter_dist=variance_jitter_dist,
+        )
+
+        return term
+
+
+class LinearTerm(lsl.Var):
+    def __init__(
+        self,
+        x: lsl.Var | Array,
+        name: str,
+        distribution: lsl.Dist | None = None,
+        inference: InferenceTypes = None,
+        add_intercept: bool = False,
+        coef_name: str | None = None,
+        basis_name: str | None = None,
+    ):
+        coef_name = f"{name}_coef" if coef_name is None else coef_name
+        basis_name = f"B({name})" if basis_name is None else basis_name
+
+        def _matrix(x):
+            x = jnp.atleast_1d(x)
+            if len(jnp.shape(x)) == 1:
+                x = jnp.expand_dims(x, -1)
+            if add_intercept:
+                ones = jnp.ones(x.shape[0])
+                x = jnp.c_[ones, x]
+            return x
+
+        if not isinstance(x, lsl.Var):
+            x = lsl.Var.new_obs(x, name=f"{name}_input")
+
+        basis = lsl.Var(lsl.TransientCalc(_matrix, x=x), name=basis_name)
+        basis.role = Roles.basis
+
+        nbases = jnp.shape(basis.value)[-1]
+
+        self.nbases = nbases
+        self.basis = basis
+        self.coef = lsl.Var.new_param(
+            jnp.zeros(nbases), distribution, inference=inference, name=coef_name
+        )
+        calc = lsl.Calc(jnp.dot, basis, self.coef)
+
+        super().__init__(calc, name=name)
+        self.coef.role = Roles.coef_linear
+        self.role = Roles.term_linear
+
+
+class Intercept(lsl.Var):
+    def __init__(
+        self,
+        name: str,
+        value: Array | float = 0.0,
+        distribution: lsl.Dist | None = None,
+        inference: InferenceTypes = None,
+    ) -> None:
+        super().__init__(
+            value=value, distribution=distribution, name=name, inference=inference
+        )
+        self.parameter = True
+        self.role = Roles.intercept
+
+
+class Basis(lsl.Var):
+    def __init__(
+        self,
+        value: lsl.Var | lsl.Node,
+        basis_fn: Callable[[Array], Array] | Callable[..., Array],
+        *args,
+        name: str | None = None,
+        **kwargs,
+    ) -> None:
+        try:
+            value_ar = jnp.asarray(value.value)
+        except AttributeError:
+            raise TypeError(f"{value=} should be a liesel.model.Var instance.")
+
+        dtype = value_ar.dtype
+
+        input_shape = jnp.shape(basis_fn(value_ar, *args, **kwargs))
+        if len(input_shape):
+            k = input_shape[-1]
+
+        def fn(x):
+            n = jnp.shape(jnp.atleast_1d(x))[0]
+            if len(input_shape) == 2:
+                shape = (n, k)
+            elif len(input_shape) == 1:
+                shape = (n,)
+            elif not len(input_shape):
+                shape = ()
+            else:
+                raise RuntimeError(
+                    "Return shape of 'basis_fn(value)' must"
+                    " have <= dimensions, got {input_shape}"
+                )
+            result_shape = jax.ShapeDtypeStruct(shape, dtype)
+            result = jax.pure_callback(
+                basis_fn, result_shape, x, *args, vmap_method="sequential", **kwargs
+            )
+            return result
+
+        if not value.name:
+            raise ValueError(f"{value=} must be named.")
+
+        if name is None:
+            name_ = f"B({value.name})"
+
+        super().__init__(lsl.Calc(fn, value, _name=name_ + "_calc"), name=name_)
+        self.update()
+        self.role = Roles.basis

liesel_gam-0.0.4.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: liesel_gam
+Version: 0.0.4
+Summary: Functionality for Generalized Additive Models in Liesel
+Author: Johannes Brachem
+License-File: LICENSE
+Keywords: machine-learning,statistics
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+Requires-Dist: liesel>=0.4
+Description-Content-Type: text/markdown
+
+# Generalized Additive Models Functionality in Liesel
+
+[![pre-commit](https://github.com/liesel-devs/liesel_gam/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/liesel-devs/liesel_gam/actions/workflows/pre-commit.yml)
+[![pytest](https://github.com/liesel-devs/liesel_gam/actions/workflows/pytest.yml/badge.svg)](https://github.com/liesel-devs/liesel_gam/actions/workflows/pytest.yml)
+[![pytest-cov](tests/coverage.svg)](https://github.com/liesel-devs/liesel_gam/actions/workflows/pytest.yml)
+
+This package provides functionality to make the setup of
+semiparametric generalized additive distributional regression models in [Liesel](https://github.com/liesel-devs/liesel)
+convenient. It works nicely with [liesel-devs/smoothcon](https://github.com/liesel-devs/smoothcon),
+which can be used to obtain basis and penalty matrices from the R package [mgcv](https://cran.r-project.org/web/packages/mgcv/index.html).
+
+## Disclaimer
+
+This package is experimental and under active development. That means:
+
+- The API cannot be considered stable. If you depend on this package, pin the version.
+- Testing has not been extensive as of now. Please check and verify!
+- There is currently no documentation beyond this readme.
+
+In any case, this package comes with no warranty or guarantees.
+
+## Installation
+
+You can install the development version from GitHub via pip:
+
+```bash
+pip install git+https://github.com/liesel-devs/liesel_gam.git
+```
+
+## Illustration
+
+This is a short pseudo-code illustration without real data. For full examples, please
+consider the [notebooks](https://github.com/liesel-devs/liesel_gam/blob/main/notebooks).
+
+```python
+import liesel.model as lsl
+import liesel.goose as gs
+
+import liesel_gam as gam
+
+import jax.numpy as jnp
+```
+
+Set up the response model.
+
+```python
+loc = gam.AdditivePredictor("loc")
+scale = gam.AdditivePredictor("scale", inv_link=jnp.exp) # terms will be added on the linked level
+
+y = lsl.Var.new_obs(
+    value=...,
+    distribution=lsl.Dist(..., loc=loc, scale=scale),
+    name="y"
+)
+```
+
+Add intercept terms
+
+```python
+loc += gam.Intercept(
+    value=0.0, # this is the default
+    distribution=None, # this is the default
+    inference=gs.MCMCSpec(gs.IWLSKernel), # supply inference information here
+    name="b0"
+)
+
+scale += gam.Intercept( # this term will be applied on the log link level
+    value=0.0,
+    distribution=None,
+    inference=gs.MCMCSpec(gs.IWLSKernel),
+    name="g0"
+)
+
+```
+
+Add a smooth term, which can be any structured additive term defined by a basis matrix
+and a penalty matrix. A potentially rank-deficient multivariate normal prior will
+be set up for the coefficient of this term.
+
+```python
+loc += gam.SmoothTerm(
+    basis=...,
+    penalty=...,
+    scale=lsl.Var.new_param(..., name="tau"),
+    inference=gs.MCMCSpec(gs.IWLSKernel),
+    name="s(x)"
+)
+```
+
+Add a linear term.
+
+```python
+loc += gam.LinearTerm(
+    x=..., # 1d-array or 2d-array are both allowed
+    distribution=lsl.Dist(...),
+    inference=gs.MCMCSpec(gs.IWLSKernel),
+    name="x"
+)
+```
+
+Get a Liesel EngineBuilder instance to set up MCMC sampling.
+
+```python
+model = lsl.Model([y])
+eb = gs.LieselMCMC(model).get_engine_builder() # get your engine builder instance
+```
+
+## Contents
+
+```python
+import liesel.model as lsl
+import liesel.goose as gs
+
+import liesel_gam as gam
+```
+
+This package provides the following classes and functions:
+
+- `gam.AdditivePredictor`: A `lsl.Var` object that provides a convenient way to define an additive predictor.
+- `gam.SmoothTerm`: A `lsl.Var` object that provides a convenient way to set up a structured additive term with a singular multivariate normal prior, given a basis matrix, a penalty matrix, and a `lsl.Var` representing the prior scale parameter.
+  - The alternative constructor `gam.SmoothTerm.new_ig` can be used to quickly set up a term with an inverse gamma prior on the prior variance parameter. This variance parameter will be initialized with a suitable Gibbs kernel.
+- `gam.LinearTerm`: A `lsl.Var` object that provides a convenient way to set up a linear term.
+- `gam.Intercept`: A `lsl.Var` parameter object that represents an intercept.
+- `gam.Basis`: An observed `lsl.Var` object that represents a basis matrix.
+
+A bit more behind the scenes:
+
+- `gam.MultivariateNormalSingular`: An implementation of the singular multivariate normal distribution in the `tensorflow_probability` interface.
+- `gam.star_ig_gibbs` and `gam.init_star_ig_gibbs`: Shortcuts for setting up a `gs.GibbsKernel` for a variance parameter with an inverse gamma prior.
+
+## Usage
+
+Usage is illustrated in the following notebooks.
+
+- [notebooks/test_gam_gibbs.ipynb](https://github.com/liesel-devs/liesel_gam/blob/main/notebooks/test_gam_gibbs.ipynb): Uses the `gam.SmoothTerm.new_ig` constructor for the quickest and most convenient setup.
+- [notebooks/test_gam_manual.ipynb](https://github.com/liesel-devs/liesel_gam/blob/main/notebooks/test_gam_manual.ipynb): Uses `gam.SmoothTerm` with a manually initialized scale parameter. This is less convenient, but demonstrates how to use any  `lsl.Var` for the scale parameter.
+
+## Usage with bases and penalties from `mgcv` via `smoothcon`
+
+We can get access to a large class of possible basis and penalty matrices by
+interfacing with the wonderful R package [mgcv](https://cran.r-project.org/web/packages/mgcv/index.html)
+via [liesel-devs/smoothcon](https://github.com/liesel-devs/smoothcon).
+
+Example notebooks that illustrate smoothcon usage are provided in the [smoothcon
+repository](https://github.com/liesel-devs/smoothcon/tree/main/notebooks).

liesel_gam-0.0.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+liesel_gam/__about__.py,sha256=1mptEzQihbdyqqzMgdns_j5ZGK9gz7hR2bsgA_TnjO4,22
+liesel_gam/__init__.py,sha256=BlkbwITQP5raDtDdtg69C5yZB_pdptVcwgE3uAJWvNQ,455
+liesel_gam/dist.py,sha256=ZrxMjGRqNWWNGE2NAPAfvabEO6QeHteZaKFG-G6BFBI,3466
+liesel_gam/kernel.py,sha256=x1cPHf8orgv_X1824GYvgjIYPLydljq2Gp3xEgvAMSE,1552
+liesel_gam/predictor.py,sha256=SMfo7fybgAcYN9WqSyyCMmic_5GROUv6ui_aRzXdJwc,1473
+liesel_gam/roles.py,sha256=eZeuZI5YccNzlrgqOR5ltREB4dRBV4k4afZt9701doM,335
+liesel_gam/var.py,sha256=4-KEQLupQUok8ZWaiL-UF0eSRnXndeamtc3dyg6TbI0,6444
+liesel_gam-0.0.4.dist-info/METADATA,sha256=y7ldCSSJaS-h9P0LoDKV2DMBteYisdBIjD5NpD2Ry64,6067
+liesel_gam-0.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+liesel_gam-0.0.4.dist-info/licenses/LICENSE,sha256=pjhYbDHmDl8Gms9kI5nPaJoWte2QGB0F6Cwa1r9jsQ0,1063
+liesel_gam-0.0.4.dist-info/RECORD,,

liesel_gam-0.0.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

liesel_gam-0.0.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Liesel
+
+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.