infoweight 0.0.1__tar.gz

infoweight-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2020, John Healy, Leland McInnes, Colin Weir and Vectorizers contributors
+Copyright (c) 2026 Ryan DeWolfe
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of project-template nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

infoweight-0.0.1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: infoweight
+Version: 0.0.1
+Summary: An information theoretic generalization of TF-IDF.
+Maintainer-email: Ryan DeWolfe <ryan.dewolfe@uwaterloo.ca>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/ryandewolfe33/infoweight
+Project-URL: Repository, https://github.com/ryandewolfe33/infoweight
+Keywords: tfidf,information theory,metric learning,unsupervised learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: numba>=0.51
+Requires-Dist: scikit-learn>=0.22
+Requires-Dist: scipy
+Dynamic: license-file
+
+===========
+Infoweight
+===========
+
+This package provides an information theoretic generalization of the `TFIDFTransformer`.
+
+
+This package is still under development,
+The `InformationWeightTransformer` was originally part of the
+`vectorizers <https://github.com/TutteInstitute/vectorizers>`_
+package, but has been factored out to ease development. You can find an
+overview and example of using the package in the
+`vectorizers documentation <https://vectorizers.readthedocs.io/en/latest/>`_.
+
+----------
+Installing
+----------
+
+To install the package from PyPI:
+
+.. code:: bash
+
+    pip install infoweight
+
+Or to clone and install locally:
+.. code:: bash
+
+    git clone https://github.com/ryandewolfe33/infoweight.git &&
+    cd infoweight &&
+    pip install .
+
+To install the package from source:
+
+.. code:: bash
+
+    pip install https://github.com/ryandewolfe33/infoweight/archive/master.zip
+
+------------
+Contributing
+------------
+
+Contributions are more than welcome! There are lots of opportunities
+for potential projects, so please get in touch if you would like to
+help out. Everything from code to notebooks to examples and documentation
+are all *equally valuable* so please don't feel you can't contribute. 
+
+
+To contribute please `fork the project <https://github.com/ryandewolfe33/infoweight/issues#fork-destination-box>`_
+make your changes and submit a pull request. We will do our best to work
+through any issues with you and get your code merged into the main branch.
+
+-------
+License
+-------
+
+The infoweight package is 3-clause BSD licensed.

infoweight-0.0.1/README.rst

@@ -0,0 +1,56 @@
+===========
+Infoweight
+===========
+
+This package provides an information theoretic generalization of the `TFIDFTransformer`.
+
+
+This package is still under development,
+The `InformationWeightTransformer` was originally part of the
+`vectorizers <https://github.com/TutteInstitute/vectorizers>`_
+package, but has been factored out to ease development. You can find an
+overview and example of using the package in the
+`vectorizers documentation <https://vectorizers.readthedocs.io/en/latest/>`_.
+
+----------
+Installing
+----------
+
+To install the package from PyPI:
+
+.. code:: bash
+
+    pip install infoweight
+
+Or to clone and install locally:
+.. code:: bash
+
+    git clone https://github.com/ryandewolfe33/infoweight.git &&
+    cd infoweight &&
+    pip install .
+
+To install the package from source:
+
+.. code:: bash
+
+    pip install https://github.com/ryandewolfe33/infoweight/archive/master.zip
+
+------------
+Contributing
+------------
+
+Contributions are more than welcome! There are lots of opportunities
+for potential projects, so please get in touch if you would like to
+help out. Everything from code to notebooks to examples and documentation
+are all *equally valuable* so please don't feel you can't contribute. 
+
+
+To contribute please `fork the project <https://github.com/ryandewolfe33/infoweight/issues#fork-destination-box>`_
+make your changes and submit a pull request. We will do our best to work
+through any issues with you and get your code merged into the main branch.
+
+-------
+License
+-------
+
+The infoweight package is 3-clause BSD licensed.

infoweight-0.0.1/infoweight/__init__.py

