semvec/pypi-packages huggingface dataset:
pdmn 1.0.0
A package providing a pDMN solver
Requires Python: >=3.6

# pDMN

## Welcome to the pDMN solver's code repository.

pDMN stands for Probabilistic Decision and Model Notation.
It is an extension to the [DMN](https://www.omg.org/spec/DMN/About-DMN/) standard, which aims to add probabilistic reasoning while maintaining DMN's goal of being readable and user-friendly.

## Installation and usage

In short for Linux: after cloning this repo, install the Python dependencies.

```
git clone https://gitlab.com/EAVISE/cdmn/pdmn
cd pdmn
pip3 install -r requirements.txt
```

After this, you can run the solver. Example usage is as follows:

```
python3 -O solver.py Name_Of_XLSX.xlsx -n "Name_Of_Sheet" -o output_name.lp
```


## How to reference

If you wish to refer to pDMN or you use it in other works, please reference us as follows:

```
Vandevelde, S., Verreet, V., De Raedt, L., & Vennekens, J. (2021). A Table-Based Representation for Probabilistic Logic: Preliminary Results. arXiv preprint arXiv:2110.01909.
```

or 

```
@article{pDMN,
  title={A Table-Based Representation for Probabilistic Logic: Preliminary Results},
  author={Vandevelde, Simon and Verreet, Victor and De Raedt, Luc and Vennekens, Joost},
  journal={arXiv preprint arXiv:2110.01909},
  year={2021}
}
```
easy-dp 0.1.0
A not-so-efficient library for easy implementation of multi-gpu differential privacy
Requires Python: >=3.7

# easy-dp

This library provides a simple way to implement differential privacy in PyTorch. The focus is only on supporting multi-gpu training with FSDP to allow for large models.

Note: the code is heavily based on [private-transformers](https://github.com/lxuechen/private-transformers)

## Installation

    pip install easy-dp

## Usage

    from easy_dp import PrivacyEngine

    privacy_engine = PrivacyEngine(
        len_dataset=len(train_dataset),
        batch_size=batch_size,
        max_grad_norm=max_grad_norm,
        num_epochs=num_epochs,
        target_epsilon=target_epsilon,
        target_delta=target_delta,
    )

Compute the gradient of a single sample, then clip it:

    privacy_engine.clip_gradient(model.parameters())

You can accumulate the gradients into a variable, for example here we use the `summed_clipped_gradients` attribute. Then add noise to the accumulated gradients and divide by the batch size before saving the gradients to the model parameters:

    for param in model.parameters():
        param.grad = privacy_engine.add_noise(param.summed_clipped_gradients)
        param.grad = param.grad / batch_size

Now you can call `optimizer.step()` to update the model parameters.

## Upload to PyPI

    python -m build

    twine upload dist/*
gentoopm 0.5.0
Python wrapper for APIs of Gentoo package managers
Requires Python: >=3.9

========
gentoopm
========

GentooPM is a wrapper for API of Gentoo package managers (Portage_,
PkgCore_ and historically Paludis_).  It has served two purposes:

1. Making it possible to easily write apps that can utilize any
   of the available PMs.

2. Replacing the awful API provided by package managers (especially
   Portage) with something more Pythonic, easier to use and more
   readable.

The project provides a ``gentoopmq`` tool providing basic lookups
into the PM data.  Most importantly, it provides an IPython-friendly
``gentoopmq shell`` command that can be used to play with the API.

The project maintenance is slowly resuming but the code needs major
cleanup.


.. _Portage: https://wiki.gentoo.org/wiki/Project:Portage
.. _PkgCore: https://github.com/pkgcore/pkgcore
.. _Paludis: https://paludis.exherbo.org/