condensite 0.0.1__tar.gz

condensite-0.0.1/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2025-, condensité Developers.
+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 condensité 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.

condensite-0.0.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: condensite
+Version: 0.0.1
+Summary: Transforming conditional density estimation into a single nonparametric regression task.
+Author-email: Alexander Reisach <alexander.reisach@math.cnrs.fr>
+License: BSD 3-Clause License
+Keywords: conditional density estimation,machine learning,statistics
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Science/Research
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: lightgbm
+Dynamic: license-file
+
+# condensité
+
+The approach behind `condensité` enables transforming conditional density estimation into a single nonparametric regression task. Our package implements this approach and provides a way of turning regressors from common libraries such as `sklearn` or `torch` into conditional density estimators. See below for a complete example. See `example.py` for further examples using the reference implementations in `src/example_models`.
+
+```python
+import torch
+import condensite as cde
+from sklearn.ensemble import HistGradientBoostingRegressor
+
+# create a condensité predictor based on sklearn's HistGradientBoostingRegressor
+class TreePredictor(cde.CondensitePredictor):
+    def __init__(self, params):
+        self.tree = HistGradientBoostingRegressor(**params)
+
+    def device(self):
+        return "cpu"
+
+    def to(self, device):
+        return self
+
+    def forward(self, x):
+        return self.tree.predict(x)
+
+    def predict(self, x):
+        return torch.tensor(self.forward(x), dtype=torch.float32)
+
+    def fit(self, dataset: cde.RepeatDataset):
+        # create data loader (c.f. cde.RepeatDataset and cde.concat_collate)
+        train_DL = torch.utils.data.DataLoader(dataset=dataset,                 
+                                               batch_size=dataset.n*dataset.M, 
+                                               shuffle=True, 
+                                               collate_fn=cde.concat_collate)
+        xtorch, ytorch = next(iter(train_DL))  # single batch of all data
+        self.tree.fit(xtorch.numpy(), ytorch.numpy())
+
+# instantiate and wrap using Condensite
+tree_predictor = TreePredictor(params={
+    'max_bins': 40,
+    'max_leaf_nodes': 100,
+    'l2_regularization': 0.1,
+})
+sklearn_model = cde.Condensite(tree_predictor, h=0.01, M=100, name='sklearn_model')
+
+# generate some data and fit
+def sample_data(n_obs=1000, n_features=10):
+    x = torch.empty((n_obs, n_features)).normal_(0,1)
+    x1 = x[:, 0]
+    std = torch.sqrt(0.25 + x1**2)
+    noise = torch.distributions.Normal(torch.zeros_like(x1), std).sample()
+    y = x1 + noise
+    return x, y
+
+# fit conditional density estimator
+x_train, y_train = sample_data()
+sklearn_model.fit(x_train, y_train, train_frac=0.8, n_grid_ISE=100)
+
+# evaluate fit out-of-sample
+x_test, y_test = sample_data()
+test_ISE = cde.utils.ISE(sklearn_model, x_test, y_test, n_grid=100).item()
+print(f'{sklearn_model.name}:\t {test_ISE=:.4f}')
+```
+
+If you find our algorithms useful please consider citing
+```
+```

condensite-0.0.1/README.md

