Pot

Latest version: v0.9.3

Safety actively analyzes 613682 Python packages for vulnerabilities to keep your Python projects secure.

Scan your dependencies

Page 1 of 5

0.9.3

Closed issues
- Fixed an issue with cost correction for mismatched labels in `ot.da.BaseTransport` fit methods. This fix addresses the original issue introduced PR 587 (PR 593)

What's Changed
* tiny typos in doc by gabrielfougeron in https://github.com/PythonOT/POT/pull/591
* Fix DA cost correction when cost limit is set to Inf by kachayev in https://github.com/PythonOT/POT/pull/593
* [MRG] Release 0.9.3 by rflamary in https://github.com/PythonOT/POT/pull/594

New Contributors
* gabrielfougeron made their first contribution in https://github.com/PythonOT/POT/pull/591

**Full Changelog**: https://github.com/PythonOT/POT/compare/0.9.2...0.9.3

0.9.2

This new release contains several new features and bug fixes. Among the new features
we have a new solver for estimation of nearest Brenier potentials (SSNB) that can be used for OT mapping estimation (on small problems), new Bregman Alternated Projected Gradient solvers for GW and FGW, and new solvers for Bures-Wasserstein barycenters. We also provide a first solver for Low Rank Sinkhorn that will be ussed to provide low rak OT extensions in the next releases. Finally we have a new exact line-search for (F)GW solvers with KL loss that can be used to improve the convergence of the solvers.

We also have a new `LazyTensor` class that can be used to model OT plans and low rank tensors in large scale OT. This class is used to return the plan for the new wrapper for `geomloss` Sinkhorn solver on empirical samples that can lead to x10/x100 speedups on CPU or GPU and have a lazy implementation that allows solving very large problems of a few millions samples.

We also have a new API for solving OT problems from empirical samples with `ot.solve_sample` Finally we have a new API for Gromov-Wasserstein solvers with `ot.solve_gromov` function that centralizes most of the (F)GW methods with unified notation. Some example of how to use the new API below:

python
Generate random data
xs, xt = np.random.randn(100, 2), np.random.randn(50, 2)

Solve OT problem with empirical samples
sol = ot.solve_sample(xs, xt) Exact OT betwen smaples with uniform weights
sol = ot.solve_sample(xs, xt, wa, wb) Exact OT with weights given by user

sol = ot.solve_sample(xs, xt, reg= 1, metric='euclidean') sinkhorn with euclidean metric

sol = ot.solve_sample(xs, xt, reg= 1, method='geomloss') faster sinkhorn solver on CPU/GPU

sol = ot.solve_sample(x,x2, method='factored', rank=10) compute factored OT

sol = ot.solve_sample(x,x2, method='lowrank', rank=10) compute lowrank sinkhorn OT

value_bw = ot.solve_sample(xs, xt, method='gaussian').value Bures-Wasserstein distance

Solve GW problem
Cs, Ct = ot.dist(xs, xs), ot.dist(xt, xt) compute cost matrices
sol = ot.solve_gromov(Cs,Ct) Exact GW between samples with uniform weights

Solve FGW problem
M = ot.dist(xs, xt) compute cost matrix

Exact FGW between samples with uniform weights
sol = ot.solve_gromov(Cs, Ct, M, loss='KL', alpha=0.7) FGW with KL data fitting


recover solutions objects
P = sol.plan OT plan
u, v = sol.potentials dual variables
value = sol.value OT value

for GW and FGW
value_linear = sol.value_linear linear part of the loss
value_quad = sol.value_quad quadratic part of the loss



Users are encouraged to use the new API (it is much simpler) but it might still be subjects to small changes before the release of POT 1.0.


We also fixed a number of issues, the most pressing being a problem of GPU memory allocation when pytorch is installed that will not happen now thanks to Lazy initialization of the backends. We now also have the possibility to deactivate some backends using environment which prevents POT from importing them and can lead to large import speedup.


