humancompatible-train 0.1.0__py3-none-any.whl

humancompatible/train/fairness/constraints/constraint.py

@@ -0,0 +1,97 @@
+from typing import Callable, Iterable
+
+import numpy as np
+import fairret
+import torch
+from torch.utils.data import DataLoader, SubsetRandomSampler
+
+
+def _make_dataloaders(dataset, group_indices, batch_size, device, drop_last, gen=None):
+    dataloaders = []
+    for idx in group_indices:
+        sampler = SubsetRandomSampler(idx, gen)
+        dataloaders.append(iter(DataLoader(dataset, batch_size, sampler=sampler, drop_last=True)))
+    return dataloaders
+
+
+class FairnessConstraint:
+    def __init__(
+        self,
+        dataset: torch.utils.data.Dataset,
+        group_indices: Iterable[Iterable[int]],
+        fn: Callable,
+        batch_size: int = None,
+        use_dataloaders=True,
+        device="cpu",
+        seed=None,
+        loader_drop_last=False,
+    ):
+        self.dataset = dataset
+        self.group_sets = [
+            torch.utils.data.Subset(dataset, idx) for idx in group_indices
+        ]
+        self._group_indices = group_indices
+        self.fn = fn
+        self._seed = seed
+        self._rng = np.random.default_rng(seed)
+        self._torch_rng = torch.manual_seed(seed) if seed is not None else torch.Generator(device=device)
+        self._device = device
+        self._drop_last = loader_drop_last
+        if batch_size is not None:
+            self._batch_size = batch_size
+            if use_dataloaders:
+                self.group_dataloaders = _make_dataloaders(
+                    dataset, group_indices, batch_size, device, gen=self._torch_rng, drop_last=loader_drop_last
+                )
+
+    def group_sizes(self):
+        return [len(group) for group in self.group_sets]
+
+    def eval(self, net, sample, **kwargs):
+        return self.fn(net, sample, **kwargs)
+        
+    # def eval_fairret(self, net, sample, group_id, **kwargs):
+    #     if self._fairret_results is None:
+    #         statistic = fairret.statistic.TruePositiveRate()
+    #         loss = fairret.loss.NormLoss(statistic)
+            
+        
+    #     return self._fairret_results[group_id]
+
+    def sample_loader(self):
+        self._fairret_results = None
+        samples = []
+        for i, l in enumerate(self.group_dataloaders):
+            try:
+                sample = next(l)
+            except StopIteration:
+                sampler = SubsetRandomSampler(self._group_indices[i], self._torch_rng)
+                l = iter(DataLoader(self.dataset, self._batch_size, sampler=sampler, drop_last=self._drop_last))
+                sample = next(l)
+                self.group_dataloaders[i] = l
+                
+            samples.append(sample)
+        return samples
+
+    def sample_dataset(
+        self, N, rng: np.random.Generator = None, indices=None, return_indices=False
+    ):
+        if rng is None:
+            rng = self._rng
+
+        if indices is None:
+            indices = []
+            # returns len(group) points if N > len(group)
+            for group in self.group_sets:
+                indices.append(
+                    rng.choice(group.indices, N)
+                    if N < len(group)
+                    else rng.choice(group.indices, len(group))
+                )
+
+        sample = [self.dataset[indices[i]] for i, _ in enumerate(self.group_sets)]
+
+        if return_indices:
+            return sample, indices
+        else:
+            return sample

humancompatible/train/fairness/constraints/constraint_fns.py

