gemlib 0.9.2__py3-none-any.whl

gemlib/mcmc/gibbs_kernel_test.py

@@ -0,0 +1,212 @@
+"""Test GibbsKernel"""
+
+# Dependency imports
+
+from collections import namedtuple
+
+import numpy as np
+import tensorflow as tf
+import tensorflow_probability as tfp
+from tensorflow_probability.python import distributions as tfd
+from tensorflow_probability.python.internal import test_util
+
+from gemlib.mcmc.gibbs_kernel import GibbsKernel, GibbsStep
+
+
+@test_util.test_all_tf_execution_regimes
+class TestGibbsKernel(test_util.TestCase):
+    def test_2d_mvn(self):
+        """Sample from 2-variate MVN Distribution."""
+        dtype = np.float32
+        true_mean = dtype([1, 1])
+        true_cov = dtype([[1, 0.5], [0.5, 1]])
+        target = tfd.MultivariateNormalTriL(
+            loc=true_mean, scale_tril=tf.linalg.cholesky(true_cov)
+        )
+
+        def logp(x1, x2):
+            return target.log_prob([x1, x2])
+
+        def kernel_make_fn(target_log_prob_fn, state):
+            return tfp.mcmc.RandomWalkMetropolis(
+                target_log_prob_fn=target_log_prob_fn
+            )
+
+        kernel_list = [(0, kernel_make_fn), (1, kernel_make_fn)]
+        kernel = GibbsKernel(target_log_prob_fn=logp, kernel_list=kernel_list)
+        samples = tfp.mcmc.sample_chain(
+            num_results=2000,
+            current_state=[dtype(1), dtype(1)],
+            kernel=kernel,
+            num_burnin_steps=500,
+            trace_fn=None,
+        )
+
+        sample_mean = tf.math.reduce_mean(samples, axis=1)
+        [sample_mean_] = self.evaluate([sample_mean])
+        self.assertAllClose(sample_mean_, true_mean, atol=0.2, rtol=0.2)
+
+        sample_cov = tfp.stats.covariance(tf.transpose(samples))
+        sample_cov_ = self.evaluate(sample_cov)
+        self.assertAllClose(sample_cov_, true_cov, atol=0.1, rtol=0.1)
+
+    def test_2d_mvn_namedtuple(self):
+        """Sample from 2-variate MVN Distribution."""
+        dtype = np.float32
+        true_mean = dtype([1, 1])
+        true_cov = dtype([[1, 0.5], [0.5, 1]])
+        target = tfd.MultivariateNormalTriL(
+            loc=true_mean, scale_tril=tf.linalg.cholesky(true_cov)
+        )
+
+        def logp(x, y):
+            return target.log_prob([x, y])
+
+        def kernel_make_fn(target_log_prob_fn, state):
+            return tfp.mcmc.RandomWalkMetropolis(
+                target_log_prob_fn=target_log_prob_fn
+            )
+
+        kernel_list = [
+            GibbsStep("x", kernel_make_fn),
+            GibbsStep("y", kernel_make_fn),
+        ]
+        kernel = GibbsKernel(target_log_prob_fn=logp, kernel_list=kernel_list)
+        StateTuple = namedtuple("StateTuple", ["x", "y"])
+        current_state = StateTuple(dtype(1), dtype(1))
+
+        samples = tfp.mcmc.sample_chain(
+            num_results=2000,
+            current_state=current_state,
+            kernel=kernel,
+            num_burnin_steps=500,
+            trace_fn=None,
+        )
+
+        sample_mean = tf.math.reduce_mean(samples, axis=1)
+        [sample_mean_] = self.evaluate([sample_mean])
+        self.assertAllClose(sample_mean_, true_mean, atol=0.2, rtol=0.2)
+
+        sample_cov = tfp.stats.covariance(tf.transpose(samples))
+        sample_cov_ = self.evaluate(sample_cov)
+        self.assertAllClose(sample_cov_, true_cov, atol=0.1, rtol=0.1)
+
+    def test_float64(self):
+        """Sample with dtype float64."""
+        dtype = np.float64
+        true_mean = dtype([1, 1])
+        true_cov = dtype([[1, 0.5], [0.5, 1]])
+        target = tfd.MultivariateNormalTriL(
+            loc=true_mean, scale_tril=tf.linalg.cholesky(true_cov)
+        )
+
+        def logp(x1, x2):
+            return target.log_prob([x1, x2])
+
+        def kernel_make_fn(target_log_prob_fn, state):
+            return tfp.mcmc.RandomWalkMetropolis(
+                target_log_prob_fn=target_log_prob_fn
+            )
+
+        kernel_list = [(0, kernel_make_fn), (1, kernel_make_fn)]
+        kernel = GibbsKernel(target_log_prob_fn=logp, kernel_list=kernel_list)
+        tfp.mcmc.sample_chain(
+            num_results=20,
+            current_state=[dtype(1), dtype(1)],
+            kernel=kernel,
+            trace_fn=None,
+        )
+
+    def test_bijector(self):
+        """Employ bijector when sampling."""
+        dtype = np.float32
+        true_mean = dtype([1, 1])
+        true_cov = dtype([[1, 0.5], [0.5, 1]])
+        target = tfd.MultivariateNormalTriL(
+            loc=true_mean, scale_tril=tf.linalg.cholesky(true_cov)
+        )
+
+        def logp(x1, x2):
+            return target.log_prob([x1, x2])
+
+        def kernel_make_fn(target_log_prob_fn, state):
+            inner_kernel = tfp.mcmc.RandomWalkMetropolis(
+                target_log_prob_fn=target_log_prob_fn
+            )
+            return tfp.mcmc.TransformedTransitionKernel(
+                inner_kernel=inner_kernel, bijector=tfp.bijectors.Exp()
+            )
+
+        kernel_list = [(0, kernel_make_fn), (1, kernel_make_fn)]
+        kernel = GibbsKernel(target_log_prob_fn=logp, kernel_list=kernel_list)
+        tfp.mcmc.sample_chain(
+            num_results=20,
+            current_state=[dtype(1), dtype(1)],
+            kernel=kernel,
+            trace_fn=None,
+        )
+
+    def test_gradient_based_sampler(self):
+        """Make sure Gibbs kernel is compatible with gradient-based
+        samplers
+        """
+        dtype = np.float32
+        true_mean = dtype([1, 1])
+        true_cov = dtype([[1, 0.5], [0.5, 1]])
+        target = tfd.MultivariateNormalTriL(
+            loc=true_mean, scale_tril=tf.linalg.cholesky(true_cov)
+        )
+
+        def logp(x1, x2):
+            return target.log_prob([x1, x2])
+
+        def kernel_make_rwm_fn(target_log_prob_fn, state):
+            inner_kernel = tfp.mcmc.RandomWalkMetropolis(
+                target_log_prob_fn=target_log_prob_fn
+            )
+            return tfp.mcmc.TransformedTransitionKernel(
+                inner_kernel=inner_kernel, bijector=tfp.bijectors.Exp()
+            )
+
+        def kernel_make_hmc_fn(target_log_prob_fn, state):
+            inner_kernel = tfp.mcmc.HamiltonianMonteCarlo(
+                target_log_prob_fn=target_log_prob_fn,
+                step_size=0.1,
+                num_leapfrog_steps=3,
+            )
+            return tfp.mcmc.TransformedTransitionKernel(
+                inner_kernel=inner_kernel, bijector=tfp.bijectors.Exp()
+            )
+
+        kernel_list = [(0, kernel_make_rwm_fn), (1, kernel_make_hmc_fn)]
+        kernel = GibbsKernel(target_log_prob_fn=logp, kernel_list=kernel_list)
+        tfp.mcmc.sample_chain(
+            num_results=20,
+            current_state=[dtype(1), dtype(1)],
+            kernel=kernel,
+            trace_fn=None,
+        )
+
+    def test_is_calibrated(self):
+        dtype = np.float32
+        true_mean = dtype([1, 1])
+        true_cov = dtype([[1, 0.5], [0.5, 1]])
+        target = tfd.MultivariateNormalTriL(
+            loc=true_mean, scale_tril=tf.linalg.cholesky(true_cov)
+        )
+
+        def logp(x1, x2):
+            return target.log_prob([x1, x2])
+
+        def kernel_make_fn(target_log_prob_fn, state):
+            return tfp.mcmc.RandomWalkMetropolis(
+                target_log_prob_fn=target_log_prob_fn
+            )
+
+        kernel_list = [(0, kernel_make_fn), (1, kernel_make_fn)]
+        kernel = GibbsKernel(target_log_prob_fn=logp, kernel_list=kernel_list)
+        self.assertTrue(kernel.is_calibrated)
+
+
+if __name__ == "__main__":
+    tf.test.main()

