CircleCI update of dev docs (2862).

Author: Circle CI

master/_downloads/0228827bdcc2a6735b1faf26c864145d/plot_OT_1D_smooth.zip

@@ -0,0 +1,97 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Translation Invariant Sinkhorn for Unbalanced Optimal Transport\n\nThis examples illustrates the better convergence of the translation\ninvariance Sinkhorn algorithm proposed in [73] compared to the classical\nSinkhorn algorithm.\n\n[73] S\u00e9journ\u00e9, T., Vialard, F. X., & Peyr\u00e9, G. (2022).\nFaster unbalanced optimal transport: Translation invariant sinkhorn and 1-d frank-wolfe.\nIn International Conference on Artificial Intelligence and Statistics (pp. 4995-5021). PMLR.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "# Author: Cl\u00e9ment Bonet <clement.bonet@ensae.fr>\n# License: MIT License\n\nimport numpy as np\nimport matplotlib.pylab as pl\nimport ot"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setting parameters\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "n_iter = 50  # nb iters\nn = 40  # nb samples\n\nnum_iter_max = 100\nn_noise = 10\n\nreg = 0.005\nreg_m_kl = 0.05\n\nmu_s = np.array([-1, -1])\ncov_s = np.array([[1, 0], [0, 1]])\n\nmu_t = np.array([4, 4])\ncov_t = np.array([[1, -.8], [-.8, 1]])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Compute entropic kl-regularized UOT with Sinkhorn and Translation Invariant Sinkhorn\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "err_sinkhorn_uot = np.empty((n_iter, num_iter_max))\nerr_sinkhorn_uot_ti = np.empty((n_iter, num_iter_max))\n\n\nfor seed in range(n_iter):\n    np.random.seed(seed)\n    xs = ot.datasets.make_2D_samples_gauss(n, mu_s, cov_s)\n    xt = ot.datasets.make_2D_samples_gauss(n, mu_t, cov_t)\n\n    xs = np.concatenate((xs, ((np.random.rand(n_noise, 2) - 4))), axis=0)\n    xt = np.concatenate((xt, ((np.random.rand(n_noise, 2) + 6))), axis=0)\n\n    n = n + n_noise\n\n    a, b = np.ones((n,)) / n, np.ones((n,)) / n  # uniform distribution on samples\n\n    # loss matrix\n    M = ot.dist(xs, xt)\n    M /= M.max()\n\n    entropic_kl_uot, log_uot = ot.unbalanced.sinkhorn_unbalanced(a, b, M, reg, reg_m_kl, reg_type=\"kl\", log=True, numItermax=num_iter_max, stopThr=0)\n    entropic_kl_uot_ti, log_uot_ti = ot.unbalanced.sinkhorn_unbalanced(a, b, M, reg, reg_m_kl, reg_type=\"kl\",\n                                                                       method=\"sinkhorn_translation_invariant\", log=True,\n                                                                       numItermax=num_iter_max, stopThr=0)\n\n    err_sinkhorn_uot[seed] = log_uot[\"err\"]\n    err_sinkhorn_uot_ti[seed] = log_uot_ti[\"err\"]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Plot the results\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "mean_sinkh = np.mean(err_sinkhorn_uot, axis=0)\nstd_sinkh = np.std(err_sinkhorn_uot, axis=0)\n\nmean_sinkh_ti = np.mean(err_sinkhorn_uot_ti, axis=0)\nstd_sinkh_ti = np.std(err_sinkhorn_uot_ti, axis=0)\n\nabsc = list(range(num_iter_max))\n\npl.plot(absc, mean_sinkh, label=\"Sinkhorn\")\npl.fill_between(absc, mean_sinkh - 2 * std_sinkh, mean_sinkh + 2 * std_sinkh, alpha=0.5)\n\npl.plot(absc, mean_sinkh_ti, label=\"Translation Invariant Sinkhorn\")\npl.fill_between(absc, mean_sinkh_ti - 2 * std_sinkh_ti, mean_sinkh_ti + 2 * std_sinkh_ti, alpha=0.5)\n\npl.yscale(\"log\")\npl.legend()\npl.xlabel(\"Number of Iterations\")\npl.ylabel(r\"$\\|u-v\\|_\\infty$\")\npl.grid(True)\npl.show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.10.15"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