@@ -0,0 +1,244 @@
+import torch
+from fairret.statistic import (
+    TruePositiveRate,
+    FalseNegativeFalsePositiveFraction,
+    FalsePositiveRate,
+    PositiveRate,
+    Accuracy,
+)
+from fairret.loss import NormLoss
+
+
+def tpr_equality(_, net, c_data):
+    statistic = TruePositiveRate()
+    loss = NormLoss(statistic, p=1)
+
+    return fairret_stat_equality(net, c_data, loss)
+
+
+def ppv_equality(_, net, c_data):
+    statistic = FalseNegativeFalsePositiveFraction()
+    loss = NormLoss(statistic, p=1)
+
+    return fairret_stat_equality(net, c_data, loss)
+
+
+def acc_equality(_, net, c_data):
+    statistic = Accuracy()
+    loss = NormLoss(statistic, p=1)
+
+    return fairret_stat_equality(net, c_data, loss)
+
+
+def fairret_stat_equality(net, c_data, loss):
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+
+    g1_outs = net(g1_inputs).squeeze()
+    g2_outs = net(g2_inputs).squeeze()
+    # if not (1 in a_labels or 1 in g2_labels):
+    #     return torch.tensor(0)
+
+    group_codes = [0] * len(g1_labels) + [1] * len(g2_labels)
+    group_codes = torch.tensor(
+        [[0.0, 1.0] if x == 1 else [1.0, 0.0] for x in group_codes]
+    )
+
+    return loss(
+        torch.concat([g1_outs, g2_outs]).unsqueeze(1),
+        group_codes,
+        torch.concat([g1_labels, g2_labels]).unsqueeze(1),
+    )
+
+
+def dummy(_, net, c_data):
+    r = torch.zeros(1)
+    r.grad = 0
+    return r
+
+
+def loss_equality(loss, net, c_data):
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+    g1_outs = net(g1_inputs)
+    if g1_labels.ndim == 0:
+        g1_labels = g1_labels.reshape(1)
+        g2_labels = g2_labels.reshape(1)
+    if g1_labels.ndim < g1_outs.ndim:
+        g1_labels = g1_labels.unsqueeze(1)
+        g2_labels = g2_labels.unsqueeze(1)
+    g1_loss = loss(g1_outs, g1_labels)
+    g2_outs = net(g2_inputs)
+    g2_loss = loss(g2_outs, g2_labels)
+
+    val = g1_loss - g2_loss
+    return val
+
+
+
+def abs_diff_tpr(_, net, c_data):#, stat):
+    tpr = TruePositiveRate()
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+    g1_outs = torch.nn.functional.sigmoid(net(g1_inputs))
+    g2_outs = torch.nn.functional.sigmoid(net(g2_inputs))
+    
+    g1_pos_pred_mask = (g1_outs >= 0).squeeze()
+    g2_pos_pred_mask = (g2_outs >= 0).squeeze()
+
+    if g1_labels.ndim == 0:
+        g1_labels = g1_labels.reshape(1)
+        g2_labels = g2_labels.reshape(1)
+    if g1_labels.ndim < g1_outs.ndim:
+        g1_labels = g1_labels.unsqueeze(1)
+        g2_labels = g2_labels.unsqueeze(1)
+
+    g1_loss = tpr(g1_outs[g1_pos_pred_mask], None, g1_labels[g1_pos_pred_mask])
+    g2_loss = tpr(g2_outs[g2_pos_pred_mask], None, g2_labels[g2_pos_pred_mask])
+
+    val = abs(g1_loss - g2_loss)
+
+    return val
+
+def abs_diff_pr(_, net, c_data):#, stat):
+    pr = PositiveRate()
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+    g1_outs = torch.nn.functional.sigmoid(net(g1_inputs))
+    g2_outs = torch.nn.functional.sigmoid(net(g2_inputs))
+
+    if g1_labels.ndim == 0:
+        g1_labels = g1_labels.reshape(1)
+        g2_labels = g2_labels.reshape(1)
+    if g1_labels.ndim < g1_outs.ndim:
+        g1_labels = g1_labels.unsqueeze(1)
+        g2_labels = g2_labels.unsqueeze(1)
+
+    g1_loss = pr(g1_outs, None)
+    g2_loss = pr(g2_outs, None)
+
+    val = abs(g1_loss - g2_loss)
+
+    return val
+
+def abs_diff_fpr(_, net, c_data):#, stat):
+    tpr = FalsePositiveRate()
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+    g1_outs = torch.nn.functional.sigmoid(net(g1_inputs))
+    g2_outs = torch.nn.functional.sigmoid(net(g2_inputs))
+
+    if g1_labels.ndim == 0:
+        g1_labels = g1_labels.reshape(1)
+        g2_labels = g2_labels.reshape(1)
+    if g1_labels.ndim < g1_outs.ndim:
+        g1_labels = g1_labels.unsqueeze(1)
+        g2_labels = g2_labels.unsqueeze(1)
+
+    g1_loss = tpr(g1_outs, None, g1_labels)
+    g2_loss = tpr(g2_outs, None, g2_labels)
+
+    val = abs(g1_loss - g2_loss)
+
+    return val
+
+def abs_max_dev_from_overall_tpr(_, net, c_data):
+    stats = []
+    st = TruePositiveRate()
+    for input, label in c_data:
+        out = net(input)
+        pred_sigm = torch.nn.functional.sigmoid(out)
+        pos_pred_mask = (pred_sigm >= 0).squeeze()
+        tpr = st(pred_sigm[pos_pred_mask], None, label[pos_pred_mask].unsqueeze(1))
+        stats.append(tpr)
+
+    stats = torch.cat(stats)
+    all_inp = torch.cat([x[0] for x in c_data])
+    all_lab = torch.cat([x[1] for x in c_data])
+    all_out = net(all_inp)
+    all_pred_sigm = torch.nn.functional.sigmoid(all_out)
+    pos_pred_mask = (all_pred_sigm >= 0).squeeze()
+    all_tpr = st(all_pred_sigm[pos_pred_mask], None, all_lab[pos_pred_mask].unsqueeze(1))
+
+    val = torch.max(
+        torch.abs(stats - all_tpr)
+    )
+
+    # val = torch.max(
+    #     torch.abs(stats/all_tpr - 1)
+    # )
+
+    return val
+
+
+
+def abs_max_dev_from_overall_fpr(_, net, c_data):
+    stats = []
+    st = FalsePositiveRate()
+    for input, label in c_data:
+        out = net(input)
+        pred_sigm = torch.nn.functional.sigmoid(out)
+        tpr = st(pred_sigm, None, label.unsqueeze(1))
+        stats.append(tpr)
+
+    stats = torch.cat(stats)
+    all_inp = torch.cat([x[0] for x in c_data])
+    all_lab = torch.cat([x[1] for x in c_data])
+    all_out = net(all_inp)
+    all_pred_sigm = torch.nn.functional.sigmoid(all_out)
+    all_tpr = st(all_pred_sigm, None, all_lab.unsqueeze(1))
+
+    val = torch.max(
+        torch.abs(stats - all_tpr)
+    )
+
+    # val = torch.max(
+    #     torch.abs(stats/all_tpr - 1)
+    # )
+
+    return val
+
+
+def abs_loss_equality(loss, net, c_data):
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+    g1_outs = net(g1_inputs)
+    if g1_labels.ndim == 0:
+        g1_labels = g1_labels.reshape(1)
+        g2_labels = g2_labels.reshape(1)
+    if g1_labels.ndim < g1_outs.ndim:
+        g1_labels = g1_labels.unsqueeze(1)
+        g2_labels = g2_labels.unsqueeze(1)
+    g1_loss = loss(g1_outs, g1_labels)
+    g2_outs = net(g2_inputs)
+    g2_loss = loss(g2_outs, g2_labels)
+
+    val = g1_loss - g2_loss
+    return torch.abs(val)
+
+
+def fairret_constr(loss, net, c_data):
+    g1_inputs, g1_labels = c_data[0]
+    g2_inputs, g2_labels = c_data[1]
+    g1_logits = net(g1_inputs)
+    g2_logits = net(g2_inputs)
+    g1_onehot = torch.tensor([[0.0, 1.0]] * len(g1_inputs))
+    g2_onehot = torch.tensor([[1.0, 0.0]] * len(g2_inputs))
+    logits = torch.concat([g1_logits, g2_logits])
+    sens = torch.vstack([g1_onehot, g2_onehot])
+    labels = torch.hstack([g1_labels, g2_labels]).unsqueeze(1)
+
+    return loss(logits, sens, label=labels)
+
+
+def fairret_pr_constr(loss, net, c_data):
+    g1_inputs, _ = c_data[0]
+    g2_inputs, _ = c_data[1]
+    g1_logits = net(g1_inputs)
+    g2_logits = net(g2_inputs)
+    g1_onehot = torch.tensor([[0.0, 1.0]] * len(g1_inputs))
+    g2_onehot = torch.tensor([[1.0, 0.0]] * len(g2_inputs))
+    logits = torch.concat([g1_logits, g2_logits])
+    sens = torch.vstack([g1_onehot, g2_onehot])
+
+    return loss(logits, sens)