gemlib/mcmc/h5_posterior.py

@@ -0,0 +1,77 @@
+"""Class for writing posterior samples"""
+
+import h5py
+
+
+def _maybe_tf_dtype(dtype):
+    if hasattr(dtype, "as_numpy_dtype"):
+        return dtype.as_numpy_dtype
+    return dtype
+
+
+def _maybe_to_numpy(val):
+    if hasattr(val, "numpy"):
+        return val.numpy()
+    return val
+
+
+class Posterior:
+    def __init__(self, filename, sample_dict, results_dict, num_samples):
+        """Constructs a posterior output object
+
+        :param filename: the name of the backend HDF5 file
+        :param sample_dict: a dictionary containing `key`:`shape_tuple`
+        :param results_dict: a dictionary containing `key`:`shape_tuple`
+        :param num_samples: total number of samples
+        """
+        self._num_samples = num_samples
+        self._file = h5py.File(
+            filename,
+            "w",
+            rdcc_nbytes=1024**2 * 400,
+            rdcc_nslots=100000,
+            libver="latest",
+        )
+        self._file.swmr_mode = True
+
+        self._sample_group = self._file.create_group("samples")
+        self._create_data_tree(sample_dict, self._sample_group)
+
+        self._results_group = self._file.create_group("results")
+        self._create_data_tree(results_dict, self._results_group)
+
+    def __del__(self):
+        self._file.close()
+
+    def __getitem__(self, path):
+        return self._file[path]
+
+    def _create_data_tree(self, data_dict, h5dataset):
+        for k, v in data_dict.items():
+            if isinstance(v, dict):
+                h5group = h5dataset.create_group(k)
+                self._create_data_tree(v, h5group)
+
+            else:
+                h5dataset.create_dataset(
+                    k,
+                    (self._num_samples,) + v.shape[1:],
+                    dtype=_maybe_tf_dtype(v.dtype),
+                    compression="gzip",
+                )
+
+    def _write(self, sample_dict, dset, first_dim_offset=0):
+        for k, v in sample_dict.items():
+            if isinstance(v, dict):
+                self._write(v, dset[k], first_dim_offset)
+            else:
+                s = slice(first_dim_offset, first_dim_offset + v.shape[0])
+                dset[k][s, ...] = _maybe_to_numpy(v)
+
+    def write_samples(self, samples_dict, first_dim_offset=0):
+        self._write(samples_dict, self._sample_group, first_dim_offset)
+        self._file.flush()
+
+    def write_results(self, results_dict, first_dim_offset=0):
+        self._write(results_dict, self._results_group, first_dim_offset)
+        self._file.flush()