@@ -0,0 +1,4 @@
+from .infoweight import (
+    InformationWeightTransformer,
+    information_weight,
+)

infoweight-0.0.1/infoweight/infoweight.py

@@ -0,0 +1,375 @@
+import numba
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+import scipy.sparse
+
+MOCK_TARGET = np.ones(1, dtype=np.int64)
+MOCK_BOOL = np.ones(1, dtype=np.bool)
+
+
+@numba.njit(nogil=True)
+def column_kl_divergence_exact_prior(
+    count_indices,
+    count_data,
+    baseline_probabilities,
+    prior_strength=0.1,
+    target=MOCK_TARGET,
+):
+    observed_norm = count_data.sum() + prior_strength
+    observed_zero_constant = (prior_strength / observed_norm) * np.log(
+        prior_strength / observed_norm
+    )
+    result = 0.0
+    count_indices_set = set(count_indices)
+    for i in range(baseline_probabilities.shape[0]):
+        if i in count_indices_set:
+            idx = np.searchsorted(count_indices, i)
+            observed_probability = (
+                count_data[idx] + prior_strength * baseline_probabilities[i]
+            ) / observed_norm
+            if observed_probability > 0.0:
+                result += observed_probability * np.log(
+                    observed_probability / baseline_probabilities[i]
+                )
+        else:
+            result += baseline_probabilities[i] * observed_zero_constant
+
+    return result
+
+
+@numba.njit(nogil=True)
+def column_kl_divergence_approx_prior(
+    count_indices,
+    count_data,
+    baseline_probabilities,
+    prior_strength=0.1,
+    target=MOCK_TARGET,
+):
+    observed_norm = count_data.sum() + prior_strength
+    observed_zero_constant = (prior_strength / observed_norm) * np.log(
+        prior_strength / observed_norm
+    )
+    result = 0.0
+    zero_count_component_estimate = (
+        np.mean(baseline_probabilities)
+        * observed_zero_constant
+        * (baseline_probabilities.shape[0] - count_indices.shape[0])
+    )
+    result += zero_count_component_estimate
+    for i in range(count_indices.shape[0]):
+        idx = count_indices[i]
+        observed_probability = (
+            count_data[i] + prior_strength * baseline_probabilities[idx]
+        ) / observed_norm
+        if observed_probability > 0.0 and baseline_probabilities[idx] > 0:
+            result += observed_probability * np.log(
+                observed_probability / baseline_probabilities[idx]
+            )
+
+    return result
+
+
+@numba.njit(nogil=True)
+def supervised_column_kl(
+    count_indices,
+    count_data,
+    baseline_probabilities,
+    prior_strength=0.1,
+    target=MOCK_TARGET,
+):
+    observed = np.zeros_like(baseline_probabilities)
+    for i in range(count_indices.shape[0]):
+        idx = count_indices[i]
+        label = target[idx]
+        if label >= 0:
+            observed[label] += count_data[i]
+
+    observed += prior_strength * baseline_probabilities
+    observed /= observed.sum()
+
+    # Zeros in baseline_probabilities may cause nans in the log
+    # But this can only happen when observed is also 0, so due
+    # to the multiplication it does not contribute to the sum
+    non_zero = observed > 0
+    result = np.sum(
+        observed[non_zero]
+        * np.log(observed[non_zero] / baseline_probabilities[non_zero])
+    )
+    return result
+
+
+@numba.njit(nogil=True, parallel=True)
+def column_weights(
+    indptr,
+    indices,
+    data,
+    baseline_probabilities,
+    column_kl_divergence_func,
+    prior_strength=0.1,
+    target=MOCK_TARGET,
+    column_groups=None,
+):
+    n_cols = indptr.shape[0] - 1
+    weights = np.ones(n_cols)
+    for i in numba.prange(n_cols):
+        group = 0
+        if column_groups is not None:
+            group = column_groups[i]
+        weights[i] = column_kl_divergence_func(
+            indices[indptr[i] : indptr[i + 1]],
+            data[indptr[i] : indptr[i + 1]],
+            baseline_probabilities[group, :],
+            prior_strength=prior_strength,
+            target=target,
+        )
+    return weights
+
+
+@numba.njit(nogil=True)
+def compute_baseline_probabilities(
+    indptr,
+    indices,
+    data,
+    target=None,
+    column_groups=None,
+):
+    """
+    Compute the marginals to compare each column to. Returns
+    an (n column groups) x (n samples) matrix (unsupervised) or an
+    (n column groups) x (n targets) matrix (supervised) where each
+    row is the marginal of the column group.
+
+    indptr, indices, and data arrays are from csr format.
+    """
+    n_groups = 1
+    if column_groups is not None:
+        n_groups = column_groups.max() + 1
+    n_targets = indptr.shape[0] - 1
+    if target is not None:
+        n_targets = target.max() + 1
+    counts = np.zeros((n_groups, n_targets), dtype=np.int64)
+    for row in range(indptr.shape[0] - 1):
+        this_target = row
+        if target is not None:
+            if target[row] >= 0:
+                this_target = target[row]
+            else:
+                continue
+        for i in range(indptr[row], indptr[row + 1]):
+            group = 0
+            if column_groups is not None:
+                group = column_groups[indices[i]]
+            counts[group, this_target] += data[i]
+    probabilities = counts / np.sum(counts, axis=1).reshape(-1, 1)
+    return probabilities
+
+
+def information_weight(
+    data,
+    prior_strength=0.1,
+    approximate_prior=False,
+    target=None,
+    column_groups=None,
+):
+    """Compute information based weights for columns. The information weight
+    is estimated as the amount of information gained by moving from a baseline
+    model to a model derived from the observed counts. In practice this can be
+    computed as the KL-divergence between distributions. For the baseline model
+    we assume data will be distributed according to the row sums -- i.e.
+    proportional to the frequency of the row. For the observed counts we use
+    a background prior of pseudo counts equal to ``prior_strength`` times the
+    baseline prior distribution. The Bayesian prior can either be computed
+    exactly (the default) at some computational expense, or estimated for a much
+    fast computation, often suitable for large or very sparse datasets.
+
+    Parameters
+    ----------
+    data: scipy sparse matrix (n_samples, n_features)
+        A matrix of count data where rows represent observations and
+        columns represent features. Column weightings will be learned
+        from this data.
+
+    prior_strength: float (optional, default=0.1)
+        How strongly to weight the prior when doing a Bayesian update to
+        derive a model based on observed counts of a column.
+
+    approximate_prior: bool (optional, default=False)
+        Whether to approximate weights based on the Bayesian prior or perform
+        exact computations. Approximations are much faster especially for very
+        large or very sparse datasets.
+
+    target: ndarray or None (optional, default=None)
+        If supervised target labels are available, these can be used to define distributions
+        over the target classes rather than over rows, allowing weights to be
+        supervised and target based. If None then unsupervised weighting is used.
+
+    column_groups: ndarray or None (optional, default=None)
+        If columns have a natural grouping, i.e. cols 10-15 are a one-hot-encoding of a single
+        categorical variable, we should compare the column distribution to the within group
+        marginal. If passed None then all columns have the same group.
+
+    Returns
+    -------
+    weights: ndarray of shape (n_features,)
+        The learned weights to be applied to columns based on the amount
+        of information provided by the column.
+    """
+    if target is not None:
+        column_kl_divergence_func = supervised_column_kl
+    elif approximate_prior:
+        column_kl_divergence_func = column_kl_divergence_approx_prior
+    else:
+        column_kl_divergence_func = column_kl_divergence_exact_prior
+
+    csr_data = data.tocsr()
+    baseline_probabilities = compute_baseline_probabilities(
+        csr_data.indptr,
+        csr_data.indices,
+        csr_data.data,
+        target,
+        column_groups,
+    )
+
+    csc_data = data.tocsc()
+    csc_data.sort_indices()
+    weights = column_weights(
+        csc_data.indptr,
+        csc_data.indices,
+        csc_data.data,
+        baseline_probabilities,
+        column_kl_divergence_func,
+        prior_strength=prior_strength,
+        target=target,
+        column_groups=column_groups,
+    )
+
+    return weights
+
+
+class InformationWeightTransformer(BaseEstimator, TransformerMixin):
+    """A data transformer that re-weights columns of count data. Column weights
+    are computed as information based weights for columns. The information weight
+    is estimated as the amount of information gained by moving from a baseline
+    model to a model derived from the observed counts. In practice this can be
+    computed as the KL-divergence between distributions. For the baseline model
+    we assume data will be distributed according to the row sums -- i.e.
+    proportional to the frequency of the row. For the observed counts we use
+    a background prior of pseudo counts equal to ``prior_strength`` times the
+    baseline prior distribution. The Bayesian prior can either be computed
+    exactly (the default) at some computational expense, or estimated for a much
+    fast computation, often suitable for large or very sparse datasets.
+
+    Parameters
+    ----------
+    prior_strength: float (optional, default=0.1)
+        How strongly to weight the prior when doing a Bayesian update to
+        derive a model based on observed counts of a column.
+
+    approximate_prior: bool (optional, default=False)
+        Whether to approximate weights based on the Bayesian prior or perform
+        exact computations. Approximations are much faster especially for very
+        large or very sparse datasets.
+
+    Attributes
+    ----------
+
+    information_weights_: ndarray of shape (n_features,)
+        The learned weights to be applied to columns based on the amount
+        of information provided by the column.
+    """
+
+    def __init__(
+        self,
+        prior_strength=1e-4,
+        approx_prior=True,
+        weight_power=2.0,
+        supervision_weight=0.95,
+    ):
+        self.prior_strength = prior_strength
+        self.approx_prior = approx_prior
+        self.weight_power = weight_power
+        self.supervision_weight = supervision_weight
+
+    def fit(self, X, y=None, column_groups=None, **fit_kwds):
+        """Learn the appropriate column weighting as information weights
+        from the observed count data ``X``.
+
+        Parameters
+        ----------
+        X: ndarray of scipy sparse matrix of shape (n_samples, n_features)
+            The count data to be trained on. Note that, as count data all
+            entries should be positive or zero.
+
+        Returns
+        -------
+        self:
+            The trained model.
+        """
+        if not scipy.sparse.isspmatrix(X):
+            X = scipy.sparse.csc_matrix(X)
+
+        self.information_weights_ = information_weight(
+            X,
+            self.prior_strength,
+            self.approx_prior,
+            column_groups=column_groups,
+        )
+
+        mean_weight = np.mean(self.information_weights_)
+        if mean_weight > 0:
+            self.information_weights_ /= mean_weight
+            # This should never happen
+        self.information_weights_ = np.maximum(self.information_weights_, 0.0)
+        self.information_weights_ = np.power(
+            self.information_weights_, self.weight_power
+        )
+
+        if y is not None:
+            unsupervised_power = (1.0 - self.supervision_weight) * self.weight_power
+            supervised_power = self.supervision_weight * self.weight_power
+
+            target_classes = np.unique(y)
+            target_dict = dict(
+                np.vstack((target_classes, np.arange(target_classes.shape[0]))).T
+            )
+            target = np.array(
+                [np.int64(target_dict[label]) for label in y], dtype=np.int64
+            )
+            self.supervised_weights_ = information_weight(
+                X,
+                self.prior_strength,
+                self.approx_prior,
+                target=target,
+                column_groups=column_groups,
+            )
+            mean_supervised_weight = np.mean(self.information_weights_)
+            if mean_supervised_weight > 0:
+                self.supervised_weights_ /= mean_supervised_weight
+            # This should never happen
+            self.supervised_weights_ = np.maximum(self.supervised_weights_, 0.0)
+            self.supervised_weights_ = np.power(
+                self.supervised_weights_, supervised_power
+            )
+
+            self.information_weights_ = (
+                self.information_weights_ * self.supervised_weights_
+            )
+
+        return self
+
+    def transform(self, X):
+        """Reweight data ``X`` based on learned information weights of columns.
+
+        Parameters
+        ----------
+        X: ndarray of scipy sparse matrix of shape (n_samples, n_features)
+            The count data to be transformed. Note that, as count data all
+            entries should be positive or zero.
+
+        Returns
+        -------
+        result: ndarray of scipy sparse matrix of shape (n_samples, n_features)
+            The reweighted data.
+        """
+        result = X @ scipy.sparse.diags(self.information_weights_)
+        return result