master/_downloads/06f3dd7c3258690ab730be0a658b5e36/plot_ssw_unif_torch.zip

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""
+===============================================================
+Translation Invariant Sinkhorn for Unbalanced Optimal Transport
+===============================================================
+
+This examples illustrates the better convergence of the translation
+invariance Sinkhorn algorithm proposed in [73] compared to the classical
+Sinkhorn algorithm.
+
+[73] Séjourné, T., Vialard, F. X., & Peyré, G. (2022).
+Faster unbalanced optimal transport: Translation invariant sinkhorn and 1-d frank-wolfe.
+In International Conference on Artificial Intelligence and Statistics (pp. 4995-5021). PMLR.
+
+"""
+
+# Author: Clément Bonet <clement.bonet@ensae.fr>
+# License: MIT License
+
+import numpy as np
+import matplotlib.pylab as pl
+import ot
+
+##############################################################################
+# Setting parameters
+# -------------
+
+# %% parameters
+
+n_iter = 50  # nb iters
+n = 40  # nb samples
+
+num_iter_max = 100
+n_noise = 10
+
+reg = 0.005
+reg_m_kl = 0.05
+
+mu_s = np.array([-1, -1])
+cov_s = np.array([[1, 0], [0, 1]])
+
+mu_t = np.array([4, 4])
+cov_t = np.array([[1, -.8], [-.8, 1]])
+
+
+##############################################################################
+# Compute entropic kl-regularized UOT with Sinkhorn and Translation Invariant Sinkhorn
+# -----------
+
+err_sinkhorn_uot = np.empty((n_iter, num_iter_max))
+err_sinkhorn_uot_ti = np.empty((n_iter, num_iter_max))
+
+
+for seed in range(n_iter):
+    np.random.seed(seed)
+    xs = ot.datasets.make_2D_samples_gauss(n, mu_s, cov_s)
+    xt = ot.datasets.make_2D_samples_gauss(n, mu_t, cov_t)
+
+    xs = np.concatenate((xs, ((np.random.rand(n_noise, 2) - 4))), axis=0)
+    xt = np.concatenate((xt, ((np.random.rand(n_noise, 2) + 6))), axis=0)
+
+    n = n + n_noise
+
+    a, b = np.ones((n,)) / n, np.ones((n,)) / n  # uniform distribution on samples
+
+    # loss matrix
+    M = ot.dist(xs, xt)
+    M /= M.max()
+
+    entropic_kl_uot, log_uot = ot.unbalanced.sinkhorn_unbalanced(a, b, M, reg, reg_m_kl, reg_type="kl", log=True, numItermax=num_iter_max, stopThr=0)
+    entropic_kl_uot_ti, log_uot_ti = ot.unbalanced.sinkhorn_unbalanced(a, b, M, reg, reg_m_kl, reg_type="kl",
+                                                                       method="sinkhorn_translation_invariant", log=True,
+                                                                       numItermax=num_iter_max, stopThr=0)
+
+    err_sinkhorn_uot[seed] = log_uot["err"]
+    err_sinkhorn_uot_ti[seed] = log_uot_ti["err"]
+
+##############################################################################
+# Plot the results
+# ----------------
+
+mean_sinkh = np.mean(err_sinkhorn_uot, axis=0)
+std_sinkh = np.std(err_sinkhorn_uot, axis=0)
+
+mean_sinkh_ti = np.mean(err_sinkhorn_uot_ti, axis=0)
+std_sinkh_ti = np.std(err_sinkhorn_uot_ti, axis=0)
+
+absc = list(range(num_iter_max))
+
+pl.plot(absc, mean_sinkh, label="Sinkhorn")
+pl.fill_between(absc, mean_sinkh - 2 * std_sinkh, mean_sinkh + 2 * std_sinkh, alpha=0.5)
+
+pl.plot(absc, mean_sinkh_ti, label="Translation Invariant Sinkhorn")
+pl.fill_between(absc, mean_sinkh_ti - 2 * std_sinkh_ti, mean_sinkh_ti + 2 * std_sinkh_ti, alpha=0.5)
+
+pl.yscale("log")
+pl.legend()
+pl.xlabel("Number of Iterations")
+pl.ylabel(r"$\|u-v\|_\infty$")
+pl.grid(True)
+pl.show()

master/_downloads/07fcc19ba03226cd3d83d4e40ec44385/auto_examples_python.zip

@@ -2267,9 +2267,7 @@ <h1>Source code for ot.backend</h1><div class="highlight"><pre>
         <span class="k">if</span> <span class="n">a</span><span class="o">.</span><span class="n">ndim</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
             <span class="k">return</span> <span class="n">jnp</span><span class="o">.</span><span class="n">searchsorted</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">side</span><span class="p">)</span>
         <span class="k">else</span><span class="p">:</span>
-            <span class="c1"># this is a not very efficient way to make jax numpy</span>
-            <span class="c1"># searchsorted work on 2d arrays</span>
-            <span class="k">return</span> <span class="n">jnp</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="n">jnp</span><span class="o">.</span><span class="n">searchsorted</span><span class="p">(</span><span class="n">a</span><span class="p">[</span><span class="n">i</span><span class="p">,</span> <span class="p">:],</span> <span class="n">v</span><span class="p">[</span><span class="n">i</span><span class="p">,</span> <span class="p">:],</span> <span class="n">side</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">a</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">])])</span></div>
+            <span class="k">return</span> <span class="n">jax</span><span class="o">.</span><span class="n">vmap</span><span class="p">(</span><span class="k">lambda</span> <span class="n">b</span><span class="p">,</span> <span class="n">u</span><span class="p">:</span> <span class="n">jnp</span><span class="o">.</span><span class="n">searchsorted</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">u</span><span class="p">,</span> <span class="n">side</span><span class="p">))(</span><span class="n">a</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span></div>
 
 
 <div class="viewcode-block" id="JaxBackend.flip">