gemlib/mcmc/multi_scan_kernel.py

@@ -0,0 +1,59 @@
+"""MultiScanKernel calls one_step a number of times on an inner kernel"""
+
+import tensorflow as tf
+import tensorflow_probability as tfp
+from tensorflow_probability.python.internal import samplers
+
+mcmc = tfp.mcmc
+
+
+class MultiScanKernel(mcmc.TransitionKernel):
+    def __init__(self, num_updates, inner_kernel, name=None):
+        """Performs multiple steps of an inner kernel
+           returning the state and results after the last step.
+
+        :param num_updates: integer giving the number of updates
+        :param inner_kernel: an instance of a `tfp.mcmc.TransitionKernel`
+        """
+        self._parameters = {
+            "num_updates": num_updates,
+            "inner_kernel": inner_kernel,
+            "name": name,
+        }
+
+    @property
+    def is_calibrated(self):
+        return True
+
+    @property
+    def num_updates(self):
+        return self._parameters["num_updates"]
+
+    @property
+    def inner_kernel(self):
+        return self._parameters["inner_kernel"]
+
+    @property
+    def name(self):
+        return self._parameters["name"]
+
+    def one_step(self, current_state, prev_results, seed=None):
+        seed = samplers.sanitize_seed(seed, salt="MultiScanKernel")
+
+        def body(i, state, results, seed):
+            this_seed, next_seed = samplers.split_seed(seed)
+            state, results = self.inner_kernel.one_step(
+                state, results, this_seed
+            )
+            return i + 1, state, results, next_seed
+
+        def cond(i, *_):
+            return i < self.num_updates
+
+        _, next_state, next_results, _ = tf.while_loop(
+            cond, body, (0, current_state, prev_results, seed)
+        )
+        return next_state, next_results
+
+    def bootstrap_results(self, current_state):
+        return self.inner_kernel.bootstrap_results(current_state)