@@ -0,0 +1,65 @@
+# condensité
+
+The approach behind `condensité` enables transforming conditional density estimation into a single nonparametric regression task. Our package implements this approach and provides a way of turning regressors from common libraries such as `sklearn` or `torch` into conditional density estimators. See below for a complete example. See `example.py` for further examples using the reference implementations in `src/example_models`.
+
+```python
+import torch
+import condensite as cde
+from sklearn.ensemble import HistGradientBoostingRegressor
+
+# create a condensité predictor based on sklearn's HistGradientBoostingRegressor
+class TreePredictor(cde.CondensitePredictor):
+    def __init__(self, params):
+        self.tree = HistGradientBoostingRegressor(**params)
+
+    def device(self):
+        return "cpu"
+
+    def to(self, device):
+        return self
+
+    def forward(self, x):
+        return self.tree.predict(x)
+
+    def predict(self, x):
+        return torch.tensor(self.forward(x), dtype=torch.float32)
+
+    def fit(self, dataset: cde.RepeatDataset):
+        # create data loader (c.f. cde.RepeatDataset and cde.concat_collate)
+        train_DL = torch.utils.data.DataLoader(dataset=dataset,                 
+                                               batch_size=dataset.n*dataset.M, 
+                                               shuffle=True, 
+                                               collate_fn=cde.concat_collate)
+        xtorch, ytorch = next(iter(train_DL))  # single batch of all data
+        self.tree.fit(xtorch.numpy(), ytorch.numpy())
+
+# instantiate and wrap using Condensite
+tree_predictor = TreePredictor(params={
+    'max_bins': 40,
+    'max_leaf_nodes': 100,
+    'l2_regularization': 0.1,
+})
+sklearn_model = cde.Condensite(tree_predictor, h=0.01, M=100, name='sklearn_model')
+
+# generate some data and fit
+def sample_data(n_obs=1000, n_features=10):
+    x = torch.empty((n_obs, n_features)).normal_(0,1)
+    x1 = x[:, 0]
+    std = torch.sqrt(0.25 + x1**2)
+    noise = torch.distributions.Normal(torch.zeros_like(x1), std).sample()
+    y = x1 + noise
+    return x, y
+
+# fit conditional density estimator
+x_train, y_train = sample_data()
+sklearn_model.fit(x_train, y_train, train_frac=0.8, n_grid_ISE=100)
+
+# evaluate fit out-of-sample
+x_test, y_test = sample_data()
+test_ISE = cde.utils.ISE(sklearn_model, x_test, y_test, n_grid=100).item()
+print(f'{sklearn_model.name}:\t {test_ISE=:.4f}')
+```
+
+If you find our algorithms useful please consider citing
+```
+```

condensite-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project]
+name = "condensite"
+description = "Transforming conditional density estimation into a single nonparametric regression task."
+authors = [
+    {name = "Alexander Reisach", email = "alexander.reisach@math.cnrs.fr"}
+]
+license = {text = "BSD 3-Clause License"}
+keywords = [
+  "conditional density estimation",
+  "machine learning",
+  "statistics",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Mathematics",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "License :: OSI Approved :: BSD License",
+  "Intended Audience :: Science/Research",
+]
+dependencies = [
+    "torch",
+    "numpy",
+    "scikit-learn",
+    "lightgbm",
+]
+readme = "README.md"
+version = "0.0.1"

condensite-0.0.1/setup.cfg

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

condensite-0.0.1/src/condensite/__init__.py

@@ -0,0 +1,5 @@
+from .core import Condensite, CondensitePredictor, RepeatDataset, concat_collate
+__all__ = ["Condensite", 
+           "CondensitePredictor", 
+           "RepeatDataset", 
+           "concat_collate"]

condensite-0.0.1/src/condensite/core.py