infoweight-0.0.1/infoweight.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: infoweight
+Version: 0.0.1
+Summary: An information theoretic generalization of TF-IDF.
+Maintainer-email: Ryan DeWolfe <ryan.dewolfe@uwaterloo.ca>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/ryandewolfe33/infoweight
+Project-URL: Repository, https://github.com/ryandewolfe33/infoweight
+Keywords: tfidf,information theory,metric learning,unsupervised learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: numba>=0.51
+Requires-Dist: scikit-learn>=0.22
+Requires-Dist: scipy
+Dynamic: license-file
+
+===========
+Infoweight
+===========
+
+This package provides an information theoretic generalization of the `TFIDFTransformer`.
+
+
+This package is still under development,
+The `InformationWeightTransformer` was originally part of the
+`vectorizers <https://github.com/TutteInstitute/vectorizers>`_
+package, but has been factored out to ease development. You can find an
+overview and example of using the package in the
+`vectorizers documentation <https://vectorizers.readthedocs.io/en/latest/>`_.
+
+----------
+Installing
+----------
+
+To install the package from PyPI:
+
+.. code:: bash
+
+    pip install infoweight
+
+Or to clone and install locally:
+.. code:: bash
+
+    git clone https://github.com/ryandewolfe33/infoweight.git &&
+    cd infoweight &&
+    pip install .
+
+To install the package from source:
+
+.. code:: bash
+
+    pip install https://github.com/ryandewolfe33/infoweight/archive/master.zip
+
+------------
+Contributing
+------------
+
+Contributions are more than welcome! There are lots of opportunities
+for potential projects, so please get in touch if you would like to
+help out. Everything from code to notebooks to examples and documentation
+are all *equally valuable* so please don't feel you can't contribute. 
+
+
+To contribute please `fork the project <https://github.com/ryandewolfe33/infoweight/issues#fork-destination-box>`_
+make your changes and submit a pull request. We will do our best to work
+through any issues with you and get your code merged into the main branch.
+
+-------
+License
+-------
+
+The infoweight package is 3-clause BSD licensed.