New features
+ Added support for [Nearest Brenier Potentials (SSNB)](http://proceedings.mlr.press/v108/paty20a/paty20a.pdf) (PR #526) + minor fix (PR 535)
+ Tweaked `get_backend` to ignore `None` inputs (PR 525)
+ Callbacks for generalized conditional gradient in `ot.da.sinkhorn_l1l2_gl` are now vectorized to improve performance (PR 507)
+ The `linspace` method of the backends now has the `type_as` argument to convert to the same dtype and device. (PR 533)
+ The `convolutional_barycenter2d` and `convolutional_barycenter2d_debiased` functions now work with different devices.. (PR 533)
+ New API for Gromov-Wasserstein solvers with `ot.solve_gromov` function (PR 536)
+ New LP solvers from scipy used by default for LP barycenter (PR 537)
+ Update wheels to Python 3.12 and remove old i686 arch that do not have scipy wheels (PR 543)
+ Upgraded unbalanced OT solvers for more flexibility (PR 539)
+ Add LazyTensor for modeling plans and low rank tensor in large scale OT (PR 544)
+ Add exact line-search for `gromov_wasserstein` and `fused_gromov_wasserstein` with KL loss (PR 556)
+ Add KL loss to all semi-relaxed (Fused) Gromov-Wasserstein solvers (PR 559)
+ Further upgraded unbalanced OT solvers for more flexibility and future use (PR 551)
+ New API function `ot.solve_sample` for solving OT problems from empirical samples (PR 563)
+ Wrapper for `geomloss`` solver on empirical samples (PR 571)
+ Add `stop_criterion` feature to (un)regularized (f)gw barycenter solvers (PR 578)
+ Add `fixed_structure` and `fixed_features` to entropic fgw barycenter solver (PR 578)
+ Add new BAPG solvers with KL projections for GW and FGW (PR 581)
+ Add Bures-Wasserstein barycenter in `ot.gaussian` and example (PR 582, PR 584)
+ Domain adaptation method `SinkhornL1l2Transport` now supports JAX backend (PR 587)
+ Added support for [Low-Rank Sinkhorn Factorization](https://arxiv.org/pdf/2103.04737.pdf) (PR #568)


Closed issues
- Fix line search evaluating cost outside of the interpolation range (Issue 502, PR 504)
- Lazily instantiate backends to avoid unnecessary GPU memory pre-allocations on package import (Issue 516, PR 520)
- Handle documentation and warnings when integers are provided to (f)gw solvers based on cg (Issue 530, PR 559)
- Correct independence of `fgw_barycenters` to `init_C` and `init_X` (Issue 547, PR 566)
- Avoid precision change when computing norm using PyTorch backend (Discussion 570, PR 572)
- Create `ot/bregman/`repository (Issue 567, PR 569)
- Fix matrix feature shape in `entropic_fused_gromov_barycenters`(Issue 574, PR 573)
- Fix (fused) gromov-wasserstein barycenter solvers to support `kl_loss`(PR 576)

New Contributors
* laudavid made their first contribution in https://github.com/PythonOT/POT/pull/568

**Full Changelog**: https://github.com/PythonOT/POT/compare/0.9.1...0.9.2

0.9.1

This new release contains several new features and bug fixes.

New features include a new submodule `ot.gnn` that contains two new Graph neural network layers (compatible with [Pytorch Geometric](https://pytorch-geometric.readthedocs.io/)) for template-based pooling of graphs with an example on [graph classification](https://pythonot.github.io/master/auto_examples/gromov/plot_gnn_TFGW.html). Related to this, we also now provide FGW and semi relaxed FGW solvers for which the resulting loss is differentiable w.r.t. the parameter `alpha`. Other contributions on the (F)GW front include a new solver for the Proximal Point algorithm [that can be used to solve entropic GW problems](https://pythonot.github.io/master/auto_examples/gromov/plot_fgw_solvers.html) (using the parameter `solver="PPA"`), new solvers for entropic FGW barycenters, novels Sinkhorn-based solvers for entropic semi-relaxed (F)GW, the possibility to provide a warm-start to the solvers, and optional marginal weights of the samples (uniform weights ar used by default). Finally we added in the submodule `ot.gaussian` and `ot.da` new loss and mapping estimators for the Gaussian Gromov-Wasserstein that can be used as a fast alternative to GW and estimates linear mappings between unregistered spaces that can potentially have different size (See the update [linear mapping example](https://pythonot.github.io/master/auto_examples/domain-adaptation/plot_otda_linear_mapping.html) for an illustration).

We also provide a new solver for the [Entropic Wasserstein Component Analysis](https://pythonot.github.io/master/auto_examples/others/plot_EWCA.html) that is a generalization of the celebrated PCA taking into account the local neighborhood of the samples. We also now have a new solver in `ot.smooth` for the [sparsity-constrained OT (last plot)](https://pythonot.github.io/master/auto_examples/plot_OT_1D_smooth.html) that can be used to find regularized OT plans with sparsity constraints. Finally we have a first multi-marginal solver for regular 1D distributions with a Monge loss (see [here](https://pythonot.github.io/master/auto_examples/others/plot_dmmot.html)).

The documentation and testings have also been updated. We now have nearly 95% code coverage with the tests. The documentation has been updated and some examples have been streamlined to build more quickly and avoid timeout problems with CircleCI. We also added an optional CI on GPU for the master branch and approved PRs that can be used when a GPU runner is online.

Many other bugs and issues have been fixed and we want to thank all the contributors, old and new, who made this release possible. More details below.


New features
- Gaussian Gromov Wasserstein loss and mapping (PR 498)
- Template-based Fused Gromov Wasserstein GNN layer in `ot.gnn` (PR 488)
- Make alpha parameter in semi-relaxed Fused Gromov Wasserstein differentiable (PR 483)
- Make alpha parameter in Fused Gromov Wasserstein differentiable (PR 463)
- Added the sparsity-constrained OT solver to `ot.smooth` and added `projection_sparse_simplex` to `ot.utils` (PR 459)
- Add tests on GPU for master branch and approved PR (PR 473)
- Add `median` method to all inherited classes of `backend.Backend` (PR 472)
- Update tests for macOS and Windows, speedup documentation (PR 484)
- Added Proximal Point algorithm to solve GW problems via a new parameter `solver="PPA"` in `ot.gromov.entropic_gromov_wasserstein` + examples (PR 455)
- Added features `warmstart` and `kwargs` in `ot.gromov.entropic_gromov_wasserstein` to respectively perform warmstart on dual potentials and pass parameters to `ot.sinkhorn` (PR 455)
- Added sinkhorn projection based solvers for FGW `ot.gromov.entropic_fused_gromov_wasserstein` and entropic FGW barycenters + examples (PR 455)
- Added features `warmstartT` and `kwargs` to all CG and entropic (F)GW barycenter solvers (PR 455)
- Added entropic semi-relaxed (Fused) Gromov-Wasserstein solvers in `ot.gromov` + examples (PR 455)
- Make marginal parameters optional for (F)GW solvers in `._gw`, `._bregman` and `._semirelaxed` (PR 455)
- Add Entropic Wasserstein Component Analysis (ECWA) in ot.dr (PR 486)
- Added feature Efficient Discrete Multi Marginal Optimal Transport Regularization + examples (PR 454)

Closed issues

- Fix gromov conventions (PR 497)
- Fix change in scipy API for `cdist` (PR 487)
- More permissive check_backend (PR 494)
- Fix circleci-redirector action and codecov (PR 460)
- Fix issues with cuda for ot.binary_search_circle and with gradients for ot.sliced_wasserstein_sphere (PR 457)
- Major documentation cleanup (PR 462, PR 467, PR 475)
- Fix gradients for "Wasserstein2 Minibatch GAN" example (PR 466)
- Faster Bures-Wasserstein distance with NumPy backend (PR 468)
- Fix issue backend for ot.sliced_wasserstein_sphere ot.sliced_wasserstein_sphere_unif (PR 471)
- Fix issue with ot.barycenter_stabilized when used with PyTorch tensors and log=True (PR 474)
- Fix `utils.cost_normalization` function issue to work with multiple backends (PR 472)
- Fix precision error on marginal sums and (Issue 429, PR 496)


New Contributors
* kachayev made their first contribution in https://github.com/PythonOT/POT/pull/462
* liutianlin0121 made their first contribution in https://github.com/PythonOT/POT/pull/459
* francois-rozet made their first contribution in https://github.com/PythonOT/POT/pull/468
* framunoz made their first contribution in https://github.com/PythonOT/POT/pull/472
* SoniaMaz8 made their first contribution in https://github.com/PythonOT/POT/pull/483
* tomMoral made their first contribution in https://github.com/PythonOT/POT/pull/494
* x12hengyu made their first contribution in https://github.com/PythonOT/POT/pull/454

**Full Changelog**: https://github.com/PythonOT/POT/compare/0.9.0...0.9.1

0.9.0

This new release contains so many new features and bug fixes since 0.8.2 that we decided to make it a new minor release at 0.9.0.

The release contains many new features. First we did a major update of all Gromov-Wasserstein solvers that brings up to 30% gain in
computation time (see PR 431) and allows the GW solvers to work on non symmetricmatrices. It also brings novel solvers for the veryefficient [semi-relaxed GW problem](https://pythonot.github.io/master/auto_examples/gromov/plot_semirelaxed_fgw.html#sphx-glr-auto-examples-gromov-plot-semirelaxed-fgw-py) that can be used to find the best re-weighting for one of the distributions. We also now have fast and differentiable solvers for [Wasserstein on the circle](https://pythonot.github.io/master/auto_examples/plot_compute_wasserstein_circle.html#sphx-glr-auto-examples-plot-compute-wasserstein-circle-py) and [sliced Wasserstein on the sphere](https://pythonot.github.io/master/auto_examples/backends/plot_ssw_unif_torch.html#sphx-glr-auto-examples-backends-plot-ssw-unif-torch-py). We are also very happy to provide new OT barycenter solvers such as the [Free support Sinkhorn barycenter](https://pythonot.github.io/master/auto_examples/barycenters/plot_free_support_sinkhorn_barycenter.html#sphx-glr-auto-examples-barycenters-plot-free-support-sinkhorn-barycenter-py) and the [Generalized Wasserstein barycenter](https://pythonot.github.io/master/auto_examples/barycenters/plot_generalized_free_support_barycenter.html#sphx-glr-auto-examples-barycenters-plot-generalized-free-support-barycenter-py). A new differentiable solver for OT across spaces that provides OT plans between samples and features simultaneously and called [Co-Optimal Transport](https://pythonot.github.io/master/auto_examples/others/plot_COOT.html) has also been implemented. Finally we began working on OT between Gaussian distributions and now provide differentiable estimation for the Bures-Wasserstein [divergence](https://pythonot.github.io/master/gen_modules/ot.gaussian.html#ot.gaussian.bures_wasserstein_distance) and [mappings](https://pythonot.github.io/master/auto_examples/domain-adaptation/plot_otda_linear_mapping.html#sphx-glr-auto-examples-domain-adaptation-plot-otda-linear-mapping-py).

Another important first step toward POT 1.0 is the implementation of a unified API for OT solvers with introduction of the [`ot.solve`](https://pythonot.github.io/master/all.html#ot.solve) function that can solve (depending on parameters) exact, regularized and unbalanced OT and return a new [`OTResult`](https://pythonot.github.io/master/gen_modules/ot.utils.html#ot.utils.OTResult) object. The idea behind this new API is to facilitate exploring different solvers with just a change of parameter and get a more unified API for them. We will keep the old solvers API for power users but it will be the preferred way to solve problems starting from release 1.0.0. We provide below some examples of use for the new function and how to recover different aspects of the solution (OT plan, full loss, linear part of the loss, dual variables) :
python
Solve exact ot
sol = ot.solve(M)

get the results
G = sol.plan OT plan
ot_loss = sol.value OT value (full loss for regularized and unbalanced)
ot_loss_linear = sol.value_linear OT value for linear term np.sum(sol.plan*M)
alpha, beta = sol.potentials dual potentials

direct plan and loss computation
G = ot.solve(M).plan
ot_loss = ot.solve(M).value

OT exact with marginals a/b
sol2 = ot.solve(M, a, b)

regularized and unbalanced OT
sol_rkl = ot.solve(M, a, b, reg=1) KL regularization
sol_rl2 = ot.solve(M, a, b, reg=1, reg_type='L2')
sol_ul2 = ot.solve(M, a, b, unbalanced=10, unbalanced_type='L2')
sol_rkl_ukl = ot.solve(M, a, b, reg=10, unbalanced=10) KL + KL


The function is fully compatible with backends and will be implemented for different types of distribution support (empirical distributions, grids) and OT problems (Gromov-Wasserstein) in the new releases. This new API is not yet presented in the kickstart part of the documentation as there is a small change that it might change when implementing new solvers but we encourage users to play with it.

Finally, in addition to those many new this release fixes 20 issues (some long standing) and we want to thank all the contributors who made this release so big. More details below.


New features
- Added feature to (Fused) Gromov-Wasserstein solvers herited from `ot.optim` to support relative and absolute loss variations as stopping criterions (PR 431)
- Added feature to (Fused) Gromov-Wasserstein solvers to handle asymmetric matrices (PR 431)
- Added semi-relaxed (Fused) Gromov-Wasserstein solvers in `ot.gromov` + examples (PR 431)
- Added the spherical sliced-Wasserstein discrepancy in `ot.sliced.sliced_wasserstein_sphere` and `ot.sliced.sliced_wasserstein_sphere_unif` + examples (PR 434)
- Added the Wasserstein distance on the circle in ``ot.lp.solver_1d.wasserstein_circle`` (PR 434)
- Added the Wasserstein distance on the circle (for p>=1) in `ot.lp.solver_1d.binary_search_circle` + examples (PR 434)
- Added the 2-Wasserstein distance on the circle w.r.t a uniform distribution in `ot.lp.solver_1d.semidiscrete_wasserstein2_unif_circle` (PR 434)
- Added Bures Wasserstein distance in `ot.gaussian` (PR 428)
- Added Generalized Wasserstein Barycenter solver + example (PR 372), fixed graphical details on the example (PR 376)
- Added Free Support Sinkhorn Barycenter + example (PR 387)
- New API for OT solver using function `ot.solve` (PR 388)
- Backend version of `ot.partial` and `ot.smooth` (PR 388 and 449)
- Added argument for warmstart of dual potentials in Sinkhorn-based methods in `ot.bregman` (PR 437)
- Added parameters method in `ot.da.SinkhornTransport` (PR 440)
- `ot.dr` now uses the new Pymanopt API and POT is compatible with current
Pymanopt (PR 443)
- Added CO-Optimal Transport solver + examples (PR 447)
- Remove the redundant `nx.abs()` at the end of `wasserstein_1d()` (PR 448)

Closed issues


- Fixed an issue with the documentation gallery sections (PR 395)
- Fixed an issue where sinkhorn divergence did not have a gradients (Issue 393, PR 394)
- Fixed an issue where we could not ask TorchBackend to place a random tensor on GPU
(Issue 371, PR 373)
- Fixed an issue where Sinkhorn solver assumed a symmetric cost matrix (Issue 374, PR 375)
- Fixed an issue where hitting iteration limits would be reported to stderr by std::cerr regardless of Python's stderr stream status (PR 377)
- Fixed an issue where the metric argument in ot.dist did not allow a callable parameter (Issue 378, PR 379)
- Fixed an issue where the max number of iterations in ot.emd was not allowed to go beyond 2^31 (PR 380)
- Fixed an issue where pointers would overflow in the EMD solver, returning an
incomplete transport plan above a certain size (slightly above 46k, its square being
roughly 2^31) (PR 381)
- Error raised when mass mismatch in emd2 (PR 386)
- Fixed an issue where a pytorch example would throw an error if executed on a GPU (Issue 389, PR 391)
- Added a work-around for scipy's bug, where you cannot compute the Hamming distance with a "None" weight attribute. (Issue 400, PR 402)
- Fixed an issue where the doc could not be built due to some changes in matplotlib's API (Issue 403, PR 402)
- Replaced Numpy C Compiler with Setuptools C Compiler due to deprecation issues (Issue 408, PR 409)
- Fixed weak optimal transport docstring (Issue 404, PR 410)
- Fixed error with parameter `log=True`for `SinkhornLpl1Transport` (Issue 412,
PR 413)
- Fixed an issue about `warn` parameter in `sinkhorn2` (PR 417)
- Fix an issue where the parameter `stopThr` in `empirical_sinkhorn_divergence` was rendered useless by subcalls
that explicitly specified `stopThr=1e-9` (Issue 421, PR 422).
- Fixed a bug breaking an example where we would try to make an array of arrays of different shapes (Issue 424, PR 425)
- Fixed an issue with the documentation gallery section (PR 444)
- Fixed issues with cuda variables for `line_search_armijo` and `entropic_gromov_wasserstein` (Issue 445, PR 446)

New Contributors
* eloitanguy made their first contribution in https://github.com/PythonOT/POT/pull/372
* stanleyjs made their first contribution in https://github.com/PythonOT/POT/pull/377
* zdk123 made their first contribution in https://github.com/PythonOT/POT/pull/379
* clecoz made their first contribution in https://github.com/PythonOT/POT/pull/386
* eddardd made their first contribution in https://github.com/PythonOT/POT/pull/387
* decarpentierg made their first contribution in https://github.com/PythonOT/POT/pull/398
* tlacombe made their first contribution in https://github.com/PythonOT/POT/pull/423
* arincbulgur made their first contribution in https://github.com/PythonOT/POT/pull/417
* tgnassou made their first contribution in https://github.com/PythonOT/POT/pull/428
* clbonet made their first contribution in https://github.com/PythonOT/POT/pull/434
* chaosink made their first contribution in https://github.com/PythonOT/POT/pull/448
* antoinecollas made their first contribution in https://github.com/PythonOT/POT/pull/449

**Full Changelog**: https://github.com/PythonOT/POT/compare/0.8.2...0.9.0

0.8.2

This releases introduces several new notable features. The less important but most exiting one being that we now have a logo for the toolbox (color and dark background) :
![](https://pythonot.github.io/master/_images/logo.svg)

This logo is generated using with matplotlib and using the solution of an OT problem provided by POT (with `ot.emd`). Generating the logo can be done with a simple python script also provided in the [documentation gallery](https://pythonot.github.io/auto_examples/others/plot_logo.html#sphx-glr-auto-examples-others-plot-logo-py).

New OT solvers include [Weak OT](https://pythonot.github.io/gen_modules/ot.weak.html#ot.weak.weak_optimal_transport) and [OT with factored coupling](https://pythonot.github.io/gen_modules/ot.factored.html#ot.factored.factored_optimal_transport) that can be used on large datasets. The [Majorization Minimization](https://pythonot.github.io/gen_modules/ot.unbalanced.html?highlight=mm_#ot.unbalanced.mm_unbalanced) solvers for non-regularized Unbalanced OT are now also available. We also now provide an implementation of [GW and FGW unmixing](https://pythonot.github.io/gen_modules/ot.gromov.html#ot.gromov.gromov_wasserstein_linear_unmixing) and [dictionary learning](https://pythonot.github.io/gen_modules/ot.gromov.html#ot.gromov.gromov_wasserstein_dictionary_learning). It is now possible to use autodiff to solve entropic an quadratic regularized OT in the dual for full or stochastic optimization thanks to the new functions to compute the dual loss for [entropic](https://pythonot.github.io/gen_modules/ot.stochastic.html#ot.stochastic.loss_dual_entropic) and [quadratic](https://pythonot.github.io/gen_modules/ot.stochastic.html#ot.stochastic.loss_dual_quadratic) regularized OT and reconstruct the [OT plan](https://pythonot.github.io/gen_modules/ot.stochastic.html#ot.stochastic.plan_dual_entropic) on part or all of the data. They can be used for instance to solve OT problems with stochastic gradient or for estimating the [dual potentials as neural networks](https://pythonot.github.io/auto_examples/backends/plot_stoch_continuous_ot_pytorch.html#sphx-glr-auto-examples-backends-plot-stoch-continuous-ot-pytorch-py).

On the backend front, we now have backend compatible functions and classes in the domain adaptation [`ot.da`](https://pythonot.github.io/gen_modules/ot.da.html#module-ot.da) and unbalanced OT [`ot.unbalanced`](https://pythonot.github.io/gen_modules/ot.unbalanced.html) modules. This means that the DA classes can be used on tensors from all compatible backends. The [free support Wasserstein barycenter](https://pythonot.github.io/gen_modules/ot.lp.html?highlight=free%20support#ot.lp.free_support_barycenter) solver is now also backend compatible.

Finally we have worked on the documentation to provide an update of existing examples in the gallery and and several new examples including [GW dictionary learning](https://pythonot.github.io/auto_examples/gromov/plot_gromov_wasserstein_dictionary_learning.html#sphx-glr-auto-examples-gromov-plot-gromov-wasserstein-dictionary-learning-py) and [weak Optimal Transport](https://pythonot.github.io/auto_examples/others/plot_WeakOT_VS_OT.html#sphx-glr-auto-examples-others-plot-weakot-vs-ot-py).

New features

- Remove deprecated `ot.gpu` submodule (PR 361)
- Update examples in the gallery (PR 359)
- Add stochastic loss and OT plan computation for regularized OT and
backend examples(PR 360)
- Implementation of factored OT with emd and sinkhorn (PR 358)
- A brand new logo for POT (PR 357)
- Better list of related examples in quick start guide with `minigallery` (PR 334)
- Add optional log-domain Sinkhorn implementation in WDA to support smaller values
of the regularization parameter (PR 336)
- Backend implementation for `ot.lp.free_support_barycenter` (PR 340)
- Add weak OT solver + example (PR 341)
- Add backend support for Domain Adaptation and Unbalanced solvers (PR 343)
- Add (F)GW linear dictionary learning solvers + example (PR 319)
- Add links to related PR and Issues in the doc release page (PR 350)
- Add new minimization-maximization algorithms for solving exact Unbalanced OT + example (PR 362)

Closed issues

- Fix mass gradient of `ot.emd2` and `ot.gromov_wasserstein2` so that they are
centered (Issue 364, PR 363)
- Fix bug in instantiating an `autograd` function `ValFunction` (Issue 337,
PR 338)
- Fix POT ABI compatibility with old and new numpy (Issue 346, PR 349)
- Warning when feeding integer cost matrix to EMD solver resulting in an integer transport plan (Issue 345, PR 343)
- Fix bug where gromov_wasserstein2 does not perform backpropagation with CUDA
tensors (Issue 351, PR 352)

0.8.1

This release fixes several bugs and introduces two new backends: Cupy and Tensorflow. Note that the tensorflow backend will work only when tensorflow has enabled the Numpy behavior (for transpose that is not by default in tensorflow). We also introduce a simple benchmark on CPU GPU for the sinkhorn solver that will be provided in the [backend](https://pythonot.github.io/gen_modules/ot.backend.html) documentation.

This release also brings a few changes in dependencies and compatibility. First we removed tests for Python 3.6 that will not be updated in the future. Also note that POT now depends on Numpy (>= 1.20) because a recent change in ABI is making the wheels non-compatible with older numpy versions. If you really need an older numpy POT will work with no problems but you will need to build it from source.

As always we want to that the contributors who helped make POT better (and bug free).

New features

- New benchmark for sinkhorn solver on CPU/GPU and between backends (PR 316)
- New tensorflow backend (PR 316)
- New Cupy backend (PR 315)
- Documentation always up-to-date with README, RELEASES, CONTRIBUTING and
CODE_OF_CONDUCT files (PR 316, PR 322).

Closed issues

- Fix bug in older Numpy ABI (<1.20) (Issue 308, PR 326)
- Fix bug in `ot.dist` function when non euclidean distance (Issue 305, PR 306)
- Fix gradient scaling for functions using `nx.set_gradients` (Issue 309, PR 310)
- Fix bug in generalized Conditional gradient solver and SinkhornL1L2 (Issue 311, PR 313)
- Fix log error in `gromov_barycenters` (Issue 317, PR 3018)

Page 1 of 5

© 2024 Safety CLI Cybersecurity Inc. All Rights Reserved.