humancompatible/train/fairness/constraints/torch/__init__.py

@@ -0,0 +1 @@
+from .constraints import loss_equality

humancompatible/train/fairness/constraints/torch/constraints.py

@@ -0,0 +1,36 @@
+import torch
+from torch import Tensor
+from torch.nn import Module
+
+def loss_equality(preds: Tensor, sens: Tensor, labels: Tensor, criterion: Module = None, diff_to_overall: bool = False):
+    """
+    A constraint that penalizes the sum of difference between the loss of each group and the overall loss if`diff_to_overall`is`True`,
+    and the absolute difference in loss between the two groups if`diff_to_overall`is`False`.
+    
+    Args:
+            logits (torch.Tensor): Predictions of shape :math:`(N)`, as we assume to be performing binary
+                classification or regression.
+            sens (torch.Tensor): One-hot encoding of group membership of shape`(N, S)`with`S`the number of sensitive features.
+                `S`must be 2 if`diff_to_overall`is`True`.
+            labels (torch.Tensor): Predictions of shape`(N)`.
+            loss: (torch.nn.Module): The loss function to calculate.
+            diff_to_overall: (bool): Determines whether to penalize the sum of the absolute difference between
+                each group's loss and the overall loss if`True`, or the absolute difference in losses of two groups otherwise.
+    """
+    if not diff_to_overall and sens.shape[-1] != 2:
+        raise ValueError(f"If`diff_to_overall` is`False`, expected`sens.shape[-1]` to be 2, got {sens.shape[-1]}")
+    
+    if criterion is None:
+        criterion = torch.nn.BCEWithLogitsLoss()
+        
+    sens_t = sens.T
+    group_losses = torch.empty(sens.shape[-1])
+    for group in range(sens.shape[-1]):
+        group_preds, group_labels = preds[sens_t[group] == 1], labels[sens_t[group] == 1]
+        group_losses[group] = criterion(group_preds.squeeze(), group_labels)
+        
+    if not diff_to_overall:
+        return torch.abs(group_losses[0] - group_losses[1])
+    
+    overall_loss = criterion(preds.squeeze(), labels)
+    return torch.sum(torch.abs(overall_loss-group_losses))