infoweight-0.0.1/infoweight.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.rst
+pyproject.toml
+infoweight/__init__.py
+infoweight/infoweight.py
+infoweight.egg-info/PKG-INFO
+infoweight.egg-info/SOURCES.txt
+infoweight.egg-info/dependency_links.txt
+infoweight.egg-info/requires.txt
+infoweight.egg-info/top_level.txt
+tests/test_infoweight.py

infoweight-0.0.1/infoweight.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

infoweight-0.0.1/infoweight.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=2.0.0
+numba>=0.51
+scikit-learn>=0.22
+scipy

infoweight-0.0.1/infoweight.egg-info/top_level.txt

@@ -0,0 +1 @@
+infoweight

infoweight-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "infoweight"
+version = "0.0.1"
+readme = "README.rst"
+description = "An information theoretic generalization of TF-IDF."
+maintainers = [{name = "Ryan DeWolfe", email = "ryan.dewolfe@uwaterloo.ca"}]
+keywords = ["tfidf", "information theory", "metric learning", "unsupervised learning"]
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+]
+
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=2.0.0",
+    "numba>=0.51",
+    "scikit-learn>=0.22",
+    "scipy",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/ryandewolfe33/infoweight"
+Repository = "https://github.com/ryandewolfe33/infoweight"