@@ -0,0 +1,344 @@
+import os
+import pickle
+import torch
+import torch.nn as nn
+import torch.distributions as dist
+from copy import deepcopy
+from abc import ABC, abstractmethod
+import torch
+from torch.utils.data import DataLoader
+from . import utils as ut
+import warnings
+import logging
+logger = logging.getLogger(__name__)
+
+
+class RepeatDataset(torch.utils.data.Dataset):
+    """ 
+    Custom dataset for the auxiliary condensite samples (keeps RAM usage in check). 
+    """
+    def __init__(self, x, y_aux, targets, M):
+        """
+        Args:
+            x (torch.Tensor): the features to be repeated
+            y_aux (torch.Tensor): the auxiliary labels
+            targets (torch.Tensor): target values
+            M (int): number of repetitions
+        """
+        self.n = len(x)
+        # assert dimensions
+        assert len(y_aux) == self.n*M
+        assert len(targets) == self.n*M
+        # parameters
+        self.x = x  # (Nxd)
+        self.y_aux = y_aux  # (NM)
+        self.targets = targets  # (NM)
+        self.M = M  # scalar
+        # precompute indices
+        self.j_map = torch.arange(self.n * self.M) // self.M
+
+    def __len__(self):
+        return self.n * self.M
+
+    def __getitem__(self, i):
+        return self.x[self.j_map[i]], self.y_aux[i], self.targets[i]
+
+
+def concat_collate(batch):
+    """
+    To be used in a DataLoader, as collate_fn for RepeatDataset.
+    Args:
+        batch (torch.Tensor): batch of features, auxiliary labels, and targets.
+    """
+    x, y_aux, targets = zip(*batch)  # tuples of tensors
+    x = torch.stack(x)            # shape: (B, d)
+    y_aux = torch.stack(y_aux).reshape(-1, 1)  # shape: (B, 1)
+    features = torch.cat([x, y_aux], dim=1)  # shape: (B, d+1)
+    targets = torch.stack(targets)
+    return features, targets
+
+
+class CondensitePredictor(ABC):
+    """ Defines the interface predictors have to implement. """
+    def __init__(self, device):
+        pass
+
+    @abstractmethod
+    def device(self):
+        """
+        Return device (would typically be "cpu" or "cuda").
+        """
+        return self._device
+
+    @abstractmethod
+    def to(self, device):
+        """ 
+        Port to device if applicable. Otherwise, simply return self. 
+        Args:
+            device (str): output of self.device()
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def forward(self, features: torch.Tensor):
+        """ 
+        Transform features into targets. 
+        Args:
+            features (torch.Tensor): feature values
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def predict(self, features: torch.Tensor) -> torch.Tensor:
+        """ 
+        Predict from given features.
+        Args:
+            features (torch.Tensor): feature values
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def fit(self, dataset: RepeatDataset) -> torch.Tensor:
+        """ 
+        Fit the predictor to data. 
+        Args:
+            dataset (RepeatDataset): virtual dataset of features and targets
+        Returns:
+            loss (torch.Tensor)
+        """
+        raise NotImplementedError
+
+
+class Condensite:
+    """ 
+    Fits CondensitePredictor objects to training data from a conditional density and provides a prediction function for the fitted object. 
+    """
+
+    def __init__(self, predictor, h, M, 
+                 name='condensite', 
+                 prediction_batch_size=None):
+        """
+        Args:
+            predictor (CondensitePredictor): conditional density estimator.
+            h (int): sharpness; for transformation into regression task.
+            M (int): number of auxiliary samples.
+            name (str): model name
+            prediction_batch_size (int): batch size when predicting (to limit RAM usage)
+        """
+        self.name = name
+        self.device = predictor.device()
+        self.predictor = predictor.to(self.device)
+        self.h = h
+        self.M = M
+        # parameters for standardization; crucial for training stability
+        self.x_mean = None
+        self.x_scale = None
+        self.y_min = None
+        self.y_max = None
+        self.y_aux_mean = None
+        self.y_aux_scale = None
+        self.t_mean = None
+        self.t_scale = None
+        self.prediction_batch_size=prediction_batch_size
+
+    def fit(self, x, y, train_frac, n_grid_ISE, verbose=0, epochs=None, patience=None):
+        """
+        Train the predictor on the data.
+        Args:
+            x (tensor): (n x d)
+            y (tensor): (n x 1)
+            train_frac (float): fraction fo data to use for training, rest is used for cross-validation.
+            n_grid_ISE: number of grid points for ISE in cross-validation.
+            verbose (int): verbosity of training.
+            epochs (int or None): train epochs, None if irrelevant
+            patience (int or None): early stopping count, None if irrelevant
+        """
+        # check if epochs relevant
+        if epochs is None:
+            epochs = 1
+        # train-CV split index
+        x_train, x_val, y_train, y_val = ut.train_test_split(x, y, train_frac)
+        # sample auxiliary features
+        y_aux_train = self.sample_y_aux(y_train)        
+        # feature-scaling parameters
+        self.set_sample_scaling_params(x_train, y_train, y_aux_train)
+        # min-max scale y
+        y_01 = (y_train-self.y_min)/(self.y_max-self.y_min)
+        # training targets
+        targets = self.compute_targets(y_01, y_aux_train)
+        # label-scaling parameters
+        self.set_target_scaling_params(targets)
+        # standardize
+        x_train = self.standardize(x_train, self.x_mean, self.x_scale)
+        y_aux_train = self.standardize(y_aux_train, self.y_aux_mean, self.y_aux_scale)
+        targets = self.standardize(targets, self.t_mean, self.t_scale)
+        
+        # create the condensite RepeatDataset for training
+        train_dataset = RepeatDataset(x=x_train, 
+                                      y_aux=y_aux_train, 
+                                      targets=targets, 
+                                      M=self.M)
+
+        # training
+        best_val_ise = float('inf')
+        best_epoch_predictor = None
+        for epoch in range(epochs):
+            # call the predictor's fit method
+            mse = self.predictor.fit(train_dataset)
+            # compute ISE on validation set
+            val_ise = ut.ISE(self, x_val, y_val, n_grid_ISE)
+            if verbose > 0:
+                if epochs > 1:
+                    logger.info(f"Epoch {epoch+1}/{epochs}, Train mse: {mse:.4f}, Validation ISE: {val_ise:.4f}")
+                else:
+                    logger.info(f"Train mse: {mse:.4f}, Validation ISE: {val_ise:.4f}")
+            # Early stopping
+            if val_ise < best_val_ise:
+                best_val_ise = val_ise
+                best_epoch_predictor = deepcopy(self.predictor)
+                epochs_without_improvement = 0
+            else:
+                epochs_without_improvement += 1
+                if epochs_without_improvement >= patience:
+                    if verbose>0:
+                        logger.info(f'Early stopping at epoch {epoch + 1}')
+                    break
+        
+        # select best network
+        self.predictor = best_epoch_predictor
+        self.ise = best_val_ise
+        
+        # return run summary
+        return {'h': self.h,
+                'M': self.M,
+                'epochs': epoch,
+                'ISE': best_val_ise}
+
+    def set_sample_scaling_params(self, x_train, y_train, y_aux_train):
+        """
+        Store values for scaling the observations and auxiliary samples.
+        Args:
+            x_train (torch.Tensor): training set feature values
+            y_train (torch.Tensor): training set labels
+            y_aux_train (torch.Tensor): auxiliary labels 
+        """
+        # standard scaling for x
+        self.x_mean = x_train.mean(dim=0).to(self.device)
+        self.x_scale = x_train.std(dim=0).to(self.device)
+        # for min-max scaling of y
+        self.y_min = y_train.min()
+        self.y_max = y_train.max()
+        # standard scaling for auxiliary samples y_aux
+        self.y_aux_mean = y_aux_train.mean(dim=0).to(self.device)
+        self.y_aux_scale = y_aux_train.std(dim=0).to(self.device)
+
+    def set_target_scaling_params(self, t_train):
+        """
+        Store mean and standard deviation of targets for scaling.
+        Args:
+            t_train (torch.Tensor): targets derived from auxiliary samples
+        """
+        self.t_mean = t_train.mean(dim=0).to(self.device)
+        self.t_scale = t_train.std(dim=0).to(self.device)
+
+    def standardize(self, x, mean, scale):
+        """
+        Standardize features.
+        Args:
+            x: features,
+            mean (torch.Tensor): mean values for standardization
+            scale (torch.Tensor): standard deviations for standardization
+        """
+        if not x.is_cuda:
+            mean, scale = mean.cpu(), scale.cpu()
+        return (x - mean) / (scale + 1e-8)
+
+    def predict(self, x, n_grid):
+        """
+        Predict cdes for x at a grid across the range of y seen at training; batching to limit RAM usage.
+        Args:
+            x (torch.Tensor): features
+            n_grid (int): number of grid points for prediction
+        """
+        # create grid on [0,1] scale using RepeatDataset
+        x = self.standardize(x, self.x_mean, self.x_scale)
+        y_points_01 = torch.linspace(0, 1, n_grid).view(-1,1)        
+        grid_y = y_points_01.repeat(len(x), 1)
+        grid_y = self.standardize(grid_y, self.y_aux_mean, self.y_aux_scale)
+        dataset = RepeatDataset(
+            x=x, 
+            y_aux=grid_y, 
+            targets=torch.zeros_like(grid_y),  # not actually needed here 
+            M=n_grid
+        )
+
+        # let predictor predict and scale up
+        if self.prediction_batch_size is None:
+            batch_size = len(grid_y)  # single batch
+        else:
+            batch_size = self.prediction_batch_size
+        predict_DL = DataLoader(
+            dataset, 
+            batch_size, 
+            shuffle=False, 
+            collate_fn=concat_collate
+        )
+        cdes = torch.empty(len(x)*n_grid, device="cpu")
+        start = 0
+        for feature_batch, _ in predict_DL:
+            feature_batch = feature_batch.to(self.device)
+            batch_preds = self.predictor.predict(feature_batch)
+            batch_preds = batch_preds*self.t_scale+self.t_mean
+            cdes[start:(start+len(batch_preds))] = batch_preds.flatten().cpu()
+            start += len(batch_preds)
+        cdes = cdes.view(len(x), n_grid)
+
+        # min-max upscaling; we want a density on the original scale
+        y_points = y_points_01 * (self.y_max - self.y_min) + self.y_min
+        cdes = self.make_density(cdes, y_points)        
+        return cdes, y_points
+
+    def make_density(self, cdes, y):
+        """
+        Make sure estimated densities are positive and add up to 1 under numerical integration.
+        Args:
+            cdes (torch.Tensor): (n x n_grid) density estimates
+        """
+        # force positive
+        cdes = torch.where(cdes<0, 0, cdes)
+        area = torch.trapz(cdes, y.flatten(), dim=1).reshape(-1, 1)
+        # if we predict zero density everywhere, assume a uniform distribution
+        empty_pred = torch.argwhere(area.ravel() == 0)
+        cdes[empty_pred, :] = 1/cdes.shape[1]
+        area[empty_pred] = 1
+        # normalize density
+        cdes = cdes / area
+        return cdes
+    
+    def sample_y_aux(self, y):
+        """
+        Sample auxiliary labels.
+        Args:
+            y (torch.Tensor): the (n) y values
+        """
+        return torch.empty(len(y)*self.M).uniform_(0, 1).view(-1,1)
+
+    def compute_targets(self, y_01, y_aux):
+        """ 
+        Compute targets via $K_h(Y_i-Y_{im})$.
+        Args:
+            y_01 (torch.Tensor): observed y rescaled to [0,1]
+            y_aux (torch.Tensor): auxiliary labels for target construction
+        """
+        # prepare for grid
+        y_bar = y_01.repeat_interleave(self.M, dim=0).view(-1,1)
+        # compute auxiliary densities
+        Kh = dist.MultivariateNormal(loc=torch.zeros(1),
+                                     covariance_matrix=torch.eye(1) * self.h**2)
+        targets = torch.exp(Kh.log_prob(y_bar - y_aux))
+        return targets
+
+    def save(self, path):
+        """ Save the model. """
+        with open(os.path.join(path, f"{self.name}.pkl"), "wb") as f:
+            pickle.dump(self, f)

condensite-0.0.1/src/condensite/utils.py

@@ -0,0 +1,49 @@
+import torch
+
+
+def ISE_from_pred(cdes_grid, y_points, y):
+    """
+    Separate this from the predict part since sometimes we'd like to load saved predictions.
+    Args:
+        cdes_grid (torch.Tensor): conditional density estimates over a grid
+        y_points (torch.Tensor): the grid points
+        y (torch.Tensor): the labels
+    """
+    ## ISE term 1: volume under squared curve for each X point
+    a2 = torch.mean(torch.trapz(cdes_grid**2, y_points.flatten(), dim=1))
+    ## ISE term 2: density height at the actual data points.
+    # choose the grid value closest to a real value as nearest neighbor
+    nn = torch.argmin(torch.abs(y.view(-1,1)-y_points.view(1,-1)), axis=1)
+    cdes = cdes_grid[range(len(y)), nn]
+    ab = torch.mean(cdes)
+    # combine first two terms
+    return a2 - 2*ab
+
+
+def ISE(model, x, y, n_grid):
+    """
+    ISE approximation up to a constant; on a grid of length n_grid.
+    Args:
+        model (object): one of our CDE models
+        x (torch.Tensor): (n x d)
+        y (torch.Tensor): (n x 1)
+        n_grid (int): number of grid points for evaluation
+    """
+    cdes_grid, y_points = model.predict(x, n_grid)
+    return ISE_from_pred(cdes_grid, y_points, y)
+
+
+def train_test_split(x, y, train_frac):
+    """ 
+    Akin to sklearn.model_selection.train_test_split.
+    Args:
+        x (torch.Tensor): features
+        y (torch.Tensor): labels
+        train_frac (float): fraction to be used for training
+    """
+    split_idx = int(train_frac*len(y))
+    mask = torch.randperm(len(y))
+    train_mask, test_mask = mask[:split_idx], mask[split_idx:]
+    x_train, x_test = x[train_mask], x[test_mask]
+    y_train, y_test = y[train_mask], y[test_mask]
+    return x_train, x_test, y_train, y_test

condensite-0.0.1/src/condensite.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: condensite
+Version: 0.0.1
+Summary: Transforming conditional density estimation into a single nonparametric regression task.
+Author-email: Alexander Reisach <alexander.reisach@math.cnrs.fr>
+License: BSD 3-Clause License
+Keywords: conditional density estimation,machine learning,statistics
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Intended Audience :: Science/Research
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: lightgbm
+Dynamic: license-file
+
+# condensité
+
+The approach behind `condensité` enables transforming conditional density estimation into a single nonparametric regression task. Our package implements this approach and provides a way of turning regressors from common libraries such as `sklearn` or `torch` into conditional density estimators. See below for a complete example. See `example.py` for further examples using the reference implementations in `src/example_models`.
+
+```python
+import torch
+import condensite as cde
+from sklearn.ensemble import HistGradientBoostingRegressor
+
+# create a condensité predictor based on sklearn's HistGradientBoostingRegressor
+class TreePredictor(cde.CondensitePredictor):
+    def __init__(self, params):
+        self.tree = HistGradientBoostingRegressor(**params)
+
+    def device(self):
+        return "cpu"
+
+    def to(self, device):
+        return self
+
+    def forward(self, x):
+        return self.tree.predict(x)
+
+    def predict(self, x):
+        return torch.tensor(self.forward(x), dtype=torch.float32)
+
+    def fit(self, dataset: cde.RepeatDataset):
+        # create data loader (c.f. cde.RepeatDataset and cde.concat_collate)
+        train_DL = torch.utils.data.DataLoader(dataset=dataset,                 
+                                               batch_size=dataset.n*dataset.M, 
+                                               shuffle=True, 
+                                               collate_fn=cde.concat_collate)
+        xtorch, ytorch = next(iter(train_DL))  # single batch of all data
+        self.tree.fit(xtorch.numpy(), ytorch.numpy())
+
+# instantiate and wrap using Condensite
+tree_predictor = TreePredictor(params={
+    'max_bins': 40,
+    'max_leaf_nodes': 100,
+    'l2_regularization': 0.1,
+})
+sklearn_model = cde.Condensite(tree_predictor, h=0.01, M=100, name='sklearn_model')
+
+# generate some data and fit
+def sample_data(n_obs=1000, n_features=10):
+    x = torch.empty((n_obs, n_features)).normal_(0,1)
+    x1 = x[:, 0]
+    std = torch.sqrt(0.25 + x1**2)
+    noise = torch.distributions.Normal(torch.zeros_like(x1), std).sample()
+    y = x1 + noise
+    return x, y
+
+# fit conditional density estimator
+x_train, y_train = sample_data()
+sklearn_model.fit(x_train, y_train, train_frac=0.8, n_grid_ISE=100)
+
+# evaluate fit out-of-sample
+x_test, y_test = sample_data()
+test_ISE = cde.utils.ISE(sklearn_model, x_test, y_test, n_grid=100).item()
+print(f'{sklearn_model.name}:\t {test_ISE=:.4f}')
+```
+
+If you find our algorithms useful please consider citing
+```
+```

condensite-0.0.1/src/condensite.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/condensite/__init__.py
+src/condensite/core.py
+src/condensite/utils.py
+src/condensite.egg-info/PKG-INFO
+src/condensite.egg-info/SOURCES.txt
+src/condensite.egg-info/dependency_links.txt
+src/condensite.egg-info/requires.txt
+src/condensite.egg-info/top_level.txt
+src/examples/example.py
+src/examples/example_models/LGBMPredictor.py
+src/examples/example_models/sklearnPredictor.py
+src/examples/example_models/torchPredictor.py
+tests/test_core.py

condensite-0.0.1/src/condensite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

condensite-0.0.1/src/condensite.egg-info/requires.txt

@@ -0,0 +1,4 @@
+torch
+numpy
+scikit-learn
+lightgbm

condensite-0.0.1/src/condensite.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+condensite
+examples

condensite-0.0.1/src/examples/example.py

@@ -0,0 +1,61 @@
+
+import condensite as cde
+import torch
+import torch.distributions as dist
+from example_models.sklearnPredictor import TreePredictor
+from example_models.LGBMPredictor import LGBMPredictor
+from example_models.torchPredictor import NNPredictor
+import logging
+logging.basicConfig(level=logging.INFO)
+
+# create some example data
+def sample_data(n_obs=1000, n_features=10):
+    x = torch.empty((n_obs, n_features)).normal_(0,1)
+    x1 = x[:, 0]
+    std = torch.sqrt(0.25 + x1**2)
+    noise = torch.distributions.Normal(torch.zeros_like(x1), std).sample()
+    y = x1 + noise
+    return x, y
+
+x_train, y_train = sample_data()
+
+# ------------------------------------------------------------------------------
+
+# model 1) condensité with a sklearn predictor
+tree_predictor = TreePredictor(params={
+    'max_bins': 40,
+    'max_leaf_nodes': 100,
+    'l2_regularization': 0.1,
+})
+sklearn_model = cde.Condensite(tree_predictor, h=0.01, M=100, name='sklearn_model')
+sklearn_model.fit(x_train, y_train, train_frac=0.8, n_grid_ISE=100)
+
+# model 2) condensité with a lgbm predictor
+lgbm_predictor = LGBMPredictor(params={
+    'objective': 'regression', 
+    'metric': 'mse',
+    'min_data_in_leaf': 50,
+    'max_bin': 40,
+    'num_leaves': 40,
+})
+lgbm_model = cde.Condensite(lgbm_predictor, h=0.01, M=100, name='lgbm_model')
+lgbm_model.fit(x_train, y_train, train_frac=0.8, n_grid_ISE=100)
+
+# model 3) condensité with a torch predictor
+torch_predictor = NNPredictor(
+    n_in=x_train.shape[1]+1,  # note extra feature (all methods, here explicit)
+    n_hidden=20,
+    batch_size=512,
+    lr=1e-3,
+    weight_decay=1e-4
+)
+torch_model = cde.Condensite(torch_predictor, h=0.01, M=100, name='torch_model')
+torch_model.fit(x_train, y_train, train_frac=0.8, n_grid_ISE=100, epochs=20, patience=5, verbose=1)
+
+# ------------------------------------------------------------------------------
+
+# compare their out-of-sample ISE
+x_test, y_test = sample_data()
+for model in [sklearn_model, lgbm_model, torch_model]:
+    test_ISE = cde.utils.ISE(model, x_test, y_test, n_grid=100).item()
+    print(f'{model.name}:\t {test_ISE=:.4f}')

condensite-0.0.1/src/examples/example_models/LGBMPredictor.py

@@ -0,0 +1,35 @@
+import torch
+from torch.utils.data import DataLoader
+import condensite as cde
+import lightgbm as lgb
+import warnings
+warnings.filterwarnings("ignore", message="Converting data to scipy sparse matrix.")
+
+
+class LGBMPredictor(cde.CondensitePredictor):
+    def __init__(self, params):
+        self.tree = None
+        self.params = params
+
+    def device(self):
+        return "cpu"
+
+    def to(self, device):
+        return self
+
+    def forward(self, x):
+        return self.tree.predict(x)
+
+    def predict(self, x):
+        return torch.tensor(self.forward(x), dtype=torch.float32)
+
+    def fit(self, dataset):
+        # create dataset (c.f. RepeatDataset and concat_collate)
+        train_DL = torch.utils.data.DataLoader(dataset=dataset,                 
+                                               batch_size=dataset.n*dataset.M, 
+                                               shuffle=True, 
+                                               collate_fn=cde.concat_collate)
+        xtorch, ytorch = next(iter(train_DL))  # single batch of all data
+        x, y = xtorch.numpy(), ytorch.numpy()
+        train_data = lgb.Dataset(x, label=y)
+        self.tree = lgb.train(self.params, train_data)

condensite-0.0.1/src/examples/example_models/sklearnPredictor.py

@@ -0,0 +1,29 @@
+import torch
+import condensite as cde
+from sklearn.ensemble import HistGradientBoostingRegressor
+
+
+class TreePredictor(cde.CondensitePredictor):
+    def __init__(self, params):
+        self.tree = HistGradientBoostingRegressor(**params)
+
+    def device(self):
+        return "cpu"
+
+    def to(self, device):
+        return self
+
+    def forward(self, x):
+        return self.tree.predict(x)
+
+    def predict(self, x):
+        return torch.tensor(self.forward(x), dtype=torch.float32)
+
+    def fit(self, dataset: cde.RepeatDataset):
+        # create data loader (c.f. cde.RepeatDataset and cde.concat_collate)
+        train_DL = torch.utils.data.DataLoader(dataset=dataset,                 
+                                               batch_size=dataset.n*dataset.M, 
+                                               shuffle=True, 
+                                               collate_fn=cde.concat_collate)
+        xtorch, ytorch = next(iter(train_DL))  # single batch of all data
+        self.tree.fit(xtorch.numpy(), ytorch.numpy())

condensite-0.0.1/src/examples/example_models/torchPredictor.py

@@ -0,0 +1,96 @@
+""" Use a neural network (NN) as predictor in Condensité. """
+import torch
+import torch.nn as nn
+from torch.optim import AdamW
+from torch.utils.data import TensorDataset, DataLoader
+from condensite import CondensitePredictor, concat_collate
+
+
+class NNPredictor(nn.Module, CondensitePredictor):
+    def __init__(self, 
+        n_in, n_hidden,  # structure params
+        batch_size, lr, weight_decay # training params
+    ):
+        super().__init__()
+        # define device
+        self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        # network architecture
+        self.network = nn.Sequential(
+            nn.Linear(n_in, n_hidden),
+            nn.BatchNorm1d(n_hidden),
+            nn.SiLU(),
+            nn.Linear(n_hidden, n_hidden),
+            nn.BatchNorm1d(n_hidden),
+            nn.SiLU(),
+            nn.Linear(n_hidden, n_hidden),
+            nn.BatchNorm1d(n_hidden),
+            nn.SiLU(),
+            nn.Linear(n_hidden, n_hidden),
+            nn.BatchNorm1d(n_hidden),
+            nn.SiLU(),
+            nn.Linear(n_hidden, n_hidden),
+            nn.BatchNorm1d(n_hidden),
+            nn.SiLU(),
+            nn.Linear(n_hidden, 1)
+        )
+        self.network.apply(self.init_weights)
+        # set training params
+        self.batch_size = batch_size
+        self.lr = lr
+        self.weight_decay = weight_decay
+        # define optimizer
+        self.optimizer = AdamW(params=self.network.parameters(), 
+                               lr=lr, weight_decay=weight_decay)
+
+    def device(self):
+        return self._device
+
+    def init_weights(self, m):
+        # initialization to match ReLU activations
+        if isinstance(m, nn.Linear):
+            nn.init.kaiming_normal_(m.weight, nonlinearity='relu')
+            nn.init.zeros_(m.bias)
+
+    def forward(self, features):
+        return self.network(features).ravel()
+
+    def predict(self, features):
+        """ Predict for given features. """
+        # labels don't matter here, set to zeros
+        self.eval()
+        dataset = TensorDataset(features, torch.zeros(len(features)))
+        loader = DataLoader(dataset, self.batch_size, shuffle=False)
+        predictions = torch.empty(len(features), device=self.device())
+        start = 0
+        with torch.no_grad():
+            for feature_batch, _ in loader:
+                feature_batch = feature_batch.to(self.device())
+                batch_preds = self.forward(feature_batch).detach()
+                predictions[start:(start+len(batch_preds))] = batch_preds.flatten()
+                start += len(batch_preds)
+        return predictions
+
+    def fit(self, dataset):
+        """
+        Perform a fit on the features and targets in the dataset passed.
+        """
+        self.train()
+        ## batching
+        train_DL = DataLoader(dataset, self.batch_size, shuffle=True, collate_fn=concat_collate)
+        # training
+        epoch_losses = []
+        loss_fn = nn.MSELoss()
+        # loss_fn = nn.BCEWithLogitsLoss()
+        for feature_batch, target_batch in train_DL:
+            # move to device
+            feature_batch = feature_batch.to(self.device())
+            target_batch = target_batch.to(self.device())
+            # compute MSE and update weights
+            self.optimizer.zero_grad()
+            pred = self.forward(feature_batch)
+            loss = loss_fn(target_batch, pred)
+            loss.backward()
+            self.optimizer.step()
+            epoch_losses.append(loss.item())
+        # results of epoch
+        return sum(epoch_losses) / len(epoch_losses)

condensite-0.0.1/tests/test_core.py

@@ -0,0 +1,3 @@
+def test_import():
+    import condensite
+    assert condensite is not None