gemlib/mcmc/zarr_posterior.py

@@ -0,0 +1,132 @@
+"""Class for writing posterior samples"""
+
+import math
+from datetime import datetime
+from typing import Tuple
+
+import numpy as np
+import zarr
+
+import gemlib
+
+__all__ = ["ZarrPosterior"]
+
+CHUNK_BASE = 100 * 1024 * 1024  # Multiplier by which chunks are adjusted
+CHUNK_MIN = 128 * 1024  # Soft lower limit (128k)
+CHUNK_MAX = 300 * 1024 * 1024  # Hard upper limit
+
+
+def _guess_chunks(shape: Tuple[int, ...], typesize: int) -> Tuple[int, ...]:
+    """Guess an appropriate chunk layout for an array, given its shape and
+    the size of each element in bytes.  Will allocate chunks only as large
+    as MAX_SIZE.  Chunks are generally close to some power-of-2 fraction of
+    each axis, slightly favoring bigger values for the last index.
+    Undocumented and subject to change without warning.
+    """
+    ndims = len(shape)
+    # require chunks to have non-zero length for all dimensions
+    chunks = np.maximum(np.array(shape, dtype="=f8"), 1)
+
+    # Determine the optimal chunk size in bytes using a PyTables expression.
+    # This is kept as a float.
+    dset_size = np.product(chunks) * typesize
+    target_size = CHUNK_BASE * (2 ** np.log10(dset_size / (1024.0 * 1024)))
+
+    if target_size > CHUNK_MAX:
+        target_size = CHUNK_MAX
+    elif target_size < CHUNK_MIN:
+        target_size = CHUNK_MIN
+
+    idx = 0
+    while True:
+        # Repeatedly loop over the axes, dividing them by 2.  Stop when:
+        # 1a. We're smaller than the target chunk size, OR
+        # 1b. We're within 50% of the target chunk size, AND
+        # 2. The chunk is smaller than the maximum chunk size
+        chunk_bytes = np.product(chunks) * typesize
+        if (
+            chunk_bytes < target_size
+            or abs(chunk_bytes - target_size) / target_size < 0.5  # noqa: PLR2004
+        ) and chunk_bytes < CHUNK_MAX:
+            break
+
+        if np.product(chunks) == 1:
+            break  # Element size larger than CHUNK_MAX
+
+        chunks[idx % ndims] = math.ceil(chunks[idx % ndims] / 2.0)
+        idx += 1
+
+    return tuple(int(x) for x in chunks)
+
+
+def _maybe_tf_dtype(dtype):
+    if hasattr(dtype, "as_numpy_dtype"):
+        return dtype.as_numpy_dtype
+    return dtype
+
+
+def _maybe_to_numpy(val):
+    if hasattr(val, "numpy"):
+        return val.numpy()
+    return val
+
+
+class ZarrPosterior:
+    def __init__(self, filename, sample_dict, results_dict, num_samples):
+        """Constructs a posterior output object
+
+        :param filename: the name of the backend HDF5 file
+        :param sample_dict: a dictionary containing `key`:`shape_tuple`
+        :param results_dict: a dictionary containing `key`:`shape_tuple`
+        :param num_samples: total number of samples
+        """
+        self._num_samples = num_samples
+        self._archive = zarr.open(
+            filename,
+            "w",
+        )
+
+        self._sample_group = self._archive.create_group("samples")
+        self._create_data_tree(sample_dict, self._sample_group)
+
+        self._results_group = self._archive.create_group("results")
+        self._create_data_tree(results_dict, self._results_group)
+
+        self._archive.attrs["created_at"] = str(datetime.now())
+        self._archive.attrs["inference_library"] = "gemlib"
+        self._archive.attrs["inference_library_version"] = gemlib.__version__
+
+    def __getitem__(self, path):
+        return self._archive[path]
+
+    def _create_data_tree(self, data_dict, group):
+        for k, v in data_dict.items():
+            if isinstance(v, dict):
+                subgroup = group.create_group(k)
+                self._create_data_tree(v, subgroup)
+
+            else:
+                dtype = _maybe_tf_dtype(v.dtype)
+                chunks = _guess_chunks(
+                    shape=(self._num_samples,) + v.shape,
+                    typesize=np.dtype(dtype).itemsize,
+                )
+                dset_shape = (0,) + v.shape
+
+                group.create_dataset(
+                    k,
+                    shape=dset_shape,
+                    chunks=chunks,
+                    dtype=dtype,
+                )
+
+    def _append(self, sample_dict, dset):
+        for k, v in sample_dict.items():
+            if isinstance(v, dict):
+                self._append(v, dset[k])
+            else:
+                dset[k].append(_maybe_to_numpy(v))
+
+    def append(self, samples_dict, results_dict):
+        self._append(samples_dict, self._sample_group)
+        self._append(results_dict, self._results_group)