humancompatible/train/fairness/utils/__init__.py

@@ -0,0 +1 @@
+from .balanced_batch_sampler import BalancedBatchSampler

humancompatible/train/fairness/utils/balanced_batch_sampler.py

@@ -0,0 +1,65 @@
+import numpy as np
+import torch
+from torch.utils.data import Sampler
+
+class BalancedBatchSampler(Sampler):
+    def __init__(self, subgroup_onehot=None, subgroup_indices=None, batch_size=1, drop_last=True):
+        """
+        A Sampler that yields an equal number of samples from each group specified with either one-hot encoding or indices.
+        
+        Args:
+            subset_indices (list of list): List of indices for each subset. Defaults to None.
+            subgroup_onehot (tensor): Tensor of one-hot-encoded group memberships of shape `(N, S)`, where`S`is the number of subgroups. Defaults to None.
+            batch_size (int): Number of samples per batch.
+            drop_last (bool): If True, drop the last incomplete batch.
+        """
+        
+        if subgroup_indices is None and subgroup_onehot is None:
+            raise ValueError(f"Exactly one of`subgroup_indices`,`subgroup_onehot`must be`None`")
+        
+        if subgroup_onehot is not None:
+            subgroup_onehot = subgroup_onehot.numpy()
+            subgroup_indices = [
+                np.argwhere(subgroup_onehot[:, gr] == 1).squeeze() for gr in range(subgroup_onehot.shape[-1])
+            ]
+            
+        self.subset_indices = subgroup_indices
+        self.batch_size = batch_size
+        if drop_last is False:
+            raise NotImplementedError('drop_last=True not supported yet!')
+        self.drop_last = drop_last
+        self.n_subsets = len(subgroup_indices)
+        self.subset_sizes = [len(indices) for indices in subgroup_indices]
+        self.n_samples_per_subset = batch_size // self.n_subsets
+        # Check if batch_size is divisible by the number of subsets
+        assert batch_size % self.n_subsets == 0, (
+            f"Batch size ({batch_size}) must be divisible by the number of subsets ({self.n_subsets})."
+        )
+
+    def __iter__(self):
+        # Shuffle indices within each subset
+        shuffled_subset_indices = [torch.randperm(len(indices)).tolist() for indices in self.subset_indices]
+
+        # Calculate the maximum number of batches per subset
+        max_batches = min(len(indices) // self.n_samples_per_subset for indices in self.subset_indices)
+        if not self.drop_last and any(len(indices) % self.n_samples_per_subset != 0 for indices in self.subset_indices):
+            max_batches += 1  # Include partial batches if drop_last is False
+        # TODO: randomly permute the batch as well
+        # Yield balanced batches
+        for batch_idx in range(max_batches):
+            batch = []
+            for subset_idx in range(self.n_subsets):
+                start = batch_idx * self.n_samples_per_subset
+                end = start + self.n_samples_per_subset
+                subset_batch_indices = shuffled_subset_indices[subset_idx][start:end]
+                batch.extend([self.subset_indices[subset_idx][i] for i in subset_batch_indices])
+
+            # Yield the global indices for the batch
+            yield batch
+
+    def __len__(self):
+        if self.drop_last:
+            return min(len(indices) // self.n_samples_per_subset for indices in self.subset_indices)
+        else:
+            return max((len(indices) + self.n_samples_per_subset - 1) // self.n_samples_per_subset
+                       for indices in self.subset_indices)

humancompatible_train-0.1.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: humancompatible-train
+Version: 0.1.0
+Summary: PyTorch-based package for constrained training of neural networks
+Author: Gilles Bareilles, Jana Lepsova, Jakub Marecek
+Author-email: Andrii Kliachkin <kliachkin.andrii@gmail.com>
+Maintainer-email: Andrii Kliachkin <kliachkin.andrii@gmail.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: torch
+Requires-Dist: numpy
+Provides-Extra: ghost
+Requires-Dist: qpsolvers; extra == "ghost"
+Requires-Dist: scipy; extra == "ghost"
+Dynamic: license-file
+
+# Benchmarking Stochastic Approximation Algorithms for Fairness-Constrained Training of Deep Neural Networks
+
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Setup](https://github.com/humancompatible/train/actions/workflows/setup.yml/badge.svg)](https://github.com/humancompatible/train/actions/workflows/setup.yml)
+
+The toolkit implements algorithms for constrained training of neural networks based on PyTorch, and inspired by PyTorch's API, as well as a tool to compare stochastic-constrained stochastic optimization algorithms on a _fair learning_ task in the `experiments` folder.
+
+## Table of Contents
+1. [Basic installation instructions](#basic-installation-instructions)
+2. [Using the toolkit](#using-the-toolkit)
+3. [Reproducing the Benchmark](#reproducing-the-benchmark)
+4. [Extending the toolkit](#extending-the-toolkit) <!-- 6. [Citing humancompatible/train](#Citing-humancompatible/train) -->
+5. [License and terms of use](#license-and-terms-of-use)
+6. [References](#references)
+
+Humancompatible/train is still under active development! If you find bugs or have feature
+requests, please file a
+[Github issue](https://github.com/humancompatible/train/issues). 
+
+## Basic installation instructions
+The code requires Python version ```3.11```.
+
+1. Create a virtual environment
+
+**bash** (Linux)
+```
+python3.11 -m venv fairbenchenv
+source fairbenchenv/bin/activate
+```
+**cmd** (Windows)
+```
+python -m venv fairbenchenv
+fairbenchenv\Scripts\activate.bat
+```
+2. Install from source.
+```
+git clone https://github.com/humancompatible/train.git
+cd train
+pip install -r requirements.txt
+pip install .
+```
+
+If you wish to edit the code of the algorithms, install as an editable package:
+```
+pip install -e .
+```
+
+__Warning__: it is recommended to use Stochastic Ghost with the mkl-accelerated version of the scipy package with Stochastic Ghost; to install it, run
+
+```pip install --force-reinstall -i https://software.repos.intel.com/python/pypi scipy```
+
+after installing requirements.txt; otherwise, the algorithm will run slower. However, this is not supported on MacOS and may fail on some Windows devices.
+
+<!-- Install via pip -->
+<!-- ``` -->
+<!-- pip install folktables -->
+<!-- ``` -->
+
+## Using the toolkit
+
+The toolkit implements algorithms for constrained training of neural networks based on PyTorch, and inspired by PyTorch's API.
+
+### Code examples
+
+You are invited to check out the new API presented in notebooks in the `examples` folder.
+
+The algorithms follow the `dual_step()` - `step()` framework: taking inspiration from PyTorch, the `double_step` does updates related to the dual parameters and prepares for the primal update (by, e.g., saving constraint gradients), and `step()` updates the primal parameters.
+
+The idea is to make different algorithms nearly interchangable in the code.
+
+The legacy API used for the benchmark is presented in `examples/_old_/algorithm_demo.ipynb` and `examples/_old_/constraint_demo.ipynb`.
+
+## Reproducing the Benchmark
+
+### Running the algorithms
+
+The benchmark comprises the following algorithms:
+- Stochastic Ghost [[2]](#2),
+- SSL-ALM [[3]](#3),
+- Stochastic Switching Subgradient [[4]](#4).
+
+To reproduce the experiments of the paper, run the following:
+``` python
+cd experiments
+python run_folktables.py data=folktables alg=sslalm
+python run_folktables.py data=folktables alg=alm
+python run_folktables.py data=folktables alg=ghost
+python run_folktables.py data=folktables alg=ssg
+python run_folktables.py data=folktables alg=sgd     # baseline, no fairness
+python run_folktables.py data=folktables alg=fairret # baseline, fairness with regularizer
+```
+Each command will start 10 runs of the `alg`, 30 seconds each.
+The results will be saved to `experiments/utils/saved_models` and `experiments/utils/exp_results`.
+<!-- In the repository, we include the configuration needed to reproduce the experiments in the paper. To do so, go to `experiments` and run `python run_folktables.py data=folktables alg=sslalm`. -->
+<!-- Repeat for the other algorithms by changing the `alg` parameter. -->
+
+This repository uses [Hydra](https://hydra.cc/) to manage parameters; see `experiments/conf` for configuration files. 
+* To change the parameters of the experiment, such as the number of runs for each algorithm, run time, the dataset used (*note: for now supports only Folktables*) - use `experiment.yaml`. 
+* To change the dataset settings - such as file location - or do dataset-specific adjustments - such as the configuration of the protected attributes - use `data/{dataset_name}.yaml`
+* To change algorithm hyperparameters, use `alg/{algorithm_name}.yaml`.
+* To change constraint hyperparameters, use `constraint/{constraint_name}.yaml`
+
+<!-- ; it is installed as one of the dependencies. -->
+<!-- To learn more about using Hydra, please check out the [official tutorial](https://hydra.cc/docs/tutorials/basic/your_first_app). -->
+
+### Producing plots
+The plots and tables like the ones in the paper can be produced using the two notebooks. `experiments/algo_plots.ipynb` houses the convergence plots, and `experiments/model_plots.ipynb` - all the others.
+
+## Extending the toolkit
+
+### Adding new code
+
+**To add a new algorithm**, you can subclass the PyTorch ```Optimizer``` class and proceed following the API guideline presented above.
+
+## License and terms of use
+
+humancompatible/train is provided under the Apache 2.0 Licence.
+
+The benchmark part of the package relies on the Folktables package, provided under MIT Licence.
+It provides code to download data from the American Community Survey
+(ACS) Public Use Microdata Sample (PUMS) files managed by the US Census Bureau.
+The data itself is governed by the terms of use provided by the Census Bureau.
+For more information, see https://www.census.gov/data/developers/about/terms-of-service.html
+
+<!-- ## Cite this work -->
+
+<!-- If you use this work, we encourage you to cite our paper, and the folktables dataset [[1]](#1). -->
+
+<!-- ``` -->
+<!-- @article{ding2021retiring, -->
+<!--   title={Retiring Adult: New Datasets for Fair Machine Learning}, -->
+<!--   author={Ding, Frances and Hardt, Moritz and Miller, John and Schmidt, Ludwig}, -->
+<!--   journal={Advances in Neural Information Processing Systems}, -->
+<!--   volume={34}, -->
+<!--   year={2021} -->
+<!-- } -->
+<!-- ``` -->
+
+## Future work
+
+- Add more algorithms with PyTorch-like API
+- Add more examples from different fields where constrained training of DNNs is employed
+- Migrate the benchmark to the new API
+
+## References
+
+If you use this work, we encourage you to cite [our paper](https://arxiv.org/abs/2507.04033),
+
+```
+@misc{kliachkin2025benchmarkingstochasticapproximationalgorithms,
+      title={Benchmarking Stochastic Approximation Algorithms for Fairness-Constrained Training of Deep Neural Networks}, 
+      author={Andrii Kliachkin and Jana Lepšová and Gilles Bareilles and Jakub Mareček},
+      year={2025},
+      eprint={2507.04033},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2507.04033}, 
+}
+```
+
+<a id="1">[1]</a> 
+Ding, Hardt & Miller et al. (2021) Retiring Adult: New Datasets for Fair Machine Learning, Curran Associates, Inc..
+
+<a id="2">[2]</a> 
+Facchinei & Kungurtsev (2023) Stochastic Approximation for Expectation Objective and Expectation Inequality-Constrained Nonconvex Optimization, arXiv.
+
+<a id="3">[3]</a> 
+Huang, Zhang & Alacaoglu (2025) Stochastic Smoothed Primal-Dual Algorithms for Nonconvex Optimization with Linear Inequality Constraints, arXiv.
+
+<a id="4">[4]</a> 
+Huang & Lin (2023) Oracle Complexity of Single-Loop Switching Subgradient Methods for Non-Smooth Weakly Convex Functional Constrained Optimization, Curran Associates Inc..
+

humancompatible_train-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+experiments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+experiments/calculate_iteration_values.py,sha256=ZkqrARRW7b_hvayoliNN2TlA-KYHteDL2EbJWXlt4tY,10509
+experiments/run_folktables.py,sha256=8pxav2pGAVQP_fzvL0r0q0H5FJWh9OjT-NqFjWnoYWc,13942
+experiments/run_folktables_torchalgs.py,sha256=5SoDXx9e2Wm1An--nWDLIsbA2S2eO20WfvwvxsslToo,36506
+humancompatible/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humancompatible/train/__init__.py,sha256=5OfDdJBkjlvz4VJUsgn3TGT0u0qyAdNfThRREzMy2d4,74
+humancompatible/train/algorithms/Algorithm.py,sha256=mt39i5hcr1eaIfGPFwuEVyyEmlhqKFZJRLMINUqK9mE,650
+humancompatible/train/algorithms/__init__.py,sha256=1Euo6eQo362PKuX54EihBlvSWnFW7vHF7TtD6DEsKy0,243
+humancompatible/train/algorithms/ghost.py,sha256=_S6tDWT-98G7O11gp2r0efFSynL8T0MH1xtQqMc6hiU,8247
+humancompatible/train/algorithms/sgd.py,sha256=aqaug5XJqdFTf6z9LrXTnZq_HO7zDcRaa63pJUa6P34,3360
+humancompatible/train/algorithms/ssl_alm.py,sha256=tsGr2IRAHaUm7Vmc-y5eOn9rOi4Hodavdtw8FqtHht4,11190
+humancompatible/train/algorithms/switching_subgradient.py,sha256=qZr_su-nNn_5kOq28w-LBBKwJUf4mZpGgnLzP7eTUOg,6723
+humancompatible/train/algorithms/utils.py,sha256=h32UCmjT-KlbW2LAC_AWkyA6uvHUsl45fNj7n_iXeu4,1742
+humancompatible/train/algorithms/torch/__init__.py,sha256=T4kthURISj0xgLfG_7VVywrJi-XChkSh7Lop-eCSOFI,78
+humancompatible/train/algorithms/torch/ssl_alm.py,sha256=2ufFtVKoYZEzMFMmti6vYjnp414wIe83HQkfLpjaMlw,7907
+humancompatible/train/algorithms/torch/ssw.py,sha256=9HRUBp3RsG1S-Ph39vIKJDTBygv36gsMgg9-AXjrfCY,5301
+humancompatible/train/constraints/__init__.py,sha256=1rhhYnXKFhkrdJr1Cse24M3kw3hrIv5-P_qDxaqMVuY,247
+humancompatible/train/constraints/constraint.py,sha256=T_xw_JU7Kpr7IY02mzw6LvMGdfLmO_rir2q6JIqmvYg,2948
+humancompatible/train/constraints/constraint_fns.py,sha256=wtAx_OOUeq9Xv7hwNiGvoMTiGooNaisXjbWNtaABecc,3323
+humancompatible/train/fairness/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humancompatible/train/fairness/constraints/__init__.py,sha256=00l89E-p9pF6C7zMEewLRA7jwmjYuulaJOQPdOuujDA,333
+humancompatible/train/fairness/constraints/constraint.py,sha256=u736vUoFHDyB1ao3TOtAQ3hw18GkRA5jg2AccLUVHAk,3304
+humancompatible/train/fairness/constraints/constraint_fns.py,sha256=--vuLrNYL_NWiZ8iAUhm1qMIdKlBnTJ6NVxmIaArgYQ,6994
+humancompatible/train/fairness/constraints/torch/__init__.py,sha256=y4NZpfk0OnggOItrrwwP57_LM42txDIYB5Cy3NpZUv8,38
+humancompatible/train/fairness/constraints/torch/constraints.py,sha256=38uUXfvkcwPaMUqR6CaUUG2ij0aAPmfgXdiGnPBqMH4,1897
+humancompatible/train/fairness/utils/__init__.py,sha256=ij77OdmUzgMKnx0L4VHaENsprZn3rLy7HcgUCpLBhGE,56
+humancompatible/train/fairness/utils/balanced_batch_sampler.py,sha256=J6eHeUIqZG3qGCgCZSBuT710vuBEcudNK1q4pkhWT8Q,3296
+humancompatible_train-0.1.0.dist-info/licenses/LICENCE.txt,sha256=vjeFbYz-1t5Gs7Nj2kXpLKRiLtRrhlx4drCybRNjNm4,11338
+humancompatible_train-0.1.0.dist-info/METADATA,sha256=-VtMN0aZt-C9OenUSl26diKriYJeVw1_7grM6f8UxMk,8357
+humancompatible_train-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+humancompatible_train-0.1.0.dist-info/top_level.txt,sha256=hQ41HOSAFFSm6ksFDFX7HlOfle9UI72wCdD_sbWd4Yk,28
+humancompatible_train-0.1.0.dist-info/RECORD,,

humancompatible_train-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+