roam_best_vs_weighted.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba76ab6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# importing the necessary libraries:\n",
    "# NumPy, SciPy (optimization), \n",
    "# multiprocessing features for speed-ups, and also\n",
    "# plotting functions, and a handler for csv files\n",
    "#\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.optimize as opt\n",
    "import multiprocess as mp\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5ef45a88",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Number of CPU cores\n",
    "#\n",
    "CPU_COUNT = mp.cpu_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e3944ea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Centering a point cloud X\n",
    "#\n",
    "def barycentered(X):\n",
    "    #\n",
    "    bar = np.sum(X, axis=1)/X.shape[1]\n",
    "    #\n",
    "    return X - bar[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f1f516a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# First constructing a random psd matrix with specified condition number,\n",
    "# then multiplying it by a random orthogonal matrix \n",
    "#\n",
    "# Bierlaire, M., Toint, P., and Tuyttens, D. (1991). \n",
    "# On iterative algorithms for linear ls problems with bound constraints. \n",
    "# Linear Algebra and Its Applications, 143, 111–143.\n",
    "#\n",
    "def rand_mat_cond(dim=3, cond=5.0):\n",
    "    #\n",
    "    log_cond = np.log(cond)\n",
    "    exp_vec = np.arange(-log_cond/4.0, log_cond * (dim + 1)/(4 * (dim - 1)),\\\n",
    "                                                                    log_cond/(2.0*(dim-1)))\n",
    "    D = np.diag(np.exp(exp_vec[:dim]))\n",
    "    U, _ = np.linalg.qr((np.random.rand(dim,dim) - 5.0) * 200)\n",
    "    V, _ = np.linalg.qr((np.random.rand(dim,dim) - 5.0) * 200)\n",
    "    P = U @ D @ V.T\n",
    "    P = P @ P.T\n",
    "    #\n",
    "    seed = np.random.normal(0.0, 1.0, (dim,dim))\n",
    "    O, _ = np.linalg.qr(seed, mode='complete')\n",
    "    if np.linalg.det(O) < 0:\n",
    "        O = O @ np.diag([1]*(dim-1)+[-1])\n",
    "    #\n",
    "    M = P @ O\n",
    "    #\n",
    "    return M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "be1bda9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Orthogonal projection onto ker X: R^n -> R^d (generically dim ker X = n-d)\n",
    "#\n",
    "def ortho_proj_ker(X):\n",
    "    #\n",
    "    Ux, Sigmax, Vx = np.linalg.svd(X)\n",
    "    rank = Sigmax.shape[0]\n",
    "    ker = Vx[:rank]\n",
    "    proj = ker.T @ ker\n",
    "    #\n",
    "    return proj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fbab8583",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Relative Hamming distance between two permutation matrices of size mat_size\n",
    "#\n",
    "def hamming_dist(s1, s2, mat_size):\n",
    "    return np.linalg.norm(s1 - s2, 'fro')**2 / (2*mat_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8ec71070",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First trying to choose the best feature matching among the number of probabilistic trials n_iter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "862f8ce0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Running tests for the setting of multiplicative noise with point discrepancy\n",
    "\n",
    "num_tests  = number of tests per batch (default 100)\n",
    "num_points = number of points per random cloud generated (default 100)\n",
    "dim = dimension (default 3)\n",
    "sigma  = noise level, for N(1, \\sigma^2) noise\n",
    "level  = discrepancy level in (0,1], with 0 = all points removed, 1 = all points present\n",
    "cond   = condition number of random linear map (default 3.0)\n",
    "n_iter = number of trials for probabilistic voting (default 2**10)\n",
    "\"\"\"\n",
    "\n",
    "def test_feature_matching_best(num_tests=100, num_points=100, dim=3, sigma=0.1, level=0.95, cond=3.0, n_iter=2**10):\n",
    "    #\n",
    "    noise_list_best  = []\n",
    "    disc_X_list_best = []\n",
    "    err_L_list_best  = []\n",
    "    err_Y_list_best  = []\n",
    "    err_X_list_best  = []\n",
    "    hamming_dist_list_best = []\n",
    "    #\n",
    "    for count in tqdm(range(num_tests)):\n",
    "        #\n",
    "        X0 = np.random.uniform(low=-1.0, high=1.0, size=(3, num_points))\n",
    "        X0 = barycentered(X0)\n",
    "        dim, num_y = X0.shape\n",
    "        #\n",
    "        num_x = int(level * num_y)\n",
    "        ind = np.random.default_rng().choice(num_y, size=num_x, replace=False)\n",
    "        ind = ind[np.argsort(ind)] # need to sort to be able to compare permutations later on\n",
    "        X = X0[:, ind]\n",
    "        X = barycentered(X)\n",
    "        #\n",
    "        assert(num_x <= num_y)\n",
    "        #\n",
    "        dX = X0[:, np.setdiff1d(np.arange(num_y), ind)]\n",
    "        if dX.shape[1]>0:\n",
    "            disc_X = np.linalg.norm(dX, 2) / np.linalg.norm(X0, 2)\n",
    "        else:\n",
    "            disc_X = .0\n",
    "        disc_X_list_best += [disc_X]\n",
    "        #\n",
    "        #print(\"Dimension = {}, number of points: {} vs {}\".format(dim, num_x, num_y))\n",
    "        #print(\"Relative discrepancy = {}\".format(disc_X))\n",
    "        #\n",
    "        I = np.identity(num_y)\n",
    "        #\n",
    "        L  = rand_mat_cond(dim, cond)\n",
    "        #\n",
    "        S  = np.random.default_rng().permutation(I)\n",
    "        #\n",
    "        N  = np.random.normal(1, sigma, (dim, num_y))\n",
    "        #\n",
    "        Y0 = L @ X0 @ S\n",
    "        Y  = N * Y0\n",
    "        Y  = barycentered(Y)\n",
    "        #\n",
    "        noise = np.linalg.norm(Y - Y0, 2) / np.linalg.norm(Y0, 2)\n",
    "        noise_list_best += [noise]\n",
    "        #print(\"Noise = {}\".format(noise))\n",
    "        #\n",
    "        Px = ortho_proj_ker(X)\n",
    "        o  = np.zeros((num_y-num_x, num_y-num_x))\n",
    "        oo = np.zeros((num_y-num_x, num_x))\n",
    "        Px = np.block([[Px, oo.T],[oo, o]])\n",
    "        Py = ortho_proj_ker(Y)\n",
    "        #\n",
    "        def f_opt(i):\n",
    "            np.random.seed(i) # reseed to avoid races for the RNG\n",
    "            sol = opt.quadratic_assignment(Px, Py, method=\"faq\", options = {'maximize':True, 'P0':'randomized', 'tol':1e-3})\n",
    "            ind = sol['col_ind']\n",
    "            s = I[ind]\n",
    "            return s, i\n",
    "        #\n",
    "        with mp.Pool(CPU_COUNT, maxtasksperchild=int(100)) as pool:\n",
    "            vals = pool.map(f_opt, range(n_iter))\n",
    "        #\n",
    "        def sort_key(v):\n",
    "            s = v[0]\n",
    "            return np.linalg.norm(Px - s @ Py @ s.T, 2)\n",
    "        #\n",
    "        mat, _ = sorted(vals, key=sort_key)[0]\n",
    "        #\n",
    "        col_ind = np.argmax(mat, axis=1)\n",
    "        h_dist = hamming_dist(I[col_ind], S, num_y)\n",
    "        hamming_dist_list_best += [h_dist]\n",
    "        #print(\"Hamming distance between original and recovered permutations: {}\".format(h_dist))\n",
    "        #\n",
    "        L0 = Y[:, col_ind][:, :num_x] @ X.T @ np.linalg.inv(X @ X.T)\n",
    "        #\n",
    "        err_L = np.linalg.norm(L0 - L, 2) / np.linalg.norm(L, 2)\n",
    "        err_L_list_best += [err_L]\n",
    "        #\n",
    "        #print(\"Relative error in L = err_L = {}\".format(err_L))\n",
    "        #\n",
    "        err_Y = np.linalg.norm(L @ X - L0 @ X, 2) / np.linalg.norm(L @ X, 2)\n",
    "        err_Y_list_best += [err_Y]\n",
    "        #\n",
    "        #print(\"Relative error in matching images err_Y = {}\".format(err_Y))\n",
    "        #\n",
    "        X_pre = np.linalg.inv(L0) @ Y[:, col_ind][:, :num_x]    \n",
    "        err_X = np.linalg.norm(X - X_pre, 2) / np.linalg.norm(X, 2)\n",
    "        err_X_list_best += [err_X]\n",
    "        #\n",
    "        #print(\"Relative error in matching inverse images err_X = {}\".format(err_X))\n",
    "        #\n",
    "        #print(\"err_X : err_Y = {} ~ {} = cond(L)\".format(err_X / err_Y, cond))\n",
    "        #\n",
    "        #img  = point3d(X.T, color='yellow', size=2)\n",
    "        #img += point3d(X_pre.T, color='red', size=2)\n",
    "        #img += point3d(dX.T, color='blue', size=4)\n",
    "        #img.plot().show()\n",
    "        #\n",
    "    noise_list_best  = np.array(noise_list_best)\n",
    "    disc_X_list_best = np.array(disc_X_list_best)\n",
    "    err_L_list_best  = np.array(err_L_list_best)\n",
    "    err_Y_list_best  = np.array(err_Y_list_best)\n",
    "    err_X_list_best  = np.array(err_X_list_best)\n",
    "    hamming_dist_list_best = np.array(hamming_dist_list_best)\n",
    "    #\n",
    "    output = {}\n",
    "    output['num_x']  = num_x\n",
    "    output['num_y']  = num_y \n",
    "    output['noise']  = (noise_list_best.mean(), noise_list_best.std())\n",
    "    output['disc_X'] = (disc_X_list_best.mean(), disc_X_list_best.std())\n",
    "    output['err_L']  = (err_L_list_best.mean(), err_L_list_best.std())\n",
    "    output['err_Y']  = (err_Y_list_best.mean(), err_Y_list_best.std())\n",
    "    output['err_X']  = (err_X_list_best.mean(), err_X_list_best.std())\n",
    "    output['h_dist'] = (hamming_dist_list_best.mean(), hamming_dist_list_best.std())\n",
    "    #\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "54a939dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Second computing the weighted feature matching from n_iter probabilistic trials "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "41a4faa8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Running tests for the setting of multiplicative noise with point discrepancy\n",
    "\n",
    "num_tests  = number of tests per batch (default 100)\n",
    "num_points = number of points per random cloud generated (default 100)\n",
    "dim = dimension (default 3)\n",
    "sigma  = noise level, for N(1, \\sigma^2) noise\n",
    "level  = discrepancy level in (0,1], with 0 = all points removed, 1 = all points present\n",
    "cond   = condition number of random linear map (default 3.0)\n",
    "n_iter = number of trials for probabilistic voting (default 2**10)\n",
    "\"\"\"\n",
    "\n",
    "def test_feature_matching_weighted(num_tests=100, num_points=100, dim=3, sigma=0.1, level=0.95, cond=3.0, n_iter=2**10):\n",
    "    #\n",
    "    noise_list_weighted  = []\n",
    "    disc_X_list_weighted = []\n",
    "    err_L_list_weighted  = []\n",
    "    err_Y_list_weighted  = []\n",
    "    err_X_list_weighted  = []\n",
    "    hamming_dist_list_weighted = []\n",
    "    #\n",
    "    for count in tqdm(range(num_tests)):\n",
    "        #\n",
    "        X0 = np.random.uniform(low=-1.0, high=2.0, size=(dim, num_points))\n",
    "        X0 = barycentered(X0)\n",
    "        dim, num_y = X0.shape\n",
    "        #\n",
    "        num_x = int(level * num_y)\n",
    "        ind = np.random.default_rng().choice(num_y, size=num_x, replace=False)\n",
    "        ind = ind[np.argsort(ind)] # need to sort to be able to compare permutations later on\n",
    "        X = X0[:, ind]\n",
    "        X = barycentered(X)\n",
    "        #\n",
    "        assert(num_x <= num_y)\n",
    "        #\n",
    "        dX = X0[:, np.setdiff1d(np.arange(num_y), ind)]\n",
    "        #\n",
    "        if dX.shape[1]>0:\n",
    "            disc_X = np.linalg.norm(dX, 2) / np.linalg.norm(X0, 2)\n",
    "        else:\n",
    "            disc_X = .0\n",
    "        #\n",
    "        disc_X_list_weighted += [disc_X]\n",
    "        #\n",
    "        #print(\"Dimension = {}, number of points: {} vs {}\".format(dim, num_x, num_y))\n",
    "        #print(\"Relative discrepancy = {}\".format(disc_X))\n",
    "        #\n",
    "        I = np.identity(num_y)\n",
    "        #\n",
    "        L  = rand_mat_cond(dim, cond)\n",
    "        #\n",
    "        S  = np.random.default_rng().permutation(I)\n",
    "        #\n",
    "        N  = np.random.normal(1, sigma, (dim, num_y))\n",
    "        #\n",
    "        Y0 = L @ X0 @ S\n",
    "        Y  = N * Y0\n",
    "        Y  = barycentered(Y)\n",
    "        #\n",
    "        noise = np.linalg.norm(Y - Y0, 2) / np.linalg.norm(Y0, 2)\n",
    "        noise_list_weighted += [noise]\n",
    "        #print(\"Noise = {}\".format(noise))\n",
    "        #\n",
    "        Px = ortho_proj_ker(X)\n",
    "        o  = np.zeros((num_y-num_x, num_y-num_x))\n",
    "        oo = np.zeros((num_y-num_x, num_x))\n",
    "        Px = np.block([[Px, oo.T],[oo, o]])\n",
    "        Py = ortho_proj_ker(Y)\n",
    "        #\n",
    "        def f_opt(i):\n",
    "            np.random.seed(i) # reseed to avoid races for the RNG\n",
    "            sol = opt.quadratic_assignment(Px, Py, method=\"faq\", options = {'maximize':True, 'P0':'randomized', 'tol':1e-3})\n",
    "            ind = sol['col_ind']\n",
    "            s = I[ind]\n",
    "            weight = np.exp(-1000.0*(np.trace(Px @ s @ Py @ s.T) - dim)**2)\n",
    "            return weight, s, i\n",
    "        #\n",
    "        with mp.Pool(CPU_COUNT, maxtasksperchild=int(100)) as pool:\n",
    "            vals = pool.map(f_opt, range(n_iter))\n",
    "        #\n",
    "        mat = sum([v[0]*v[1] for v in vals])\n",
    "        #\n",
    "        row_ind, col_ind = opt.linear_sum_assignment(mat, maximize=True)\n",
    "        #\n",
    "        h_dist = hamming_dist(I[col_ind], S, num_y)\n",
    "        hamming_dist_list_weighted += [h_dist]\n",
    "        #print(\"Hamming distance between original and recovered permutations: {}\".format(h_dist))\n",
    "        #\n",
    "        L0 = Y[:, col_ind][:, :num_x] @ X.T @ np.linalg.inv(X @ X.T)\n",
    "        #\n",
    "        err_L = np.linalg.norm(L0 - L, 2) / np.linalg.norm(L, 2)\n",
    "        err_L_list_weighted += [err_L]\n",
    "        #\n",
    "        #print(\"Relative error in L = err_L = {}\".format(err_L))\n",
    "        #\n",
    "        err_Y = np.linalg.norm(L @ X - L0 @ X, 2) / np.linalg.norm(L @ X, 2)\n",
    "        err_Y_list_weighted += [err_Y]\n",
    "        #\n",
    "        #print(\"Relative error in matching images err_Y = {}\".format(err_Y))\n",
    "        #\n",
    "        X_pre = np.linalg.inv(L0) @ Y[:, col_ind][:, :num_x]    \n",
    "        err_X = np.linalg.norm(X - X_pre, 2) / np.linalg.norm(X, 2)\n",
    "        err_X_list_weighted += [err_X]\n",
    "        #\n",
    "        #print(\"Relative error in matching inverse images err_X = {}\".format(err_X))\n",
    "        #\n",
    "        #print(\"err_X : err_Y = {} ~ {} = cond(L)\".format(err_X / err_Y, cond))\n",
    "        #\n",
    "    #\n",
    "    noise_list_weighted  = np.array(noise_list_weighted)\n",
    "    disc_X_list_weighted = np.array(disc_X_list_weighted)\n",
    "    err_L_list_weighted  = np.array(err_L_list_weighted)\n",
    "    err_Y_list_weighted  = np.array(err_Y_list_weighted)\n",
    "    err_X_list_weighted  = np.array(err_X_list_weighted)\n",
    "    hamming_dist_list_weighted = np.array(hamming_dist_list_weighted)\n",
    "    #\n",
    "    output = {}\n",
    "    output['num_x']  = num_x\n",
    "    output['num_y']  = num_y \n",
    "    output['noise']  = (noise_list_weighted.mean(), noise_list_weighted.std())\n",
    "    output['disc_X'] = (disc_X_list_weighted.mean(), disc_X_list_weighted.std())\n",
    "    output['err_L']  = (err_L_list_weighted.mean(), err_L_list_weighted.std())\n",
    "    output['err_Y']  = (err_Y_list_weighted.mean(), err_Y_list_weighted.std())\n",
    "    output['err_X']  = (err_X_list_weighted.mean(), err_X_list_weighted.std())\n",
    "    output['h_dist'] = (hamming_dist_list_weighted.mean(), hamming_dist_list_weighted.std())\n",
    "    #\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "49ae3ec7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collecting some quick stats for \"choosing the best feature correspondence\" approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "92f25938",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:35<00:00,  2.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                              Value\n",
      "num_x                                           100\n",
      "num_y                                           100\n",
      "noise   (0.08562757265815076, 0.008805664097259308)\n",
      "disc_X                                   (0.0, 0.0)\n",
      "err_L    (0.15083811846810735, 0.36355940659499897)\n",
      "err_Y     (0.1457868564039155, 0.35269368589737427)\n",
      "err_X    (0.19842377552151322, 0.05133371571186018)\n",
      "h_dist                (0.1468, 0.26922065299675657)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "out_best = test_feature_matching_best(num_tests=100, num_points=100, dim=3,\\\n",
    "                                      sigma=0.1, level=1.0, cond=3.0, n_iter=2**7)\n",
    "#\n",
    "df_best  = pd.DataFrame.from_dict(out_best, orient='index', columns=['Value'])\n",
    "#\n",
    "print(df_best)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "237367fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Collecting stats for \"feature correspondence from the weighted sum\" approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d1417e5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:30<00:00,  3.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                              Value\n",
      "num_x                                           100\n",
      "num_y                                           100\n",
      "noise   (0.08432110984221872, 0.007583378688837096)\n",
      "disc_X                                   (0.0, 0.0)\n",
      "err_L     (0.07248010788257911, 0.2779250753455331)\n",
      "err_Y     (0.06987997049827727, 0.2680738090522467)\n",
      "err_X   (0.18908714786332678, 0.037851734283778984)\n",
      "h_dist   (0.08259999999999999, 0.16058405898469502)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "out_weighted = test_feature_matching_weighted(num_tests=100, num_points=100, dim=3,\\\n",
    "                                              sigma=0.1, level=1.0, cond=3.0, n_iter=2**7)\n",
    "#\n",
    "df_weighted  = pd.DataFrame.from_dict(out_weighted, orient='index', columns=['Value'])\n",
    "#\n",
    "print(df_weighted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "12364a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Defining the test parameters:\n",
    "num_tests  = number of tests per batch (default 100)\n",
    "num_points = number of points per random cloud generated (default 100)\n",
    "dim = dimension (default 3)\n",
    "sigma  = noise level, for N(1, \\sigma^2) noise\n",
    "level  = discrepancy level in (0,1], with 0 = all points removed, 1 = all points present\n",
    "cond   = condition number of random linear map (default 3.0)\n",
    "n_iter = number of trials for probabilistic voting (default 2**10)\n",
    "\"\"\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fd6b1fda",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "num_tests  = 100\n",
    "num_points = 100\n",
    "dim = 3\n",
    "level = 1.0\n",
    "cond = 3.0\n",
    "#\n",
    "# Noise level: sigma varies from 0.05 to 0.25 with step 0.05\n",
    "sigma_values = np.arange(0.05, 0.30, 0.05)  \n",
    "# Number of probabilistic votes varies from 32 (2^5) to 1024 (2^10)\n",
    "n_iter_values = 2**np.arange(5, 11) \n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "2227e57a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Heatmap for various values of noise magnitude and number of probabilistic votes\n",
    "# for \"choosing the best\" approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a55d6ab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:12<00:00,  8.18it/s]\n",
      "100%|██████████| 100/100 [00:17<00:00,  5.59it/s]\n",
      "100%|██████████| 100/100 [00:28<00:00,  3.45it/s]\n",
      "100%|██████████| 100/100 [00:51<00:00,  1.93it/s]\n",
      "100%|██████████| 100/100 [01:37<00:00,  1.03it/s]\n",
      "100%|██████████| 100/100 [03:16<00:00,  1.96s/it]\n",
      "100%|██████████| 100/100 [00:16<00:00,  6.04it/s]\n",
      "100%|██████████| 100/100 [00:22<00:00,  4.48it/s]\n",
      "100%|██████████| 100/100 [00:32<00:00,  3.09it/s]\n",
      "100%|██████████| 100/100 [00:54<00:00,  1.83it/s]\n",
      "100%|██████████| 100/100 [01:42<00:00,  1.02s/it]\n",
      "100%|██████████| 100/100 [03:10<00:00,  1.91s/it]\n",
      "100%|██████████| 100/100 [00:16<00:00,  6.00it/s]\n",
      "100%|██████████| 100/100 [00:22<00:00,  4.44it/s]\n",
      "100%|██████████| 100/100 [00:33<00:00,  2.97it/s]\n",
      "100%|██████████| 100/100 [00:55<00:00,  1.81it/s]\n",
      "100%|██████████| 100/100 [01:38<00:00,  1.01it/s]\n",
      "100%|██████████| 100/100 [03:07<00:00,  1.87s/it]\n",
      "100%|██████████| 100/100 [00:17<00:00,  5.86it/s]\n",
      "100%|██████████| 100/100 [00:22<00:00,  4.44it/s]\n",
      "100%|██████████| 100/100 [00:33<00:00,  2.99it/s]\n",
      "100%|██████████| 100/100 [00:55<00:00,  1.80it/s]\n",
      "100%|██████████| 100/100 [01:41<00:00,  1.01s/it]\n",
      "100%|██████████| 100/100 [03:15<00:00,  1.95s/it]\n",
      "100%|██████████| 100/100 [00:17<00:00,  5.87it/s]\n",
      "100%|██████████| 100/100 [00:22<00:00,  4.37it/s]\n",
      "100%|██████████| 100/100 [00:33<00:00,  2.96it/s]\n",
      "100%|██████████| 100/100 [00:56<00:00,  1.76it/s]\n",
      "100%|██████████| 100/100 [01:46<00:00,  1.07s/it]\n",
      "100%|██████████| 100/100 [03:18<00:00,  1.99s/it]\n"
     ]
    }
   ],
   "source": [
    "# Initialize the heatmap\n",
    "heatmap_err_L_best  = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "heatmap_err_Y_best  = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "heatmap_err_X_best  = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "heatmap_h_dist_best = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "# Populate the heatmap\n",
    "for i, sigma in enumerate(sigma_values):\n",
    "    for j, n_iter in enumerate(n_iter_values):\n",
    "        #\n",
    "        out_best = test_feature_matching_best(num_tests, num_points, dim, sigma,\\ \n",
    "                                              level, cond, n_iter)\n",
    "        # \n",
    "        heatmap_err_L_best[i, j],  _  = out_best['err_L']\n",
    "        heatmap_err_Y_best[i, j],  _  = out_best['err_Y']\n",
    "        heatmap_err_X_best[i, j],  _  = out_best['err_X']\n",
    "        heatmap_h_dist_best[i, j], _  = out_best['h_dist']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d67f3aac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Heatmap for various values of noise magnitude and number of probabilistic votes\n",
    "# for \"weighted sum\" approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f77de990",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:16<00:00,  6.11it/s]\n",
      "100%|██████████| 100/100 [00:20<00:00,  4.87it/s]\n",
      "100%|██████████| 100/100 [00:28<00:00,  3.55it/s]\n",
      "100%|██████████| 100/100 [00:45<00:00,  2.22it/s]\n",
      "100%|██████████| 100/100 [01:18<00:00,  1.27it/s]\n",
      "100%|██████████| 100/100 [02:23<00:00,  1.44s/it]\n",
      "100%|██████████| 100/100 [00:17<00:00,  5.80it/s]\n",
      "100%|██████████| 100/100 [00:21<00:00,  4.71it/s]\n",
      "100%|██████████| 100/100 [00:28<00:00,  3.47it/s]\n",
      "100%|██████████| 100/100 [00:45<00:00,  2.22it/s]\n",
      "100%|██████████| 100/100 [01:20<00:00,  1.24it/s]\n",
      "100%|██████████| 100/100 [02:24<00:00,  1.44s/it]\n",
      "100%|██████████| 100/100 [00:18<00:00,  5.55it/s]\n",
      "100%|██████████| 100/100 [00:21<00:00,  4.57it/s]\n",
      "100%|██████████| 100/100 [00:28<00:00,  3.48it/s]\n",
      "100%|██████████| 100/100 [00:45<00:00,  2.20it/s]\n",
      "100%|██████████| 100/100 [01:21<00:00,  1.23it/s]\n",
      "100%|██████████| 100/100 [02:33<00:00,  1.53s/it]\n",
      "100%|██████████| 100/100 [00:17<00:00,  5.65it/s]\n",
      "100%|██████████| 100/100 [00:21<00:00,  4.58it/s]\n",
      "100%|██████████| 100/100 [00:29<00:00,  3.35it/s]\n",
      "100%|██████████| 100/100 [00:47<00:00,  2.12it/s]\n",
      "100%|██████████| 100/100 [01:24<00:00,  1.19it/s]\n",
      "100%|██████████| 100/100 [02:28<00:00,  1.49s/it]\n",
      "100%|██████████| 100/100 [00:18<00:00,  5.52it/s]\n",
      "100%|██████████| 100/100 [00:22<00:00,  4.45it/s]\n",
      "100%|██████████| 100/100 [00:30<00:00,  3.26it/s]\n",
      "100%|██████████| 100/100 [00:48<00:00,  2.07it/s]\n",
      "100%|██████████| 100/100 [01:23<00:00,  1.19it/s]\n",
      "100%|██████████| 100/100 [02:34<00:00,  1.54s/it]\n"
     ]
    }
   ],
   "source": [
    "# Initialize the heatmap\n",
    "heatmap_err_L_weighted  = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "heatmap_err_Y_weighted  = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "heatmap_err_X_weighted  = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "heatmap_h_dist_weighted = np.zeros((len(sigma_values), len(n_iter_values)))\n",
    "# Populate the heatmap\n",
    "for i, sigma in enumerate(sigma_values):\n",
    "    for j, n_iter in enumerate(n_iter_values):\n",
    "        #\n",
    "        out_weighted = test_feature_matching_weighted(num_tests, num_points, dim, sigma,\\\n",
    "                                                      level, cond, n_iter)\n",
    "        # \n",
    "        heatmap_err_L_weighted[i, j],  _  = out_weighted['err_L']\n",
    "        heatmap_err_Y_weighted[i, j],  _  = out_weighted['err_Y']\n",
    "        heatmap_err_X_weighted[i, j],  _  = out_weighted['err_X']\n",
    "        heatmap_h_dist_weighted[i, j], _  = out_weighted['h_dist']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "18205fef",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "# Create the heatmap plot\n",
    "#\n",
    "heatmap_data = [(heatmap_err_L_best, 'Error in L (best)'),\n",
    "                (heatmap_err_L_weighted, 'Error in L (weighted)'),\n",
    "                (heatmap_err_Y_best, 'Error in Y (best)'),\n",
    "                (heatmap_err_Y_weighted, 'Error in Y (weighted)'),\n",
    "                (heatmap_err_X_best, 'Error in X (best)'),\n",
    "                (heatmap_err_X_weighted, 'Error in X (weighted)'),\n",
    "                (heatmap_h_dist_best, 'Hamming distance (best)'),\n",
    "                (heatmap_h_dist_weighted, 'Hamming distance (weighted)')]\n",
    "#\n",
    "# Create a 4x2 grid for the subplots\n",
    "fig, axs = plt.subplots(4, 2, figsize=(20, 20))\n",
    "#\n",
    "# Create a common axis for the colorbar\n",
    "cax = fig.add_axes([1.05, 0.15, 0.02, 0.7])  \n",
    "#\n",
    "for i, ax in enumerate(axs.flatten()):\n",
    "    data, description = heatmap_data[i]\n",
    "    im = ax.imshow(data, cmap='tab20', origin='lower', aspect='auto',\n",
    "                   extent=[n_iter_values[0], n_iter_values[-1], sigma_values[0], sigma_values[-1]])\n",
    "    ax.set_xlabel('n_iter')\n",
    "    ax.set_ylabel('sigma')\n",
    "    ax.set_title(description)\n",
    "    ax.set_xscale('log', base=2)\n",
    "    ax.set_yscale('linear')\n",
    "    ax.grid(True, which='both', linestyle='--', linewidth=0.5, color='grey')\n",
    "\n",
    "# Create a common colorbar using the cax parameter\n",
    "fig.colorbar(im, cax=cax, label=\"Relative Error\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e5b5492",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.7",
   "language": "sage",
   "name": "sagemath-9.7"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}