gemlib/util.py

@@ -0,0 +1,117 @@
+"""Utility functions for model implementation code."""
+
+import numpy as np
+import tensorflow as tf
+
+
+def which(predicate):
+    """Return the indices of True elements of `predicate`."""
+    with tf.name_scope("which"):
+        x = tf.cast(predicate, dtype=tf.int32)
+        index_range = tf.range(x.shape[0])
+        indices = tf.cumsum(x) * x
+        indices = tf.scatter_nd(indices[:, None], index_range, x.shape)
+        return indices[1:]
+
+
+def batch_gather(arr, indices):
+    """Gather `indices` from the right-most dimensions of `arr`.
+
+    This function gathers elements on the right-most `indices` of `tensor`
+
+    Args
+    ----
+        arr: an N-dimensional tensor
+        indices: an iterable of N-dimensional coordinates into the rightmost
+             `indices.shape[-1]` dimensions of `arr`
+
+    Returns
+    -------
+    A tensor of dimension `rank(arr) - indices.shape[-1]` of gathered values in
+    `arr`.
+    """
+
+    arr = tf.convert_to_tensor(arr)
+    # TF shapes and indices are 32 bit
+    indices = tf.cast(tf.convert_to_tensor(indices), tf.int32)
+
+    index_dims = indices.shape[-1]
+
+    # Flatten the dims which we are indexing - this is cheap, as no data needs
+    # to be copied.  `flat_arr` is just a "view" of `arr`.
+    flat_shape = arr.shape[:-index_dims].as_list() + [
+        np.prod(arr.shape[-index_dims:])
+    ]
+    flat_arr = tf.reshape(arr, shape=flat_shape)
+
+    # Compute the stride for each dim in the indices
+    flat_coord_stride = tf.math.cumprod(
+        tf.concat(
+            [arr.shape[arr.shape.rank - (index_dims - 1) :], [1]], axis=0
+        ),
+        axis=0,
+        reverse=True,
+    )
+    flat_indices = tf.linalg.matvec(indices, flat_coord_stride)
+
+    return tf.gather(flat_arr, flat_indices, axis=-1)
+
+
+def transition_coords(incidence_matrix):
+    """Compute coordinates of transitions in a Markov transition matrix
+
+    Args
+    ----
+        incidence_matrix: a (batch of) `[S, R]` matrix describing R
+                          transitions between S states.
+
+    Returns
+    -------
+    a [..., R, 2] tensor of coordinates of the transitions in a square
+        transition matrix.
+    """
+
+    incidence_matrix = tf.convert_to_tensor(incidence_matrix)
+
+    is_src_dest = tf.stack(
+        [incidence_matrix < 0, incidence_matrix > 0], axis=-1
+    )
+
+    coords = tf.reduce_sum(
+        tf.cumsum(
+            tf.cast(is_src_dest, tf.int64),
+            exclusive=True,
+            reverse=True,
+            axis=-3,
+        ),
+        axis=-3,
+    )
+
+    return coords
+
+
+def states_from_transition_idx(
+    transition_index, incidence_matrix, output_type=tf.int32
+):
+    """Return source and destination state indices given a transition index.
+
+    Given the index of a transition in `stoichiometry`, return
+    the indices of the source and destination states.
+
+    Note: this algorithm depends on the stoichiometry matrix
+    describing a state transition model and taking the values `[-1, 0, 1]`.
+
+    Args:
+    ----
+        event_index: the index (row id) of the event in `stoichiometry`
+        incidence_matrix: a `[S, R]` matrix relating transitions to states
+
+    Returns:
+    -------
+        a tuple of integers denoting indices of `(src, dest)`.
+
+    """
+    transition_index = tf.convert_to_tensor(transition_index, tf.int32)
+    coords = transition_coords(incidence_matrix)[..., transition_index, :]
+
+    return coords[..., 0], coords[..., 1]