infoweight-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

infoweight-0.0.1/tests/test_infoweight.py

@@ -0,0 +1,72 @@
+import pytest
+import numpy as np
+import scipy.sparse
+from infoweight import InformationWeightTransformer
+
+test_matrix = scipy.sparse.csr_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+test_matrix_zero_row = scipy.sparse.csr_matrix([[1, 2, 3], [4, 5, 6], [0, 0, 0]])
+test_matrix_zero_row.eliminate_zeros()
+test_matrix_zero_column = scipy.sparse.csr_matrix([[1, 2, 0], [4, 5, 0], [7, 8, 0]])
+test_matrix_zero_column.eliminate_zeros()
+
+@pytest.mark.parametrize("prior_strength", [0.1, 1.0])
+@pytest.mark.parametrize("approx_prior", [True, False])
+def test_iw_transformer(prior_strength, approx_prior):
+    IWT = InformationWeightTransformer(
+        prior_strength=prior_strength,
+        approx_prior=approx_prior,
+    )
+    result = IWT.fit_transform(test_matrix)
+    transform = IWT.transform(test_matrix)
+    assert np.allclose(result.toarray(), transform.toarray())
+
+
+@pytest.mark.parametrize("prior_strength", [0.1, 1.0])
+@pytest.mark.parametrize("approx_prior", [True, False])
+@pytest.mark.parametrize("target", [None, np.array([0, 1, 1])])
+@pytest.mark.parametrize("column_groups", [None, np.array([0, 1, 1])])
+def test_iw_transformer_fit_args(prior_strength, approx_prior, target, column_groups):
+    IWT = InformationWeightTransformer(
+        prior_strength=prior_strength,
+        approx_prior=approx_prior,
+    )
+    result = IWT.fit_transform(test_matrix, target, column_groups=column_groups)
+    transform = IWT.transform(test_matrix)
+    assert np.allclose(result.toarray(), transform.toarray())
+    assert np.all(IWT.information_weights_ >= 0)
+
+
+@pytest.mark.parametrize("prior_strength", [0.1, 1.0])
+@pytest.mark.parametrize("approx_prior", [True, False])
+@pytest.mark.parametrize("target", [None, np.array([0, 1, 1])])
+@pytest.mark.parametrize("column_groups", [None, np.array([0, 1, 1])])
+def test_iw_transformer_zero_column(
+    prior_strength, approx_prior, target, column_groups
+):
+    IWT = InformationWeightTransformer(
+        prior_strength=prior_strength,
+        approx_prior=approx_prior,
+    )
+    result = IWT.fit_transform(
+        test_matrix_zero_column, target, column_groups=column_groups
+    )
+    transform = IWT.transform(test_matrix_zero_column)
+    assert np.allclose(result.toarray(), transform.toarray())
+    assert np.all(IWT.information_weights_ >= 0)
+
+
+@pytest.mark.parametrize("prior_strength", [0.1, 1.0])
+@pytest.mark.parametrize("approx_prior", [True, False])
+@pytest.mark.parametrize("target", [None, np.array([0, 1, 1])])
+@pytest.mark.parametrize("column_groups", [None, np.array([0, 1, 1])])
+def test_iw_transformer_zero_row(prior_strength, approx_prior, target, column_groups):
+    IWT = InformationWeightTransformer(
+        prior_strength=prior_strength,
+        approx_prior=approx_prior,
+    )
+    result = IWT.fit_transform(
+        test_matrix_zero_row, target, column_groups=column_groups
+    )
+    transform = IWT.transform(test_matrix_zero_row)
+    assert np.allclose(result.toarray(), transform.toarray())
+    assert np.all(IWT.information_weights_ >= 0)