From 3e33e334d2e962453b0aabef1dd8831002170800 Mon Sep 17 00:00:00 2001 From: iFyroxx Date: Wed, 1 May 2024 18:01:19 +0200 Subject: [PATCH] Added SSN.ipynb to the tutorials --- docs/tutorials/SSN.ipynb | 2431 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 2431 insertions(+) create mode 100644 docs/tutorials/SSN.ipynb diff --git a/docs/tutorials/SSN.ipynb b/docs/tutorials/SSN.ipynb new file mode 100644 index 000000000..b557e6533 --- /dev/null +++ b/docs/tutorials/SSN.ipynb @@ -0,0 +1,2431 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specialized Semismooth Newton Method for Kernel-Based Optimal Transport" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### DISCLAIMER : The current code does not work as intended in every scenario, further improvement should be made for it to be implemented in the toolbox." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook serves as an example of implementation of $\\textbf{A Specialized Semismooth Newton Method for Kernel-Based Optimal Transport}$ by Tianyi Lin and Marco Cuturi and Michael I. Jordan (https://doi.org/10.48550/arXiv.2310.14087)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reminders on Kernel-Based OT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let $X$ and $Y$ be two bounded domains in $\\mathbb{R}^d$, and let $\\mathcal{P}(X)$ and $\\mathcal{P}(X)$ be the set of probability measures on $X$ and $Y$. Let $\\mu \\in \\mathcal{P}(X)$ and $\\nu \\in \\mathcal{P}(X)$ and $\\Pi(\\mu,\\nu)$ the set of couplings between $\\mu$ and $\\nu$.\n", + "The primal OT problem is defined as :\n", + "\\begin{align*}\n", + "OT(\\mu,\\nu) := \\frac{1}{2} \\left( \\underset{\\pi \\in \\Pi(\\mu,\\nu)}{\\inf} \\int_{X\\times Y} \\lVert x-y \\rVert^2 d\\pi(x,y) \\right)\n", + "\\end{align*}\n", + "and the associated dual problem is:\n", + "\\begin{align*}\n", + "\\underset{u,v \\in C^0(\\mathbb{R}^d)}{\\sup} \\int_X u(x)d\\mu(x) + \\int_Y v(y) d\\nu(y), \\text{ such that } \\frac{1}{2} \\lVert x-y \\rVert^2 \\geq u(x) + v(y) , \\forall (x,y) \\in X\\times Y\n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we assume finiteness and a certain degree of smoothness for the densities of $\\mu$ and $\\nu$, along with the convexity of $X$ and $Y$ and some other properties, we can define $H^s(Z) := \\{f \\in L^2(Z) | \\lVert f \\rVert_{H^s(Z)} := \\sum_{|\\alpha|\\leq s}\\lVert D^\\alpha f \\rVert_{L^2(Z)} < +\\infty \\}$, and see that $\\forall s > \\frac{d}{2} + k,H^s(Z) \\subset C^k(Z)$. \n", + "With the previous assumptions, we get that $H^{m+1}(X), H^{m+1}(Y)$ and $H^m(X \\times Y)$ are RKHS, with associated feature maps $\\phi_X, \\phi_Y$ and $\\phi_{XY}$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Under these assumptions, the dual problem now can be rewritten:\n", + "\\begin{align*}\n", + "&\\underset{u,v,A}{\\max} \\langle u, w_\\mu \\rangle_{H_X} + \\langle v, w_\\nu \\rangle_{H_Y}\\\\\n", + "& \\text{s.t.} \\frac{1}{2} \\lVert x-y \\rVert^2 -u(x)-v(y) = \\langle \\phi_{XY}(x,y), A\\phi_{XY}(x,y) \\rangle_{H_{XY}}\n", + "\\end{align*}\n", + "This reformulation presents the advantage of (i) having a neat approximation of the equality constraint and (ii) allowing the kernel trick since we are working with RKHS.\n", + "This problem can now be approximated by using the data $(x_i,y_i)_{i=1}^{n_{sample}} \\sim \\mu\\times\\nu $ and sampling filling points $(\\tilde{x_i},\\tilde{y_i})_{i=1}^n \\subset X\\times Y$. We can then define the empirical measures $\\tilde{\\mu}$ and $\\tilde{\\nu}$ as usually done and the corresponding empirical $\\textit{kernel mean embeddings } w_{\\tilde{\\mu}} = \\frac{1}{n_{sample}} \\sum_{i=1}^{n_{sample}} \\phi_X(x_i)$ and $w_{\\tilde{\\nu}}$.\n", + "However, this methods induces some error due to sampling, which can be reduced by regularization as follows:\n", + "\\begin{align*}\n", + "&\\underset{u,v,A}{\\max} \\langle u, w_\\mu \\rangle_{H_X} + \\langle v, w_\\nu \\rangle_{H_Y} - \\lambda_1 \\text{Tr}(A) - \\lambda_2(\\lVert u \\rVert^2_{H_X} + \\lVert v \\rVert^2_{H_Y})\\\\\n", + "& \\text{s.t.} \\frac{1}{2} \\lVert \\tilde{x_i}-\\tilde{y_i} \\rVert^2 -u(\\tilde{x_i})-v(\\tilde{y_i}) = \\langle \\phi_{XY}(\\tilde{x_i},\\tilde{y_i}), A\\phi_{XY}(\\tilde{x_i},\\tilde{y_i}) \\rangle_{H_{XY}}\n", + "\\end{align*}\n", + "Defining $\\hat{u}_*$ and $\\hat{v}_*$ as the only minimizers of this problem, we obtain the estimator :\n", + "\\begin{align*}\n", + "\\hat{OT}^n = \\langle \\hat{u}_*, w_{\\tilde{\\mu}} \\rangle_{H_X} + \\langle \\hat{v}_*, w_{\\tilde{\\nu}} \\rangle_{H_Y}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The issue of this formulation is that it is extremely hard to solve. However, we can present it as a finite-dimensional problem, for which strong duality holds true.\n", + "We define $Q\\in \\mathbb{R}^{n\\times n}$ with $Q_{ij} = k_X(\\tilde{x_i},\\tilde{x_j}) + k_Y(\\tilde{y_i},\\tilde{y_j}), z\\in \\mathbb{R}^n$ with $z_i = w_{\\tilde{\\mu}}(\\tilde{x_i}) + w_{\\tilde{\\nu}}(\\tilde{y_i}) - \\lambda_2 \\lVert \\tilde{x_i}-\\tilde{y_i} \\rVert^2$, and $q^2 = \\lVert w_{\\tilde{\\mu}} \\rVert_{H_X}^2 + \\lVert w_{\\tilde{\\nu}} \\rVert_{H_Y}^2$. If we note $N = n_{sample}$, we have the following :\n", + "\\begin{align*}\n", + "w_{\\tilde{\\mu}}(\\tilde{x_i}) &= \\frac{1}{N} \\sum_{j=1}^N k_X(x_j,\\tilde{x_i}) \\\\\n", + "w_{\\tilde{\\nu}}(\\tilde{y_i}) &= \\frac{1}{N} \\sum_{j=1}^N k_Y(y_j,\\tilde{y_i})\\\\\n", + "\\lVert w_{\\tilde{\\mu}} \\rVert_{H_X}^2 &= \\frac{1}{N^2} \\sum_{1\\leq i,j\\leq N}^N k_X(x_i,x_j)\\\\\n", + "\\lVert w_{\\tilde{\\nu}} \\rVert_{H_Y}^2 &= \\frac{1}{N^2} \\sum_{1\\leq i,j\\leq N}^N k_Y(y_i,y_j)\\\\\n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can define $K \\in \\mathbb{R}^{n\\times n}$ by $K_{ij} = k_{XY}((\\tilde{x_i},\\tilde{y_i}),(\\tilde{x_j},\\tilde{y_j}))$, and $R$ as the upper triangular matrix for the Cholesky decomposition of $K$, whose columns are denoted $\\Phi_i$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now rewrite the dual OT problem again, as:\n", + "\\begin{align*}\n", + "&\\underset{\\gamma \\in \\mathbb{R}^n}{\\min} \\frac{1}{4\\lambda_2} \\gamma^T Q \\gamma - \\frac{1}{2\\lambda_2} \\gamma^T z + \\frac{q^2}{4\\lambda_2} \\\\\n", + "&\\text{s.t. } \\sum_{i=1}^n \\gamma_i \\Phi_i \\Phi_i^T + \\lambda_1 I \\succeq 0 \n", + "\\end{align*}\n", + "\n", + "Denoting $\\hat{\\gamma}$ a minimizer, we obtain our estimator :\n", + "\\begin{align*}\n", + "\\hat{OT}^n = \\frac{q^2}{2\\lambda_2} - \\frac{1}{2\\lambda_2} \\sum_{i=1}^n \\hat{\\gamma}_i(w_{\\tilde{\\mu}}(\\tilde{x_i}) + w_{\\tilde{\\nu}}(\\tilde{y_i}))\n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Methods and implementations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Defining the operator $\\Phi : \\mathbb{R}^{n\\times n} \\mapsto \\mathbb{R}^n$ by $\\Phi(X) = (\\langle X, \\Phi_i \\Phi_i^T \\rangle)_{i=1}^n$, we can also define its adjoint $\\Phi^* : \\mathbb{R}^{n} \\mapsto \\mathbb{R}^{n\\times n}$ by $\\Phi^*(\\gamma) = \\sum_{i=1}^n \\gamma_i \\Phi_i \\Phi_i^T$.\n", + "This allows to reformulate the previous problem as follows :\n", + "\\begin{align*}\n", + "\\underset{\\gamma \\in \\mathbb{R}^n}{\\min} \\underset{X\\in \\mathcal{S}^n_{+}}{\\min} \\frac{1}{4\\lambda_2} \\gamma^T Q \\gamma - \\frac{1}{2\\lambda_2} \\gamma^T z + \\frac{q^2}{4\\lambda_2} - \\langle X, \\Phi^*(\\gamma) + \\lambda_1 I \\rangle\n", + "\\end{align*}\n", + "where $\\mathcal{S}^n_{+}$ is the set of symmetric positive matrices.\n", + "We now denote $w = (\\gamma, X)$ a vector-matrix pair, and we define :\n", + "\\begin{align*}\n", + "R(w) = \\begin{pmatrix} \\frac{1}{2\\lambda_2}Q\\gamma - \\frac{1}{2\\lambda_2}\\gamma^Tz - \\Phi(X) \\\\ X - \\text{proj}_{\\mathcal{S}^n_{+}}(X - (\\Phi^*(\\gamma) + \\lambda_1I)) \\end{pmatrix}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get an optimal solution of the OT problem, we will look for a couple $\\hat{w} = (\\hat{\\gamma}, \\hat{X})$ such that $R(\\hat{w}) = 0$. However, the previous problem is nonsmooth, therefore we will use $R$ to try and get a semismooth solution. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "if \"google.colab\" in sys.modules:\n", + " !pip install -q git+https://github.com/ott-jax/ott@main" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import jax\n", + "\n", + "from scipy.stats.qmc import Sobol\n", + "from jax import random\n", + "from scipy.stats import norm\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Hyperparameters specification" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "alpha1 = 1e-6\n", + "alpha2 = 1.0\n", + "beta0 = 0.5\n", + "beta1 = 1.2\n", + "beta2 = 5\n", + "bandwidth = 0.005\n", + "d = 1\n", + "n = 50\n", + "n_samples = 50\n", + "lambda1 = 1/n\n", + "lambda2 = 1/jnp.sqrt(n_samples)\n", + "theta_down = 1e-6\n", + "theta_up = 1e6\n", + "tau = 0.005" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sampling of source and target distributions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Utilitary function to compute norm of $\\lVert w \\rVert = \\lVert \\gamma \\rVert_2 + \\lVert X \\rVert_F$ :" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def custom_norm(w):\n", + " return jnp.linalg.norm(w[0]) + jnp.sqrt(jnp.sum(w[1]**2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we need to define functions that can generate the data and filling points. The source distribution follows a mixture of 3 $d$-dimensional Gaussians, and the target distribution follows a mixture of 5 $d$-dimensional Gaussians. The filling points are generated following a $2d$ Sobol sequence." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_filling_points(d=d, n_samples=n_samples):\n", + " sobol = Sobol(2*d, scramble=True)\n", + " sobol = jnp.array(sobol.random(n_samples))\n", + " if d == 1:\n", + " sobol = jnp.insert(sobol, 0, jnp.array([1e-2, 1e-2]))\n", + " sobol = jnp.insert(sobol, 0, jnp.array([1-1e-2, 1-1e-2]))\n", + " sobol = jnp.insert(sobol, 0, jnp.array([1e-2, 1-1e-2]))\n", + " sobol = jnp.insert(sobol, 0, jnp.array([1.-1e-2, 1e-2]))\n", + " sobol = sobol.reshape(-1, 2*d)[:-4 , :]\n", + " return sobol\n", + "\n", + "def get_data(d=d, n_samples=n_samples):\n", + " rng = random.PRNGKey(0)\n", + "\n", + " # Sample means and covariances for x and y\n", + " means_x = random.uniform(rng, (3, d), minval=0.2, maxval=0.8)\n", + " covariances_x = jnp.stack([0.075 * jnp.eye(d)]*3)\n", + " weights_x = jnp.array([0.1, 0.6, 0.3])\n", + "\n", + " means_y = random.uniform(rng, (5, d), minval=0.2, maxval=0.8)\n", + " covariances_y = jnp.stack([0.075 * jnp.eye(d)]*5)\n", + " weights_y = jnp.array([0.1, 0.2, 0.1, 0.2, 0.4])\n", + " # Sample x and y in one go using vectorized multivariate_normal\n", + " X = jnp.sum((random.multivariate_normal(rng, means_x, covariances_x, shape=(n_samples, 3))*weights_x[:, jnp.newaxis]), axis=1)\n", + " Y = jnp.sum((random.multivariate_normal(rng, means_y, covariances_y, shape=(n_samples, 5))*weights_y[:, jnp.newaxis]), axis=1)\n", + "\n", + " X = jnp.clip(X, 0, 1)\n", + " Y = jnp.clip(Y, 0, 1)\n", + "\n", + " if d==1:\n", + " x = jnp.linspace(0, 1, 2000)\n", + " \n", + " r_tmp = [] \n", + " for mode in means_x:\n", + " r_tmp.append(norm.pdf(x,mode, 0.075))\n", + " \n", + " c_tmp = []\n", + " for mode in means_y:\n", + " c_tmp.append(norm.pdf(x,mode, 0.075))\n", + " \n", + " mu = jnp.dot(weights_x,jnp.array(r_tmp))\n", + " nu = jnp.dot(weights_y,jnp.array(c_tmp))\n", + "\n", + " return X, Y, mu, nu\n", + " else:\n", + " return X, Y" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n" + ] + } + ], + "source": [ + "if d==1:\n", + " x,y, mu, nu = get_data()\n", + "else:\n", + " x, y = get_data()\n", + "\n", + "filling_points = get_filling_points()\n", + "x_fill, y_fill = filling_points[:,:d], filling_points[:,d:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can plot our data points if they are 1D, which is the case in the provided example, do not run if you changed $d$. We also show the filling points." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "T = np.linspace(0, 1, 2000)\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "ax.plot(T, mu, label = 'mu density')\n", + "ax.plot(T, nu, label = 'nu density')\n", + "\n", + "ax.scatter(x, mu[(2000 * x).astype(int)], label = 'mu samples')\n", + "ax.scatter(y, nu[np.minimum((2000 * y).astype(int), 2000-1)], label = 'nu samples')\n", + "\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.scatter(x_fill, y_fill)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Implementation of functions for the SSN algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define a function that returns the Gaussian kernel matrix for two sets of points : $k(x,y) = \\exp\\left(-\\frac{(x-y)^2}{2 \\sigma^2}\\right)$" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def kernel(x1,x2, bandwidth):\n", + " x1 = x1[..., None]\n", + " x2 = x2[..., None]\n", + " squared_diffs = jnp.sum((x1 - x2.T)**2, axis=1)\n", + " return jnp.exp(-squared_diffs/(2*bandwidth))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to $R, Q, z, w_{\\hat{\\mu}}, w_{\\hat{\\nu}}$ and $q^2$ as defined in the method presentation :" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def get_QRzq2w_hat(x, y, filling_points, lambda_2, bandwidth):\n", + " n_sample = filling_points.shape[0]\n", + " d = int(filling_points.shape[1]/2)\n", + " x_tilde, y_tilde = filling_points[:,:d], filling_points[:,d:]\n", + "\n", + " Kx1 = kernel(x_tilde, x_tilde, bandwidth)\n", + " Ky1 = kernel(y_tilde, y_tilde, bandwidth)\n", + "\n", + " Kx2 = kernel(x, x_tilde, bandwidth)\n", + " Ky2 = kernel(y, y_tilde, bandwidth)\n", + "\n", + " Kx3 = kernel(x, x, bandwidth)\n", + " Ky3 = kernel(y, y, bandwidth)\n", + "\n", + " K = kernel(filling_points, filling_points, bandwidth)\n", + " \n", + " Q = Kx1 + Ky1\n", + " R = jnp.linalg.cholesky(K, upper=True)\n", + "\n", + " w_mu_hat = 1/n_sample * jnp.sum(Kx3, axis=0)\n", + " w_nu_hat = 1/n_sample * jnp.sum(Ky3, axis=0)\n", + " z = w_mu_hat + w_nu_hat - lambda_2*(jnp.linalg.norm(x_tilde - y_tilde, axis=1)**2)\n", + " q2 = 1/n_sample**2 * (jnp.sum(Kx2) + jnp.sum(Ky2))\n", + "\n", + " return Q, R, z, q2, w_mu_hat, w_nu_hat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we will implement the operators $\\Phi$ and $\\Phi^*$ and the function that allows to project a matrix on $\\mathcal{S}^n_+$. For $Z \\in \\mathcal{M}_n(\\mathbb{R})$, we denote $\\alpha = \\{i | \\sigma_i > 0\\}$, and $\\bar{\\alpha} = \\{1,...,n\\} \\setminus \\alpha$, the sets of indices of positive and nonpositive eigenvalues of $Z$ respectively. We know that we can write $Z = P \\Sigma P^T$, with $\\Sigma = \\text{diag}(\\sigma_1,...,\\sigma_n) = \\begin{pmatrix} \\Sigma_\\alpha & 0 \\\\ 0 & \\Sigma_{\\bar{\\alpha}} \\end{pmatrix}$ and $P = \\begin{pmatrix} P_\\alpha & P_{\\bar{\\alpha}} \\end{pmatrix}$. \n", + "Therefore, we have $\\text{proj}_{\\mathcal{S}^n_+}(Z) = P_\\alpha \\Sigma_\\alpha P_\\alpha^T$." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def phi(A, X):\n", + " n = X.shape[0]\n", + " return jnp.matmul(A, jnp.ravel(X))\n", + " \n", + "\n", + "@jax.jit\n", + "def phi_star(A, gamma):\n", + " return jnp.matmul(A.T, gamma).reshape((n,n))\n", + "\n", + "# This function does not directly return the projection, but rather the different elements required to obtain it. \n", + "# The algorithm needs alpha and alpha_bar at some point, so we return them as well \n", + "@jax.jit\n", + "def project(Z):\n", + " eigenvals, P = jnp.linalg.eig(Z)\n", + " alpha = jnp.where(eigenvals>=0,1,0)\n", + " alpha_bar = jnp.where(eigenvals<0,1,0)\n", + "\n", + " eigenvals = jnp.real(eigenvals)\n", + " P = jnp.real(P)\n", + " return P, eigenvals, alpha, alpha_bar" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we need a function to compute $R(w)$ and the gradient of the function we look to max/min, which will be used in the EG algorithm :\n", + "\\begin{align*}\n", + "R(w) &= \\begin{pmatrix} \\frac{1}{2\\lambda_2}Q\\gamma - \\frac{1}{2\\lambda_2}\\gamma^Tz - \\Phi(X) \\\\ X - \\text{proj}_{\\mathcal{S}^n_{+}}(X - (\\Phi^*(\\gamma) + \\lambda_1I)) \\end{pmatrix}\\\\\n", + "f(w) = \\nabla F(w) &= \\begin{pmatrix} \\frac{1}{2\\lambda_2}Q\\gamma - \\frac{1}{2\\lambda_2}\\gamma^Tz - \\Phi(X) \\\\ - \\Phi^*(\\gamma) - \\lambda_1I \\end{pmatrix}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def R_w(A, w, Q, z, lambda1, lambda2):\n", + " gamma, X = w\n", + " n = gamma.shape[0]\n", + " Z = X - phi_star(A, gamma) - lambda1*jnp.eye(n)\n", + " P, eigenvals, alpha, alpha_bar = project(Z)\n", + "\n", + " eigenvals = jnp.maximum(0, eigenvals)\n", + "\n", + " r1 = 1/(2*lambda2) * (jnp.matmul(Q, gamma) - z) - phi(A, X)\n", + " r2 = X - jnp.matmul(P, jnp.matmul(jnp.diag(eigenvals), P.T))\n", + " \n", + " return (r1, r2)\n", + "\n", + "# Gradient of the function to min/max\n", + "@jax.jit\n", + "def f(A, w, Q, z, lambda1, lambda2):\n", + " gamma, X = w\n", + " n = gamma.shape[0]\n", + " f1 = 1/(2*lambda2) * (jnp.matmul(Q, gamma) - z) - phi(A, X)\n", + " f2 = -phi_star(A, gamma) - lambda1*jnp.eye(n)\n", + " return (f1, f2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we will have to implement a function that updates $v_k$ using the one-step extragradient (EG) method, which we recall is defined by the following update of $v_k = (\\gamma_k, X_k)$ in our case:\n", + "\n", + "$$\\begin{align*}\n", + "\\gamma_{k+\\frac{1}{2}} &= \\gamma_k - \\varepsilon \\nabla_\\gamma F(v_k) \\\\\n", + "X_{k+\\frac{1}{2}} &= \\mathcal{P}_{\\mathcal{S}^n_+}(X_k + \\varepsilon \\nabla_X F(v_k)) \\\\\n", + "\\gamma_{k+1} &= \\gamma_k - \\varepsilon \\nabla_\\gamma F(v_{k+\\frac{1}{2}}) \\\\\n", + "X_{k+1} &= \\mathcal{P}_{\\mathcal{S}^n_+}(X_k + \\varepsilon \\nabla_X F(v_{k+\\frac{1}{2}})) \\\\\n", + "\\end{align*}$$\n", + "where $\\mathcal{P}_{\\mathcal{S}^n_+}$ is the projection onto symmetric positive matrices, and $v_{k+\\frac{1}{2}} = (\\gamma_{k+\\frac{1}{2}}, X_{k+\\frac{1}{2}})$." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def extragradient(A, w, Q, z, lambda1, lambda2):\n", + " epsilon = d*0.01/(n_samples/50)\n", + " # Intermediary step of update + projection\n", + " r1, r2 = f(A, w, Q, z, lambda1, lambda2)\n", + " P, eigenvals, alpha, alpha_bar = project(w[1] + epsilon*r2)\n", + "\n", + " eigenvals = jnp.maximum(0, eigenvals)\n", + "\n", + " w_inter = (w[0] - epsilon*r1, jnp.matmul(P, jnp.matmul(jnp.diag(eigenvals), P.T)))\n", + "\n", + " # Final step\n", + " r1, r2 = f(A, w_inter, Q, z, lambda1, lambda2)\n", + " P, eigenvals, alpha, alpha_bar = project(w[1] + epsilon*r2)\n", + "\n", + " eigenvals = jnp.maximum(0, eigenvals)\n", + " \n", + " w_final = (w[0] - epsilon*r1, jnp.matmul(P, jnp.matmul(jnp.diag(eigenvals), P.T)))\n", + " return w_final\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we need a function to compute $\\mathcal{T}_k$ using the Zhao trick :\n", + "\\begin{align*}\n", + "\\mathcal{T}_k[S] = \\begin{cases}\n", + "G + G^T, G = P_k(:, \\alpha_k) \\left( \\frac{1}{2\\mu_k} (U P_k(:, \\alpha_k)) P_k(:, \\alpha_k)^T + \\xi_{\\alpha_k \\bar{\\alpha_k}} \\circ (U P_k(:, \\bar{\\alpha_k})) P_k(:, \\bar{\\alpha_k})^T\\right) &if |\\alpha_k| < |\\bar{\\alpha}_k|\\\\\n", + " \\frac{1}{\\mu_k} S - P_k((\\frac{1}{\\mu_k} E - \\Psi_k) \\circ (P_k^T S P_k))P_k^T, &if |\\alpha_k| > |\\bar{\\alpha}_k|\n", + "\\end{cases}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def T_k(alpha, alpha_bar, S, P, mu, ksi):\n", + " n = alpha.shape[0]\n", + " E_alpha = (jnp.ones((n,n))*alpha).T * alpha\n", + " psi = E_alpha/mu + ksi + ksi.T\n", + " condition = jnp.sum(alpha) > jnp.sum(alpha_bar)\n", + " P1 = P*alpha \n", + " P2 = P*alpha_bar\n", + " U = jnp.matmul(P1.T,S)\n", + " inter = jnp.matmul(ksi*jnp.matmul(U,P2),P2.T)\n", + " G = jnp.matmul(P1,1/(2*mu)*jnp.matmul(jnp.matmul(U,P1),P1.T) + inter)\n", + " result = jax.lax.cond(condition,\n", + " lambda : 1/mu * S - jnp.matmul(P, jnp.matmul((1/mu*jnp.ones_like(psi) - psi)*jnp.matmul(P.T, jnp.matmul(S,P)), P.T)),\n", + " lambda : G + G.T)\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Function to retrieve $\\Delta w_k$ using all the previously defined functions. We define $r_k^1, r_k^2 = R(w_k)$, \n", + "\\begin{align*}\n", + "a^{1}&=-r_{k}^{1}-\\frac{1}{\\mu_{k}+1}\\Phi(r_{k}^{2}+\\mathcal{T}_{k}[r_{k}^{2}]), \\\\\n", + "a^{2}&=-r_{k}^{2} \\\\\n", + "\\tilde{a}^1 &= \\left(\\frac{1}{2\\lambda_2}\\mathcal{Q} + \\mu_k \\mathcal{I} + \\Phi \\mathcal{T}_k \\Phi^* \\right)^{-1}a^1 \\\\\n", + "\\tilde{a}^2 &= \\frac{1}{\\mu_{k}+1}(a^{2}+\\mathcal{T}_{k}[a^{2}]) \\\\\n", + "\\Delta w_k^1 &= \\tilde{a}^1 \\\\\n", + "\\Delta w_k^2 &= \\tilde{a}^2 - \\mathcal{T}_k[\\Phi^*(\\tilde{a}^1)]\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def get_delta_w(A, Q, z, w, lambda1, lambda2, theta):\n", + " # Fixing parameters to improve readability\n", + " gamma, X = w\n", + " n = gamma.shape[0]\n", + " I = jnp.eye(n)\n", + " Z = X - (phi_star(A, gamma) + lambda1*I)\n", + " # Projection of Z to retrieve alpha, P and sigma\n", + " P, eigenvals, alpha, alpha_bar = project(Z)\n", + " # Current r_k\n", + " r1, r2 = R_w(A, w, Q, z, lambda1, lambda2)\n", + "\n", + " differences = eigenvals[None, :] - eigenvals[:, None]\n", + " stacked_sigma = jnp.stack([eigenvals]*n)\n", + " eta = jnp.where(differences!=0, stacked_sigma/differences, 0)\n", + " eta = ((eta*alpha_bar).T * alpha).T # We do this to keep only the coefficients corresponding to alpha x alpha_bar\n", + "\n", + " mu = theta * custom_norm((r1,r2))\n", + "\n", + " # Application of Zhao trick to retrieve a and then delta w_k\n", + " ksi = eta/(mu + 1 - eta)\n", + " a1 = -r1 - 1/(mu+1) * phi(A, r2 + T_k(alpha, alpha_bar, r2, P, mu, ksi))\n", + " a2 = -r2\n", + "\n", + " # Operator for the conjugate gradient step\n", + " operator = lambda x : (1/(2*lambda2)*Q + mu*I) @ x + A @ T_k(alpha, alpha_bar, phi_star(A, x), P, mu, ksi).flatten()\n", + " a1_tilde = jax.scipy.sparse.linalg.cg(operator, a1)[0]\n", + " a2_tilde = 1/(mu+1)* (a2 + T_k(alpha, alpha_bar, a2, P, mu, ksi))\n", + "\n", + " return (a1_tilde, a2_tilde - T_k(alpha, alpha_bar, phi_star(A, a1_tilde), P, mu, ksi))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Function to update $\\theta_k$, following the algorithm:\n", + "\\begin{align*}\n", + "\\theta_{k+1} &= \\begin{cases}\n", + "\\max(\\underline{\\theta}, \\beta_0 \\theta_k), &\\text{if } \\rho_k \\geq \\alpha_2 \\lVert \\Delta w_k \\rVert^2, \\\\\n", + "\\beta_1 \\theta_k, &\\text{if } \\alpha_1 \\lVert \\Delta w_k \\rVert^2 \\leq \\rho_k < \\alpha_2 \\lVert \\Delta w_k \\rVert^2, \\\\\n", + "\\min(\\overline{\\theta}, \\beta_2 \\theta_k), &\\text{otherwise}. \n", + "\\end{cases}\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def update_theta(theta, delta_w, rho, beta0, beta1, beta2, alpha1, alpha2, theta_up, theta_down):\n", + " norm_delta_w = custom_norm(delta_w)\n", + " condition1 = rho >= alpha2*norm_delta_w**2\n", + " condition2 = rho >= alpha1*norm_delta_w**2\n", + " theta1 = jnp.max(jnp.array([theta_down, beta0*theta]))\n", + " theta2 = jnp.min(jnp.array([theta_up, beta2*theta]))\n", + "\n", + " result = jax.lax.cond(condition1, lambda: theta1, lambda: jax.lax.cond(condition2, lambda: beta1*theta1, lambda: theta2))\n", + " \n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Function to run the algorithm :\n", + "\n", + "Using inputs $\\tau, \\alpha_2 \\geq \\alpha_1 > 0, \\beta_0, \\beta_1 < 1, \\beta_2 > 1, \\underline{\\theta}, \\overline{\\theta}>0, x, y$ and the filling points $\\tilde{x}, \\tilde{y}$.\n", + "\n", + "We initialize $v_0 = w_0 = (0, 0) \\in \\mathbb{R}^n \\times \\mathcal{S}^n_+$ and $\\theta_0 = \\min(100, \\overline{\\theta})$ and we compute the data-dependent parameters $Q, R, z, q^2, w_{\\hat{\\mu}}, w_{\\hat{\\nu}}, A$.\n", + "\n", + "For each iteration $k$, while $\\lVert R(w_k) \\rVert > \\tau$ :\n", + "1. We update $v_k$ using 1-step EG\n", + "2. We compute $\\Delta w_k$ using Zhao's trick\n", + "3. We set $\\tilde{w}_{k+1} = w_k + \\Delta w_k$\n", + "4. We update $\\theta_k$ in the adaptive manner\n", + "5. We set $w_{k+1} = \\begin{cases} \\tilde{w}_{k+1} &\\text{if } \\lVert R(\\tilde{w}_{k+1}) \\rVert \\leq \\lVert R(v_{k+1}) \\rVert \\\\v_{k+1}, &\\text{otherwise}\\\\ \\end{cases}$" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def SSN(x, y, filling_points, tau, nb_iter = 1000, verbose = True, display_gap = 10):\n", + " # Initialization\n", + " gamma = jnp.ones((n,))\n", + " X = jnp.ones((n,n))\n", + " v = (gamma.copy(), X.copy())\n", + " w = (gamma.copy(), X.copy())\n", + " theta = min(100.0, theta_up)\n", + " Q, R, z, q2, w_mu_hat, w_nu_hat = get_QRzq2w_hat(x,y, filling_points, lambda2, bandwidth)\n", + " # Matrix form of the phi operator\n", + " A = jnp.vstack([jnp.kron(R[:,i].T, R[:,i].T) for i in range(n)])\n", + "\n", + " norme = jnp.inf\n", + " residuals = []\n", + " start = time.time()\n", + " for iter in range(nb_iter):\n", + " # Update of v using EG\n", + " v = extragradient(A, v, Q, z, lambda1, lambda2)\n", + " # Obtaining delta_w\n", + " delta_w = get_delta_w(A, Q, z, w, lambda1, lambda2, theta)\n", + " w_tilde = (w[0] + delta_w[0], w[1] + delta_w[1])\n", + " # Updating theta\n", + " r_w_tilde = R_w(A, w_tilde, Q, z, lambda1, lambda2)\n", + " rho = -(jnp.sum(r_w_tilde[0]*delta_w[0]) + jnp.sum(r_w_tilde[1]*delta_w[1]))\n", + " theta = update_theta(theta, delta_w, rho, beta0, beta1, beta2, alpha1, alpha2, theta_up, theta_down)\n", + " # Update w\n", + " norm_w_tilde = custom_norm(r_w_tilde)\n", + " norm_v = custom_norm(R_w(A, v, Q, z, lambda1, lambda2))\n", + " stay = int(norm_w_tilde <= norm_v)\n", + " w = (w_tilde[0]*stay + v[0]*(1-stay), w_tilde[1]*stay + v[1]*(1-stay))\n", + " norme = norm_w_tilde*stay + norm_v*(1-stay)\n", + " residuals.append(norme)\n", + " if verbose:\n", + " if iter%display_gap==0:\n", + " print(\"Norm at iteration {} :\".format(iter+1), norme)\n", + " if normetau and i < nb_iter:\n", + " # Update of v using EG\n", + " v = extragradient(A,v,Q,z,lambda1,lambda2)\n", + " norme_v = custom_norm(R_w(A,v,Q,z,lambda1, lambda2))\n", + " if verbose:\n", + " if i%display_gap==0:\n", + " print(\"Norm at iteration {} :\".format(i+1), norme_v)\n", + " i += 1\n", + " return v, time.time()-start" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Testing the convergence rate for SSN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check the rate of convergence, we will store the residual norm in memory and plot it against a curve of equation $f(k) = \\frac{C}{\\sqrt{k}}$, where $C$ is a chosen constant." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Norm at iteration 1 : 284.57068\n", + "Norm at iteration 2 : 214.95143\n", + "Norm at iteration 3 : 162.39957\n", + "Norm at iteration 4 : 122.736984\n", + "Norm at iteration 5 : 92.8103\n", + "Norm at iteration 6 : 70.23982\n", + "Norm at iteration 7 : 46.52472\n", + "Norm at iteration 8 : 19.04137\n", + "Norm at iteration 9 : 6.255589\n", + "Norm at iteration 10 : 6.384733\n", + "Norm at iteration 11 : 4.965457\n", + "Norm at iteration 12 : 3.0994186\n", + "Norm at iteration 13 : 1.1176759\n", + "Norm at iteration 14 : 1.154814\n", + "Norm at iteration 15 : 1.6169097\n", + "Norm at iteration 16 : 1.6489675\n", + "Norm at iteration 17 : 1.0086476\n", + "Norm at iteration 18 : 0.73451626\n", + "Norm at iteration 19 : 0.5731676\n", + "Norm at iteration 20 : 0.43341964\n", + "Norm at iteration 21 : 0.4764041\n", + "Norm at iteration 22 : 2.044343\n", + "Norm at iteration 23 : 1.6231263\n", + "Norm at iteration 24 : 1.1307285\n", + "Norm at iteration 25 : 0.64076316\n", + "Norm at iteration 26 : 0.45146844\n", + "Norm at iteration 27 : 0.50602597\n", + "Norm at iteration 28 : 1.6416514\n", + "Norm at iteration 29 : 0.8632307\n", + "Norm at iteration 30 : 0.45683926\n", + "Norm at iteration 31 : 0.7657501\n", + "Norm at iteration 32 : 0.40781334\n", + "Norm at iteration 33 : 0.2843976\n", + "Norm at iteration 34 : 0.3743725\n", + "Norm at iteration 35 : 0.98271495\n", + "Norm at iteration 36 : 0.5449707\n", + "Norm at iteration 37 : 0.35025698\n", + "Norm at iteration 38 : 0.27855125\n", + "Norm at iteration 39 : 0.25297457\n", + "Norm at iteration 40 : 0.2301111\n", + "Norm at iteration 41 : 0.20875368\n", + "Norm at iteration 42 : 0.28619146\n", + "Norm at iteration 43 : 0.9406788\n", + "Norm at iteration 44 : 0.54114926\n", + "Norm at iteration 45 : 0.28441674\n", + "Norm at iteration 46 : 0.5664842\n", + "Norm at iteration 47 : 0.34037793\n", + "Norm at iteration 48 : 0.21036331\n", + "Norm at iteration 49 : 0.21588838\n", + "Norm at iteration 50 : 0.32162732\n", + "Norm at iteration 51 : 0.18977283\n", + "Norm at iteration 52 : 0.16510169\n", + "Norm at iteration 53 : 0.2215894\n", + "Norm at iteration 54 : 0.5390848\n", + "Norm at iteration 55 : 0.3304837\n", + "Norm at iteration 56 : 0.19426638\n", + "Norm at iteration 57 : 0.23004279\n", + "Norm at iteration 58 : 0.15258658\n", + "Norm at iteration 59 : 0.14497979\n", + "Norm at iteration 60 : 0.15606266\n", + "Norm at iteration 61 : 0.2690668\n", + "Norm at iteration 62 : 0.17282252\n", + "Norm at iteration 63 : 0.14103405\n", + "Norm at iteration 64 : 0.15657058\n", + "Norm at iteration 65 : 0.29433236\n", + "Norm at iteration 66 : 0.18905863\n", + "Norm at iteration 67 : 0.1327575\n", + "Norm at iteration 68 : 0.14714445\n", + "Norm at iteration 69 : 0.2654792\n", + "Norm at iteration 70 : 0.16415693\n", + "Norm at iteration 71 : 0.12018349\n", + "Norm at iteration 72 : 0.13745621\n", + "Norm at iteration 73 : 0.29908705\n", + "Norm at iteration 74 : 0.19321421\n", + "Norm at iteration 75 : 0.12579818\n", + "Norm at iteration 76 : 0.108475216\n", + "Norm at iteration 77 : 0.102908775\n", + "Norm at iteration 78 : 0.09906327\n", + "Norm at iteration 79 : 0.0950949\n", + "Norm at iteration 80 : 0.10407443\n", + "Norm at iteration 81 : 0.3384855\n", + "Norm at iteration 82 : 0.21162833\n", + "Norm at iteration 83 : 0.1164826\n", + "Norm at iteration 84 : 0.09997898\n", + "Norm at iteration 85 : 0.09515852\n", + "Norm at iteration 86 : 0.09031921\n", + "Norm at iteration 87 : 0.08308379\n", + "Norm at iteration 88 : 0.093953066\n", + "Norm at iteration 89 : 0.34489763\n", + "Norm at iteration 90 : 0.20993803\n", + "Norm at iteration 91 : 0.109747335\n", + "Norm at iteration 92 : 0.08660625\n", + "Norm at iteration 93 : 0.08274939\n", + "Norm at iteration 94 : 0.08054191\n", + "Norm at iteration 95 : 0.068975054\n", + "Norm at iteration 96 : 0.07685621\n", + "Norm at iteration 97 : 0.23730345\n", + "Norm at iteration 98 : 0.11405146\n", + "Norm at iteration 99 : 0.114248306\n", + "Norm at iteration 100 : 0.08035728\n", + "Norm at iteration 101 : 0.065768704\n", + "Norm at iteration 102 : 0.0671175\n", + "Norm at iteration 103 : 0.110627025\n", + "Norm at iteration 104 : 0.06657958\n", + "Norm at iteration 105 : 0.062272713\n", + "Norm at iteration 106 : 0.06944736\n", + "Norm at iteration 107 : 0.054487497\n", + "Norm at iteration 108 : 0.0530058\n", + "Norm at iteration 109 : 0.053963218\n", + "Norm at iteration 110 : 0.062311716\n", + "Norm at iteration 111 : 0.047750697\n", + "Norm at iteration 112 : 0.04738531\n", + "Norm at iteration 113 : 0.04651882\n", + "Norm at iteration 114 : 0.061929565\n", + "Norm at iteration 115 : 0.047526173\n", + "Norm at iteration 116 : 0.042273816\n", + "Norm at iteration 117 : 0.040786393\n", + "Norm at iteration 118 : 0.05200342\n", + "Norm at iteration 119 : 0.22591864\n", + "Norm at iteration 120 : 0.16405997\n", + "Norm at iteration 121 : 0.067025654\n", + "Norm at iteration 122 : 0.066213556\n", + "Norm at iteration 123 : 0.043545194\n", + "Norm at iteration 124 : 0.0408165\n", + "Norm at iteration 125 : 0.039790355\n", + "Norm at iteration 126 : 0.07465788\n", + "Norm at iteration 127 : 0.041573383\n", + "Norm at iteration 128 : 0.039908074\n", + "Norm at iteration 129 : 0.05935606\n", + "Norm at iteration 130 : 0.04124334\n", + "Norm at iteration 131 : 0.033989873\n", + "Norm at iteration 132 : 0.03531776\n", + "Norm at iteration 133 : 0.061430454\n", + "Norm at iteration 134 : 0.039231945\n", + "Norm at iteration 135 : 0.031557877\n", + "Norm at iteration 136 : 0.03281217\n", + "Norm at iteration 137 : 0.057877578\n", + "Norm at iteration 138 : 0.037637495\n", + "Norm at iteration 139 : 0.032336507\n", + "Norm at iteration 140 : 0.0376881\n", + "Norm at iteration 141 : 0.029234225\n", + "Norm at iteration 142 : 0.026822742\n", + "Norm at iteration 143 : 0.027064566\n", + "Norm at iteration 144 : 0.031421218\n", + "Norm at iteration 145 : 0.082664\n", + "Norm at iteration 146 : 0.0517047\n", + "Norm at iteration 147 : 0.033844344\n", + "Norm at iteration 148 : 0.028784579\n", + "Norm at iteration 149 : 0.025575107\n", + "Norm at iteration 150 : 0.024450388\n", + "Norm at iteration 151 : 0.023841053\n", + "Norm at iteration 152 : 0.023410153\n", + "Norm at iteration 153 : 0.04229171\n", + "Norm at iteration 154 : 0.024062306\n", + "Norm at iteration 155 : 0.023634043\n", + "Norm at iteration 156 : 0.04324531\n", + "Norm at iteration 157 : 0.02593159\n", + "Norm at iteration 158 : 0.023885645\n", + "Norm at iteration 159 : 0.02917684\n", + "Norm at iteration 160 : 0.022640653\n", + "Norm at iteration 161 : 0.020498805\n", + "Norm at iteration 162 : 0.020519817\n", + "Norm at iteration 163 : 0.019599948\n", + "Norm at iteration 164 : 0.018930703\n", + "Norm at iteration 165 : 0.018948248\n", + "Norm at iteration 166 : 0.030178022\n", + "Norm at iteration 167 : 0.029519334\n", + "Norm at iteration 168 : 0.022732668\n", + "Norm at iteration 169 : 0.019480595\n", + "Norm at iteration 170 : 0.018542966\n", + "Norm at iteration 171 : 0.017994532\n", + "Norm at iteration 172 : 0.019094363\n", + "Norm at iteration 173 : 0.042499892\n", + "Norm at iteration 174 : 0.019618884\n", + "Norm at iteration 175 : 0.018535273\n", + "Norm at iteration 176 : 0.021583151\n", + "Norm at iteration 177 : 0.057580758\n", + "Norm at iteration 178 : 0.02749095\n", + "Norm at iteration 179 : 0.02606616\n", + "Norm at iteration 180 : 0.019455818\n", + "Norm at iteration 181 : 0.017464386\n", + "Norm at iteration 182 : 0.016078554\n", + "Norm at iteration 183 : 0.016463285\n", + "Norm at iteration 184 : 0.030327667\n", + "Norm at iteration 185 : 0.016854439\n", + "Norm at iteration 186 : 0.016311768\n", + "Norm at iteration 187 : 0.019797802\n", + "Norm at iteration 188 : 0.014797516\n", + "Norm at iteration 189 : 0.014125767\n", + "Norm at iteration 190 : 0.0140049355\n", + "Norm at iteration 191 : 0.015255202\n", + "Norm at iteration 192 : 0.03375668\n", + "Norm at iteration 193 : 0.018699717\n", + "Norm at iteration 194 : 0.017229848\n", + "Norm at iteration 195 : 0.015071655\n", + "Norm at iteration 196 : 0.0141229285\n", + "Norm at iteration 197 : 0.01347498\n", + "Norm at iteration 198 : 0.013062417\n", + "Norm at iteration 199 : 0.012560909\n", + "Norm at iteration 200 : 0.013049418\n", + "Norm at iteration 201 : 0.042774465\n", + "Norm at iteration 202 : 0.025857389\n", + "Norm at iteration 203 : 0.01533878\n", + "Norm at iteration 204 : 0.014381712\n", + "Norm at iteration 205 : 0.012415249\n", + "Norm at iteration 206 : 0.013345167\n", + "Norm at iteration 207 : 0.013038918\n", + "Norm at iteration 208 : 0.015699891\n", + "Norm at iteration 209 : 0.07130804\n", + "Norm at iteration 210 : 0.17749226\n", + "Norm at iteration 211 : 0.13045032\n", + "Norm at iteration 212 : 0.052560486\n", + "Norm at iteration 213 : 0.06417062\n", + "Norm at iteration 214 : 0.037678603\n", + "Norm at iteration 215 : 0.026142929\n", + "Norm at iteration 216 : 0.023062222\n", + "Norm at iteration 217 : 0.020902287\n", + "Norm at iteration 218 : 0.01819543\n", + "Norm at iteration 219 : 0.015895367\n", + "Norm at iteration 220 : 0.0148209715\n", + "Norm at iteration 221 : 0.019191887\n", + "Norm at iteration 222 : 0.012989352\n", + "Norm at iteration 223 : 0.013566891\n", + "Norm at iteration 224 : 0.03424933\n", + "Norm at iteration 225 : 0.016835755\n", + "Norm at iteration 226 : 0.016650477\n", + "Norm at iteration 227 : 0.012769296\n", + "Norm at iteration 228 : 0.010283441\n", + "Norm at iteration 229 : 0.010159268\n", + "Norm at iteration 230 : 0.010256334\n", + "Norm at iteration 231 : 0.014817539\n", + "Norm at iteration 232 : 0.0095714545\n", + "Norm at iteration 233 : 0.009427713\n", + "Norm at iteration 234 : 0.010051188\n", + "Norm at iteration 235 : 0.021856183\n", + "Norm at iteration 236 : 0.0125072235\n", + "Norm at iteration 237 : 0.010550216\n", + "Norm at iteration 238 : 0.00954157\n", + "Norm at iteration 239 : 0.008833486\n", + "Norm at iteration 240 : 0.008676385\n", + "Norm at iteration 241 : 0.008713607\n", + "Norm at iteration 242 : 0.010182992\n", + "Norm at iteration 243 : 0.04547905\n", + "Norm at iteration 244 : 0.02850721\n", + "Norm at iteration 245 : 0.012797044\n", + "Norm at iteration 246 : 0.009730088\n", + "Norm at iteration 247 : 0.008849616\n", + "Norm at iteration 248 : 0.008681295\n", + "Norm at iteration 249 : 0.008306542\n", + "Norm at iteration 250 : 0.008118388\n", + "Norm at iteration 251 : 0.008035412\n", + "Norm at iteration 252 : 0.007897399\n", + "Norm at iteration 253 : 0.007816752\n", + "Norm at iteration 254 : 0.008518281\n", + "Norm at iteration 255 : 0.022296267\n", + "Norm at iteration 256 : 0.088734545\n", + "Norm at iteration 257 : 0.06358835\n", + "Norm at iteration 258 : 0.03175192\n", + "Norm at iteration 259 : 0.012437006\n", + "Norm at iteration 260 : 0.015989933\n", + "Norm at iteration 261 : 0.038329378\n", + "Norm at iteration 262 : 0.02308375\n", + "Norm at iteration 263 : 0.017545108\n", + "Norm at iteration 264 : 0.014451787\n", + "Norm at iteration 265 : 0.013235104\n", + "Norm at iteration 266 : 0.011437343\n", + "Norm at iteration 267 : 0.015294691\n", + "Norm at iteration 268 : 0.01778085\n", + "Norm at iteration 269 : 0.014912057\n", + "Norm at iteration 270 : 0.017801534\n", + "Norm at iteration 271 : 0.013273548\n", + "Norm at iteration 272 : 0.011319558\n", + "Norm at iteration 273 : 0.010436819\n", + "Norm at iteration 274 : 0.011870022\n", + "Norm at iteration 275 : 0.009646406\n", + "Norm at iteration 276 : 0.01913231\n", + "Norm at iteration 277 : 0.011873624\n", + "Norm at iteration 278 : 0.014664161\n", + "Norm at iteration 279 : 0.010273499\n", + "Norm at iteration 280 : 0.00861045\n", + "Norm at iteration 281 : 0.008209569\n", + "Norm at iteration 282 : 0.008589733\n", + "Norm at iteration 283 : 0.0072148135\n", + "Norm at iteration 284 : 0.006427765\n", + "Norm at iteration 285 : 0.006715005\n", + "Norm at iteration 286 : 0.009922771\n", + "Norm at iteration 287 : 0.045950986\n", + "Norm at iteration 288 : 0.022285111\n", + "Norm at iteration 289 : 0.012012303\n", + "Norm at iteration 290 : 0.019709505\n", + "Norm at iteration 291 : 0.018637177\n", + "Norm at iteration 292 : 0.012902478\n", + "Norm at iteration 293 : 0.010559482\n", + "Norm at iteration 294 : 0.010567864\n", + "Norm at iteration 295 : 0.008892794\n", + "Norm at iteration 296 : 0.010569282\n", + "Norm at iteration 297 : 0.007836599\n", + "Norm at iteration 298 : 0.008327555\n", + "Norm at iteration 299 : 0.010529436\n", + "Norm at iteration 300 : 0.006720808\n", + "Norm at iteration 301 : 0.006714807\n", + "Norm at iteration 302 : 0.0070957877\n", + "Norm at iteration 303 : 0.007932457\n", + "Norm at iteration 304 : 0.005957289\n", + "Norm at iteration 305 : 0.0059934156\n", + "Norm at iteration 306 : 0.005904711\n", + "Norm at iteration 307 : 0.005549503\n", + "Norm at iteration 308 : 0.006784772\n", + "Norm at iteration 309 : 0.01939657\n", + "Norm at iteration 310 : 0.0076472564\n", + "Norm at iteration 311 : 0.00713728\n", + "Norm at iteration 312 : 0.00699707\n", + "Norm at iteration 313 : 0.006756184\n", + "Norm at iteration 314 : 0.0061873323\n", + "Norm at iteration 315 : 0.0059949625\n", + "Norm at iteration 316 : 0.006076785\n", + "Norm at iteration 317 : 0.0065729395\n", + "Norm at iteration 318 : 0.035357423\n", + "Norm at iteration 319 : 0.0077318065\n", + "Norm at iteration 320 : 0.009845298\n", + "Norm at iteration 321 : 0.024200713\n", + "Norm at iteration 322 : 0.012209329\n", + "Norm at iteration 323 : 0.0113028195\n", + "Norm at iteration 324 : 0.008687293\n", + "Norm at iteration 325 : 0.007416753\n", + "Norm at iteration 326 : 0.0070672263\n", + "Norm at iteration 327 : 0.007778286\n", + "Norm at iteration 328 : 0.013194945\n", + "Norm at iteration 329 : 0.006413535\n", + "Norm at iteration 330 : 0.006810578\n", + "Norm at iteration 331 : 0.013016059\n", + "Norm at iteration 332 : 0.008723148\n", + "Norm at iteration 333 : 0.0060170065\n", + "Norm at iteration 334 : 0.0066944784\n", + "Norm at iteration 335 : 0.0052972673\n", + "Norm at iteration 336 : 0.0049494854\n" + ] + } + ], + "source": [ + "w, q2, w_mu_hat, w_nu_hat, residuals, exec_time_SSN = SSN(x, y, filling_points, tau, nb_iter=1000, display_gap=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "T = np.arange(len(residuals))\n", + "plt.plot(T[100:], residuals[100:])\n", + "plt.plot(T[100:], (residuals[0] /(np.sqrt(T)*400))[100:])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison of SSN and EG execution times" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare the execution times of both methods, we will vary the dimension of the data points from 1 to 10, and compute the execution time." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n", + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n" + ] + } + ], + "source": [ + "exec_times_SSN = []\n", + "exec_times_EG = []\n", + "\n", + "for d in range(1,11):\n", + " if d==1:\n", + " x,y, mu, nu = get_data(d = d, n_samples=n)\n", + " else:\n", + " x, y = get_data(d = d, n_samples=n)\n", + "\n", + " filling_points = get_filling_points(d = d, n_samples=n_samples)\n", + " x_fill, y_fill = filling_points[:,:d], filling_points[:,d:]\n", + "\n", + " _, _, _, _, _, exec_time_SSN = SSN(x, y, filling_points, tau, nb_iter=1000, verbose=False)\n", + " _, exec_time_EG = EG(x, y, filling_points, tau, nb_iter=1000, verbose=False)\n", + " exec_times_SSN.append(exec_time_SSN)\n", + " exec_times_EG.append(exec_time_EG)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(exec_times_SSN, marker = \"p\", color = \"blue\", markersize=12, markeredgecolor=\"k\", label = \"SSN\")\n", + "plt.plot(exec_times_EG, marker = \"o\", color = \"red\", markersize=12, markeredgecolor=\"k\", label = \"EG\")\n", + "\n", + "plt.legend()\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now obtain the Wasserstein distance estimator for both methods" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\charl\\anaconda3\\Lib\\site-packages\\scipy\\stats\\_qmc.py:763: UserWarning: The balance properties of Sobol' points require n to be a power of 2.\n", + " sample = self._random(n, workers=workers)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Norm at iteration 1 : 285.1371\n", + "Norm at iteration 11 : 3.3477292\n", + "Norm at iteration 21 : 0.89563316\n", + "Norm at iteration 31 : 0.2223846\n", + "Norm at iteration 41 : 0.39989018\n", + "Norm at iteration 51 : 0.17701319\n", + "Norm at iteration 61 : 0.24597722\n", + "Norm at iteration 71 : 0.13342115\n", + "Norm at iteration 81 : 0.20561346\n", + "Norm at iteration 91 : 0.108565055\n", + "Norm at iteration 101 : 0.10862228\n", + "Norm at iteration 111 : 0.09614268\n", + "Norm at iteration 121 : 0.08149175\n", + "Norm at iteration 131 : 0.06714382\n", + "Norm at iteration 141 : 0.05843069\n", + "Norm at iteration 151 : 0.061702907\n", + "Norm at iteration 161 : 0.04627314\n", + "Norm at iteration 171 : 0.06959003\n", + "Norm at iteration 181 : 0.033873536\n", + "Norm at iteration 191 : 0.045172125\n", + "Norm at iteration 201 : 0.02554205\n", + "Norm at iteration 211 : 0.022948995\n", + "Norm at iteration 221 : 0.0228598\n", + "Norm at iteration 231 : 0.019387797\n", + "Norm at iteration 241 : 0.017098574\n", + "Norm at iteration 251 : 0.01557671\n", + "Norm at iteration 261 : 0.022489898\n", + "Norm at iteration 271 : 0.06293415\n", + "Norm at iteration 281 : 0.019429758\n", + "Norm at iteration 291 : 0.012081472\n", + "Norm at iteration 301 : 0.013824471\n", + "Norm at iteration 311 : 0.04854741\n", + "Norm at iteration 321 : 0.016063074\n", + "Norm at iteration 331 : 0.011511762\n", + "Norm at iteration 341 : 0.0096444525\n", + "Norm at iteration 351 : 0.014724437\n", + "Norm at iteration 361 : 0.010334389\n", + "Norm at iteration 371 : 0.009187464\n", + "Norm at iteration 381 : 0.007482248\n", + "Norm at iteration 391 : 0.009205528\n", + "Norm at iteration 401 : 0.007007255\n", + "Norm at iteration 411 : 0.0061842054\n", + "Norm at iteration 421 : 0.011093894\n", + "Norm at iteration 431 : 0.010453158\n", + "Norm at iteration 441 : 0.01667729\n", + "Norm at iteration 451 : 0.013955379\n", + "Norm at iteration 461 : 0.010357634\n", + "Norm at iteration 471 : 0.0067157475\n", + "Norm at iteration 481 : 0.006225356\n", + "Norm at iteration 491 : 0.0054539684\n", + "Norm at iteration 501 : 0.0058100806\n", + "Norm at iteration 1 : 12.483098\n", + "Norm at iteration 11 : 3.0590177\n", + "Norm at iteration 21 : 2.901959\n", + "Norm at iteration 31 : 2.9502697\n", + "Norm at iteration 41 : 3.0267122\n", + "Norm at iteration 51 : 3.109229\n", + "Norm at iteration 61 : 3.1886735\n", + "Norm at iteration 71 : 3.260459\n", + "Norm at iteration 81 : 3.3221405\n", + "Norm at iteration 91 : 3.3720095\n", + "Norm at iteration 101 : 3.4089746\n", + "Norm at iteration 111 : 3.4324822\n", + "Norm at iteration 121 : 3.4424078\n", + "Norm at iteration 131 : 3.43899\n", + "Norm at iteration 141 : 3.4228153\n", + "Norm at iteration 151 : 3.3948436\n", + "Norm at iteration 161 : 3.3564413\n", + "Norm at iteration 171 : 3.3094761\n", + "Norm at iteration 181 : 3.2564173\n", + "Norm at iteration 191 : 3.2004008\n", + "Norm at iteration 201 : 3.1453862\n", + "Norm at iteration 211 : 3.0960524\n", + "Norm at iteration 221 : 3.0572948\n", + "Norm at iteration 231 : 3.0331764\n", + "Norm at iteration 241 : 3.025632\n", + "Norm at iteration 251 : 3.0336084\n", + "Norm at iteration 261 : 3.0536034\n", + "Norm at iteration 271 : 3.0809593\n", + "Norm at iteration 281 : 3.1111305\n", + "Norm at iteration 291 : 3.140358\n", + "Norm at iteration 301 : 3.1658692\n", + "Norm at iteration 311 : 3.185813\n", + "Norm at iteration 321 : 3.1990948\n", + "Norm at iteration 331 : 3.2052493\n", + "Norm at iteration 341 : 3.2043\n", + "Norm at iteration 351 : 3.1966953\n", + "Norm at iteration 361 : 3.1832294\n", + "Norm at iteration 371 : 3.165008\n", + "Norm at iteration 381 : 3.143424\n", + "Norm at iteration 391 : 3.1200142\n", + "Norm at iteration 401 : 3.0967288\n", + "Norm at iteration 411 : 3.0752323\n", + "Norm at iteration 421 : 3.0568204\n", + "Norm at iteration 431 : 3.0422797\n", + "Norm at iteration 441 : 3.031777\n", + "Norm at iteration 451 : 3.025115\n", + "Norm at iteration 461 : 3.0215428\n", + "Norm at iteration 471 : 3.0198631\n", + "Norm at iteration 481 : 3.0188649\n", + "Norm at iteration 491 : 3.0175157\n", + "Norm at iteration 501 : 3.0150602\n", + "Norm at iteration 511 : 3.0109992\n", + "Norm at iteration 521 : 3.0051403\n", + "Norm at iteration 531 : 2.997475\n", + "Norm at iteration 541 : 2.9879813\n", + "Norm at iteration 551 : 2.9772186\n", + "Norm at iteration 561 : 2.9655232\n", + "Norm at iteration 571 : 2.953185\n", + "Norm at iteration 581 : 2.9402895\n", + "Norm at iteration 591 : 2.9266157\n", + "Norm at iteration 601 : 2.9124575\n", + "Norm at iteration 611 : 2.8980427\n", + "Norm at iteration 621 : 2.882607\n", + "Norm at iteration 631 : 2.8669465\n", + "Norm at iteration 641 : 2.8506627\n", + "Norm at iteration 651 : 2.8339362\n", + "Norm at iteration 661 : 2.8164282\n", + "Norm at iteration 671 : 2.7978585\n", + "Norm at iteration 681 : 2.7787728\n", + "Norm at iteration 691 : 2.7597098\n", + "Norm at iteration 701 : 2.7409053\n", + "Norm at iteration 711 : 2.7219343\n", + "Norm at iteration 721 : 2.7025223\n", + "Norm at iteration 731 : 2.6773708\n", + "Norm at iteration 741 : 2.647263\n", + "Norm at iteration 751 : 2.6181588\n", + "Norm at iteration 761 : 2.590456\n", + "Norm at iteration 771 : 2.5634847\n", + "Norm at iteration 781 : 2.5387228\n", + "Norm at iteration 791 : 2.5133796\n", + "Norm at iteration 801 : 2.486733\n", + "Norm at iteration 811 : 2.4618733\n", + "Norm at iteration 821 : 2.4278564\n", + "Norm at iteration 831 : 2.3871226\n", + "Norm at iteration 841 : 2.3474154\n", + "Norm at iteration 851 : 2.3084002\n", + "Norm at iteration 861 : 2.275303\n", + "Norm at iteration 871 : 2.248888\n", + "Norm at iteration 881 : 2.2281928\n", + "Norm at iteration 891 : 2.2162294\n", + "Norm at iteration 901 : 2.2067056\n", + "Norm at iteration 911 : 2.1976688\n", + "Norm at iteration 921 : 2.18588\n", + "Norm at iteration 931 : 2.1715326\n", + "Norm at iteration 941 : 2.1566806\n", + "Norm at iteration 951 : 2.1392608\n", + "Norm at iteration 961 : 2.1243982\n", + "Norm at iteration 971 : 2.1107345\n", + "Norm at iteration 981 : 2.0988545\n", + "Norm at iteration 991 : 2.0825524\n", + "Norm at iteration 1001 : 2.0603788\n", + "Norm at iteration 1011 : 2.0389519\n", + "Norm at iteration 1021 : 2.0199614\n", + "Norm at iteration 1031 : 2.0026054\n", + "Norm at iteration 1041 : 1.9864422\n", + "Norm at iteration 1051 : 1.963589\n", + "Norm at iteration 1061 : 1.9401357\n", + "Norm at iteration 1071 : 1.9195327\n", + "Norm at iteration 1081 : 1.9008982\n", + "Norm at iteration 1091 : 1.8820891\n", + "Norm at iteration 1101 : 1.8639526\n", + "Norm at iteration 1111 : 1.8471656\n", + "Norm at iteration 1121 : 1.8312325\n", + "Norm at iteration 1131 : 1.8072612\n", + "Norm at iteration 1141 : 1.7846285\n", + "Norm at iteration 1151 : 1.7672765\n", + "Norm at iteration 1161 : 1.7551107\n", + "Norm at iteration 1171 : 1.7477486\n", + "Norm at iteration 1181 : 1.7445254\n", + "Norm at iteration 1191 : 1.7444799\n", + "Norm at iteration 1201 : 1.7462554\n", + "Norm at iteration 1211 : 1.7488265\n", + "Norm at iteration 1221 : 1.7508802\n", + "Norm at iteration 1231 : 1.7512748\n", + "Norm at iteration 1241 : 1.7486007\n", + "Norm at iteration 1251 : 1.7394384\n", + "Norm at iteration 1261 : 1.7288879\n", + "Norm at iteration 1271 : 1.7178929\n", + "Norm at iteration 1281 : 1.706932\n", + "Norm at iteration 1291 : 1.6965191\n", + "Norm at iteration 1301 : 1.6871256\n", + "Norm at iteration 1311 : 1.6791445\n", + "Norm at iteration 1321 : 1.6712444\n", + "Norm at iteration 1331 : 1.6645622\n", + "Norm at iteration 1341 : 1.6592412\n", + "Norm at iteration 1351 : 1.6549615\n", + "Norm at iteration 1361 : 1.6513722\n", + "Norm at iteration 1371 : 1.6480236\n", + "Norm at iteration 1381 : 1.6444421\n", + "Norm at iteration 1391 : 1.6403275\n", + "Norm at iteration 1401 : 1.6337886\n", + "Norm at iteration 1411 : 1.6261511\n", + "Norm at iteration 1421 : 1.6161693\n", + "Norm at iteration 1431 : 1.6042142\n", + "Norm at iteration 1441 : 1.591821\n", + "Norm at iteration 1451 : 1.5794075\n", + "Norm at iteration 1461 : 1.5676413\n", + "Norm at iteration 1471 : 1.5564185\n", + "Norm at iteration 1481 : 1.5459819\n", + "Norm at iteration 1491 : 1.5362906\n", + "Norm at iteration 1501 : 1.5274619\n", + "Norm at iteration 1511 : 1.5193493\n", + "Norm at iteration 1521 : 1.5115108\n", + "Norm at iteration 1531 : 1.504169\n", + "Norm at iteration 1541 : 1.4971237\n", + "Norm at iteration 1551 : 1.482453\n", + "Norm at iteration 1561 : 1.4638438\n", + "Norm at iteration 1571 : 1.4463439\n", + "Norm at iteration 1581 : 1.4305081\n", + "Norm at iteration 1591 : 1.4164276\n", + "Norm at iteration 1601 : 1.4032636\n", + "Norm at iteration 1611 : 1.3916919\n", + "Norm at iteration 1621 : 1.3823268\n", + "Norm at iteration 1631 : 1.3752487\n", + "Norm at iteration 1641 : 1.3693464\n", + "Norm at iteration 1651 : 1.3643162\n", + "Norm at iteration 1661 : 1.3599246\n", + "Norm at iteration 1671 : 1.3543963\n", + "Norm at iteration 1681 : 1.3485503\n", + "Norm at iteration 1691 : 1.3425035\n", + "Norm at iteration 1701 : 1.3363075\n", + "Norm at iteration 1711 : 1.3298409\n", + "Norm at iteration 1721 : 1.3231254\n", + "Norm at iteration 1731 : 1.3161688\n", + "Norm at iteration 1741 : 1.3091791\n", + "Norm at iteration 1751 : 1.3021855\n", + "Norm at iteration 1761 : 1.2952074\n", + "Norm at iteration 1771 : 1.2868683\n", + "Norm at iteration 1781 : 1.2785678\n", + "Norm at iteration 1791 : 1.2674444\n", + "Norm at iteration 1801 : 1.2571216\n", + "Norm at iteration 1811 : 1.2483768\n", + "Norm at iteration 1821 : 1.2412553\n", + "Norm at iteration 1831 : 1.2353423\n", + "Norm at iteration 1841 : 1.2254252\n", + "Norm at iteration 1851 : 1.2163699\n", + "Norm at iteration 1861 : 1.2082362\n", + "Norm at iteration 1871 : 1.2007769\n", + "Norm at iteration 1881 : 1.1906166\n", + "Norm at iteration 1891 : 1.1792371\n", + "Norm at iteration 1901 : 1.1689142\n", + "Norm at iteration 1911 : 1.160101\n", + "Norm at iteration 1921 : 1.1527119\n", + "Norm at iteration 1931 : 1.1460088\n", + "Norm at iteration 1941 : 1.1400969\n", + "Norm at iteration 1951 : 1.1350534\n", + "Norm at iteration 1961 : 1.1311393\n", + "Norm at iteration 1971 : 1.1283277\n", + "Norm at iteration 1981 : 1.126473\n", + "Norm at iteration 1991 : 1.1253192\n", + "Norm at iteration 2001 : 1.1231494\n", + "Norm at iteration 2011 : 1.1210409\n", + "Norm at iteration 2021 : 1.118745\n", + "Norm at iteration 2031 : 1.1158309\n", + "Norm at iteration 2041 : 1.1106246\n", + "Norm at iteration 2051 : 1.1032407\n", + "Norm at iteration 2061 : 1.0949934\n", + "Norm at iteration 2071 : 1.0861746\n", + "Norm at iteration 2081 : 1.077141\n", + "Norm at iteration 2091 : 1.0680959\n", + "Norm at iteration 2101 : 1.0592905\n", + "Norm at iteration 2111 : 1.052075\n", + "Norm at iteration 2121 : 1.0461075\n", + "Norm at iteration 2131 : 1.0408292\n", + "Norm at iteration 2141 : 1.036218\n", + "Norm at iteration 2151 : 1.023807\n", + "Norm at iteration 2161 : 1.012463\n", + "Norm at iteration 2171 : 1.0034938\n", + "Norm at iteration 2181 : 0.99667835\n", + "Norm at iteration 2191 : 0.99177665\n", + "Norm at iteration 2201 : 0.9884852\n", + "Norm at iteration 2211 : 0.9864654\n", + "Norm at iteration 2221 : 0.982195\n", + "Norm at iteration 2231 : 0.97766495\n", + "Norm at iteration 2241 : 0.9737333\n", + "Norm at iteration 2251 : 0.9704046\n", + "Norm at iteration 2261 : 0.967661\n", + "Norm at iteration 2271 : 0.9652839\n", + "Norm at iteration 2281 : 0.96323395\n", + "Norm at iteration 2291 : 0.9608309\n", + "Norm at iteration 2301 : 0.95781946\n", + "Norm at iteration 2311 : 0.9550153\n", + "Norm at iteration 2321 : 0.9525299\n", + "Norm at iteration 2331 : 0.95020604\n", + "Norm at iteration 2341 : 0.948019\n", + "Norm at iteration 2351 : 0.9458319\n", + "Norm at iteration 2361 : 0.94354844\n", + "Norm at iteration 2371 : 0.94095516\n", + "Norm at iteration 2381 : 0.93806946\n", + "Norm at iteration 2391 : 0.9347849\n", + "Norm at iteration 2401 : 0.929561\n", + "Norm at iteration 2411 : 0.9196166\n", + "Norm at iteration 2421 : 0.9099575\n", + "Norm at iteration 2431 : 0.9008346\n", + "Norm at iteration 2441 : 0.8924855\n", + "Norm at iteration 2451 : 0.8850896\n", + "Norm at iteration 2461 : 0.87876487\n", + "Norm at iteration 2471 : 0.8737737\n", + "Norm at iteration 2481 : 0.87006795\n", + "Norm at iteration 2491 : 0.8668777\n", + "Norm at iteration 2501 : 0.8637605\n", + "Norm at iteration 2511 : 0.8607421\n", + "Norm at iteration 2521 : 0.85780036\n", + "Norm at iteration 2531 : 0.85487366\n", + "Norm at iteration 2541 : 0.85203284\n", + "Norm at iteration 2551 : 0.84917784\n", + "Norm at iteration 2561 : 0.8462528\n", + "Norm at iteration 2571 : 0.8430778\n", + "Norm at iteration 2581 : 0.8386388\n", + "Norm at iteration 2591 : 0.83438766\n", + "Norm at iteration 2601 : 0.83046395\n", + "Norm at iteration 2611 : 0.826867\n", + "Norm at iteration 2621 : 0.8235629\n", + "Norm at iteration 2631 : 0.8205042\n", + "Norm at iteration 2641 : 0.8176491\n", + "Norm at iteration 2651 : 0.8149873\n", + "Norm at iteration 2661 : 0.81243634\n", + "Norm at iteration 2671 : 0.80991006\n", + "Norm at iteration 2681 : 0.80697477\n", + "Norm at iteration 2691 : 0.8040203\n", + "Norm at iteration 2701 : 0.8009975\n", + "Norm at iteration 2711 : 0.797883\n", + "Norm at iteration 2721 : 0.7947786\n", + "Norm at iteration 2731 : 0.7916845\n", + "Norm at iteration 2741 : 0.78862435\n", + "Norm at iteration 2751 : 0.78566426\n", + "Norm at iteration 2761 : 0.7828816\n", + "Norm at iteration 2771 : 0.78013957\n", + "Norm at iteration 2781 : 0.777441\n", + "Norm at iteration 2791 : 0.7747246\n", + "Norm at iteration 2801 : 0.771981\n", + "Norm at iteration 2811 : 0.7691855\n", + "Norm at iteration 2821 : 0.7663348\n", + "Norm at iteration 2831 : 0.76343745\n", + "Norm at iteration 2841 : 0.76052773\n", + "Norm at iteration 2851 : 0.7576333\n", + "Norm at iteration 2861 : 0.7547871\n", + "Norm at iteration 2871 : 0.7520524\n", + "Norm at iteration 2881 : 0.74947345\n", + "Norm at iteration 2891 : 0.74704784\n", + "Norm at iteration 2901 : 0.74481666\n", + "Norm at iteration 2911 : 0.7427715\n", + "Norm at iteration 2921 : 0.7406499\n", + "Norm at iteration 2931 : 0.73866403\n", + "Norm at iteration 2941 : 0.7367492\n", + "Norm at iteration 2951 : 0.7348511\n", + "Norm at iteration 2961 : 0.7327632\n", + "Norm at iteration 2971 : 0.7305424\n", + "Norm at iteration 2981 : 0.728264\n", + "Norm at iteration 2991 : 0.7259139\n", + "Norm at iteration 3001 : 0.7235164\n", + "Norm at iteration 3011 : 0.72101617\n", + "Norm at iteration 3021 : 0.7184093\n", + "Norm at iteration 3031 : 0.7156642\n", + "Norm at iteration 3041 : 0.7126502\n", + "Norm at iteration 3051 : 0.7096443\n", + "Norm at iteration 3061 : 0.7066521\n", + "Norm at iteration 3071 : 0.7037989\n", + "Norm at iteration 3081 : 0.7011609\n", + "Norm at iteration 3091 : 0.6986776\n", + "Norm at iteration 3101 : 0.6963383\n", + "Norm at iteration 3111 : 0.6941819\n", + "Norm at iteration 3121 : 0.6920171\n", + "Norm at iteration 3131 : 0.68990636\n", + "Norm at iteration 3141 : 0.6875463\n", + "Norm at iteration 3151 : 0.6850235\n", + "Norm at iteration 3161 : 0.6822871\n", + "Norm at iteration 3171 : 0.6762878\n", + "Norm at iteration 3181 : 0.6678477\n", + "Norm at iteration 3191 : 0.6594365\n", + "Norm at iteration 3201 : 0.65190506\n", + "Norm at iteration 3211 : 0.64566624\n", + "Norm at iteration 3221 : 0.6408014\n", + "Norm at iteration 3231 : 0.6374266\n", + "Norm at iteration 3241 : 0.6353644\n", + "Norm at iteration 3251 : 0.63445324\n", + "Norm at iteration 3261 : 0.63418657\n", + "Norm at iteration 3271 : 0.63354504\n", + "Norm at iteration 3281 : 0.6322781\n", + "Norm at iteration 3291 : 0.63061917\n", + "Norm at iteration 3301 : 0.6287893\n", + "Norm at iteration 3311 : 0.62689126\n", + "Norm at iteration 3321 : 0.624959\n", + "Norm at iteration 3331 : 0.6230819\n", + "Norm at iteration 3341 : 0.6211721\n", + "Norm at iteration 3351 : 0.6192348\n", + "Norm at iteration 3361 : 0.6173238\n", + "Norm at iteration 3371 : 0.6154069\n", + "Norm at iteration 3381 : 0.61347795\n", + "Norm at iteration 3391 : 0.61155754\n", + "Norm at iteration 3401 : 0.6095971\n", + "Norm at iteration 3411 : 0.60759336\n", + "Norm at iteration 3421 : 0.60548306\n", + "Norm at iteration 3431 : 0.6029692\n", + "Norm at iteration 3441 : 0.5997075\n", + "Norm at iteration 3451 : 0.5956649\n", + "Norm at iteration 3461 : 0.5913621\n", + "Norm at iteration 3471 : 0.5869769\n", + "Norm at iteration 3481 : 0.5825578\n", + "Norm at iteration 3491 : 0.5782037\n", + "Norm at iteration 3501 : 0.57409936\n", + "Norm at iteration 3511 : 0.5704285\n", + "Norm at iteration 3521 : 0.56716126\n", + "Norm at iteration 3531 : 0.56395805\n", + "Norm at iteration 3541 : 0.56098163\n", + "Norm at iteration 3551 : 0.55848014\n", + "Norm at iteration 3561 : 0.5564674\n", + "Norm at iteration 3571 : 0.5548924\n", + "Norm at iteration 3581 : 0.5536761\n", + "Norm at iteration 3591 : 0.5527066\n", + "Norm at iteration 3601 : 0.5518651\n", + "Norm at iteration 3611 : 0.55099905\n", + "Norm at iteration 3621 : 0.5500185\n", + "Norm at iteration 3631 : 0.54880923\n", + "Norm at iteration 3641 : 0.54735947\n", + "Norm at iteration 3651 : 0.5455883\n", + "Norm at iteration 3661 : 0.54361594\n", + "Norm at iteration 3671 : 0.5415285\n", + "Norm at iteration 3681 : 0.5394282\n", + "Norm at iteration 3691 : 0.5373441\n", + "Norm at iteration 3701 : 0.535416\n", + "Norm at iteration 3711 : 0.5336654\n", + "Norm at iteration 3721 : 0.5321235\n", + "Norm at iteration 3731 : 0.5307678\n", + "Norm at iteration 3741 : 0.5295441\n", + "Norm at iteration 3751 : 0.52836883\n", + "Norm at iteration 3761 : 0.52714247\n", + "Norm at iteration 3771 : 0.5257436\n", + "Norm at iteration 3781 : 0.52409303\n", + "Norm at iteration 3791 : 0.5221015\n", + "Norm at iteration 3801 : 0.51971614\n", + "Norm at iteration 3811 : 0.51675224\n", + "Norm at iteration 3821 : 0.5132198\n", + "Norm at iteration 3831 : 0.50946724\n", + "Norm at iteration 3841 : 0.5056814\n", + "Norm at iteration 3851 : 0.50194556\n", + "Norm at iteration 3861 : 0.49845648\n", + "Norm at iteration 3871 : 0.49532196\n", + "Norm at iteration 3881 : 0.4925799\n", + "Norm at iteration 3891 : 0.4901948\n", + "Norm at iteration 3901 : 0.4862616\n", + "Norm at iteration 3911 : 0.4827581\n", + "Norm at iteration 3921 : 0.47974858\n", + "Norm at iteration 3931 : 0.47722006\n", + "Norm at iteration 3941 : 0.47505862\n", + "Norm at iteration 3951 : 0.47319537\n", + "Norm at iteration 3961 : 0.47155783\n", + "Norm at iteration 3971 : 0.47015578\n", + "Norm at iteration 3981 : 0.46880466\n", + "Norm at iteration 3991 : 0.46749258\n", + "Norm at iteration 4001 : 0.46613896\n", + "Norm at iteration 4011 : 0.46452618\n", + "Norm at iteration 4021 : 0.46272475\n", + "Norm at iteration 4031 : 0.46102256\n", + "Norm at iteration 4041 : 0.4595135\n", + "Norm at iteration 4051 : 0.45805353\n", + "Norm at iteration 4061 : 0.45659953\n", + "Norm at iteration 4071 : 0.4551725\n", + "Norm at iteration 4081 : 0.45374158\n", + "Norm at iteration 4091 : 0.45218876\n", + "Norm at iteration 4101 : 0.4504934\n", + "Norm at iteration 4111 : 0.44861847\n", + "Norm at iteration 4121 : 0.44667703\n", + "Norm at iteration 4131 : 0.44456586\n", + "Norm at iteration 4141 : 0.44226277\n", + "Norm at iteration 4151 : 0.43989086\n", + "Norm at iteration 4161 : 0.43739313\n", + "Norm at iteration 4171 : 0.43494347\n", + "Norm at iteration 4181 : 0.43257496\n", + "Norm at iteration 4191 : 0.43036598\n", + "Norm at iteration 4201 : 0.4283516\n", + "Norm at iteration 4211 : 0.426539\n", + "Norm at iteration 4221 : 0.4248508\n", + "Norm at iteration 4231 : 0.42333868\n", + "Norm at iteration 4241 : 0.42193443\n", + "Norm at iteration 4251 : 0.42058352\n", + "Norm at iteration 4261 : 0.41921037\n", + "Norm at iteration 4271 : 0.4177765\n", + "Norm at iteration 4281 : 0.41624796\n", + "Norm at iteration 4291 : 0.41461828\n", + "Norm at iteration 4301 : 0.412933\n", + "Norm at iteration 4311 : 0.41120505\n", + "Norm at iteration 4321 : 0.40944898\n", + "Norm at iteration 4331 : 0.40772757\n", + "Norm at iteration 4341 : 0.40604708\n", + "Norm at iteration 4351 : 0.40445203\n", + "Norm at iteration 4361 : 0.40295193\n", + "Norm at iteration 4371 : 0.40153646\n", + "Norm at iteration 4381 : 0.40018496\n", + "Norm at iteration 4391 : 0.39885175\n", + "Norm at iteration 4401 : 0.39751524\n", + "Norm at iteration 4411 : 0.39614117\n", + "Norm at iteration 4421 : 0.3946485\n", + "Norm at iteration 4431 : 0.39305615\n", + "Norm at iteration 4441 : 0.39133045\n", + "Norm at iteration 4451 : 0.3894912\n", + "Norm at iteration 4461 : 0.38756424\n", + "Norm at iteration 4471 : 0.3855958\n", + "Norm at iteration 4481 : 0.38363189\n", + "Norm at iteration 4491 : 0.38171625\n", + "Norm at iteration 4501 : 0.37988883\n", + "Norm at iteration 4511 : 0.37819096\n", + "Norm at iteration 4521 : 0.37661588\n", + "Norm at iteration 4531 : 0.3750648\n", + "Norm at iteration 4541 : 0.37336546\n", + "Norm at iteration 4551 : 0.37174007\n", + "Norm at iteration 4561 : 0.37015337\n", + "Norm at iteration 4571 : 0.36857784\n", + "Norm at iteration 4581 : 0.36697102\n", + "Norm at iteration 4591 : 0.36530304\n", + "Norm at iteration 4601 : 0.362916\n", + "Norm at iteration 4611 : 0.36078447\n", + "Norm at iteration 4621 : 0.35883474\n", + "Norm at iteration 4631 : 0.35706335\n", + "Norm at iteration 4641 : 0.35547203\n", + "Norm at iteration 4651 : 0.35407865\n", + "Norm at iteration 4661 : 0.35301208\n", + "Norm at iteration 4671 : 0.35218507\n", + "Norm at iteration 4681 : 0.35160643\n", + "Norm at iteration 4691 : 0.35121548\n", + "Norm at iteration 4701 : 0.35092306\n", + "Norm at iteration 4711 : 0.35065782\n", + "Norm at iteration 4721 : 0.3503242\n", + "Norm at iteration 4731 : 0.34973675\n", + "Norm at iteration 4741 : 0.3488881\n", + "Norm at iteration 4751 : 0.34779015\n", + "Norm at iteration 4761 : 0.3464901\n", + "Norm at iteration 4771 : 0.34499893\n", + "Norm at iteration 4781 : 0.3433771\n", + "Norm at iteration 4791 : 0.34174672\n", + "Norm at iteration 4801 : 0.34022892\n", + "Norm at iteration 4811 : 0.33880717\n", + "Norm at iteration 4821 : 0.33751726\n", + "Norm at iteration 4831 : 0.33638668\n", + "Norm at iteration 4841 : 0.33541262\n", + "Norm at iteration 4851 : 0.33455655\n", + "Norm at iteration 4861 : 0.33377692\n", + "Norm at iteration 4871 : 0.3330071\n", + "Norm at iteration 4881 : 0.33219695\n", + "Norm at iteration 4891 : 0.33129758\n", + "Norm at iteration 4901 : 0.3302821\n", + "Norm at iteration 4911 : 0.3291408\n", + "Norm at iteration 4921 : 0.32789937\n", + "Norm at iteration 4931 : 0.32651532\n", + "Norm at iteration 4941 : 0.32522395\n", + "Norm at iteration 4951 : 0.32395607\n", + "Norm at iteration 4961 : 0.32278073\n", + "Norm at iteration 4971 : 0.321744\n", + "Norm at iteration 4981 : 0.32086223\n", + "Norm at iteration 4991 : 0.32018912\n", + "Norm at iteration 5001 : 0.31961697\n", + "Norm at iteration 5011 : 0.31913513\n", + "Norm at iteration 5021 : 0.3187657\n", + "Norm at iteration 5031 : 0.31834185\n", + "Norm at iteration 5041 : 0.31776583\n", + "Norm at iteration 5051 : 0.31704766\n", + "Norm at iteration 5061 : 0.3161712\n", + "Norm at iteration 5071 : 0.31512612\n", + "Norm at iteration 5081 : 0.31401062\n", + "Norm at iteration 5091 : 0.3127796\n", + "Norm at iteration 5101 : 0.31151554\n", + "Norm at iteration 5111 : 0.31029296\n", + "Norm at iteration 5121 : 0.30905128\n", + "Norm at iteration 5131 : 0.307738\n", + "Norm at iteration 5141 : 0.3064645\n", + "Norm at iteration 5151 : 0.3051502\n", + "Norm at iteration 5161 : 0.30394068\n", + "Norm at iteration 5171 : 0.3028158\n", + "Norm at iteration 5181 : 0.30174437\n", + "Norm at iteration 5191 : 0.300711\n", + "Norm at iteration 5201 : 0.29968312\n", + "Norm at iteration 5211 : 0.29866558\n", + "Norm at iteration 5221 : 0.29760498\n", + "Norm at iteration 5231 : 0.29657343\n", + "Norm at iteration 5241 : 0.29553413\n", + "Norm at iteration 5251 : 0.29451257\n", + "Norm at iteration 5261 : 0.293554\n", + "Norm at iteration 5271 : 0.29268062\n", + "Norm at iteration 5281 : 0.29192224\n", + "Norm at iteration 5291 : 0.2912779\n", + "Norm at iteration 5301 : 0.290726\n", + "Norm at iteration 5311 : 0.29024622\n", + "Norm at iteration 5321 : 0.28981015\n", + "Norm at iteration 5331 : 0.28936768\n", + "Norm at iteration 5341 : 0.28889126\n", + "Norm at iteration 5351 : 0.28833276\n", + "Norm at iteration 5361 : 0.28770614\n", + "Norm at iteration 5371 : 0.28700095\n", + "Norm at iteration 5381 : 0.2862172\n", + "Norm at iteration 5391 : 0.28543139\n", + "Norm at iteration 5401 : 0.28458366\n", + "Norm at iteration 5411 : 0.28372234\n", + "Norm at iteration 5421 : 0.28285795\n", + "Norm at iteration 5431 : 0.28205827\n", + "Norm at iteration 5441 : 0.28129083\n", + "Norm at iteration 5451 : 0.2805522\n", + "Norm at iteration 5461 : 0.27932024\n", + "Norm at iteration 5471 : 0.27793476\n", + "Norm at iteration 5481 : 0.27668858\n", + "Norm at iteration 5491 : 0.27555585\n", + "Norm at iteration 5501 : 0.27451247\n", + "Norm at iteration 5511 : 0.27351698\n", + "Norm at iteration 5521 : 0.2725585\n", + "Norm at iteration 5531 : 0.27166003\n", + "Norm at iteration 5541 : 0.2708373\n", + "Norm at iteration 5551 : 0.27018738\n", + "Norm at iteration 5561 : 0.26952708\n", + "Norm at iteration 5571 : 0.26894736\n", + "Norm at iteration 5581 : 0.26846176\n", + "Norm at iteration 5591 : 0.268039\n", + "Norm at iteration 5601 : 0.26765054\n", + "Norm at iteration 5611 : 0.2672307\n", + "Norm at iteration 5621 : 0.26681724\n", + "Norm at iteration 5631 : 0.2664305\n", + "Norm at iteration 5641 : 0.26604158\n", + "Norm at iteration 5651 : 0.26561308\n", + "Norm at iteration 5661 : 0.26513007\n", + "Norm at iteration 5671 : 0.2645591\n", + "Norm at iteration 5681 : 0.26397628\n", + "Norm at iteration 5691 : 0.26328927\n", + "Norm at iteration 5701 : 0.26258463\n", + "Norm at iteration 5711 : 0.26183534\n", + "Norm at iteration 5721 : 0.26110333\n", + "Norm at iteration 5731 : 0.260356\n", + "Norm at iteration 5741 : 0.25951687\n", + "Norm at iteration 5751 : 0.2586887\n", + "Norm at iteration 5761 : 0.2578493\n", + "Norm at iteration 5771 : 0.2569986\n", + "Norm at iteration 5781 : 0.25610954\n", + "Norm at iteration 5791 : 0.25526792\n", + "Norm at iteration 5801 : 0.25446254\n", + "Norm at iteration 5811 : 0.25357497\n", + "Norm at iteration 5821 : 0.2526146\n", + "Norm at iteration 5831 : 0.25156394\n", + "Norm at iteration 5841 : 0.25049716\n", + "Norm at iteration 5851 : 0.24941978\n", + "Norm at iteration 5861 : 0.24835593\n", + "Norm at iteration 5871 : 0.24736127\n", + "Norm at iteration 5881 : 0.24644473\n", + "Norm at iteration 5891 : 0.24567473\n", + "Norm at iteration 5901 : 0.24496925\n", + "Norm at iteration 5911 : 0.24440837\n", + "Norm at iteration 5921 : 0.2438947\n", + "Norm at iteration 5931 : 0.24344346\n", + "Norm at iteration 5941 : 0.24302718\n", + "Norm at iteration 5951 : 0.24256068\n", + "Norm at iteration 5961 : 0.24209091\n", + "Norm at iteration 5971 : 0.24161999\n", + "Norm at iteration 5981 : 0.241014\n", + "Norm at iteration 5991 : 0.23973966\n", + "Norm at iteration 6001 : 0.23814917\n", + "Norm at iteration 6011 : 0.23668462\n", + "Norm at iteration 6021 : 0.2353359\n", + "Norm at iteration 6031 : 0.23416017\n", + "Norm at iteration 6041 : 0.23316312\n", + "Norm at iteration 6051 : 0.23235181\n", + "Norm at iteration 6061 : 0.2317106\n", + "Norm at iteration 6071 : 0.2312239\n", + "Norm at iteration 6081 : 0.23061758\n", + "Norm at iteration 6091 : 0.22993489\n", + "Norm at iteration 6101 : 0.2291733\n", + "Norm at iteration 6111 : 0.22832045\n", + "Norm at iteration 6121 : 0.22740287\n", + "Norm at iteration 6131 : 0.22644034\n", + "Norm at iteration 6141 : 0.22546062\n", + "Norm at iteration 6151 : 0.22448745\n", + "Norm at iteration 6161 : 0.22353858\n", + "Norm at iteration 6171 : 0.2226441\n", + "Norm at iteration 6181 : 0.22181644\n", + "Norm at iteration 6191 : 0.2210674\n", + "Norm at iteration 6201 : 0.22039726\n", + "Norm at iteration 6211 : 0.2198097\n", + "Norm at iteration 6221 : 0.21924308\n", + "Norm at iteration 6231 : 0.21869588\n", + "Norm at iteration 6241 : 0.21815638\n", + "Norm at iteration 6251 : 0.21760309\n", + "Norm at iteration 6261 : 0.21704529\n", + "Norm at iteration 6271 : 0.21645394\n", + "Norm at iteration 6281 : 0.21582955\n", + "Norm at iteration 6291 : 0.21519688\n", + "Norm at iteration 6301 : 0.21458212\n", + "Norm at iteration 6311 : 0.21399821\n", + "Norm at iteration 6321 : 0.21347505\n", + "Norm at iteration 6331 : 0.213013\n", + "Norm at iteration 6341 : 0.21262032\n", + "Norm at iteration 6351 : 0.21229751\n", + "Norm at iteration 6361 : 0.21202627\n", + "Norm at iteration 6371 : 0.21177498\n", + "Norm at iteration 6381 : 0.21150142\n", + "Norm at iteration 6391 : 0.21122986\n", + "Norm at iteration 6401 : 0.21085536\n", + "Norm at iteration 6411 : 0.21037742\n", + "Norm at iteration 6421 : 0.20978811\n", + "Norm at iteration 6431 : 0.20893966\n", + "Norm at iteration 6441 : 0.20796368\n", + "Norm at iteration 6451 : 0.20688516\n", + "Norm at iteration 6461 : 0.20575996\n", + "Norm at iteration 6471 : 0.20459798\n", + "Norm at iteration 6481 : 0.20348994\n", + "Norm at iteration 6491 : 0.20258187\n", + "Norm at iteration 6501 : 0.2017959\n", + "Norm at iteration 6511 : 0.20111209\n", + "Norm at iteration 6521 : 0.2005303\n", + "Norm at iteration 6531 : 0.20003721\n", + "Norm at iteration 6541 : 0.1996012\n", + "Norm at iteration 6551 : 0.19919315\n", + "Norm at iteration 6561 : 0.1985657\n", + "Norm at iteration 6571 : 0.19759697\n", + "Norm at iteration 6581 : 0.19654757\n", + "Norm at iteration 6591 : 0.19544917\n", + "Norm at iteration 6601 : 0.19432378\n", + "Norm at iteration 6611 : 0.19321\n", + "Norm at iteration 6621 : 0.19215038\n", + "Norm at iteration 6631 : 0.19132587\n", + "Norm at iteration 6641 : 0.19074327\n", + "Norm at iteration 6651 : 0.19025579\n", + "Norm at iteration 6661 : 0.18986116\n", + "Norm at iteration 6671 : 0.18951458\n", + "Norm at iteration 6681 : 0.18925768\n", + "Norm at iteration 6691 : 0.18889469\n", + "Norm at iteration 6701 : 0.18854687\n", + "Norm at iteration 6711 : 0.18817538\n", + "Norm at iteration 6721 : 0.18775871\n", + "Norm at iteration 6731 : 0.18728894\n", + "Norm at iteration 6741 : 0.18677092\n", + "Norm at iteration 6751 : 0.1861955\n", + "Norm at iteration 6761 : 0.18557167\n", + "Norm at iteration 6771 : 0.1849065\n", + "Norm at iteration 6781 : 0.18421006\n", + "Norm at iteration 6791 : 0.18350834\n", + "Norm at iteration 6801 : 0.18282643\n", + "Norm at iteration 6811 : 0.1821947\n", + "Norm at iteration 6821 : 0.1816898\n", + "Norm at iteration 6831 : 0.18115625\n", + "Norm at iteration 6841 : 0.18070886\n", + "Norm at iteration 6851 : 0.18031588\n", + "Norm at iteration 6861 : 0.17995793\n", + "Norm at iteration 6871 : 0.17960057\n", + "Norm at iteration 6881 : 0.17924096\n", + "Norm at iteration 6891 : 0.17885487\n", + "Norm at iteration 6901 : 0.17844054\n", + "Norm at iteration 6911 : 0.17799157\n", + "Norm at iteration 6921 : 0.17750624\n", + "Norm at iteration 6931 : 0.17698939\n", + "Norm at iteration 6941 : 0.17649156\n", + "Norm at iteration 6951 : 0.17601222\n", + "Norm at iteration 6961 : 0.1756011\n", + "Norm at iteration 6971 : 0.17517671\n", + "Norm at iteration 6981 : 0.17484975\n", + "Norm at iteration 6991 : 0.17458639\n", + "Norm at iteration 7001 : 0.17437698\n", + "Norm at iteration 7011 : 0.17419595\n", + "Norm at iteration 7021 : 0.17402159\n", + "Norm at iteration 7031 : 0.17382678\n", + "Norm at iteration 7041 : 0.17358944\n", + "Norm at iteration 7051 : 0.17336245\n", + "Norm at iteration 7061 : 0.17298284\n", + "Norm at iteration 7071 : 0.17254427\n", + "Norm at iteration 7081 : 0.17203265\n", + "Norm at iteration 7091 : 0.17149064\n", + "Norm at iteration 7101 : 0.17090373\n", + "Norm at iteration 7111 : 0.1703423\n", + "Norm at iteration 7121 : 0.16979715\n", + "Norm at iteration 7131 : 0.1693021\n", + "Norm at iteration 7141 : 0.16887848\n", + "Norm at iteration 7151 : 0.16850153\n", + "Norm at iteration 7161 : 0.16816384\n", + "Norm at iteration 7171 : 0.16784576\n", + "Norm at iteration 7181 : 0.16732758\n", + "Norm at iteration 7191 : 0.16657522\n", + "Norm at iteration 7201 : 0.16573939\n", + "Norm at iteration 7211 : 0.16487536\n", + "Norm at iteration 7221 : 0.16397017\n", + "Norm at iteration 7231 : 0.16303875\n", + "Norm at iteration 7241 : 0.16212437\n", + "Norm at iteration 7251 : 0.1616112\n", + "Norm at iteration 7261 : 0.1611372\n", + "Norm at iteration 7271 : 0.16070306\n", + "Norm at iteration 7281 : 0.16032058\n", + "Norm at iteration 7291 : 0.15998754\n", + "Norm at iteration 7301 : 0.15971443\n", + "Norm at iteration 7311 : 0.1594859\n", + "Norm at iteration 7321 : 0.15918991\n", + "Norm at iteration 7331 : 0.1589329\n", + "Norm at iteration 7341 : 0.15874627\n", + "Norm at iteration 7351 : 0.15851536\n", + "Norm at iteration 7361 : 0.15823877\n", + "Norm at iteration 7371 : 0.157753\n", + "Norm at iteration 7381 : 0.15718098\n", + "Norm at iteration 7391 : 0.15657926\n", + "Norm at iteration 7401 : 0.15595293\n", + "Norm at iteration 7411 : 0.15531495\n", + "Norm at iteration 7421 : 0.15470055\n", + "Norm at iteration 7431 : 0.15404823\n", + "Norm at iteration 7441 : 0.15355742\n", + "Norm at iteration 7451 : 0.15314718\n", + "Norm at iteration 7461 : 0.15278071\n", + "Norm at iteration 7471 : 0.15247191\n", + "Norm at iteration 7481 : 0.15220511\n", + "Norm at iteration 7491 : 0.15194255\n", + "Norm at iteration 7501 : 0.15171252\n", + "Norm at iteration 7511 : 0.15146032\n", + "Norm at iteration 7521 : 0.15119568\n", + "Norm at iteration 7531 : 0.15087536\n", + "Norm at iteration 7541 : 0.15051079\n", + "Norm at iteration 7551 : 0.15012561\n", + "Norm at iteration 7561 : 0.14970645\n", + "Norm at iteration 7571 : 0.14927432\n", + "Norm at iteration 7581 : 0.14883205\n", + "Norm at iteration 7591 : 0.14839885\n", + "Norm at iteration 7601 : 0.14799818\n", + "Norm at iteration 7611 : 0.14765686\n", + "Norm at iteration 7621 : 0.14733642\n", + "Norm at iteration 7631 : 0.14708507\n", + "Norm at iteration 7641 : 0.14687389\n", + "Norm at iteration 7651 : 0.14669286\n", + "Norm at iteration 7661 : 0.14652067\n", + "Norm at iteration 7671 : 0.14633441\n", + "Norm at iteration 7681 : 0.14611602\n", + "Norm at iteration 7691 : 0.14584987\n", + "Norm at iteration 7701 : 0.14552787\n", + "Norm at iteration 7711 : 0.1451366\n", + "Norm at iteration 7721 : 0.14469767\n", + "Norm at iteration 7731 : 0.14421223\n", + "Norm at iteration 7741 : 0.14369851\n", + "Norm at iteration 7751 : 0.14319104\n", + "Norm at iteration 7761 : 0.1426972\n", + "Norm at iteration 7771 : 0.14224456\n", + "Norm at iteration 7781 : 0.14183283\n", + "Norm at iteration 7791 : 0.14147475\n", + "Norm at iteration 7801 : 0.14115566\n", + "Norm at iteration 7811 : 0.14068133\n", + "Norm at iteration 7821 : 0.14019024\n", + "Norm at iteration 7831 : 0.13966824\n", + "Norm at iteration 7841 : 0.13911197\n", + "Norm at iteration 7851 : 0.1385225\n", + "Norm at iteration 7861 : 0.13794461\n", + "Norm at iteration 7871 : 0.13754344\n", + "Norm at iteration 7881 : 0.13712452\n", + "Norm at iteration 7891 : 0.13668323\n", + "Norm at iteration 7901 : 0.13624844\n", + "Norm at iteration 7911 : 0.13583401\n", + "Norm at iteration 7921 : 0.13544488\n", + "Norm at iteration 7931 : 0.13509706\n", + "Norm at iteration 7941 : 0.13478789\n", + "Norm at iteration 7951 : 0.13451754\n", + "Norm at iteration 7961 : 0.13427848\n", + "Norm at iteration 7971 : 0.13410299\n", + "Norm at iteration 7981 : 0.13392602\n", + "Norm at iteration 7991 : 0.13370728\n", + "Norm at iteration 8001 : 0.13345823\n", + "Norm at iteration 8011 : 0.13317913\n", + "Norm at iteration 8021 : 0.1328451\n", + "Norm at iteration 8031 : 0.13247225\n", + "Norm at iteration 8041 : 0.13205859\n", + "Norm at iteration 8051 : 0.13161987\n", + "Norm at iteration 8061 : 0.13116974\n", + "Norm at iteration 8071 : 0.1307083\n", + "Norm at iteration 8081 : 0.1302969\n", + "Norm at iteration 8091 : 0.12988149\n", + "Norm at iteration 8101 : 0.12950936\n", + "Norm at iteration 8111 : 0.1291673\n", + "Norm at iteration 8121 : 0.12885752\n", + "Norm at iteration 8131 : 0.12857497\n", + "Norm at iteration 8141 : 0.12829557\n", + "Norm at iteration 8151 : 0.1280296\n", + "Norm at iteration 8161 : 0.12774928\n", + "Norm at iteration 8171 : 0.12745646\n", + "Norm at iteration 8181 : 0.12713408\n", + "Norm at iteration 8191 : 0.12678877\n", + "Norm at iteration 8201 : 0.12642628\n", + "Norm at iteration 8211 : 0.12605105\n", + "Norm at iteration 8221 : 0.12567051\n", + "Norm at iteration 8231 : 0.12529346\n", + "Norm at iteration 8241 : 0.12493794\n", + "Norm at iteration 8251 : 0.12460638\n", + "Norm at iteration 8261 : 0.12430899\n", + "Norm at iteration 8271 : 0.12404394\n", + "Norm at iteration 8281 : 0.123813726\n", + "Norm at iteration 8291 : 0.12360312\n", + "Norm at iteration 8301 : 0.12340776\n", + "Norm at iteration 8311 : 0.1232179\n", + "Norm at iteration 8321 : 0.12302046\n", + "Norm at iteration 8331 : 0.122805215\n", + "Norm at iteration 8341 : 0.12255863\n", + "Norm at iteration 8351 : 0.1222763\n", + "Norm at iteration 8361 : 0.12195487\n", + "Norm at iteration 8371 : 0.12161985\n", + "Norm at iteration 8381 : 0.121254936\n", + "Norm at iteration 8391 : 0.12087593\n", + "Norm at iteration 8401 : 0.12049137\n", + "Norm at iteration 8411 : 0.12011759\n", + "Norm at iteration 8421 : 0.11975008\n", + "Norm at iteration 8431 : 0.11940437\n", + "Norm at iteration 8441 : 0.11908239\n", + "Norm at iteration 8451 : 0.11877112\n", + "Norm at iteration 8461 : 0.1184946\n", + "Norm at iteration 8471 : 0.11822398\n", + "Norm at iteration 8481 : 0.11795448\n", + "Norm at iteration 8491 : 0.11767243\n", + "Norm at iteration 8501 : 0.11738497\n", + "Norm at iteration 8511 : 0.117076084\n", + "Norm at iteration 8521 : 0.11674995\n", + "Norm at iteration 8531 : 0.11640866\n", + "Norm at iteration 8541 : 0.116061196\n", + "Norm at iteration 8551 : 0.11569997\n", + "Norm at iteration 8561 : 0.11535145\n", + "Norm at iteration 8571 : 0.11500776\n", + "Norm at iteration 8581 : 0.1146913\n", + "Norm at iteration 8591 : 0.11438149\n", + "Norm at iteration 8601 : 0.114113316\n", + "Norm at iteration 8611 : 0.113882706\n", + "Norm at iteration 8621 : 0.1137052\n", + "Norm at iteration 8631 : 0.11348722\n", + "Norm at iteration 8641 : 0.11331564\n", + "Norm at iteration 8651 : 0.11313765\n", + "Norm at iteration 8661 : 0.11295321\n", + "Norm at iteration 8671 : 0.11275478\n", + "Norm at iteration 8681 : 0.112533376\n", + "Norm at iteration 8691 : 0.11229293\n", + "Norm at iteration 8701 : 0.112035014\n", + "Norm at iteration 8711 : 0.11175494\n", + "Norm at iteration 8721 : 0.111462265\n", + "Norm at iteration 8731 : 0.11116794\n", + "Norm at iteration 8741 : 0.11088309\n", + "Norm at iteration 8751 : 0.11060369\n", + "Norm at iteration 8761 : 0.110330105\n", + "Norm at iteration 8771 : 0.11007163\n", + "Norm at iteration 8781 : 0.109831914\n", + "Norm at iteration 8791 : 0.10960511\n", + "Norm at iteration 8801 : 0.10938073\n", + "Norm at iteration 8811 : 0.10916728\n", + "Norm at iteration 8821 : 0.10895076\n", + "Norm at iteration 8831 : 0.10872653\n", + "Norm at iteration 8841 : 0.108489096\n", + "Norm at iteration 8851 : 0.10822876\n", + "Norm at iteration 8861 : 0.10796778\n", + "Norm at iteration 8871 : 0.10768144\n", + "Norm at iteration 8881 : 0.107395925\n", + "Norm at iteration 8891 : 0.107104875\n", + "Norm at iteration 8901 : 0.106814474\n", + "Norm at iteration 8911 : 0.106543824\n", + "Norm at iteration 8921 : 0.10628585\n", + "Norm at iteration 8931 : 0.10605201\n", + "Norm at iteration 8941 : 0.10584274\n", + "Norm at iteration 8951 : 0.105650246\n", + "Norm at iteration 8961 : 0.105478674\n", + "Norm at iteration 8971 : 0.105320334\n", + "Norm at iteration 8981 : 0.10516471\n", + "Norm at iteration 8991 : 0.10500437\n", + "Norm at iteration 9001 : 0.10483136\n", + "Norm at iteration 9011 : 0.10463618\n", + "Norm at iteration 9021 : 0.1044122\n", + "Norm at iteration 9031 : 0.104157254\n", + "Norm at iteration 9041 : 0.103922784\n", + "Norm at iteration 9051 : 0.10368067\n", + "Norm at iteration 9061 : 0.10343029\n", + "Norm at iteration 9071 : 0.10318132\n", + "Norm at iteration 9081 : 0.1029277\n", + "Norm at iteration 9091 : 0.10268101\n", + "Norm at iteration 9101 : 0.102440625\n", + "Norm at iteration 9111 : 0.10220656\n", + "Norm at iteration 9121 : 0.10198296\n", + "Norm at iteration 9131 : 0.101753935\n", + "Norm at iteration 9141 : 0.10153105\n", + "Norm at iteration 9151 : 0.10130931\n", + "Norm at iteration 9161 : 0.101079464\n", + "Norm at iteration 9171 : 0.10083361\n", + "Norm at iteration 9181 : 0.10057069\n", + "Norm at iteration 9191 : 0.10030021\n", + "Norm at iteration 9201 : 0.10001476\n", + "Norm at iteration 9211 : 0.09971644\n", + "Norm at iteration 9221 : 0.099420436\n", + "Norm at iteration 9231 : 0.09912683\n", + "Norm at iteration 9241 : 0.098845124\n", + "Norm at iteration 9251 : 0.098569304\n", + "Norm at iteration 9261 : 0.098320425\n", + "Norm at iteration 9271 : 0.098092705\n", + "Norm at iteration 9281 : 0.097887844\n", + "Norm at iteration 9291 : 0.097702235\n", + "Norm at iteration 9301 : 0.09753434\n", + "Norm at iteration 9311 : 0.09738013\n", + "Norm at iteration 9321 : 0.09722148\n", + "Norm at iteration 9331 : 0.0970622\n", + "Norm at iteration 9341 : 0.0968976\n", + "Norm at iteration 9351 : 0.09673044\n", + "Norm at iteration 9361 : 0.09654565\n", + "Norm at iteration 9371 : 0.09634797\n", + "Norm at iteration 9381 : 0.09614185\n", + "Norm at iteration 9391 : 0.09592737\n", + "Norm at iteration 9401 : 0.09571611\n", + "Norm at iteration 9411 : 0.09550777\n", + "Norm at iteration 9421 : 0.095305696\n", + "Norm at iteration 9431 : 0.09510274\n", + "Norm at iteration 9441 : 0.094910294\n", + "Norm at iteration 9451 : 0.094727814\n", + "Norm at iteration 9461 : 0.094552875\n", + "Norm at iteration 9471 : 0.09437448\n", + "Norm at iteration 9481 : 0.09419088\n", + "Norm at iteration 9491 : 0.09400058\n", + "Norm at iteration 9501 : 0.09379647\n", + "Norm at iteration 9511 : 0.09356733\n", + "Norm at iteration 9521 : 0.09332456\n", + "Norm at iteration 9531 : 0.09305923\n", + "Norm at iteration 9541 : 0.09278476\n", + "Norm at iteration 9551 : 0.092497334\n", + "Norm at iteration 9561 : 0.092209\n", + "Norm at iteration 9571 : 0.09192479\n", + "Norm at iteration 9581 : 0.09165494\n", + "Norm at iteration 9591 : 0.0914003\n", + "Norm at iteration 9601 : 0.091170266\n", + "Norm at iteration 9611 : 0.09096375\n", + "Norm at iteration 9621 : 0.090781085\n", + "Norm at iteration 9631 : 0.09061642\n", + "Norm at iteration 9641 : 0.09046899\n", + "Norm at iteration 9651 : 0.09032482\n", + "Norm at iteration 9661 : 0.09018423\n", + "Norm at iteration 9671 : 0.090037934\n", + "Norm at iteration 9681 : 0.08988094\n", + "Norm at iteration 9691 : 0.08971612\n", + "Norm at iteration 9701 : 0.089533016\n", + "Norm at iteration 9711 : 0.089339726\n", + "Norm at iteration 9721 : 0.08913033\n", + "Norm at iteration 9731 : 0.0889193\n", + "Norm at iteration 9741 : 0.088705\n", + "Norm at iteration 9751 : 0.08848807\n", + "Norm at iteration 9761 : 0.088295236\n", + "Norm at iteration 9771 : 0.08810331\n", + "Norm at iteration 9781 : 0.087918386\n", + "Norm at iteration 9791 : 0.08774455\n", + "Norm at iteration 9801 : 0.08758071\n", + "Norm at iteration 9811 : 0.08740972\n", + "Norm at iteration 9821 : 0.08723126\n", + "Norm at iteration 9831 : 0.08703367\n", + "Norm at iteration 9841 : 0.0868173\n", + "Norm at iteration 9851 : 0.086579874\n", + "Norm at iteration 9861 : 0.086336225\n", + "Norm at iteration 9871 : 0.08606808\n", + "Norm at iteration 9881 : 0.0857815\n", + "Norm at iteration 9891 : 0.08548427\n", + "Norm at iteration 9901 : 0.085198045\n", + "Norm at iteration 9911 : 0.084916696\n", + "Norm at iteration 9921 : 0.08465523\n", + "Norm at iteration 9931 : 0.08442111\n", + "Norm at iteration 9941 : 0.084213436\n", + "Norm at iteration 9951 : 0.0840376\n", + "Norm at iteration 9961 : 0.083883986\n", + "Norm at iteration 9971 : 0.08375014\n", + "Norm at iteration 9981 : 0.08363238\n", + "Norm at iteration 9991 : 0.083518095\n" + ] + } + ], + "source": [ + "x,y, mu, nu = get_data(d=1, n_samples=n_samples)\n", + "filling_points = get_filling_points(d=1, n_samples=n_samples)\n", + "\n", + "w, q2, w_mu_hat, w_nu_hat, residuals, exec_time_SSN = SSN(x, y, filling_points, tau, nb_iter=10000)\n", + "v, exec_time_EG = EG(x, y, filling_points, tau, nb_iter=10000)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "gamma_SSN, X_SSN = w\n", + "OT_hat_SSN = q2/(2*lambda2) - 1/(2*lambda2) * jnp.sum(gamma_SSN * (w_mu_hat + w_nu_hat))\n", + "\n", + "gamma_EG, X_EG = v\n", + "OT_hat_EG = q2/(2*lambda2) - 1/(2*lambda2) * jnp.sum(gamma_EG * (w_mu_hat + w_nu_hat))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import ott\n", + "from ott.geometry import pointcloud\n", + "from ott.problems.linear import linear_problem\n", + "from ott.solvers.linear import sinkhorn" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "geom = pointcloud.PointCloud(x, y)\n", + "prob = linear_problem.LinearProblem(geom)\n", + "solver = sinkhorn.Sinkhorn()\n", + "out = solver(prob)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-6.4067736\n", + "-6.464632\n", + "0.011515081\n" + ] + } + ], + "source": [ + "print(OT_hat_SSN)\n", + "print(OT_hat_EG)\n", + "print(out.reg_ot_cost)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, the estimator for the Wasserstein distance is negative, which should not be possible. We can also see that the code malfunctions when retrieving the eigenvalues from $\\sum_i \\hat{\\gamma}_i \\Phi_i \\Phi_i^T + \\lambda_1 I$, because some of these are negative, when they should all be positive at all time." + ] + } + ], + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}