gemlib/util_test.py

@@ -0,0 +1,75 @@
+"""Test `gemlib` utility functions."""
+
+import numpy as np
+import pytest
+
+from gemlib.util import (
+    batch_gather,
+    states_from_transition_idx,
+    transition_coords,
+)
+
+
+@pytest.fixture
+def svir_incidence():
+    """Fixture for SVIR incidence matrix."""
+
+    return np.array(
+        [  # SI   SV VI IR
+            [-1, -1, 0, 0],  # S
+            [0, 1, -1, 0],  # V
+            [1, 0, 1, -1],  # I
+            [0, 0, 0, 1],  # R
+        ]
+    )
+
+
+@pytest.fixture
+def sirs_incidence():
+    """Fixture for SIRS incidence matrix."""
+
+    return np.array(
+        [  #  SI  IR  RS
+            [-1, 0, 1],  # S
+            [1, -1, 0],  # I
+            [0, 1, -1],  # R
+        ],
+    )
+
+
+def test_transition_coords_svir(svir_incidence):
+    # Test svir
+    coords = transition_coords(svir_incidence)
+    expected = np.array([[0, 2], [0, 1], [1, 2], [2, 3]])
+    np.testing.assert_equal(coords, expected)
+
+
+def test_transition_coords_sirs(sirs_incidence):
+    # Test SIRS
+    coords = transition_coords(sirs_incidence)
+    expected = np.array([[0, 1], [1, 2], [2, 0]])
+    np.testing.assert_equal(coords, expected)
+
+
+def test_states_from_transition_idx(svir_incidence):
+    """Ensure source and destination enums are correct."""
+    # S->I
+    assert states_from_transition_idx(0, svir_incidence) == (0, 2)
+    # S->V
+    assert states_from_transition_idx(1, svir_incidence) == (0, 1)
+    # V->I
+    assert states_from_transition_idx(2, svir_incidence) == (1, 2)
+    # I->R
+    assert states_from_transition_idx(3, svir_incidence) == (2, 3)
+
+
+def test_batch_gather():
+    arr = np.random.uniform(low=0, high=1, size=[20, 100, 30, 20])
+
+    indices = np.array([[2, 3], [4, 7], [15, 10]])
+
+    slice_arr = batch_gather(arr, indices)
+
+    np.testing.assert_array_equal(
+        slice_arr, arr[..., indices[:, 0], indices[:, 1]]
+    )

gemlib-0.9.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 The GEM Authors.  All rights reserved.
+
+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.