notebooks/geodesic-regression/geodesic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import geoopt\n",
    "import torch\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from geoopt.manifolds.lorentz import Lorentz\n",
    "from geoopt.manifolds.lorentz import math\n",
    "\n",
    "from torch.utils.data import TensorDataset, DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_params(dim, zero=False):\n",
    "    # Generate model parameters\n",
    "    p = torch.randn((1, dim)) * 2.0\n",
    "    if zero:\n",
    "        p /= 1000\n",
    "    p = man.projx(p) # project onto the hyperboloid \n",
    "    man._check_point_on_manifold(p[0])\n",
    "    orig = man.origin((1, dim))\n",
    "    beta = torch.randn((1, dim)) * 2.0\n",
    "    if zero:\n",
    "        beta /= 1000\n",
    "    beta /= beta.norm(dim=-1)\n",
    "    beta = man.proju(orig, beta)\n",
    "    beta = man.transp(orig, p, beta)\n",
    "    return p, beta\n",
    "\n",
    "def plot_params(p, beta):\n",
    "    p_np = p.numpy()\n",
    "    beta_np = beta.numpy()\n",
    "    lins_x = np.linspace(-3, 3, 100)\n",
    "    linx_y = np.sqrt(k + lins_x**2)\n",
    "    plt.plot(lins_x, linx_y, color=\"C1\", label=\"Hyperboloid\")\n",
    "    plt.scatter(p_np[:, 1], p_np[:, 0], label=\"intercept p\")\n",
    "    plt.arrow(p_np[0, 1], p_np[0, 0], beta_np[0, 1], beta_np[0, 0], \n",
    "        width=0.01, color=\"C2\", label=\"weight beta\")\n",
    "    plt.legend()\n",
    "\n",
    "def add_noise(y, dim, sig=1.0):\n",
    "    n = y.shape[0]\n",
    "    orig = man.origin((1, dim))\n",
    "    eps = torch.randn(n, dim) * sig\n",
    "    eps = man.proju(orig, eps)\n",
    "    eps = man.transp(orig, y, eps)\n",
    "    ynoise = man.expmap(y, eps)\n",
    "    return ynoise\n",
    "\n",
    "def generate_data(n, p, beta, dim):\n",
    "    x = (torch.rand(n, 1) * 10.0) - 5.0\n",
    "    y = man.expmap(p, x * beta)\n",
    "    ynoise = add_noise(y, dim, sig=1.0)\n",
    "    return x, ynoise, y\n",
    "\n",
    "k = 50 # choose curvature parameter\n",
    "d = 80\n",
    "dim = d + 1\n",
    "man = Lorentz(k=k)\n",
    "n_train = 100 # 1000\n",
    "n_test = 100 # 500\n",
    "n = n_train + n_test\n",
    "p, beta = sample_params(dim)\n",
    "x, y, y_true = generate_data(n, p, beta, dim)\n",
    "\n",
    "if d == 1:\n",
    "    plot_params(p, beta)\n",
    "    plt.scatter(y[:, 1], y[:, 0], alpha=0.1, color='C3', label='data')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training loss: 79.59\n",
      "Validation loss:76.57\n"
     ]
    }
   ],
   "source": [
    "class GeodesicRegressor():\n",
    "    def __init__(self, K, dim, man):\n",
    "        self.K = K\n",
    "        self.dim = dim\n",
    "        self.man = man\n",
    "        q, alpha = sample_params(dim, zero=True)\n",
    "        self.q = torch.autograd.Variable(q, requires_grad=True)\n",
    "        self.alpha = torch.autograd.Variable(alpha, requires_grad=True)\n",
    "\n",
    "    def fit(self, X, Y, epochs=300, lr=0.01, verbose=False):\n",
    "        n = X.shape[0]\n",
    "\n",
    "        dataset = TensorDataset(X, Y)\n",
    "        dataloader = DataLoader(dataset, batch_size=n)\n",
    "        for e in range(epochs):\n",
    "            for X, Y in dataloader:\n",
    "                \n",
    "                Y_hat = self.man.expmap(self.q, X * self.alpha)\n",
    "                loss = torch.mean(self.man.dist2(Y, Y_hat))\n",
    "                #print(f\"Loss: {loss.item()}\")\n",
    "                \n",
    "                # Optimization step\n",
    "                loss.backward()\n",
    "                with torch.no_grad():\n",
    "\n",
    "                    # Get riemannian gradient \n",
    "                    dq = self.man.egrad2rgrad(self.q, self.q.grad)\n",
    "                    qnew = self.man.expmap(self.q, -lr * dq)\n",
    "                    # Gradient of alpha should be in the tangent space of q\n",
    "                    dalpha = self.man.egrad2rgrad(self.q, self.alpha.grad)\n",
    "                    alphanew = self.alpha - (lr * dalpha)\n",
    "                    alphanew = self.man.transp(self.q, qnew, alphanew)\n",
    "\n",
    "                    self.alpha.zero_()\n",
    "                    self.alpha.add_(alphanew)\n",
    "                    self.q.zero_()\n",
    "                    self.q.add_(qnew)\n",
    "\n",
    "                self.alpha.grad.zero_()\n",
    "                self.q.grad.zero_()\n",
    "\n",
    "            dataset = TensorDataset(X, Y)\n",
    "            dataloader = DataLoader(dataset, batch_size=n)\n",
    "            losses = []\n",
    "            for X, Y in dataloader:\n",
    "                with torch.no_grad():\n",
    "                    Y_hat = self.man.expmap(self.q, X * self.alpha)\n",
    "                    loss = torch.mean(self.man.dist2(Y, Y_hat))\n",
    "            losses.append(loss.detach().numpy())\n",
    "\n",
    "        return losses[-1]\n",
    "\n",
    "    def predict(self, X):\n",
    "        Y_hat = man.expmap(self.q, X * self.alpha)\n",
    "        return Y_hat\n",
    "\n",
    "model = GeodesicRegressor(k, dim, man)\n",
    "train_loss =  model.fit(x[:n_train], y[:n_train])\n",
    "yhat = model.predict(x[n_train:])\n",
    "val_loss = torch.mean(man.dist2(y[n_train:], yhat))\n",
    "print(f'Training loss: {train_loss:.4}')\n",
    "print(f\"Validation loss:{val_loss:.4}\")\n",
    "\n",
    "if d == 1:\n",
    "    plot_params(\n",
    "        model.q.detach(), \n",
    "        model.alpha.detach())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 examples... Validation loss:92.23408508300781\n",
      "20 examples... Validation loss:83.50495147705078\n",
      "30 examples... Validation loss:79.4647445678711\n",
      "40 examples... Validation loss:77.96101379394531\n",
      "50 examples... Validation loss:77.43061828613281\n",
      "60 examples... Validation loss:77.21734619140625\n",
      "70 examples... Validation loss:76.84571838378906\n",
      "80 examples... Validation loss:76.75630187988281\n",
      "90 examples... Validation loss:76.59426879882812\n",
      "100 examples... Validation loss:76.56623840332031\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "subset_sizes = range(10, n_train+1, 10)\n",
    "train_losses = []\n",
    "val_losses = []\n",
    "pq_norms = []\n",
    "ba_norms = []\n",
    "\n",
    "for n_subset in subset_sizes:\n",
    "    model = GeodesicRegressor(k, dim, man)\n",
    "    train_loss = model.fit(x[:n_subset], y[:n_subset])\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    pq_norms.append(\n",
    "        np.linalg.norm(p[0] - model.q.detach().numpy()[0], ord=2))\n",
    "    ba_norms.append(\n",
    "        np.linalg.norm(beta[0] - model.alpha.detach().numpy()[0], ord=2))\n",
    "\n",
    "    yhat = model.predict(x[n_train:])\n",
    "    val_loss = torch.mean(man.dist2(y[n_train:], yhat))\n",
    "    val_losses.append(val_loss.detach().numpy())\n",
    "    print(f\"{n_subset} examples... Validation loss:{val_loss}\")\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(nrows=1, ncols=2)\n",
    "ax[0].plot(subset_sizes, train_losses, label='Train loss')\n",
    "ax[0].plot(subset_sizes, val_losses, label='Validation loss')\n",
    "ax[0].set_xlabel('Number of training examples')\n",
    "ax[0].set_ylabel('Loss')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].plot(subset_sizes, pq_norms, color='C3', \n",
    "    label=r'$\\|p - \\hat{p}\\|_2$')\n",
    "ax[1].plot(subset_sizes, ba_norms, color='C4', \n",
    "    label=r'$\\|\\beta - \\hat{\\beta}\\|_2$')\n",
    "ax[1].set_xlabel('Number of training examples')\n",
    "ax[1].legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate LFs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LFGenerator():\n",
    "    def __init__(self, num_lfs, siglb=2, sigub=5, heterogeneous=True):\n",
    "        self.siglb = siglb\n",
    "        self.sigub = sigub\n",
    "        self.heterogeneous = heterogeneous\n",
    "        self.num_lfs = num_lfs\n",
    "        self.sigs = []\n",
    "\n",
    "    def fit(self, sep=15):\n",
    "        for i in range(self.num_lfs):\n",
    "            coin = np.random.randint(0, 2) * self.heterogeneous\n",
    "            sig = np.random.uniform(\n",
    "                self.siglb + (coin*sep), self.sigub + (coin*sep))\n",
    "            self.sigs.append(sig)\n",
    "    \n",
    "    def predict(self, Y_true):\n",
    "        lambdas = []\n",
    "        for i in range(self.num_lfs):\n",
    "            lambda_i_preds = add_noise(Y_true, dim, sig=self.sigs[i])\n",
    "            lambdas.append(lambda_i_preds)\n",
    "        return lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "class GeodesicLabelModel():\n",
    "    def __init__(self, num_triplets=1):\n",
    "        self.num_triplets = num_triplets\n",
    "        self.num_lfs = self.num_triplets * 3\n",
    "        self.thetas = []\n",
    "\n",
    "    def fit(self, lambdas):\n",
    "        dim = lambdas[0].shape[1]\n",
    "        for i in range(self.num_triplets):\n",
    "            Eab = torch.mean(\n",
    "                man.dist(lambdas[(i*3)+0], lambdas[(i*3)+1])) / dim\n",
    "            Ebc = torch.mean(\n",
    "                man.dist(lambdas[(i*3)+1], lambdas[(i*3)+2])) / dim\n",
    "            Eac = torch.mean(\n",
    "                man.dist(lambdas[(i*3)+0], lambdas[(i*3)+2])) / dim\n",
    "            E = np.array([Eab, Ebc, Eac])\n",
    "            coef = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 1]])\n",
    "            thetas_abc = np.reciprocal(np.linalg.solve(coef, E))\n",
    "            self.thetas += list(thetas_abc)\n",
    "\n",
    "    def predict(self, lambdas, max_steps=200, lr=0.001, \n",
    "            verbose=False, vote=False):\n",
    "        n = lambdas[0].shape[0]\n",
    "        ys = torch.zeros_like(lambdas[0])\n",
    "        for i in tqdm(range(n)):\n",
    "            if vote:\n",
    "                thetas = np.ones_like(self.thetas)\n",
    "            else:\n",
    "                thetas = self.thetas\n",
    "                \n",
    "            # Initialize y to be on the manifold\n",
    "            y = torch.randn_like(lambdas[0][0])\n",
    "            y = torch.autograd.Variable(man.projx(y), requires_grad=True) \n",
    "            \n",
    "            for step in range(max_steps):\n",
    "                objective = torch.zeros(1)\n",
    "                for j in range(self.num_lfs):\n",
    "                    objective += (\n",
    "                        thetas[j] * man.dist2(lambdas[j][i], y))\n",
    "                objective.backward()\n",
    "\n",
    "                # Riemannian descent step\n",
    "                with torch.no_grad():\n",
    "                    dy = man.egrad2rgrad(y, y.grad)\n",
    "                    ynew = man.expmap(y, -lr * dy)\n",
    "                    y.zero_()\n",
    "                    y.add_(ynew)\n",
    "                y.grad.zero_()\n",
    "            \n",
    "                if verbose:\n",
    "                    print(i, step, objective.item())\n",
    "            \n",
    "            ys[i] += y\n",
    "        return ys\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_lambdas = 3\n",
    "lfGenerator = LFGenerator(num_lambdas, siglb=1.5, sigub=2.0) # TODO\n",
    "lfGenerator.fit()\n",
    "lambdas = lfGenerator.predict(y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 200/200 [00:13<00:00, 14.77it/s]\n"
     ]
    }
   ],
   "source": [
    "labelModel = GeodesicLabelModel(num_triplets=num_lambdas//3)\n",
    "lambdas_train = [lambdas[i][:n_train, :] for i in range(len(lambdas))]\n",
    "labelModel.fit(lambdas_train) # TODO only fit label model with train examples? \n",
    "weak_labels = labelModel.predict(lambdas, max_steps=50, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_clean_loss(n_clean):\n",
    "    #n_clean = n_train // 4\n",
    "    model = GeodesicRegressor(k, dim, man)\n",
    "    train_loss = model.fit(x[:n_clean], y[:n_clean])\n",
    "    yhat = model.predict(x[n_train:])\n",
    "    val_loss = torch.mean(man.dist2(y[n_train:], yhat))\n",
    "    val_loss = val_loss.detach().numpy()\n",
    "    print(f\"Validation loss clean: {val_loss}\")\n",
    "    return val_loss\n",
    "\n",
    "def get_ws_loss(n_clean, weak_labels):\n",
    "    weak_labels = torch.Tensor(weak_labels.detach().numpy())\n",
    "    model = GeodesicRegressor(k, dim, man)\n",
    "    extended_labels = torch.vstack(\n",
    "        [y[:n_clean], weak_labels[n_clean:n_train]])\n",
    "    train_loss = model.fit(x[:n_train], extended_labels)\n",
    "    yhat = model.predict(x[n_train:])\n",
    "    val_loss = torch.mean(man.dist2(y[n_train:], yhat))\n",
    "    val_loss = val_loss.detach().numpy()\n",
    "    print(f\"Validation loss weakly supervised: {val_loss}\")\n",
    "    return val_loss\n",
    "\n",
    "def get_ws_loss_lambdas(n_clean, num_lambdas, \n",
    "        siglb=1.5, sigub=2.0, vote=False, max_steps=100):\n",
    "    lfGenerator = LFGenerator(num_lambdas, siglb=siglb, sigub=sigub)\n",
    "    lfGenerator.fit()\n",
    "    lambdas = lfGenerator.predict(y_true)\n",
    "    lambdas_train = [lambdas[i][:n_train, :] for i in range(len(lambdas))]\n",
    "    \n",
    "    if vote:\n",
    "        labelModel = GeodesicLabelModel(num_triplets=num_lambdas//3)\n",
    "        labelModel.fit(lambdas_train) \n",
    "        \n",
    "        weak_labels = labelModel.predict(lambdas_train, max_steps=max_steps, verbose=False, vote=False)\n",
    "        ws_loss = get_ws_loss(n_clean, weak_labels)\n",
    "        weak_labels = labelModel.predict(lambdas_train, max_steps=max_steps, verbose=False, vote=True)\n",
    "        vote_loss = get_ws_loss(n_clean, weak_labels)\n",
    "\n",
    "        return ws_loss, labelModel, vote_loss\n",
    "    else:\n",
    "        labelModel = GeodesicLabelModel(num_triplets=num_lambdas//3)\n",
    "        labelModel.fit(lambdas_train) \n",
    "        weak_labels = labelModel.predict(lambdas_train, max_steps=max_steps, verbose=False, vote=False)\n",
    "        return get_ws_loss(n_clean, weak_labels), labelModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss clean: 77.43062591552734\n",
      "Validation loss weakly supervised: 76.45803833007812\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array(76.45804, dtype=float32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_clean_loss(n_train // 2)\n",
    "get_ws_loss(n_train // 2, weak_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss clean: 76.75625610351562\n",
      "Validation loss clean: 76.59428405761719\n",
      "Validation loss clean: 76.56623077392578\n"
     ]
    }
   ],
   "source": [
    "fracs = [80, 90, n_train] \n",
    "\n",
    "clean_losses = []\n",
    "for i in range(len(fracs)):\n",
    "    loss = get_clean_loss(fracs[i])\n",
    "    clean_losses.append(loss)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:13<00:00,  7.47it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.97875213623047\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:13<00:00,  7.38it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 76.25904846191406\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:19<00:00,  5.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.73184967041016\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.79270935058594\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:25<00:00,  3.86it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.65396118164062\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:26<00:00,  3.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.76092529296875\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:34<00:00,  2.88it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.56144714355469\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:34<00:00,  2.90it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.63172149658203\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:42<00:00,  2.38it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.68801879882812\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:42<00:00,  2.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.77873229980469\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:49<00:00,  2.03it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.63467407226562\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:59<00:00,  1.69it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.7601318359375\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [01:13<00:00,  1.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.52759552001953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [01:07<00:00,  1.49it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation loss weakly supervised: 75.57273864746094\n"
     ]
    }
   ],
   "source": [
    "num_lfs = [3, 6, 9, 12, 15, 18, 21]\n",
    "ws_losses = []\n",
    "vote_losses = []\n",
    "label_models = []\n",
    "\n",
    "siglb = 1.5\n",
    "\n",
    "for num_lf in num_lfs:\n",
    "    ws_loss, label_model, vote_loss = get_ws_loss_lambdas(0, num_lf, \n",
    "        siglb=siglb, sigub=siglb+4.0, vote=True, max_steps=100)\n",
    "    ws_losses.append(ws_loss)\n",
    "    label_models.append(label_model)\n",
    "    vote_losses.append(vote_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[80, 90, 100]\n",
      "[array(76.756256, dtype=float32), array(76.594284, dtype=float32), array(76.56623, dtype=float32)]\n",
      "[3, 6, 9, 12, 15, 18, 21]\n",
      "[array(75.97875, dtype=float32), array(75.73185, dtype=float32), array(75.65396, dtype=float32), array(75.56145, dtype=float32), array(75.68802, dtype=float32), array(75.634674, dtype=float32), array(75.527596, dtype=float32)]\n",
      "[array(76.25905, dtype=float32), array(75.79271, dtype=float32), array(75.760925, dtype=float32), array(75.63172, dtype=float32), array(75.77873, dtype=float32), array(75.76013, dtype=float32), array(75.57274, dtype=float32)]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/chshin/opt/anaconda3/envs/universalizing-weak-supervision/lib/python3.6/site-packages/ipykernel_launcher.py:27: UserWarning: Tight layout not applied. The left and right margins cannot be made large enough to accommodate all axes decorations. \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x252 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.size'] = '25'\n",
    "fig, ax = plt.subplots(1, 1, figsize=(3.5, 3.5))\n",
    "\n",
    "for i in range(len(fracs)):\n",
    "    ax.axhline(clean_losses[i], linestyle=':', color=f'C{i}', linewidth=4,  \n",
    "        label=f'Fully supervised ({int((fracs[i]/n_train)*100)}%)')\n",
    "\n",
    "ax.plot(num_lfs, ws_losses, '-v', label='WS (Ours)',\n",
    "    linewidth=4, markeredgewidth=4, color='C3')\n",
    "ax.plot(num_lfs, vote_losses, '-o', label='WS (Majority Vote)',\n",
    "    linewidth=4, markeredgewidth=4, color='C4')\n",
    "\n",
    "print(fracs)\n",
    "print(clean_losses)\n",
    "print(num_lfs)\n",
    "print(ws_losses)\n",
    "print(vote_losses)\n",
    "\n",
    "\n",
    "ax.set_ylabel('Loss')\n",
    "ax.set_xlabel('Num LFs')\n",
    "#ax.yscale('log')\n",
    "ax.grid()\n",
    "ax.legend(bbox_to_anchor=(0.92, 0.92),\\\n",
    "    bbox_transform=plt.gcf().transFigure)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('geodesic_numLFs.pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "75e1510848ff81b2a8a3022c3bfac472ed28a49a56e1422a056d525171f2408b"
  },
  "kernelspec": {
   "display_name": "universalizing-weak-supervision",
   "language": "python",
   "name": "universalizing-weak-supervision"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}