Section_6.1_Experiment_1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorly as tl\n",
    "import os\n",
    "from tensorly.decomposition import tucker, parafac, non_negative_tucker\n",
    "from tensorly import tucker_to_tensor\n",
    "\n",
    "from sklearn.utils.extmath import randomized_svd\n",
    "from itertools import combinations, product\n",
    "import multiprocessing as mp\n",
    "import time\n",
    "\n",
    "import apgpy\n",
    "from scipy.sparse.linalg import svds\n",
    "import mkl\n",
    "mkl.set_num_threads(1)\n",
    "\n",
    "from util import std_logistic_function, get_square_set, square_unfolding, \\\n",
    "normalized_error, tenips_general, tenips_general_paper1, generate_orthogonal_mats\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "from matplotlib import rc\n",
    "rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'weight': 'bold'})\n",
    "rc('text', usetex=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part I: function definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1-bit matrix completion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_bit_MC_fully_observed(M, link, tau, gamma, max_rank=None,\n",
    "                              apg_max_iter=500, apg_eps=1e-12,\n",
    "                              apg_use_restart=True):\n",
    "    \"\"\"\n",
    "    Do one-bit matrix completion on the mask matrix M. \n",
    "    \"\"\"\n",
    "    m = M.shape[0]\n",
    "    n = M.shape[1]\n",
    "    tau_sqrt_mn = tau * np.sqrt(m*n)\n",
    "\n",
    "    def prox(_A, t):\n",
    "        _A = _A.reshape(m, n)\n",
    "        if max_rank is None:\n",
    "            U, S, VT = np.linalg.svd(_A, full_matrices=False)\n",
    "        else:\n",
    "            U, S, VT = randomized_svd(_A, max_rank)\n",
    "        nuclear_norm = np.sum(S)\n",
    "        if nuclear_norm > tau_sqrt_mn:\n",
    "            S *= tau_sqrt_mn / nuclear_norm\n",
    "            _A = np.dot(U * S, VT)\n",
    "\n",
    "        mask = np.abs(_A) > gamma\n",
    "        if mask.sum() > 0:\n",
    "            _A[mask] = np.sign(_A[mask]) * gamma\n",
    "\n",
    "        return _A.flatten()\n",
    "\n",
    "    M_one_mask = (M == 1)\n",
    "    M_zero_mask = (M == 0)\n",
    "    def grad(_A):\n",
    "        _A = _A.reshape(m, n)\n",
    "        return (std_logistic_function(_A) - M).flatten()\n",
    "\n",
    "    A_hat = apgpy.solve(grad, prox, np.zeros(m*n),\n",
    "                        max_iters=apg_max_iter,\n",
    "                        eps=apg_eps,\n",
    "                        use_gra=True,\n",
    "                        use_restart=apg_use_restart,\n",
    "                        quiet=True)\n",
    "    P_hat = link(A_hat.reshape(m, n))\n",
    "    return P_hat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameter setup for experiments. For Figure 5 in supplementary material, Section 2, change I to 5 and orders to np.linspace(4, 10, 7).astype(int)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 4\n",
    "r = [2 for _ in range(N)]\n",
    "I = 8\n",
    "orders = np.linspace(4, 8, 5).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generate data tensor $\\mathscr{B}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Low rank + noise\n",
    "# np.random.seed(1)\n",
    "# noise_para = 0.1 # noise parameter\n",
    "\n",
    "# real_core = 100 * tl.tensor(np.random.randn(*r))\n",
    "# factor_matrices = [generate_orthogonal_mats((I,r[0])) for i in range(N)]\n",
    "# real_B = tucker_to_tensor((real_core, factor_matrices)) # noiseless\n",
    "# fro_norm = np.linalg.norm(real_B)\n",
    "# noise_coeff = noise_para * fro_norm / I ** (len(r)*1./2)\n",
    "# noise_ten = tl.tensor(np.random.normal(0,1,[I]*N))\n",
    "\n",
    "# B = real_B + noise_coeff*noise_ten # noisy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "generate parameter tensor $\\mathscr{A}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_noise_para = 0.1 # noise parameter\n",
    "np.random.seed(2)\n",
    "A_real_core = 2 * np.random.uniform(-1, 1, r)\n",
    "A_factor_matrices = [generate_orthogonal_mats((I, r[0])) for i in range(N)]\n",
    "real_A = tucker_to_tensor((A_real_core, A_factor_matrices)) # noiseless\n",
    "A_fro_norm = np.linalg.norm(real_A)\n",
    "A_noise_coeff = A_noise_para * A_fro_norm / I ** (len(r)*1./2)\n",
    "A_noise_ten = tl.tensor(np.random.normal(0,1,[I]*N))\n",
    "\n",
    "A = real_A + A_noise_coeff * A_noise_ten #noisy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "get propensity tensor $\\mathscr{P}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = std_logistic_function(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "propensity distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([   3.,   11.,   64.,  353., 1765., 1523.,  297.,   61.,   14.,\n",
       "           5.]),\n",
       " array([0.42077697, 0.43678848, 0.4528    , 0.46881151, 0.48482302,\n",
       "        0.50083453, 0.51684605, 0.53285756, 0.54886907, 0.56488058,\n",
       "        0.5808921 ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAD3CAYAAAAXDE8fAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAOgElEQVR4nO3dQXYiZ5aG4e/2yQVQkpm6dNAOaGoH5MhTnLmCpHYgu1dgSzswvQJVauqR6RU0Zl4DOO6xSjKDmt8ecEMZSYKAgAjw9fuco6OISyBuQujj1x8RpLm7AAD5/MepGwAA1IOAB4CkCHgASIqAB4CkCHgASIqAB4Ck3py6gcJXX33lV1dXp24DAP5Qfv3113+5e3vdbWcT8FdXV5pMJqduAwD+UMzs/zbdxhQNACRFwANAUgQ8ACRFwANAUgQ8ACS1U8CbWbe8bGZuZrP4+inqt/F9WNp2YGZ9M7s5duMAgNdtDXgz60v6WCpduLu5+7WkbyXdRn1oZjNJ87hfV5LcfSxpUX6TAADUb2vAR0DPV9YLPXcvbvvg7tel299LWsTyXFL/CP0CAHZU+UKnGNn/o1TqRK3r7neSWpKeS7dfVn0sQJKuvv/5ZI/924/fnOyxgaoOOcj61t2LEbrc/S5G75cR9ACAEzok4MsHXodmNojVJ0kdLadnLqLWivpn4n4TM5s8Pj4e0AoAYFWlgDezzkppIqmYe7+O9Xstg17xfbxyH7n7yN177t5rt9d+Vg4AoKJdzqIZSOqVRuiF8oHXqaR3sc3M3adRK+bqF8U6AKAZWw+yuvuDpIeV2lzS31dqozX3/aIGAGgGV7ICQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAkRcADQFIEPAAktVPAm1l3Zf02vg9LtYGZ9c3s5rUaAKAZWwPezPqSPq6Uh2Y2kzSPbbqS5O5jSQsz666rHbVzAMCr3mzbwN3HZjZfKX9w94fS+ntJv8TyXFJf0uWa2vSwdoHTuPr+55M87m8/fnOSx0UOVefgOytTLy1Jz6XbLzfUAAAN2TqCX8fd7yTJzN7GFA4A4MzsPYI3s6GZDWL1SVJH0kLSRdRaUV9XW/ezJmY2eXx83LcVAMArqkzRTCSNY/k61u+1DHrF9/GG2mfcfeTuPXfvtdvtCq0AADbZ5SyagaReMWp396mkd7E+c/dp1IozbhabarX9KwAAX9jlLJoHSQ8rtdGa7XaqAQCawZWsAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASRHwAJAUAQ8ASe0U8GbWXVkfxtdtqXZb3FaqDcysb2Y3x2oYALCbrQFvZn1JH1fWx+4+ktSJdUkamtlM0jy260qSu48lLVbfJAAA9doa8BHQ81KpI6kI9XmsS9IHd7+O7SXpvaRFabu+AACNebPvHWLkXuhKuo/lYjTfdfc7SS1Jz6VtLyt3CQDY294BX4gpl6m7TyUpQl1m9rY0bQMAOJFDzqLpu/t30stB10HUn7SctllIuohaK+qfiftNzGzy+Ph4QCsAgFWVAt7MhqURe1/SRFIx934d6/f6ND/fKd3+wt1H7t5z91673a7SCgBgg13OohlI6hUj9Aj0WzObmdnvkhTTNO9im5m7v0zdxPaLYh0A0Iytc/Du/iDpobQ+lvSXNduNdqkBAJrBlawAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkBQBDwBJEfAAkNROAW9m3ZX1gZn1zexm3xoAoBlbA97M+pI+lta7kuTuY0kLM+vuWqvjHwAAWG9rwEdAz0ul95IWsTyX1N+jBgBoSJU5+Jak59L65R41AEBDOMgKAEm9qXCfhaSLWG5JeorlXWsvzGwoaShJX3/9dYVWAACbVAn4e0m9WO5IGsfyrrUX7j6SNJKkXq/nFXoBAGywy1k0A0m9+C53n0a9L2nh7tNda3X9IwAAX9o6gnf3B0kPK7XRmu12qgEAmsFBVgBIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIau+AN7OumbmZzeLrp6jfxvdhaduBmfXN7OZ4LQMAdlFlBH/h7ubu15K+lXQb9aGZzSTNpeUbgSS5+1jSolgHADRj74CPwC703H0eyx/c/bp0+3tJi1ieS+pXbxMAsK/Kc/Bm1pf0j1KpszId05L0XLr9supjAQD2d8hB1rfuXozQ5e53MXq/jPDfysyGZjYxs8nj4+MBrQAAVh0S8C9z6hHUg1h9ktTRcnrmImqtqH/G3Ufu3nP3XrvdPqAVAMCqSgFvZp2V0kRSMfd+Hev3Wga94vtYAIDGvDngvsXBVbn7NEbxz5Jm7j6VJDPrxXTNoqgBAJpRKeDjzJm/r9RGa7b7ogYAaAZXsgJAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRFwANAUgQ8ACRVKeDN7Da+D0u1gZn1zezmtRoAoBlVR/BDM5tJmkuSmXUlyd3HkhZm1l1XO0bDAIDdVA34D+5+HeEtSe8lLWJ5Lqm/oQYAaEjVgO+sTL20JD2Xbr/cUAMANKRSwLv7XYzeL82s8sjczIZmNjGzyePjY9UfAwBYY++Aj1AexOqTpI6WUzEXUWtFfV3tM+4+cveeu/fa7fa+rQAAXvGmwn0mioOrkq4l/RS1XtQ6koq5+XU1AEAD9g54d5/GKP5Z0szdp5JkZr2Yrlm8VgMANKPKCF7uPqpaAwA0gytZASApAh4AkiLgASApAh4AkiLgASApAh4AkiLgASApAh4AkiLgASApAh4AkiLgASApAh4AkiLgASCpSp8miT+3q+9/PnULAHbACB4AkiLgASApAh4AkiLgASApAh4AkuIsGuCMneqMpd9+/OYkj4vjYgQPAElVCngzG8bXbal2W9xWqg3MrG9mN4e3CgDYx94Bb2Z9SWN3H0nqxLokDc1sJmke23Ulyd3HkhbFOgCgGVVG8B1JRajPY12SPrj7dQS6JL2XtCht1xcAoDF7H2SNkXuhK+k+lovRfNfd7yS1JD2Xtr2s3CUAYG+VD7LGlMvU3aeS5O53MXq/LE3bbPsZQzObmNnk8fGxaisAgDUOOYum7+7fSS9BPYj6k5bTNgtJF1FrRf0z7j5y956799rt9gGtAABWVT6LJqZhioOuE0nF3Pt1rN/r0/x8p3Q7AKABVc+iuTWzmZn9LkkxTfMuRvEzd3+ZuontF8U6AKAZVQ6yjiX9ZU19tEsNANAMrmQFgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIioAHgKQIeABIau//8APn4er7n0/dAoAzR8AD+MIpBxC//fjNyR47G6ZoACApAh4Akqp1isbMBpIWkrruflfnYwEAPlfbCN7MupLk7mNJi2IdANCMOkfw7yX9EstzSX1J0xofD0ACpzrAm/Hgbp0B35L0XFq/rPGxTobTFYEcMp45dNLTJM1sKGkYq/82s39W+DFfSfrX8bo6GvraD33th772c9Z92e1BP+Ovm26oM+AXki5iuSXpaXUDdx9JGh3yIGY2cffeIT+jDvS1H/raD33t58/aV52nSd5L6sRyR9K4xscCAKyoLeDdfSpJZtaXtCjWAQDNqHUOPqZg6tbEY1RBX/uhr/3Q137+lH2Zu9f58wEAJ3L2H1VgZgMz65vZzZbtbkrLw/g67Nj0kft6rXbKvsysG/cbnFlfxX2Gr90Hzdn2Oha/c+teszr3e6x31gG/69WwMc//trQ8jumhTqyfvK/XamfQ13+5+4OWz9fRrziu+Dp2Jc3jPvO6roSuEli7vlmdoK9aBzY7vo5DM5tpeXFj+b617ffx86s8Xycf2GzZvw4e2Jx1wGt5NewilourYbfplLab69OZPKfuqwl79xU79/9Kkrvf1XQwvOrzVQRVp46+qgRWEx/BUbGv2gc22u11/ODu19F7Iw544zmHgc26/etoA5tzD/itV8OaWbe8M7n7qHRwtytpcg59baqdQV9/k3QZo5m6RqRVXsepljv47yv3PaYqgdXEm3uVvpoY2OxydXpndcTawH6/9/N1RgObdW+IRxvYnHvA7+JiXTHe+aYnPD1zXV9re23Yuh6eSqe11vbn6haf9WVmLS1/OX6Q9N9mdi6B1cRHcOzdV0MDm60iLMdaDhqKQKt7v6/yOp7FwGa1r2MPbM494F+9GnbLyKDv7t+dS18NjGIq9RXbFH+2LrTc8c+hr6GkH+Jjpj9IOskbz4bAOrlNfdU8sNn2Og5LA4QnxdRHk9M1m2x4vk4+sFnt69gDm3P/L/vuJRWX8b5cDWtmLXdfaLkDdbTc6S5iZ5qa2bD4/Hkz69ewg+3d16Zez6CvB30Kz5biz9Yz6OuFuz8c44DTGlsDS9JzzNM+Re9bP4LjRH0V6hzYbHsdJ/o0WLiW9JOa2e+rPF/rBjYPZ9BXV8uBzcLM5lr+blb+vzTOegT/ytWw/xO3P8STIy2fwGLbWzObxZ85Z9HXutqZ9DXX8gDQQNJl6fZT93Wn5QGoQbxh13FByNqP04hRlLQMrGJwcB3rTXwER5W+tDqwOXZTO7yOU0nvYl+aufu0if1e1Z6vh9J96hzY7P06FuJ5W+gAXOiEP7UYRc21PKA1itqv7v6fpduf4/a7Tfc5dV8Ruh+jdiHp23OYGmnKAa/js6S/1fVXT8W+buI+F4fuXwQ8ACR11lM0AIDqCHgASIqAB4CkCHgASIqAB4CkCHgASIqAB4Ck/h8E3UYl2SAFOgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(P.flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Case 1: rectangular unfolding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_rect = tl.unfold(A, mode=0)\n",
    "_, A_Sigma, _ = randomized_svd(A_rect, n_components=10, n_iter=20, random_state=None)\n",
    "alpha_of_A_rect = np.max(np.abs(A_rect))\n",
    "theta_of_A_rect = np.sum(A_Sigma) / (np.sqrt(np.prod(A_rect.shape)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.29865596, 1.36562825, 0.1363851 , 0.13379199, 0.13027435,\n",
       "       0.1250826 , 0.12043247, 0.11833373])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_Sigma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.08482163194454842"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_of_A_rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3264366005679022"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha_of_A_rect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Case 2: square unfolding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_sq = square_unfolding(A)\n",
    "_, A_Sigma, _ = randomized_svd(A_sq, n_components=10, n_iter=20, random_state=None)\n",
    "alpha_of_A_sq = np.max(np.abs(A_sq))\n",
    "theta_of_A_sq = np.sum(A_Sigma) / (np.sqrt(np.prod(A_sq.shape)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0980229845656162"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta_of_A_sq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3264366005679022"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha_of_A_sq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model A: MCAR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uniform_sampling(ratio, tensor):\n",
    "    \"\"\"\n",
    "    Uniformly sample the given tensor with given ratio. Output the sampled tensor with missing entries masked\n",
    "    by 0, and the numpy array of indices of sampled entries.\n",
    "    \"\"\"\n",
    "    sampled_tensor = tensor.copy()\n",
    "    select_indices = np.random.choice([True,False],tensor.shape,p=[ratio,1-ratio])\n",
    "    sampled_tensor[np.invert(select_indices)] = 0.0\n",
    "    return sampled_tensor, select_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_propensity_errors_from_A(A, tau=10, gamma=10, max_rank=10, method='rectangular'):\n",
    "    \"\"\"\n",
    "    Do one-bit matrix completion on one kind of matricization of the parameter tensor A.    \n",
    "    \"\"\"\n",
    "    print(\"tau: {}, gamma: {}, max_rank: {}\".format(tau, gamma, max_rank))\n",
    "    N = np.ndim(A)    \n",
    "    prop_X = std_logistic_function(A)\n",
    "    mask_X = (np.random.uniform(0, 1, A.shape) < prop_X).astype(int)\n",
    "\n",
    "    if method == 'rectangular':\n",
    "        prop_X_rect = tl.unfold(prop_X, mode=0)\n",
    "        mask_X_rect = tl.unfold(mask_X, mode=0)\n",
    "\n",
    "        start = time.time()\n",
    "        prop_X_rect_pred = one_bit_MC_fully_observed(mask_X_rect, std_logistic_function, \n",
    "                                                     tau=tau, gamma=gamma, max_rank=max_rank)\n",
    "        elapsed_rect = time.time() - start\n",
    "\n",
    "        relative_error_rect = np.linalg.norm(prop_X_rect_pred - prop_X_rect) / np.linalg.norm(prop_X_rect)\n",
    "        \n",
    "        return relative_error_rect, elapsed_rect\n",
    "\n",
    "    if method == 'square':\n",
    "        prop_X_sq = square_unfolding(prop_X)\n",
    "        mask_X_sq = square_unfolding(mask_X)\n",
    "    \n",
    "        start = time.time()\n",
    "        prop_X_sq_pred = one_bit_MC_fully_observed(mask_X_sq, std_logistic_function, \n",
    "                                                     tau=tau, gamma=gamma, max_rank=max_rank)\n",
    "        elapsed_sq = time.time() - start\n",
    "\n",
    "        relative_error_sq = np.linalg.norm(prop_X_sq_pred - prop_X_sq) / np.linalg.norm(prop_X_sq)\n",
    "        \n",
    "        return relative_error_sq, elapsed_sq\n",
    "    \n",
    "    if method == 'sliced':\n",
    "        lengths_of_fixed_dims = [I for _ in range(N - 2)]\n",
    "        indices_of_fixed_dims = list(product(*[np.arange(i) for i in lengths_of_fixed_dims]))\n",
    "        \n",
    "        start = time.time()\n",
    "        for idx, ind_fixed in enumerate(indices_of_fixed_dims):\n",
    "            print(idx)\n",
    "            prop_X_slice = prop_X[ind_fixed]\n",
    "            mask_X_slice = mask_X[ind_fixed]\n",
    "            A_slice = A[ind_fixed]\n",
    "            \n",
    "            _, A_Sigma, _ = randomized_svd(A_slice, n_components=10, n_iter=20, random_state=None)\n",
    "            alpha_of_A_slice = np.max(np.abs(A_slice))\n",
    "            theta_of_A_slice = np.sum(A_Sigma) / (np.sqrt(np.prod(A_slice.shape)))\n",
    "            \n",
    "            prop_X_slice_pred = one_bit_MC_fully_observed(mask_X_slice, std_logistic_function, \n",
    "                                                     tau=theta_of_A_slice, gamma=alpha_of_A_slice, max_rank=None)\n",
    "\n",
    "            if idx == 0:\n",
    "                prop_X_combined = prop_X_slice.copy()\n",
    "                prop_X_combined_pred = prop_X_slice_pred.copy()\n",
    "            else:\n",
    "                prop_X_combined = np.concatenate((prop_X_combined, prop_X_slice), axis=0)\n",
    "                prop_X_combined_pred = np.concatenate((prop_X_combined_pred, prop_X_slice_pred), axis=0)\n",
    "\n",
    "        elapsed_sliced = time.time() - start\n",
    "        relative_error_sliced = np.linalg.norm(prop_X_combined_pred - prop_X_combined) / np.linalg.norm(prop_X_combined)\n",
    "    \n",
    "        return relative_error_sliced, elapsed_sliced    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_propensity_errors_uniform_at_tensor_order(N, ratio=0.4, parameter_ratio=1):\n",
    "    \"\"\"\n",
    "    Given a tensor order N, get the propensity estimation error when sampling uniformly at a given ratio.\n",
    "    \"\"\"\n",
    "    print(\"order: {}\".format(N))\n",
    "    \n",
    "    # generate the low multilinear rank + noise data tensor\n",
    "    r = [2 for _ in range(N)]\n",
    "    np.random.seed(1)\n",
    "    noise_para = 0.1 # noise parameter\n",
    "    real_core = tl.tensor(np.random.randn(*r))\n",
    "    factor_matrices = [generate_orthogonal_mats((I,r[0])) for i in range(N)]\n",
    "    real_B = tucker_to_tensor((real_core, factor_matrices))\n",
    "    fro_norm = np.linalg.norm(real_B)\n",
    "    noise_coeff = noise_para * fro_norm / I ** (len(r)*1./2)\n",
    "    noise_ten = tl.tensor(np.random.normal(0,1,[I]*N))\n",
    "    B = real_B + noise_coeff*noise_ten\n",
    "    \n",
    "    _, select_idxs = uniform_sampling(ratio=ratio, tensor=B)\n",
    "    prop_B = np.ones(B.shape) * ratio\n",
    "    mask_B = np.ones(B.shape)\n",
    "    mask_B[np.invert(select_idxs)] = 0.0\n",
    "\n",
    "    A = inverse_logistic_function(prop_B)\n",
    "    \n",
    "    A_rect = tl.unfold(A, mode=0)\n",
    "    _, A_Sigma, _ = randomized_svd(A_rect, n_components=10, n_iter=20, random_state=None)\n",
    "    alpha_of_A_rect = np.max(np.abs(A_rect))\n",
    "    theta_of_A_rect = np.sum(A_Sigma) / (np.sqrt(np.prod(A_rect.shape)))\n",
    "    \n",
    "    relative_error_rect, elapsed_rect = get_propensity_errors_from_A(\n",
    "        A, tau=parameter_ratio*theta_of_A_rect, gamma=parameter_ratio*alpha_of_A_rect, max_rank=None, method='rectangular')\n",
    "    \n",
    "    A_sq = square_unfolding(A)\n",
    "    _, A_Sigma, _ = randomized_svd(A_sq, n_components=10, n_iter=20, random_state=None)\n",
    "    alpha_of_A_sq = np.max(np.abs(A_sq))\n",
    "    theta_of_A_sq = np.sum(A_Sigma) / (np.sqrt(np.prod(A_sq.shape)))\n",
    "    \n",
    "    relative_error_sq, elapsed_sq = get_propensity_errors_from_A(\n",
    "        A, tau=parameter_ratio*theta_of_A_sq, gamma=parameter_ratio*alpha_of_A_sq, max_rank=None, method='square')\n",
    "    \n",
    "    print(\"order: {} finished\".format(N))\n",
    "    return relative_error_rect, relative_error_sq, elapsed_rect, elapsed_sq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run an instance of the 1-bit completion experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order: 6\n",
      "tau: 0.8109302162163426, gamma: 0.8109302162163288, max_rank: None\n",
      "tau: 0.8109302162163267, gamma: 0.8109302162163288, max_rank: None\n",
      "order: 6 finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.27669536503287484,\n",
       " 0.24611128921344247,\n",
       " 0.08511924743652344,\n",
       " 0.3114736080169678)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_propensity_errors_uniform_at_tensor_order(6, ratio=0.4, parameter_ratio=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run the 1-bit completion experiments in parallel for $\\tau = \\theta$, $\\gamma = \\alpha$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order: 6\n",
      "order: 7\n",
      "order: 5\n",
      "order: 4\n",
      "order: 8\n",
      "tau: 0.40546510810816344, gamma: 0.4054651081081644, max_rank: None\n",
      "tau: 0.40546510810816394, gamma: 0.4054651081081644, max_rank: None\n",
      "tau: 0.40546510810816466, gamma: 0.4054651081081644, max_rank: None\n",
      "order: 4 finished\n",
      "tau: 0.4054651081081643, gamma: 0.4054651081081644, max_rank: None\n",
      "order: 5 finished\n",
      "tau: 0.4054651081081713, gamma: 0.4054651081081644, max_rank: None\n",
      "tau: 0.40546510810816333, gamma: 0.4054651081081644, max_rank: None\n",
      "order: 6 finished\n",
      "tau: 0.40546510810810327, gamma: 0.4054651081081644, max_rank: None\n",
      "tau: 0.4054651081081637, gamma: 0.4054651081081644, max_rank: None\n",
      "order: 7 finished\n",
      "tau: 0.4054651081072302, gamma: 0.4054651081081644, max_rank: None\n",
      "tau: 0.4054651081081647, gamma: 0.4054651081081644, max_rank: None\n",
      "order: 8 finished\n"
     ]
    }
   ],
   "source": [
    "p = mp.Pool(mp.cpu_count())\n",
    "results = [p.apply_async(get_propensity_errors_uniform_at_tensor_order, args=[N, 0.4, 1]) for N in orders]\n",
    "p.close()\n",
    "p.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "errors_MCAR_rect = []\n",
    "errors_MCAR_sq = []\n",
    "elapsed_times_MCAR_rect = []\n",
    "elapsed_times_MCAR_sq = []\n",
    "\n",
    "for result in results:\n",
    "    errors_MCAR_rect.append(result.get()[0])\n",
    "    errors_MCAR_sq.append(result.get()[1])\n",
    "    elapsed_times_MCAR_rect.append(result.get()[2])\n",
    "    elapsed_times_MCAR_sq.append(result.get()[3])\n",
    "\n",
    "errors_MCAR_rect_dict = dict(zip(orders, errors_MCAR_rect))\n",
    "errors_MCAR_sq_dict = dict(zip(orders, errors_MCAR_sq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run the 1-bit completion experiments in parallel for $\\tau = 2\\theta$, $\\gamma = 2\\alpha$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order: 4\n",
      "order: 6\n",
      "order: 8\n",
      "order: 5\n",
      "order: 7\n",
      "tau: 0.8109302162163269, gamma: 0.8109302162163288, max_rank: None\n",
      "tau: 0.8109302162163279, gamma: 0.8109302162163288, max_rank: None\n",
      "order: 4 finished\n",
      "tau: 0.8109302162163293, gamma: 0.8109302162163288, max_rank: None\n",
      "tau: 0.8109302162163285, gamma: 0.8109302162163288, max_rank: None\n",
      "order: 5 finished\n",
      "tau: 0.8109302162163426, gamma: 0.8109302162163288, max_rank: None\n",
      "tau: 0.8109302162163267, gamma: 0.8109302162163288, max_rank: None\n",
      "order: 6 finished\n",
      "tau: 0.8109302162162065, gamma: 0.8109302162163288, max_rank: None\n",
      "tau: 0.8109302162163274, gamma: 0.8109302162163288, max_rank: None\n",
      "order: 7 finished\n",
      "tau: 0.8109302162144604, gamma: 0.8109302162163288, max_rank: None\n",
      "tau: 0.8109302162163294, gamma: 0.8109302162163288, max_rank: None\n",
      "order: 8 finished\n"
     ]
    }
   ],
   "source": [
    "p = mp.Pool(mp.cpu_count())\n",
    "results = [p.apply_async(get_propensity_errors_uniform_at_tensor_order, args=[N, 0.4, 2]) for N in orders]\n",
    "p.close()\n",
    "p.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "errors_MCAR_rect_larger = []\n",
    "errors_MCAR_sq_larger = []\n",
    "elapsed_times_MCAR_rect_larger = []\n",
    "elapsed_times_MCAR_sq_larger = []\n",
    "\n",
    "for result in results:\n",
    "    errors_MCAR_rect_larger.append(result.get()[0])\n",
    "    errors_MCAR_sq_larger.append(result.get()[1])\n",
    "    elapsed_times_MCAR_rect_larger.append(result.get()[2])\n",
    "    elapsed_times_MCAR_sq_larger.append(result.get()[3])\n",
    "\n",
    "errors_MCAR_rect_larger_dict = dict(zip(orders, errors_MCAR_rect_larger))\n",
    "errors_MCAR_sq_larger_dict = dict(zip(orders, errors_MCAR_sq_larger))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Figure 1(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9c102b5e48>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fontsize = 30\n",
    "point_size = 50\n",
    "\n",
    "colors = ['orange', 'blue', 'red', 'purple', 'black', 'green', 'cyan']\n",
    "\n",
    "plt.plot(orders, errors_MCAR_rect, 'bo', linestyle='-', color=colors[0], label='unfolding along one order')\n",
    "plt.plot(orders, errors_MCAR_rect_larger, 'bo', linestyle='--', color=colors[0], label='unfolding along one order (2)')\n",
    "plt.plot(orders, errors_MCAR_sq, 'bo', linestyle='-', color=colors[1], label='square unfolding')\n",
    "plt.plot(orders, errors_MCAR_sq_larger, 'bo', linestyle='--', color=colors[1], label='square unfolding (2)')\n",
    "\n",
    "plt.xlabel('tensor order', fontsize=fontsize)\n",
    "plt.ylabel('relative error', fontsize=fontsize)\n",
    "\n",
    "xtick_pos = orders\n",
    "ytick_pos = [0.1*i for i in np.arange(4)]\n",
    "plt.xticks(xtick_pos, fontsize=fontsize)\n",
    "plt.yticks(ytick_pos, fontsize=fontsize)\n",
    "\n",
    "plt.ylim(0, 0.35)\n",
    "\n",
    "plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.3), fancybox=True, shadow=True, ncol=1, fontsize=fontsize-7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Figure 1(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9c101dc358>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaYAAAGLCAYAAACMQzbrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dT2wj6X3m8eeVu8dANPJwKA92DQeOw54GYtiHXbb6kp1c0lQQDDBzyEqtxRpYBHCa8i72ENiB6F7sIT7ECpVgAWMPBtVGkksOamoD7BwGyEqTg8fYy4hMYIxP3SyvF8F4AU9LHLc7iN09+u2himpKLBYpssh6JX4/AKHpquJbL19y6qk/b73lzEwAAPhiLusKAADQjWACAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVgAgB45cIEk3Mu55xrpFhe1TnXcM61olfdOVdMq3wAwGi8D6YokDYk/UjS2MERlVeXtGNmN8zsmqQb0eyGc6427joAAKPzNpicc6XoCOmepCB6peGepIqZNTsTzKxtZquStiWVnXPllNYFADgnd1GGJHLO7UkqmZkbo4xiVMZWn/k5SUfRP182s/ao6wIAjMbbI6YJWZO0229mFESdI6nSVGoEADhl1oKpKKnlnFtJWKZzyjA/hfoAAM6YtWDqnJq7mbBMLvqb1jUtAMA5zNo1ppykJTPbT1jmSGE4cY0JADJwJesKTFMUNEmhVFIYSvuEEgBkY6aCaQiV6O960kJRd/KyJM3Pz9/4jd/4jUnXCwAulUaj8aGZvRI3j2CKRB0iSpLWzSzx+pKZbSu850lLS0t2cHAwhRoCwOXhnPtxv3mz1vkhVnTtqXPj7XbW9QGAWUYwhd6RtN3vxlsAwPTMfDBFvf32zawycGEAwMTNdDBFA7Y2CSUA8MfMBlM0Ynk7LpSiEch5BAYAZGAme+VFPfCumVm/buFL06wPAOC5S3nEFD30rx71tjs7ryjpZkIoSdKyGJIIADJxkY6YClJ4mi1pVIZo9IbOIK17iu43iuYVFPbAO4g6PfRbT4HrTgCQDW+DKQqRmsJRvgt6PrjqkXOuKelQUs3MTj3Gwsz2o/mSdP9MsbWonEGPtOBoCQAy4m0wRaMvLI/43ht9po9UHgBgei7lNSYAwMVFMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxCMAEAvEIwAQC8QjABALxyJesKAMN6/IvH2vnhjh48eqDri9e19sU1LXxyIetqAUgZwYQL4fv/9/t6/a9f17Ed68nTJ5q/Oq+v/e3X9PaX39Zrn3st6+oBSBGn8uC9x794rNf/+nU9/uVjPXn6RJL05OkTPf5lOP3nv/x5xjUEkCaCCd7b+eGOju04dt6xHWvn/Z0p1wjAJBFM8N6DRw9OjpTOevL0iR4ePpxyjQBMEsEE711fvK75q/Ox8+avzuvV/KtTrhGASSKY4L21L65pzsX/VOfcnNa+tDblGgGYJHrlwXsLn1zQ219+u6dX3pyb09tfflsvvvBi1lX0Dl3rcZE5M8u6Dhfa0tKSHRwcZF2NmfDzX/5cO+/v6OHhQ72af1VrX1ojlGLEda3vhDhd6+EL51zDzJZi5xFM4yGY4JPHv3isz/63z+rxLx/3zFt4YUEffP0DwrwLR5bZSQomTuUBl8gwXeu/UvzKlGvlJ27a9hedH4BLhK71w+Gmbb8RTMAlQtf64XDTtt8IJuASoWv9cDiy9BvBBFwina71Cy8snBw5zV+d18ILC3St78KRpd/olTcmeuXBR3StT0bvxezRKw+YMS++8CK97xJw07bfCCYAM+m1z72mD77+AUeWQ5j2/V6cyhsTp/IAXGaTGkkk6VQenR8AALGyut8rlWByzn3KOfdHzrkd59wD59zfOue+5Zz7fBrlAwCmL6v7vca+xuSc+yNJVUmua/I1ScuSKs65qpn9l3HXAwCYrqzu9xormJxzfyppRdJXJe1LOuyaXZD07yR91TmXM7P/NM66LjMGkgTgo879XnHhNMn7vUbu/OCc+9eSqmb2O0Ms+78k/amZ/d1IK/PYuJ0feEQBAF9N8n6vSXV+KA8TSpIULbc6xrouJQaSBOCzrEYSGedUnhu8yCkfjbEuOedykt4xsxvjlDOtcofBIwoA+C6L+73GCabzXvUa6ZxhFBxlSXcl5UYpY5rlngcDSQK4CKY9ksg4p/KupVaLGM65knOuIemepCB6eVvuKBhIEgB6jRNMTefcHwyzoHNuU9Kj8xRuZvtmdsPMVs1sV6d7/I1sUuWOgkcUAECvkYPJzO5Jup10I61z7l85574jqWRmfz7qui4rHlEAAL3GvcF2VdI7Cm+kDSS1FR6B5BXex5ST1JR0e8z1XFoMJAkAp40VTGb2kaQl51xZYUeC7p5tgcJ7l/5snHXMAh5RAADPpfLYCzPblrQtSc65XzezH6VRLgBg9qQ+uni/UHLO/Xba6wIAXD7TfOxFbYrrmijnXNk5d+CcO/jpT3+adXUA4FIZeCovGj28eXacu6gL+HluTC2cs27e6j51ubS0xJMWASBFicHknLslaUvSkaTFM7NXdb6wYQMOABho0Km8A0m7kr4RMy+QtG5mc8O8FHYlBwAgUeIRU9QdvN89SIGkvXOsi556AICBRu4ubmZfPefysc/dAACg2zR75QEAMNBEgsk59ynn3Oedc5+aRPkAgMtr5FN5zrlNM7vbZ/Y1SUvRctckWcKyqXPO1aP/vGNmdLoAgAtknCGJSgofstfDzP5e0t93/u2ce2lAkA2jEJWVSwob51xJ0kr0zz1F9xuNWy4AYDrGOZU39KPVo9595yvcuYJzbs8513DOHen5PVNH0bQ959zK2feZ2b7CEc2bku6nVS4AYDrGOWIa+obZ6FpT3yOs2MLNAknLI9RLZnYjYd7I5QIAJm+YIYluKdyQnw2ignPuWxp85FRQeGqtMlINAQAzZWAwmdk70UMACwqHISorDCmn+BEhzgokfTV64i0AAImGOpUXPcriR5Lecc5tKRyqqKXw9FzS+859bQkAMNvOfY3JzILoibUVggcAkLZROz/sKbpPCQCANI0UTNGRUuL1pTOdJlpm9t1R1gUAmC3jdBdPZGbvSHpHOrnB9jtm9h8ntT4AwOUwlUFcoyOsxI4SAABIKRwxOef+QOEpu85j1vNnFskp7Gq+O+66AACX31jB5Jy7r/Dm2bakQ4WhdNi1SCGaVzGzPx9nXQCA2TDyqTzn3L9VGDzXzCxvZq9K2jSzV7tecwpvygUAYCjjXGO6bWZL0c23HT3j50WdIP5HdMoPAIBE4wTTj2KmOefc589OjMLr5THWBQCYEeME08OYafuS1vssP/Ro5ACA2TVOML3a/Q/n3KeiBwSuOud+LWb5m2OsCwAwI8YJpk3n3Hecc59yzh0qHNhVCp8Y23TOfcU59/lo/nfGryoAYBaM3F3czD5yzn1D0lY06f9E07ecc8uS7un06bu+D+8DAKBjrPuYohEdvhq9uqcvRyOQd+5xqpnZP4yzLgDAbJjkWHnbCk/rAQAwtKmMlQcAwLDGGvnBOffAOffbaVYIADDbxjliWpd0TeGwRAAApGKca0x7ZvY7qdUEAACNeY3JOfepcyz7t+OsCwAwG0YOJjP7M0lb57jGxCk/AMBAI5/Ki0YLP5C07pyrSWpKCiQ9ilmca1EAgKGMc41pS9JLklz072sDlmcQVwDAQONcYzqU9A1JL5vZXNJL4ZNt26nUGABwqY0TTIGkejQsUSIzayv++U0AAJwyziCu5+oqbmZLo64LADA7GJIIAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOAVggkA4BWCCQDgFYIJAOCVK1lXABja48fSzo704IF0/bq0tiYtLGRdKwApI5hwMXz/+9Lrr0vHx9KTJ9L8vPS1r0lvvy299lrWtQOQIk7lwX+PH4eh9PhxGEpS+Lcz/ec/z7Z+AFJFMMF/OzvhkVKc4+NwPoBLg2CC/x48eH6kdNaTJ9LDh9OtD4CJIpjgv+vXw2tKcebnpVdfnW59AEwUwQT/ra1Jc31+qnNz4XwAlwbBBP8tLIS97xYWnh85zc8/n/7ii9nWD0CqLkx3cedcTtI7ZnYjpfJWJC1LaklalJSTVDWzII3ykbLXXpM++CDs6PDwYXj6bm2NUAIuIe+DKQqksqS7CsMjjTJrkvJmtnpmPQ3n3LqZ7aexHqTsxRelr3wl61oAmDBvg8k5V5JUlRRI2on+FlMod0XSbTN7uXu6mbWdc+uS6s65Xzez9rjrGhojGgDACW+DKTpqOTltF4VGGqqStvut0zl3qPDorJLS+pIxogEmgZ0dXGDeBtMkOOeKkgqS3ktYrKnw1OHkg6l7RIOOzv06r78eXlPhGgrOi52d4RHgXpq1Xnml6G9SB4dAUs45V5h4bRjRAGlj+Kbhff/70mc/K/3hH0pbW+Hfz342nI5MzVow3Yz+JgXTo+jv2NezBmJEA6SNnZ3hEOBem7VgGqZXX6fTQ36SFZHEiAZIHzs7wyHAvTZrwXSesEmla3oiRjRA2tjZGQ4B7rVZC6acFHYNH2LZxX4znHNl59yBc+7gpz/96ei1YUQDpI2dneEQ4Ofz+LH03e9KlUr4t7vD1gTMVK+8tJjZtqIu50tLSzZWYYxogDR1dmrO9sqbm2Nnp9vaWthTMQ4BfloGvTxnLZjaUjjKwxBHTY8GzE8PIxogTezsDEaADyejW1pmLZjOY3ojPwBpY2dnMAJ8sGE6iUzgdzZrwdQZ1iiv/sFzLfp7OJUaAcgOAZ4so04is9b5oXP/UtLNs53eeM0J1wUA/JZRJ5FZC6bOzQlJXcELkto8/gLAzMuol+dMBZOZNRWewltOWKykPoO8AsBMyeiWlkt5jck5V4/+805M77s7ku455ypn50WPxGhL2pxCNQHAfxl0ErlIwVSQBnf1jp7jtBL9c09njn7MbNc5tyzpnqSzDwqsSlqd6rOYAMB3U+4k4m0wRaN71xT2oCvo+XWhI+dcU2GvuZqZ7Xa/L3qmUqfjwv24ss1s3Tm3Ej3JthNCOUnLXFsCgGx5G0xRQCRdC0p6740hltmVtDtoOQDAdM1U5wcAgP8IJgCAVwgmAIBXCCYAgFcIJgCAVwgmAIBXCCYAgFcIJgCAVwgmAIBXCCYAgFcIJgCAVwgmAIBXCCYAgFcIJgCAV5yZZV2HC80591NJP06puE9L+jClsi4z2ml4tNVwaKfhpNlOv2Zmr8TNIJg84pw7MLOlrOvhO9ppeLTVcGin4UyrnTiVBwDwCsEEAPAKweSX7awrcEHQTsOjrYZDOw1nKu3ENSYAgFc4YgIAeIVgAgB4hWACAHjlStYVQC/nXMPMbmRdDx845wqSapLqkvbNLOiaXpK0LKnSmY6TtqlIWpJ0GE3eM7Ot7GrlB+dcS1I7+udh0rKSama2O+EqXQjOubLC/9ckKRf9rZrZ/kTWR+cHvzjnNhR+4S7ruvjAOVeU1OgzO5C0TCg9F21AKpJWzazZNb0kqTjr4eScO88G7xq/Lck5V5e00x3SzrmcpHuSDs1sPfV1Ekz+iPZ0G5JyBFMoCqa7CvduC5LyCgNph73Z06JQqkr6dTNrn5nXkiQzu5ZF3XwQ/ZbWJG2ebZ8zy5UkFcxs5ruQO+dqCo8cm33m70mqp91WBJNHnHNVhRvfFYIpFG1MlthIJIt2aloKj5R6Ats5dyQpmOVTxFFw7ycdBXWOBMxsdXo185dzrpW0MxOFeMXMlvstMwo6P3jCObciaUeDz3sDcaqS2v2OIs3s5VkOpUhuiFNzVUl3plEZ30U7O/kBiwUKd6ZTRTB5INpLu9nvcBlIEv1+ViTdz7ouPht0fS3aOWwkneabMYeSctF1736KklLfbtErzw93zaySdSVwYd2O/vbrJIIBonBf4xTec2bWds41JVWdc4tnt1FRm1X1vLdeagimjEXnaN/Luh6+i04rrHRNWlTYBXoi3VUvmM4puiDaWJS75tFOw6kq7M2I01YV7vBsREeUq2bWjH5ndUnrk+i5SDBlb5mjpYGWFV64P3UqxjnXcM7tzHoXaJ0+x99z9O2c23PO8TvrI+pgI7qG9zKzwDl3Q2EIFSU1nHOd65gTCSWJa0yZis7d1rKuh+cChd1V4/b4KwpPM5SmXCffdIJpVdJmzPxVPd/jRa+q+P+wryh8bin8f1EKz1yk3uGhG8GUkejUVJu9tGRm1u53GiqaHoiNyom4C/fRtKbCGyLRJfr/cImOR/1FO373FJ65uKHw/7mipFbUBT91BFN2Ktybk4pAUiHawMyqThjtJSxzoLCHVXEK9blI1iVx/a2PKHjWzWzVzAIza0b3NXVOn9cG9NobCcGUgejLZi8/HZ0jzlkOps69b0ndnDvzliZcl4umrOe/IXSJdmIqcT0Vo+uVNxT+rqpp7xgSTFMW9Wa5xqmD4Qzxg+9scGc5mDob1qSbsx9Ff2d2SKKzog1vTvSK7acavWJF27BOj9BUr1/SK2/6SpJKzrl+95wUpLDHWWfCrN6xH43TVXbOxQ6zE+mMdDzLI2Z0fisF9b/ZcTH6+6jP/FnU6TTDDbXxShrQhT7qtbct6WaaKyaYpizawPYdfDQaFLE0q2F0Rl7hRiNpw9E5Uprl6wSdz35T/X9buTPL4vmNobO8U5OG7keJpIJTefDZe5JuDLg5tKRwYM6Z3euNenY2FfaU6qek8F4wTiE/19mpmdnfzgBNPT+qTLKs5I4350YwwVvRjbN9TyVEo7FL4X06s66i8BRxz7W2zmMcRDudNWiA0ll3R9LdpOu80W+r7y0doyKY/JOXhrroPytqzrn62faIejaWFR5Rzfweb7RhqEjaizrYSDr5HXWGjuFo6bTc4EVmV/R7uaPwN9XTuSHqJl7RBEZj53lMHoi+9LvqPRUTSNqd9aFkugaLzOv5xqSpAQ98m0XRHuy6wnbqtM0modQrup5bmOWHJw4j+v+ve/vU+V1N7GGdBBMAwCucygMAeIVgAgB4hWACAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVBXAF4IbqRs6TwRuprkmo84Xk2EUwAfJFXOEL6isKx/fbEQ/xmEqfycKlEQ/LgAooe3V3RgGcA4fIjmHBpRAOWLg9cEL5j/MMZRzDhMmFEduASIJhwmfC8IeASIJhwKUSn8cpZ1wPA+AgmXGjOuVz0PKtG1nUBkA66i+Oiu6vw3pdA4YPMymd65u33e9Bi16PZH0laVPhwvUr3wwc7D5NT2JV528wqURB2rmddkyQzW++zjs6ynTI7D/DLRXXreYBf9HTeG5JanfIV3tMTt2x3/Spmth09WVQKO4LURnmY2zTqELXNcrSOTpsMVdcRvrvU2gZTYGa8eF34l8INk0mqDrFsQeHGsHRm+oqkI0nFM8uWO2VL2uieHy2zJ6kRs56apJWY6aWovLPl5KKyyjHv2Yv7bFH9NqLyytE6c9E8k9QaoR0nXgeFj3uvxUzfiNrZzn4/I353qbUNr+m9Mq8AL15pvM4ZTK1+yyWEjEXz4oJm5WzQRPU5SqhDPSaYGkn1j+q9kfDZ690b7Ghj3LNxH9A2E69DFBA9bXxmfr9gOtd3l2bb8JreK/MK8OKVxmvYYOrag871md8TMtF06xc0Ck8hWndodU3rt57ymSDrHJUVEupe7ldmGkcA06iDnh8t9gR8zHdwNtDG+e44OrpALzo/YNasS2pb17WIMzpD4CzFzDsYUHa+8x/2/FpMwzm3Eo0D1+2+Tg+3sy4psOSx4fajv/16H/Zc/zmnadShc71vP3GpeON8d+O2DaaIzg+YNQVJQddF8Dj7kg5jpp933LYbkt5ReBpJzrlmVPaO9XYiKGrwxrNTp5t95o87rtw06rAkSQnhkmSa3x0yRDBhZkT3OknhXvdWwqJJ84YWhc/LUQ+3VYUb5Q1JG865LYt6C3bVK26DGqfYZ/qjUes6xTp0eiWeSwrf3chtg+njVB4uNedcses02rAb3TTWm+us18y2zWzZzF5W2PV6W2E4bUTzO3vz+fjSeqS+9z/FOgQKw+m8pvbdIXsEEy67JUUb2+j0UVvTGVNvSTHXYSwcQXtdYTh13/sUDFGvzvxJXS+ZRh2a0smzl4Y25e8OGSOYcCkMuGbRvbddkZRzzvU7FSXnXCG6+XNcawnzajp9dFIbVK+u8mrjViyhTpOuQ+d9SY8n6XfUNs3vDhkimHCZxO3xX+sOLTPbVrjXXlV/FUtnRIBiwkY0r66eadF1k6ZOH0WdVZa0NaDX3MimUQcz21f4uZPWETsY75S/O2SIYMJlUpV00jU74XTRLUl551zPXn903aff0UC/PfnO9Lj1rZ+tR/TvuAfirUpa6hpup/s9e5LuW8zwSl3lXzs7bwTTqMNq9J64dVT1/DRhXKif67tLuW0wJc7CG9CASyHaOK0pOhqJ24ieWfamwlN9naOqWvfRgHOuofAorLOBC6JltqKeYnWd3oA2FQbOoaQlez4+26Ke9wxbPLuemHotdk3KSapHRxtnl42rX2BmYz0wcRp1ODMeX1theNQUtme9a9Hls+sd47sbu20weQQTAMArnMoDAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVgAgB4hWACAHiFYAIAeIVgAgB45UrWFZhVjUbDSfq9T3ziE3eOj49/y8x+Jes6AcAwnHP/NDc39+7HH398T9Lf3Lhxw1It3yzV8jCERqPh5ubm/vuVK1d+/zOf+cz8Sy+9pCtXrsg5l3XVACCRmenZs2f66KOP9JOf/OSfnj59+ldm9p/TDCdO5WXj965cufL7X/jCF+Y//elP6+rVq4QSgAvBOaerV6/q05/+tL7whS/8ytzc3J3333//v7755pupbcQIpgx84hOfuPOZz3xm/soVzqQCuLiuXLmiX/3VX736yiuvfFXSrbTKJZgycHx8/FsvvfRS1tUAgLG99NJLeuWVV16RtPrmm2++kEaZBFMGzOxXOFoCcBlcuXJFc3NzVxV2pruWRpkEU0a4pgTgMujaljlJqZwKIpgAAGlJJVMIJgCAVwgmAIBXCCYAgFcIJgAKgkCrq6taXl7W9vZ21tXBjCOYgEgQBHr55Ze1v7+fdVUkSbu7u6pUKtra2tLq6upE11UoFFStVnVwcKB2uz2x9fjWxvATwYSZ0++IIJ/Pq1AoKJ/PT7lGvfb397W5ualqtapSqTTRsOgoFApaWlpKpayL0MbwF3d5YqY0m82+83K5nBqNxhRr01+9Xtfa2pokqVgsam9vL+MaDe+itDH8xRETZkqtVsu6CkMJgkC5XC7raozkorQx/EUwYSa0221tb29zYX+CaGOkhVN5s+bxY2lnR3rwQLp+XVpbkxYWsq5VrGazqTt37igIAt27d0+5XE5BEKher6tarapYLJ4sd3BwIElqtVpaXFzUxsbGqbK2t7fVarWUy+VUq9VOTictLy9rZWVF7XZbt27dUhAEunv3bs/7JWlra+vkKKbdbqtUKp3UYViDytjf31e9XtfBwYEODw9P6pl0FDJsO7XbbW1uburmzZsnZVer1aGOzCbZxltbW6rVagqCQKVSSfV6/aROzWZTt26Fg1aXy2VVq9WxPsegdhjUlpKGauvO50r6rof93maSmfGa8uvg4MAy8e67ZgsLZvPzZlL4d2EhnO6xXC5n1WrVGo2GmZkVi0Wr1WpmZnZ0dGT1ev3U8uVy2TY2NmLL6n5vnEKhYNVq9dS0o6MjKxaL1mq1etaTVNY4ZZRKpZ56DJLUTq1WywqFgh0dHZ0s32g0rFAoDFzvtNpY0kndu21sbJxMH/Zz9DPs+5PactD8837Xg9Z1ERwcHNgbb7zxF2+88cZvWgrbyMw30rP4yiSYfvazMISk3tfCgtnjx9Ov05CKxaKVSqXYebVazXK53KlprVbLwn2u+LKS/qeP2zCvrKzEhkRnY9q9kevnvGWMEkxJ7dSvvLPtEbfcNNrYLGyjcrncM7172WE/x3nXffb9SW05aP55v+tB67oI0g4mrjHNip0d6fg4ft7xcTjfY/1Oa5RKJZXL5VPTCoWCpLADwbja7bZ2d3e1srLSMy+Xy6lYLA68ppJGGcOKa6cgCLS/vx87b2lpaWAvuUm3ccf6+rru379/aloQBCf1HvdznPf9g06lxc0f9bue6dN2MbjGNCsePJCePImf9+SJ9PDhdOtzTteuxT/mpXNjaLvd1v3791O/P6ZzXaVfufl8Xu+9997EyxhWXDt1um8HQaDd3d1T83K5nBYXFxPLnHQbd5RKJUk6tWHf398/CcVxP8d539/vN5c0f9TvetC6Zg3BNCuuX5fm5+PDaX5eevXV6dcpJaurq8rn86pUKid78sMKgiDxPcPc2DpomTTKGEfnAvzt27d7OgjE7dnHmWQbd7t79642Nzf7HnFIo3+ONNphkKy/68uCU3mzYm1Nmuvzdc/NhfMvoNXVVbXbbdVqtb4bv6QNwaChcbpPI8XpPtU0yTLG0RnNYdTTbpNu427lclnNZvPkqOb27dsn88b9HOO+fxhZf9eXBcE0KxYWpLffDv/Oz4fT5uefT3/xxWzrNzEXgM8AAAsvSURBVKLd3d2eceQ6G4XOxrL7ukU+nz+1ER2091ooFFQqlbQTcw0uCAIFQaD19fWJlzGOXC7Xd/1S/+GDOibdxnF1rdVqOjw8PHVkM+7nGPf9w8j6u74sCKZZ8tpr0gcfSN/+tvSNb4R/P/ggnH5B5XI5tVqtU9P29/dVKBR0eHiodrt96nz/8vLywOs5jx49OvXvWq2m3d3dnr3gSqWSeBSRdhnjqNfr2t3d7RkuaHd39+TaTsfZzz+NNu62vr6ura2t2DY5z+eIM+77h5H1d30ppNG1j9cF6C5+AbVaLVtZWTFJVigUrFwu99wb0llmY2PD6vW61ev1k/tuisVibLfdcrls1WrVarXaSXnd68rlcj336BwdHdnGxsbJ+zY2Nmxvb+9cn2eYMs7Wo1wux97bc952ilt/0ufv7rY9rTbultR9OulzDGPYdohry1HbetB3nVTWRZB2d3FnZpmF4qxqNBp248aNrKsBAKloNBr65je/+ZeSvvvWW2/973HL41QeAMArBBMAwCsEEwDAKwQTAMArBBMAwCsEEwDAKwQTAMArBBMAwCsEEwDAKwQTAMArBBMAwCsEEwDAKwQTAMArBBMAwCsEEwDAKwQTAMArBBMAwCsEEwBcEkEQTPV9k0IwAVAQBFpdXdXy8rK2t7ezrg5GsLu7O3LAtNtt7e7uplyj0RFMQCQIAr388sva39/PuiqSwg1NpVLR1taWVldXJ7quQqGgarWqg4MDtdvtia3Htza+LJrNpoIgUKlUOjU9CAJVKhVVKpWTHY9ms9nz/mKxqCAIYudl4UrWFQCmbXt7W+VyuWd6Pp9XoVBQPp/PoFan7e/va3NzU41GQ81mU3t7exNfZ6FQ0NLSUiplXYQ2vkwqlUrPbyQIAu3u7qparZ5M29/f140bN1Sr1Xq+n42NDS0vL0/ltzYIR0yYKUl7hLlcTo1GQ8VicYo1ilev17W2tiYp3Jv1YWMxrIvSxpfF9vZ27BF1rVbTxsbGqWmlUkkbGxtaX1+PPTJeXV3V1tbWxOo6LIIJM6VWq2VdhaEEQaBcLpd1NUZyUdr4sqjVarp9+3bP9N3d3djrhZ0dnrjTqbdv3/bi+yOYMBPa7ba2t7e5sD9BtPH0tdtt5fP52J2YXC6nVqsVO12SDg8PY+cVCoXMrzVxjWnGPP7FY+38cEcPHj3Q9cXrWvvimhY+uZB1tWI1m03duXNHQRDo3r17yuVyCoJA9Xpd1Wr15HRQs9nUwcGBJKnVamlxcbHnFMb29rZarZZyuZxqtZoajYYkaXl5WSsrK2q327p165aCINDdu3d73i9JW1tbJ/9Tt9ttlUqlc5+SGlTG/v6+6vW6Dg4OdHh4eFLPpL3YYdup3W5rc3NTN2/ePCm7Wq0OdWQ2yTbe2tpSrVY7uXhfr9dP6tRsNnXr1i1JUrlcVrVaHetzDGqHQW0paai27nyupO962O8tyf3797W8vBw7r9P+Z3V67vW7nri8vKz9/f1sT7eaGa8pvw4ODiwL7/74XVv41oLN/8m86Y9l838ybwvfWrB3f/xuJvUZVi6Xs2q1ao1Gw8zMisWi1Wo1MzM7Ojqyer1+avlyuWwbGxuxZXW/N06hULBqtXpq2tHRkRWLRWu1Wj3rSSprnDJKpVJPPQZJaqdWq2WFQsGOjo5Olm80GlYoFAaud1ptLOmk7t02NjZOpg/7OfoZ9v1JbTlo/nm/60HrSrKysmJ7e3tDLdv9nmKx2Hf+3t6eraysnKvMg4MDe+ONN/7ijTfe+E1LYRuZ+UZ6Fl9ZBNPP/vlntvCtBdMfq+e18K0Fe/yLx1Ov07CKxaKVSqXYebVazXK53KlprVbLwn2u+LKS/qeP2zCvrKzEhkRnY9q9kevnvGWMEkxJ7dSvvLPtEbfcNNrYLGyjcrncM7172WE/x3nXffb9SW05aP55v+tB60oSF4BJGo2G5XK52B2AjlarlRhccdIOJq4xzYidH+7o2I5j5x3bsXbe35lyjc6n32mFUqnU0+21UChISudu9s6NhysrKz3zcrmcisXiwGsqaZQxrLh2CoKg76mZpaWlvqd8Oibdxh3r6+u6f//+qWlBEJzUe9zPcd73DzqVFTd/1O961NNmnWtMw1pdXVW9Xk9cXz6fn+i9bMPgGtOMePDogZ48fRI778nTJ3p4+HDKNTqfa9euxU7v3Bjabrd1//791O+P6VxX6VduPp/Xe++9N/EyhhXXTp0L2Z37WrrlcjktLi4mljnpNu7o3BzavWHf398/CcVxP8d539/vN5c0f9TvetC6+onrwNDP6uqqqtVqz024Z3WudWWJYJoR1xeva/7qfGw4zV+d16v5VzOoVTpWV1eVz+dVqVRO9uSHFQRB4nuG2XMctEwaZYyjcwH+9u3bPR0E4vbs40yyjbvdvXtXm5ubfY84pNE/RxrtMEjW33U/lUpFa2trQ33Odrud+a0KnMqbEWtfXNOci/+659yc1r60NuUapWN1dVXtdlu1Wq3vxi9pQzBoaJzu00hxuk81TbKMcXR6X426FzzpNu5WLpdPhtfZ3d09dX/OuJ9j3PcPY9rfdT6fH3jUtL29rZs3b/aEUlKX8KxH5iCYZsTCJxf09pff1sILC5q/Oi8pPFJaeCGc/uILL2Zcw9Hs7u723PXe2Sh0Npbd1y3Onj8ftPdaKBRUKpW0s9N7DS4IAgVBoPX19YmXMY5cLtd3/ZIGXt+adBvH1bVWq+nw8PDUnvu4n2Pc9w9j2t91oVAYuFOQz+djQ6lfoJ3nCHdSCKYZ8trnXtMHX/9A3/7db+sb/+Yb+vbvflsffP0Dvfa517Ku2sjibiLc399XoVDQ4eFhz8Xh5eXlgddzHj16dOrftVotduTmSqWSeBSRdhnjqNfr2t3d7dlL3t3d7bnmcPbzT6ONu62vr2trayu2Tc7zOeKM+/5hTPO7LhQKfY/Oms2m6vW6pPDzdb82Nzf71sOHYMq86/QsvrK6j+miabVatrKyYpKsUChYuVzu6RrbWWZjY8Pq9brV6/WT+26KxWJst91yuWzVatVqtdpJed3ryuVyPffoHB0d2cbGxsn7NjY2zn3/yDBlnK1HuVxO7No7bDvFrT/p83d3255WG3dL6j6d9DmGMWw7xLXlqG096LtOKitJvV6P7WJvFt4fJanvq59yuXzu33ba3cWdmU0/DWdco9GwGzduZF0NAJfAtWvXYocemmZ5jUZD3/zmN/9S0nffeuut/z1uHTiVBwAXWLFYTG1su2az6cXI7wQTAFxg1Wo1tRHBa7Xaqec3ZYVgAoALrNNRYdyjps77M+/4IIIJAC68Wq029lFTGmWkhWACgEugWq2OfC/W2UewZ40hiQDgEsjlcj2D7Q4rrSGZ0sIREwDAKwQTAMArBBMAwCsEU0YYcQPAZTCJbRnBlAHn3D89e/Ys62oAwNiePXum4+Pjp2mWSTBlYG5u7t2PPvoo62oAwNg++ugjHR0d/Tj653EaZRJMGfj444/v/eQnP3nCUROAi+zZs2f6x3/8x6c/+MEPOsNOpLLHTTBl42+ePXv2Vz/84Q//+cMPP9TTp0+55gTgQjAzPX36VB9++KHef//9pw8fPvyH733vey1Jv5SUyjDnPPYiI41Gwx0eHv6Hjz/++JuLi4ufnZub42ZnABfC8fHx06Ojox//4Ac/aH7ve9/7saR/Kemv3nrrrb9Lo3yCKWNvvvnmv5D07yV9SeEDvADgopiTdCjpf0r6/ltvvZXKNoxg8sSbb765IOkVSVezrgsADOFY0s8l/b+0AqmDYAIAeIXODwAArxBMAACvEEwAAK/8f9i1z+vqfVaeAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fontsize = 30\n",
    "point_size = 50\n",
    "\n",
    "colors = ['orange', 'blue', 'red', 'green', 'purple', 'black', 'cyan']\n",
    "\n",
    "plt.scatter(orders, np.array(errors_MCAR_rect) / np.array(errors_MCAR_sq), s=point_size, color=colors[2], label='ratio of relative error')\n",
    "plt.scatter(orders, np.array(errors_MCAR_rect_larger) / np.array(errors_MCAR_sq_larger), s=point_size, color=colors[3], label='ratio of relative error (2)')\n",
    "\n",
    "plt.xlabel('tensor order', fontsize=fontsize)\n",
    "plt.ylabel('ratio', fontsize=fontsize)\n",
    "\n",
    "ytick_pos = [1, 1.1, 1.2]\n",
    "plt.xticks(fontsize=fontsize)\n",
    "plt.yticks(ytick_pos, fontsize=fontsize)\n",
    "\n",
    "plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.3), fancybox=True, shadow=True, ncol=1, fontsize=fontsize-7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model B: MNAR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_propensity_errors_non_uniform_at_tensor_order(N, parameter_ratio=1.5):\n",
    "    print(\"order: {}\".format(N))\n",
    "    r = [2 for _ in range(N)]\n",
    "    \n",
    "    # generate parameter tensor\n",
    "    A_noise_para = 0.1\n",
    "    np.random.seed(2)\n",
    "    A_real_core = 2 * np.random.uniform(0,1,r)\n",
    "    A_factor_matrices = [generate_orthogonal_mats((I,r[0])) for i in range(N)]\n",
    "    real_A = tucker_to_tensor((A_real_core, A_factor_matrices))\n",
    "    A_fro_norm = np.linalg.norm(real_A)\n",
    "    A_noise_coeff = A_noise_para * A_fro_norm / I ** (len(r)*1./2)\n",
    "    A_noise_ten = tl.tensor(np.random.normal(0,1,[I]*N))\n",
    "    A = real_A + A_noise_coeff * A_noise_ten\n",
    "    \n",
    "    A_rect = tl.unfold(A, mode=0)\n",
    "    _, A_Sigma, _ = randomized_svd(A_rect, n_components=10, n_iter=20, random_state=None)\n",
    "    alpha_of_A_rect = np.max(np.abs(A_rect))\n",
    "    theta_of_A_rect = np.sum(A_Sigma) / (np.sqrt(np.prod(A_rect.shape)))\n",
    "    \n",
    "    relative_error_rect, elapsed_rect = get_propensity_errors_from_A(\n",
    "        A, tau=parameter_ratio*theta_of_A_rect, gamma=parameter_ratio*alpha_of_A_rect, max_rank=None, method='rectangular')\n",
    "    \n",
    "    A_sq = square_unfolding(A)\n",
    "    _, A_Sigma, _ = randomized_svd(A_sq, n_components=10, n_iter=20, random_state=None)\n",
    "    alpha_of_A_sq = np.max(np.abs(A_sq))\n",
    "    theta_of_A_sq = np.sum(A_Sigma) / (np.sqrt(np.prod(A_sq.shape)))\n",
    "    \n",
    "    relative_error_sq, elapsed_sq = get_propensity_errors_from_A(\n",
    "        A, tau=parameter_ratio*theta_of_A_rect, gamma=parameter_ratio*alpha_of_A_rect, max_rank=None, method='square')\n",
    "    \n",
    "    \n",
    "    print(\"order: {} finished\".format(N))\n",
    "    return relative_error_rect, relative_error_sq, elapsed_rect, elapsed_sq   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an instance of the 1-bit completion experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order: 6\n",
      "tau: 0.024478051061951063, gamma: 0.4732955648490587, max_rank: None\n",
      "tau: 0.024478051061951063, gamma: 0.4732955648490587, max_rank: None\n",
      "order: 6 finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.009392374130923187,\n",
       " 0.008383333680063745,\n",
       " 0.08978533744812012,\n",
       " 0.3233203887939453)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_propensity_errors_non_uniform_at_tensor_order(6, parameter_ratio=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run the 1-bit completion experiments in parallel for MNAR tensor with $\\tau = \\theta$, $\\gamma = \\alpha$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order: 6\n",
      "order: 5\n",
      "order: 7\n",
      "order: 8\n",
      "order: 4\n",
      "tau: 0.07677415212450625, gamma: 0.4570851524620143, max_rank: None\n",
      "tau: 0.07677415212450625, gamma: 0.4570851524620143, max_rank: None\n",
      "order: 4 finished\n",
      "tau: 0.042002011553797916, gamma: 0.43860386093507936, max_rank: None\n",
      "tau: 0.042002011553797916, gamma: 0.43860386093507936, max_rank: None\n",
      "order: 5 finished\n",
      "tau: 0.024478051061951063, gamma: 0.4732955648490587, max_rank: None\n",
      "tau: 0.024478051061951063, gamma: 0.4732955648490587, max_rank: None\n",
      "order: 6 finished\n",
      "tau: 0.012803822687254636, gamma: 0.2993852203892347, max_rank: None\n",
      "tau: 0.012803822687254636, gamma: 0.2993852203892347, max_rank: None\n",
      "order: 7 finished\n",
      "tau: 0.006493589646487807, gamma: 0.3491348879506197, max_rank: None\n",
      "tau: 0.006493589646487807, gamma: 0.3491348879506197, max_rank: None\n",
      "order: 8 finished\n"
     ]
    }
   ],
   "source": [
    "p = mp.Pool(mp.cpu_count())\n",
    "results = [p.apply_async(get_propensity_errors_non_uniform_at_tensor_order, args=[N, 1]) for N in orders]\n",
    "p.close()\n",
    "p.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "errors_rect = []\n",
    "errors_sq = []\n",
    "elapsed_times_rect = []\n",
    "elapsed_times_sq = []\n",
    "\n",
    "for result in results:\n",
    "    errors_rect.append(result.get()[0])\n",
    "    errors_sq.append(result.get()[1])\n",
    "    elapsed_times_rect.append(result.get()[2])\n",
    "    elapsed_times_sq.append(result.get()[3])\n",
    "\n",
    "errors_rect_dict = dict(zip(orders, errors_rect))\n",
    "errors_sq_dict = dict(zip(orders, errors_sq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "run the 1-bit completion experiments in parallel for MNAR tensor with $\\tau = 2\\theta$, $\\gamma = 2\\alpha$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order: 7\n",
      "order: 4\n",
      "order: 5\n",
      "order: 6\n",
      "order: 8\n",
      "tau: 0.1535483042490125, gamma: 0.9141703049240286, max_rank: None\n",
      "tau: 0.08400402310759583, gamma: 0.8772077218701587, max_rank: None\n",
      "tau: 0.1535483042490125, gamma: 0.9141703049240286, max_rank: None\n",
      "order: 4 finished\n",
      "tau: 0.08400402310759583, gamma: 0.8772077218701587, max_rank: None\n",
      "order: 5 finished\n",
      "tau: 0.048956102123902126, gamma: 0.9465911296981174, max_rank: None\n",
      "tau: 0.048956102123902126, gamma: 0.9465911296981174, max_rank: None\n",
      "order: 6 finished\n",
      "tau: 0.025607645374509273, gamma: 0.5987704407784694, max_rank: None\n",
      "tau: 0.025607645374509273, gamma: 0.5987704407784694, max_rank: None\n",
      "order: 7 finished\n",
      "tau: 0.012987179292975614, gamma: 0.6982697759012394, max_rank: None\n",
      "tau: 0.012987179292975614, gamma: 0.6982697759012394, max_rank: None\n",
      "order: 8 finished\n"
     ]
    }
   ],
   "source": [
    "p = mp.Pool(mp.cpu_count())\n",
    "results = [p.apply_async(get_propensity_errors_non_uniform_at_tensor_order, args=[N, 2]) for N in orders]\n",
    "p.close()\n",
    "p.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "errors_rect_larger = []\n",
    "errors_sq_larger = []\n",
    "elapsed_times_rect_larger = []\n",
    "elapsed_times_sq_larger = []\n",
    "\n",
    "for result in results:\n",
    "    errors_rect_larger.append(result.get()[0])\n",
    "    errors_sq_larger.append(result.get()[1])\n",
    "    elapsed_times_rect_larger.append(result.get()[2])\n",
    "    elapsed_times_sq_larger.append(result.get()[3])\n",
    "\n",
    "errors_rect_larger_dict = dict(zip(orders, errors_rect_larger))\n",
    "errors_sq_larger_dict = dict(zip(orders, errors_sq_larger))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Figure 1(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9c0ff87a90>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fontsize = 30\n",
    "point_size = 50\n",
    "\n",
    "colors = ['orange', 'blue', 'red', 'purple', 'black', 'green', 'cyan']\n",
    "\n",
    "plt.plot(orders, errors_rect, 'bo', linestyle='-', color=colors[0], label='unfolding along one dimension')\n",
    "plt.plot(orders, errors_rect_larger, 'bo', linestyle='--', color=colors[0], label='unfolding along one dimension (2)')\n",
    "plt.plot(orders, errors_sq, 'bo', linestyle='-', color=colors[1], label='square unfolding')\n",
    "plt.plot(orders, errors_sq_larger, 'bo', linestyle='--', color=colors[1], label='square unfolding (2)')\n",
    "\n",
    "plt.xlabel('tensor order', fontsize=fontsize)\n",
    "plt.ylabel('relative error', fontsize=fontsize)\n",
    "\n",
    "xtick_pos = orders\n",
    "ytick_pos = [0.02*i for i in [0, 1, 2]]\n",
    "plt.xticks(xtick_pos, fontsize=fontsize)\n",
    "plt.yticks(ytick_pos, fontsize=fontsize)\n",
    "\n",
    "plt.ylim(0, 0.04)\n",
    "\n",
    "plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.3), fancybox=True, shadow=True, ncol=1, fontsize=fontsize-7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Figure 1(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9c100e0dd8>"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fontsize = 30\n",
    "point_size = 50\n",
    "\n",
    "colors = ['orange', 'blue', 'red', 'green', 'purple', 'black', 'cyan']\n",
    "\n",
    "plt.scatter(orders, np.array(errors_rect) / np.array(errors_sq), s=point_size, color=colors[2], label='ratio of relative error')\n",
    "plt.scatter(orders, np.array(errors_rect_larger) / np.array(errors_sq_larger), s=point_size, color=colors[3], label='ratio of relative error (2)')\n",
    "\n",
    "plt.xlabel('tensor order', fontsize=fontsize)\n",
    "plt.ylabel('ratio', fontsize=fontsize)\n",
    "\n",
    "xtick_pos = orders\n",
    "ytick_pos = [1, 1.2, 1.4, 1.6]\n",
    "plt.xticks(xtick_pos, fontsize=fontsize)\n",
    "plt.yticks(ytick_pos, fontsize=fontsize)\n",
    "\n",
    "plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.3), fancybox=True, shadow=True, ncol=1, fontsize=fontsize-7)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}