logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "from sklearn.datasets import load_svmlight_file\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import os\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn import preprocessing\n",
    "min_max_scaler = preprocessing.MinMaxScaler()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyper Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "class arguments():\n",
    "#     data = 'NSQIP'\n",
    "    data = 'a9a'\n",
    "    \n",
    "    T = 1000 # Total number of iterations\n",
    "\n",
    "    reg = 0.05 # reglularization parameter\n",
    "    mu = reg # strong convexity of F\n",
    "\n",
    "    beta = 1\n",
    "    batch_size = 1 # number of data points used to obtain a stochastic gradient, at each iteration for each worker\n",
    "    N = 10 # number of workers\n",
    "    plot_every = 100 # frequency of evaluating the optimality error\n",
    "    \n",
    "    if data == 'a9a' and reg == 0.05:\n",
    "        f_min = 0.433426\n",
    "    elif data == 'NSQIP' and reg == 0.05:\n",
    "        f_min = 0.228248\n",
    "    else:\n",
    "        f_min = None\n",
    "        \n",
    "    reps = 10\n",
    "    print_every = reps // 5\n",
    "    \n",
    "    device = \"cpu\" #torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    print(device)\n",
    "\n",
    "arg = arguments()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _get_dense_tensor(tensor):\n",
    "    if 'sparse' in str(type(tensor)):\n",
    "        return tensor.toarray()\n",
    "    elif 'numpy' in str(type(tensor)):\n",
    "        return tensor\n",
    "\n",
    "\n",
    "def _correct_binary_labels(labels, is_01_classes=True):\n",
    "    classes = set(labels)\n",
    "\n",
    "    if -1 in classes and is_01_classes:\n",
    "        labels[labels == -1] = 0\n",
    "    return labels\n",
    "\n",
    "\n",
    "class dataset(Dataset):\n",
    "    def __init__(self, data_name):\n",
    "        # load dataset.\n",
    "        if data_name == 'a9a':\n",
    "            file_path = 'data/a9a'\n",
    "            dataset = load_svmlight_file(file_path)\n",
    "            self.features, self.labels = self._get_images_and_labels(dataset)\n",
    "            self.labels = np.reshape(self.labels, (-1,1))\n",
    "            \n",
    "        elif data_name == 'NSQIP':\n",
    "            x_path = 'data/df_NSQIP_2014_post_x.pkl'\n",
    "            y_path = 'data/Y.csv'\n",
    "            df_features = pickle.load(open(x_path, 'rb'))\n",
    "            df_labels = pd.read_csv(y_path, header=None)\n",
    "            \n",
    "            self.labels = df_labels.to_numpy(dtype = np.float32) # int\n",
    "            self.features = min_max_scaler.fit_transform(df_features).astype(np.float32)\n",
    "            \n",
    "            del df_labels\n",
    "            del df_features\n",
    "            \n",
    "        else:\n",
    "            print('Error! Data name not recognized.')\n",
    "            \n",
    "        self.labels = torch.from_numpy(self.labels).to(arg.device)\n",
    "        self.features = torch.from_numpy(self.features).to(arg.device)\n",
    "            \n",
    "\n",
    "    def _get_images_and_labels(self, data):\n",
    "        features, labels = data\n",
    "        \n",
    "        features = _get_dense_tensor(features)\n",
    "        labels = _get_dense_tensor(labels)\n",
    "        \n",
    "        labels = _correct_binary_labels(labels)\n",
    "        \n",
    "        features = features.astype(np.float32)\n",
    "        labels = labels.astype(np.float32) #int\n",
    "        return features, labels\n",
    "    \n",
    "\n",
    "    def __len__(self):\n",
    "        return self.features.size(0)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        if torch.is_tensor(idx):\n",
    "            idx = idx.tolist()\n",
    "        \n",
    "        return [self.features[idx], self.labels[idx]]\n",
    "\n",
    "    def __iter__(self):\n",
    "        idxs = list(range(self.__len__()))\n",
    "        for k in idxs:\n",
    "            yield [self.features[k], self.labels[k]]\n",
    "    \n",
    "    def get_data(self):\n",
    "        return self.__iter__()\n",
    "\n",
    "    def size(self):\n",
    "        return self.__len__()\n",
    "    \n",
    "    def num_features(self):\n",
    "        return self.features.shape[1]\n",
    "    \n",
    "    def get_batch(self, batch_size = 1, replace = False):\n",
    "        idx = np.random.choice(self.__len__(), size = batch_size, replace = replace)\n",
    "        return [self.features[idx], self.labels[idx]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train = dataset(arg.data)\n",
    "# data_train = dataset('NSQIP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of features: 231\n",
      "Size of data: 722101\n"
     ]
    }
   ],
   "source": [
    "in_features = data_train.num_features()\n",
    "print('Number of features: %d'%in_features)\n",
    "print('Size of data: %d'%data_train.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Neuron(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Neuron, self).__init__()\n",
    "        self.lin = nn.Linear(in_features,1)\n",
    "        self.lin.weight.data = torch.zeros([1,in_features], requires_grad = True)\n",
    "        self.lin.bias.data = torch.tensor([0.], requires_grad = True)\n",
    "        self.sig = nn.Sigmoid()\n",
    "    def forward(self, x):\n",
    "        x = self.lin(x)\n",
    "        x = self.sig(x)\n",
    "        return x\n",
    "\n",
    "# criterion = nn.CrossEntropyLoss()\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.558308601379395\n"
     ]
    }
   ],
   "source": [
    "# an upper bound for the smoothness\n",
    "fro_norm = torch.norm(data_train.features, p = 'fro')\n",
    "L = ((fro_norm**2)/data_train.size()).item() + 1\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_total_loss(inputs, labels, network, reg = 0.0):\n",
    "    with torch.no_grad():\n",
    "        outputs = network(inputs)\n",
    "        total_loss = criterion(outputs, labels)\n",
    "        total_loss += 0.5*reg*(torch.norm(network.lin.weight)**2)\n",
    "        total_loss += 0.5*reg*(torch.norm(network.lin.bias)**2)\n",
    "    return total_loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6931473016738892\n"
     ]
    }
   ],
   "source": [
    "net = Neuron().to(arg.device)\n",
    "loss_0 = get_total_loss(data_train.features, data_train.labels, net, arg.reg)\n",
    "print(loss_0) # Loss at the initial point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "## Find Global Optimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "net = Neuron().to(device)\n",
    "avg_losses = [loss_0]\n",
    "f_min = 1.0\n",
    "\n",
    "optimizer = optim.SGD(net.parameters(), lr=1.0, weight_decay = arg.reg)\n",
    "scheduler = optim.lr_scheduler.LambdaLR(optimizer, lambda t: 2.0/(arg.mu*(t+1.0)), last_epoch=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f_min: 0.433434\n"
     ]
    },
    {
     "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": [
    "# This block can be run many times to find a more accurate optimum\n",
    "bs_optimum = 50 # batch size used to find the global optimum\n",
    "\n",
    "for t in range(10000):\n",
    "    batch = data_train.get_batch(bs_optimum)\n",
    "    inputs, labels = batch[0], batch[1]\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "    logits = net(inputs)\n",
    "    loss = criterion(logits, labels)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    scheduler.step() #######<<<<<<<<<<-------- Comment this if you want to repeat this loop \n",
    "    \n",
    "    if (t+1)%100 == 0:\n",
    "        total_loss = get_total_loss(data_train.features, data_train.labels, net, arg.reg)\n",
    "        avg_losses.append(total_loss)\n",
    "        if total_loss<f_min:\n",
    "            f_min = total_loss\n",
    "#             print('new f_min: %f' %f_min)\n",
    "            \n",
    "\n",
    "print('f_min: %f' %  (f_min))\n",
    "\n",
    "plt.plot(np.array(avg_losses) - f_min, '-o')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arg.f_min = 0.433426 #a9a reg = 0.05\n",
    "# arg.f_min = 0.228248 #NSQIP, reg = 0.05"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Centralized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".....Done!\n"
     ]
    }
   ],
   "source": [
    "iter_error_sum = np.zeros(arg.T//arg.plot_every + 1)\n",
    "\n",
    "for rep in range(arg.reps):\n",
    "#     print('Simulation: %d/%d'%(rep+1,arg.reps))\n",
    "    \n",
    "    iter_error = [loss_0]\n",
    "    \n",
    "    net = Neuron().to(arg.device)\n",
    "    optimizer = optim.SGD(net.parameters(), lr=1.0, weight_decay = arg.reg)\n",
    "    scheduler = optim.lr_scheduler.LambdaLR(optimizer, lambda t: 2.0/(arg.mu*(t+arg.beta)), last_epoch=-1)\n",
    "    \n",
    "    for t in range(arg.T):\n",
    "        batch = data_train.get_batch(arg.N*arg.batch_size)\n",
    "        inputs, labels = batch[0], batch[1]\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        logits = net(inputs)\n",
    "        loss = criterion(logits, labels)\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        scheduler.step()\n",
    "        \n",
    "        if (t+1)% arg.plot_every == 0:\n",
    "            total_loss = get_total_loss(data_train.features, data_train.labels, net, arg.reg)\n",
    "            iter_error.append(total_loss)\n",
    "            \n",
    "        elif t == arg.T-1:\n",
    "            total_loss = get_total_loss(data_train.features, data_train.labels, net, arg.reg)\n",
    "#     print('loss: %.5f' %  (total_loss))\n",
    "\n",
    "    iter_error_sum += np.array(iter_error)\n",
    "    \n",
    "    if (rep+1) % arg.print_every == 0:\n",
    "            print('.', end='')\n",
    "            \n",
    "iter_error_avg = iter_error_sum/arg.reps    \n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAeGUlEQVR4nO3de3TV5Z3v8fd3Z+dGSLKDECCXHUAwXNWE1NHaaa03rEplqrWX07HtWFmujl090yln9EzXmdO1OqOtp3POdNVpl1Xb2hntQWsptlja2tNaL1WRIAQhgiDmQggouQAh5PKcP/ZODHEHctnJ77d/+/NaK4u9n+zL8wT47F+eqznnEBGR4At5XQEREZkaCnwRkTShwBcRSRMKfBGRNKHAFxFJE2GvK3AmM2fOdPPmzfO6GiIiKeWVV1454pybNbzc14E/b948tmzZ4nU1RERSipkdSFTuyy4dM1ttZve3t7d7XRURkcDwZeA75550zq0tLCz0uioiIoHhy8AXEZHkU+CLiKQJBb6ISJrw9Syd8dhQ28S9m+tpbuuiJJLLulWVrKkq9bpaIiKe82Xgm9lqYPXChQvH9LwNtU3c9cQOunr6AGhq6+KuJ3YAKPRFJO35sktnvLN07t1cPxj2A7p6+rh3c30yqycikpJ8Gfjj1dzWNaZyEZF0EqjAL4nkjqlcRCSdBCrw162qJDcz47Sy3MwM1q2q9KhGIiL+4ctB2/EaGJj91q9309x+kunZYb6xZrkGbEVECNgVPsRC//m7ruD8skKWlRQo7EVE4nwZ+MnYPK06WsT2xnZ6+/qTWDMRkdTly8BPxuZpVdEIXT197G7pTGLNRERSly8DPxmqo0UA1L511OOaiIj4Q2ADv6wol5nTs9n6VpvXVRER8YXABr6ZUR2NsFVX+CIiQIADH6C6oogDb5/g7WPdXldFRMRzwQ78wX78Nm8rIiLiA4EO/BWlhYRDpm4dERECHvi5WRksmVugwBcRwaeBn4yFVwOqoxFebdACLBERXwZ+MhZeDaiuKKKrp4/6Q1qAJSLpzZeBn0wDA7eajy8i6S7wgT+wAKv2gPrxRSS9BT7wzYwqLcASEQl+4EOsW+dNLcASkTSXJoEfAWBbQ5un9RAR8VJaBP75ZREtwBKRtJcWgT+4AOtAm9dVERHxTFoEPsQORHm1sU0LsEQkbaVN4FdHizhxSguwRCR9pVXgg3bOFJH0lTaBXz4jl5nTszRwKyJpy5eBn8zN04a8JlXRIl3hi0ja8mXgJ3PztKGqohH2HznOO8dPJfV1RURSgS8Df7K824+vbh0RST9pFfjnlxWSETJ164hIWkqrwJ+WFWbJ3HwN3IpIWkqrwIdYt86rDW309TuvqyIiMqXSLvCrohGOn+qjvkULsEQkvaRd4L97Apa6dUQkvaRd4EdnTOOcvCwN3IpI2km7wH93AZau8EUkvaRd4ANUV0TYd+Q4R7UAS0TSSFoGflV5fAFWg67yRSR9pGXgX1AeW4ClA1FEJJ2kZeBPywqzeE6+rvBFJK2kZeBDbHrmtre0AEtE0kf6Bn5FbAHW6zoBS0TSRPoGvhZgiUiaSdvAj86Yxoy8LA3cikjaSNvANzOqoxEN3IpI2piywDezBWb2oJk9PlXveTZV0SL2HT5O2wktwBKR4BtV4JvZQ2bWamZ1w8qvMbN6M9trZnee6TWcc/ucc7dOpLLJ9u4JWG3eVkREZAqM9gr/R8A1QwvMLAO4D/gIsBT4lJktNbMVZvbLYV/FSa11klxQXkjINHArIukhPJoHOeeeMbN5w4ovAvY65/YBmNlPgRucc3cD14+3Qma2FlgLEI1Gx/syoxJbgFWgwBeRtDCRPvxSoGHI/cZ4WUJmdo6ZfR+oMrO7Rnqcc+5+51yNc65m1qxZE6je6FRXRHi1oV0LsEQk8CYS+JagbMTUdM697Zy73Tl3bvy3AF+ojhZxrLuXPa1agCUiwTaRwG8EyofcLwOaJ1adGDNbbWb3t7e3J+PlzmhwAZbm44tIwE0k8F8GFpnZfDPLAj4JbExGpZxzTzrn1hYWFibj5c6o4pz4Aiz144tIwI12WuajwAtApZk1mtmtzrle4A5gM7ALWO+c2zl5VZ0cZkZVeUSBLyKBN9pZOp8aoXwTsCmpNfJAdUURT+9upe3EKSLTsryujojIpPDl1gpT2YcPUBWNAFDb0DYl7yci4gVfBv5U9uEDXFAWIWRQe0DdOiISXL4M/KmWlz2wAKvN66qIiEwaBX5cVTTCtgadgCUiweXLwJ/qPnx4dwHW3tZjU/aeIiJTyZeBP9V9+BCbqQPaSE1EgsuXge+FeQMLsDRwKyIBpcCP0wIsEQk6Bf4QVdEIb+gELBEJKF8GvheDtvDuRmrbtABLRALIl4HvxaAtwAXlkfgJWG1T+r4iIlPBl4HvlbzsMJVzCqhVP76IBJACf5jqaIRtb7XRrwVYIhIwCvxhqqJFdHb3skcLsEQkYBT4w1QP7Jypbh0RCRhfBr5Xs3QA5s/Mo2hapubji0jg+DLwvZqlA/EFWNEizdQRkcDxZeB7rToaYW/rMdpP9HhdFRGRpFHgJ1AVX4BV26BuHREJDgV+AgMLsGrVrSMiAaLAT2B6dpjzZudr4FZEAkWBP4LqiiK2NWgBlogEhy8D38tpmQOqo0V0nuxl72EtwBKRYPBl4Hs5LXNAVXwBlg5EEZGg8GXg+8GCmXlEpmVq4FZEAkOBPwKdgCUiQaPAP4PqaBF7Wo/R3qUFWCKS+hT4Z1BdoROwRCQ4FPhncH5ZIWYauBWRYFDgn0F+TiaVs/Op1RW+iASAAv8sqqJF1L51VAuwRCTl+TLw/bDwakB1NELnyV7e0AIsEUlxvgx8Pyy8GjAwcKvpmSKS6nwZ+H4y/5w8CnMz2XqgzeuqiIhMiAL/LEIhoyqqBVgikvoU+KOgBVgiEgQK/FGojp+A9aqmZ4pIClPgj8IF5fEFWOrWEZEUpsAfhYEFWFu1c6aIpDAF/ihVRSNagCUiKU2BP0pV8ROw9h3RAiwRSU0K/FEaGLjVfHwRSVUK/FFaMDO+AEsDtyKSohT4o6QFWCKS6nwZ+H7aPG2oqvLYAqyOk1qAJSKpx5eB76fN04aqrojgnBZgiUhq8mXg+9WF5ZH4CVhtXldFRGTMFPhjkJ+TyXnF+erHF5GUpMAfo+oKLcASkdSkwB+jqvIiOrQAS0RSkAJ/jKorIgDaV0dEUo4Cf4wWzJxOQU6YWvXji0iKUeCPUWwBVpFm6ohIylHgj0N1tIjXWzu1AEtEUooCfxyqolqAJSKpR4E/DhdGYwuwajVwKyIpRIE/DgU5mSwqnq4FWCKSUhT441QdLaL2rTYtwBKRlKHAH6fqaBHtXT3sO3Lc66qIiIyKAn+cqqIRAHXriEjKUOCP07mzBhZgtXldFRGRUVHgj1MoZFwYLdKKWxFJGQr8CaiORqg/1EmnFmCJSAqYssA3szVm9gMz+4WZXT1V7zuZqqNF8QVY/jqKUUQkkVEFvpk9ZGatZlY3rPwaM6s3s71mdueZXsM5t8E5dxvwOeAT466xj1xQHgE0cCsiqSE8ysf9CPgu8PBAgZllAPcBVwGNwMtmthHIAO4e9vy/cc61xm9/Lf68lFeYG1uApX58EUkFowp859wzZjZvWPFFwF7n3D4AM/spcINz7m7g+uGvYWYG3AM85ZzbOtJ7mdlaYC1ANBodTfU8VR0tYvNrLTjniDVRRMSfJtKHXwo0DLnfGC8byZeAK4GbzOz2kR7knLvfOVfjnKuZNWvWBKo3NaorIrSd0AIsEfG/0XbpJJLocnbEfQacc98BvjOB9/Ol6mgRAFsPHOXcWdM9ro2IyMgmcoXfCJQPuV8GNE+sOjFmttrM7m9v9//sl3NnTSc/J6wjD0XE9yYS+C8Di8xsvpllAZ8ENiajUs65J51zawsLC5PxcpMqFDIuLI9o4FZEfG+00zIfBV4AKs2s0cxudc71AncAm4FdwHrn3M7Jq6p/VUeLeP1QJ8e6e72uiojIiEY7S+dTI5RvAjYltUYpqLqiiP74CViXLpzpdXVERBLy5dYKqdSHD3DhwAKsA+rWERH/8mXgp1IfPsQWYC3UCVgi4nO+DPxUVB2NUNvQhnM6AUtE/EmBnyTV0SLaTvSwXwuwRMSnfBn4qdaHD7GBW0Dz8UXEt3wZ+KnWhw+ws7EdA7762Ktces/v2VDb5HWVRERO48vATzUbapv47xvqBveVaGrr4q4ndij0RcRXFPhJcO/merp6+k4r6+rp497N9R7VSETkvRT4SdDc1jWmchERL/gy8FNt0LYkkpuw3AFf27BDM3dExBd8GfipNmi7blUluZkZp5Vlh0NcPH8G619u5PJv/4Hbf/IKr2glroh4aCL74UvcmqrYuS/3bq6nua2Lkkgu61ZVsqaqlNbOkzz8/AF+8ucD/HpnCysrilj7wQVcuWQ2GSGdkCUiU8f8vDK0pqbGbdmyxetqJMXx7l4e29LAA8/up/FoF/Nn5vGFv5zPjdVl5Az77UBEZCLM7BXnXM17yhX4U6u3r59f72zh/mf2sb2xnRl5WdxySQW3XDKPGXlZXldPRAJAge8zzjle3P8OP3hmH0/vbiUnM8RNK8v4wgcWMG9mntfVE5EUllKBb2argdULFy68bc+ePV5XZ9LtOdTJA3/az89rm+jp72fV0jnc9sEFrIxv1yAiMhYpFfgDgnyFn0hrx0l+/MKb/Mef36K9q4eaiiJu++ACrloym5AGeEVklBT4KeR4dy/rtzTwoAZ4RWQcFPgpqLevn6fqYgO8O5raOScvi1sumcdfX1KhAV4RGZECP4UNDPDe/8w+fh8f4P34ynJu/cB85s3MY0NtU8I1ACKSnhT4AbHnUCc/+NM+NtQ209Pfz4qSAuoPHaO7t3/wMbmZGdz9sRUKfZE0NVLg+3JrBRnZotn5fOumC3j2Hz7MFy87lx1NHaeFPWinThFJzJeBn2qbp3mhuCCHdasWj/j9prYuvvJ/t/HAn/bxwhtv097VM4W1ExE/8uVeOs65J4Ena2pqbvO6Ln5XEsmlKcE2zNnhEM/uPcITQw5hic6YxrKSApaXFrK0pIDlJYXMys+eyuqKiId8GfgyeutWVXLXEztOO4BlaB/+4c5udja3s7O5Y/DPp+paBh9bnJ89+CGwrKSAZSWFlBXlYqZ5/yJBo8BPcWfaqRNgVn42l1UWc1ll8eBzOk728FpzR+xDoCn2IfDMniP09ccG8AtywiwrKTztg2DBrOnv2d1Ts4NEUotm6QgAJ3v62N3Syc7mduqaOnituZ1dLZ2cig8I52SGWDK3IPYhUFLI4c5u7vvDXk72aHaQiN9oWqaMWU9fP28cPsbOpthvA3XN7exq7qCzu3fE55RGcnnuzsunsJYiMtxIga8uHRlRZkaIxXMKWDyngBtXxsr6+x0NR0/woXv/kPA5TW1dg108IuIvvpyWKf4VChkV5+RReoZAv/Sbv+eWh17il9ub6e7tG/FxIjK1dIUv4zLS7KCvXn0e7V09PP5KI3c8UktkWiZrLizl4zVlLCtJjTOKRYLKl3346bYffqo60yydvn7Hc3uPsH5LA7/ZeYhTff0sKyng5ppybriwhMi01Nz8TTOTJBVo0FY803biFBtfbWb9lgbqmjrIyghx9bLZ3FxTzqULZ6bMYe4bapvOuOZBxC8U+OILO5vbeWxLIxu2NdF2ooeSwhxuXFnGx1eWEz1nmtfVS2hgyupnH3op4RYVmpkkfqPAF1/p7u3jd6+1sn5LA8/sOYxzcPGCGdxcU85Hls8lN8ubg16OdffyWnMHdU3t1DW3s7Opg72Hjw0uSkvEgP33XDd1lRQ5CwW++FZzWxdPbG1k/ZZG3nrnBPnZYa6/oISba8q4sDwyads8HD1+anB9QV1TO681d7DvyPHB7xfnZ7O8tJDlJQUsLSnknzbWcaij+z2vU5gbZtv/uFrbUYhvKPDF9/r7HS+9+Q6PbWlk046DdPX0sah4OjfXlLOmqnRCG721dpwcvGKvi68mHrrpXGkkl+WlsVXEA9tJFBfknPYaifrwQwb9Dj6+soxv/NVyssM6glK8p8CXlNJ5sodfbT/I+i0NbH2rjXDIuHxxMTfXlHNZ5Sx+uf1gwtkyzjkaj3YNbhYX65rp4HDnu1fmC2bmsSx+5T6wZ1DRKI+MHD5L56tXncf+d07wnaf3sLKiiO9/ZqV2IBXPKfAlZe1t7eSxLY38bGsTR451k5+dQVdPP71D+tXDIWP+zGm0dp4aHFjNCBkLZ01n2ZAr9yVz88nPyUx6HX+1/SB//9g2ZkzL4v5balheqjUH4h0FvqS8nr5+/lB/mC89spWTw075AsjMMG5aGVvgtby0kMVz8snJnLoulrqmdm57eAttJ3r49s0XcO2KuVP23iJD6YhDSXmZGSGuWjr7PUc6Dujtc9z9sfP5zMUVXFgemdKwB1heWsjGOz7Akrn5fPE/t/K/f/s6/WeY3SMy1RT4knJG2pjNDxu2zcrP5tG1F3PTyjL+7ek9/O0jWzlxauTdRUWmkgJfUs66VZXkDrt6z83MYN2qSo9qdLrscAb33nQ+X7tuCZt3tnDj916g8egJr6slosCX1LOmqpS7P7aC0kguRmxKpd+2NzAzvvCXC3jwc++j8Z0T3PDd53j5zXe8rpakOV8O2mrzNAmSva3HuO3hLTQePcE31iznE++Lel0lCbiUGrR1zj3pnFtbWKipbZL6FhZPZ8MXL+XiBefwDz/bwdef3ElvX+KBZ5HJ5MvAFwmawmmZ/PBz7+Pzl87jh8+9yed/9DLtJ967EZvIZFLgi0yRcEaIf1q9jG/euII/73ubv/r353jj8DGvqyVpRIEvMsU+8b4oj9x2Me1dPay57zn++Pphr6skaUKBL+KB982bwS/uuJSyoml8/ocv8cCf9uHHCRQSLAp8EY+UFU3j8dsv4eqlc/jGr3ax7vHtOvRdJpUCX8RDedlh/v2/VPPlKxbx+CuNfPoHL562s6dIMinwRTwWChl/d9V53PfpanY2t/PR7z5LXVO719WSAFLgi/jEdefP5fHb348BN33/eX61/aDXVZKAUeCL+Mjy0kJ+cccHWFZSyN8+spV/1Y6bkkRhrysgIqeblZ/NI7f9BV/7eR3feXoPr7d08u2bLyAv25v/rsNP+Ro4XUxSjwJfxIeywxl866bzqZyTz79s2sWN3zvOzTVlPPjsm1MavMPP8W1q6+KuJ3YATEno68MmuXy5edoAnXglAn98/TBrH36Z7t7T/6/mZmZw98dWcP35c+nu7Y9/9dHdE7t9auD+sPLBsp6h3x/y+CGP+9OeIwkPnMkJh7h8STHZ4Qyyw6HYV+aQ2+EMsjOH3A6H4vczzvr9jJABiQ+NH2izQv/MdMShSAq76J9/R+skTdc0Y8Rg3tncMeLzFhVPf88HyMnePiYaKeGQkR0O0dXTR6Lhi9JILs/defnE3iTgRgp8demIpIAzzc3/+6vOGwzprPAZrqpPu8J+94o8HDLMLOFrX3rP72lq63pPeWkkl99+5UPvKXfO0dvv4h8AfQl/80j828Z7H/vAs/sT1qmprYvn9x7hovkzCGdo3slYKPBFUkBJJHfE4P3SFYsm7X3XrapM2K0y0uliZkZmhpGZEWL6BAeZn6prSdhmAz79wIvMyMti1bLZXLtiLhcvOIdMhf9ZKfBFUsBYgzdZBvrKvRg4HanNX//oUvJzMtlU18IvtjXz6EsNRKZlcvXSWPi//9yZZIVTM/wne5BaffgiKSIdZ6ycrc0ne/r44+uHeWrHQX63q5Vj3b0U5IS5aukcrjt/DpcunEl2OOMM7+AfyRyk9nzQ1syWAF8GZgJPO+e+d7bnKPBFZLRO9vTx7J4jbKo7yG9fO0TnyV7ys8NcuXQ2H1k+hw+eN4ucTP+Ef3dvH3tbj1Hf0kl9Syc/ev7NhDOixjNIPaFBWzN7CLgeaHXOLR9Sfg3wb0AG8IBz7p6RXsM5twu43cxCwA/GVHsRkbPIyczgyqWzuXLpbE719vPcG0fYtP0gv3ntED+vbSIvK4Mrlszm2hVz+NB5xeRmTU34O+doPNpFfUsnu1s62B0P+H1HjtMXn4aUlRHi1AjHXjYnGMcYr9H24f8I+C7w8ECBmWUA9wFXAY3Ay2a2kVj43z3s+X/jnGs1s48Cd8ZfS0RkUmSFQ3y4spgPVxbzL339vPDG22zacZDNO1vY+Goz07Iy+PDiYq5dPpcPL57FtKzkDGe2n+hhd0sH9Yc62d3Sye6DHbx+6BjHunsHH1NWlMviOfmsWjaHyjn5LJ6Tz7yZeVx27x8SDlKXRHKTUjcYQ5eOmc0DfjlwhW9mlwD/0zm3Kn7/LgDn3PCwT/Rav3LOXTfC99YCawGi0ejKAwcOjKp+IiJn09vXz4v73xkM/yPHTpGTGftw+MiKuVy+uJjp2eGzjh2c6u3njcPHTrti332wk5aOk4OPKcgJs3huAYvn5A8G+3mz88nPyUxYN1/14ScI/JuAa5xzX4jf/2vgL5xzd4zw/MuAjwHZwHbn3H1ne0/14YvIZOnrd7y0/x2eqjvIU3UtHO7sJisc4rzi6dQf6qSn791szMoIcdXSYkKhEPUtHew7fJzeeHdMZoZx7qzpLJ6Tz+K5BYPhPqcgZ8T1DSNJ1sD8ZAT+x4FVwwL/Iufcl8ZcuxEo8EVkKvT1O145cJRNOw7y8AtvJlzhC7EB1IEr9so5+SyZW8D8mXm+WwMwGSttG4HyIffLgOYJvN4gM1sNrF64cGEyXk5E5IwyQsZF82dw0fwZ/Pj5NxM+xiDlt3SYyMfSy8AiM5tvZlnAJ4GNyaiUc+5J59zawsLCZLyciMiojTRImszBU6+MKvDN7FHgBaDSzBrN7FbnXC9wB7AZ2AWsd87tnLyqiohMvnWrKskdNl9/KlY1T4VRdek45z41QvkmYFNSayQi4iEvt5OYbL7cS0d9+CLipTVVpYEI+OH8NbQcpz58EZHk82Xgi4hI8inwRUTShC8D38xWm9n97e3tXldFRCQwfBn46sMXEUk+Xx+AYmaHgfHunjYTOJLE6qQCtTk9qM3BN9H2VjjnZg0v9HXgT4SZbUm0l0SQqc3pQW0Ovslqry+7dEREJPkU+CIiaSLIgX+/1xXwgNqcHtTm4JuU9ga2D19ERE4X5Ct8EREZQoEvIpImAhf4ZnaNmdWb2V4zu9Pr+iSLmZWb2f8zs11mttPMvhwvn2FmvzWzPfE/i4Y85674z6HezFZ5V/uJMbMMM6s1s1/G7we6zWYWMbPHzWx3/O/7kjRo89/F/13XmdmjZpYTtDab2UNm1mpmdUPKxtxGM1tpZjvi3/uOjeXgXOdcYL6ADOANYAGQBbwKLPW6Xklq21ygOn47H3gdWAp8C7gzXn4n8M347aXx9mcD8+M/lwyv2zHOtn8FeITYmcoEvc3Aj4EvxG9nAZEgtxkoBfYDufH764HPBa3NwAeBaqBuSNmY2wi8BFxC7NTFp4CPjLYOQbvCvwjY65zb55w7BfwUuMHjOiWFc+6gc25r/HYnsVPGSom178fxh/0YWBO/fQPwU+dct3NuP7CX2M8npZhZGXAd8MCQ4sC22cwKiAXDgwDOuVPOuTYC3Oa4MJBrZmFgGrHzsQPVZufcM8A7w4rH1EYzmwsUOOdecLH0f3jIc84qaIFfCjQMud8YLwsUM5sHVAEvArOdcwch9qEAFMcfFpSfxf8B/hvQP6QsyG1eABwGfhjvxnrAzPIIcJudc03A/wLeAg4C7c653xDgNg8x1jaWxm8PLx+VoAV+or6sQM07NbPpwM+A/+qc6zjTQxOUpdTPwsyuB1qdc6+M9ikJylKqzcSudKuB7znnqoDjxH7VH0nKtzneb30Dsa6LEiDPzD5zpqckKEupNo/CSG2cUNuDFviNQPmQ+2XEfjUMBDPLJBb2/+mceyJefCj+ax7xP1vj5UH4WVwKfNTM3iTWPXe5mf0HwW5zI9DonHsxfv9xYh8AQW7zlcB+59xh51wP8ATwfoLd5gFjbWNj/Pbw8lEJWuC/DCwys/lmlgV8EtjocZ2SIj4S/yCwyzn3r0O+tRH4bPz2Z4FfDCn/pJllm9l8YBGxwZ6U4Zy7yzlX5pybR+zv8vfOuc8Q7Da3AA1mVhkvugJ4jQC3mVhXzsVmNi3+7/wKYmNUQW7zgDG1Md7t02lmF8d/VrcMec7ZeT1yPQkj4dcSm8HyBvCPXtcnie36ALFf3bYD2+Jf1wLnAE8De+J/zhjynH+M/xzqGcNIvh+/gMt4d5ZOoNsMXAhsif9dbwCK0qDNXwd2A3XAT4jNTglUm4FHiY1R9BC7Ur91PG0EauI/pzeA7xLfMWE0X9paQUQkTQStS0dEREagwBcRSRMKfBGRNKHAFxFJEwp8EZE0ocAXEUkTCnwRkTTx/wGMAPC2PXAA9wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(arg.plot_every*np.arange(len(iter_error_avg)), iter_error_avg - arg.f_min, '-o')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file saved: results/LR_cen_NSQIP.pkl\n"
     ]
    }
   ],
   "source": [
    "file_name = f\"results/LR_cen_{arg.data}.pkl\"\n",
    "\n",
    "with open(file_name, 'wb') as f:\n",
    "    pickle.dump({'arg': arg, 'iter_error_avg': iter_error_avg}, f)\n",
    "    f.close()\n",
    "print('file saved: ' + file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['arg', 'iter_error_avg'])\n"
     ]
    }
   ],
   "source": [
    "file_name = f\"results/LR_cen_{arg.data}.pkl\"\n",
    "data = pickle.load(open(file_name, 'rb'))\n",
    "print(data.keys())\n",
    "\n",
    "try:\n",
    "    iter_error_cen = data['iter_error_avg']\n",
    "#     arg = data['arg']\n",
    "except:\n",
    "    pass\n",
    "del data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_labels = {0:r'Synchronous SGD', 1:r'[Sti19]', 2:'[HKMC19]', 3:'$H_i = a(i+1)$ [This Paper]', 4: r'$H = T/N$', 5:r'$H=T$ (OSA)'}\n",
    "\n",
    "def get_comms(method, arg, N=None, T=None):\n",
    "    if not N:\n",
    "        N = arg.N\n",
    "        T = arg.T\n",
    "    \n",
    "    if method == 0:\n",
    "        comms = np.arange(T+1)\n",
    "        print('synchronous')\n",
    "        \n",
    "    elif method == 1:\n",
    "        H = int(np.sqrt(T/N))\n",
    "        print(f\"H={H}\")\n",
    "        \n",
    "        comms = [H*t for t in range(T//H + 1)]\n",
    "        plot_labels[method] = r'$H=%d$ [Sti19]' %H\n",
    "\n",
    "    elif method == 2:\n",
    "        H = int(((T**2)/N)**(1/3))\n",
    "        print(f\"H={H}\")\n",
    "        comms = [H*t for t in range(T//H + 1)]\n",
    "        \n",
    "        plot_labels[method] = r'$H=%d$ [HKMC19]' %H\n",
    "        \n",
    "    elif method == 3: # This Paper\n",
    "        R = N #int(N*arg.kappa)\n",
    "#         a = int(np.ceil(2*T/(k**2)))\n",
    "        a = 2*T/(R*(R+1))\n",
    "        print(f\"R:{R}, a:{a}\")\n",
    "        plot_labels[method] = r'$H_i=%d(i+1)$ (This Paper)' % int(a)\n",
    "        \n",
    "        comms = [int(a*r*(r+1)/2) for r in range(R+1)]\n",
    "\n",
    "\n",
    "    elif method == 4:\n",
    "        R = N #int(N*arg.kappa)\n",
    "        H = arg.T/R\n",
    "        print(f\"H={H}\")\n",
    "        comms = [int(np.ceil(H*r)) for r in range(R+1) if H*r <= T]\n",
    "        plot_labels[method] = r'$H=%d$ $(T/N)$' %H\n",
    "\n",
    "    elif method == 5:\n",
    "        comms = [0,T]\n",
    "        print(r'H=T (OSA)')\n",
    "\n",
    "    if comms[-1] != T:\n",
    "        comms.append(T)\n",
    "        \n",
    "    comms = np.array(comms, dtype = int)\n",
    "#     print(comms)\n",
    "    return comms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_dist(comms, arg):\n",
    "    comm_error_sum = np.zeros(len(comms))\n",
    "    iter_error_sum = np.zeros(np.ceil(arg.T/arg.plot_every + 1).astype(int))\n",
    "    iter_error2_sum = np.zeros(np.ceil(arg.T/arg.plot_every + 1).astype(int))\n",
    "    \n",
    "    for rep in range(arg.reps):    \n",
    "        workers = []\n",
    "        all_params = []\n",
    "        for i in range(arg.N):\n",
    "            worker = Neuron().to(arg.device)\n",
    "            workers.append(worker)\n",
    "            all_params += list(worker.parameters())\n",
    "            \n",
    "        optimizer = optim.SGD(all_params, lr=1.0, weight_decay = arg.reg)\n",
    "        scheduler = optim.lr_scheduler.LambdaLR(optimizer, lambda t: 3/(arg.mu*(t+arg.beta)), last_epoch=-1)\n",
    "        \n",
    "        comm_error = [loss_0]\n",
    "        iter_error = [loss_0]\n",
    "        for t in range(arg.T):\n",
    "            optimizer.zero_grad()\n",
    "            loss = 0\n",
    "            for i in range(arg.N):\n",
    "                worker = workers[i]\n",
    "                batch = data_train.get_batch(arg.batch_size)\n",
    "                inputs, labels = batch[0], batch[1]\n",
    "                \n",
    "                outputs = worker(inputs)\n",
    "                loss += criterion(outputs, labels)\n",
    "            \n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            scheduler.step()\n",
    "\n",
    "            if (t+1) in comms: # calculating the average of workers' parameters\n",
    "                avg_net = Neuron().to(arg.device)\n",
    "                params_avg = avg_net.named_parameters()\n",
    "                dict_params_avg = dict(params_avg)\n",
    "\n",
    "                for worker in workers:\n",
    "                    for name, param in worker.named_parameters():\n",
    "                        dict_params_avg[name].data.add_(param/arg.N)\n",
    "\n",
    "                avg_net.load_state_dict(dict_params_avg)\n",
    "\n",
    "                # updating each worker's parameters to the average\n",
    "                for worker in workers:\n",
    "                    worker.load_state_dict(dict_params_avg)\n",
    "\n",
    "                total_loss = get_total_loss(data_train.features, data_train.labels, avg_net, arg.reg)\n",
    "                comm_error.append(total_loss)\n",
    "\n",
    "\n",
    "            if (t+1) % arg.plot_every == 0  or (t+1) == arg.T:\n",
    "                # calculating the average of workers' parameters\n",
    "                avg_net = Neuron().to(arg.device)\n",
    "                params_avg = avg_net.named_parameters()\n",
    "                dict_params_avg = dict(params_avg)\n",
    "\n",
    "                for worker in workers:\n",
    "                    for name, param in worker.named_parameters():\n",
    "                        dict_params_avg[name].data.add_(param/arg.N)\n",
    "\n",
    "                avg_net.load_state_dict(dict_params_avg)\n",
    "\n",
    "                total_loss = get_total_loss(data_train.features, data_train.labels, avg_net, arg.reg)\n",
    "                iter_error.append(total_loss)\n",
    "\n",
    "        comm_error_sum += np.array(comm_error)\n",
    "        iter_error_sum += np.array(iter_error)\n",
    "        iter_error2_sum += np.array(iter_error)**2\n",
    "        \n",
    "        if (rep+1) % arg.print_every == 0:\n",
    "            print('.', end='')\n",
    "    \n",
    "    print('Done!')\n",
    "\n",
    "    comm_error_avg = comm_error_sum/arg.reps\n",
    "    iter_error_avg = iter_error_sum/arg.reps\n",
    "    iter_error2_avg = iter_error2_sum/arg.reps\n",
    "    \n",
    "    return {'comm_error_avg': comm_error_avg, 'iter_error_avg': iter_error_avg, 'iter_error2_avg': iter_error2_avg}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeated Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "iter_avg_dict = {}\n",
    "iter_std_dict = {}\n",
    "comm_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "method 3\n",
      "R:10, a:18.181818181818183\n",
      "# of comms: 10\n",
      ".....Done!\n",
      "method 4\n",
      "H=100.0\n",
      "# of comms: 10\n",
      ".....Done!\n",
      "method 5\n",
      "H=T (OSA)\n",
      "# of comms: 1\n",
      ".....Done!\n",
      "method 0\n",
      "synchronous\n",
      "# of comms: 1000\n",
      ".....Done!\n"
     ]
    }
   ],
   "source": [
    "for method in [3,4,5,0]:\n",
    "    print('method %d'% method)\n",
    "    comms = get_comms(method, arg)\n",
    "    print('# of comms: %d' % (len(comms)-1))\n",
    "    \n",
    "    result = train_dist(comms, arg)\n",
    "    \n",
    "    comm_dict[method] = result['comm_error_avg']\n",
    "    iter_avg_dict[method] = result['iter_error_avg']\n",
    "    iter_std_dict[method] = np.sqrt(result['iter_error2_avg'] - result['iter_error_avg']**2)/np.sqrt(arg.reps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "for method in iter_avg_dict:\n",
    "    plt.plot(iter_avg_dict[method] - arg.f_min, label = 'Method %d' % method)\n",
    "\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "plot_labels[4] = r'$H=100$ $(T/N)$'\n",
    "plot_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file saved: results/LR_dis_a9a.pkl\n"
     ]
    }
   ],
   "source": [
    "# saving the results to a file\n",
    "file_name = f\"results/LR_dis_{arg.data}.pkl\"\n",
    "with open( file_name, 'wb') as f:\n",
    "    pickle.dump({'iter_avg_dict': iter_avg_dict, 'iter_std_dict': iter_std_dict,\n",
    "                 'comm_dict': comm_dict, 'arg': arg, 'plot_labels': plot_labels}, f)\n",
    "    f.close()\n",
    "print('file saved: ' + file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file: results/LR_dis_a9a.pkl loaded.\n",
      "dict_keys(['iter_avg_dict', 'iter_std_dict', 'comm_dict', 'arg', 'plot_labels'])\n"
     ]
    }
   ],
   "source": [
    "# loading data\n",
    "file_name = f\"results/LR_dis_{arg.data}.pkl\"\n",
    "data = pickle.load(open(file_name, 'rb'))\n",
    "print(f\"file: {file_name} loaded.\")\n",
    "print(data.keys())\n",
    "\n",
    "try:\n",
    "    iter_avg_dict = data['iter_avg_dict']\n",
    "    iter_std_dict = data['iter_std_dict']\n",
    "    comm_dict = data['comm_dict']\n",
    "    arg = data['arg']\n",
    "    plot_labels = data['plot_labels']\n",
    "    methods = iter_avg_dict.keys()\n",
    "except:\n",
    "    pass\n",
    "del data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.reset_defaults()\n",
    "sns.set(\n",
    "    rc={'figure.figsize':(6,4)}, \n",
    "    style=\"whitegrid\" # nicer layout\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>iter</th>\n",
       "      <th>error</th>\n",
       "      <th>txerror</th>\n",
       "      <th>method</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.259891</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.107729</td>\n",
       "      <td>10.772905</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>200.0</td>\n",
       "      <td>0.028211</td>\n",
       "      <td>5.642267</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>300.0</td>\n",
       "      <td>0.019512</td>\n",
       "      <td>5.853603</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>400.0</td>\n",
       "      <td>0.009437</td>\n",
       "      <td>3.774995</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    iter     error    txerror  method\n",
       "0    0.0  0.259891   0.000000       3\n",
       "1  100.0  0.107729  10.772905       3\n",
       "2  200.0  0.028211   5.642267       3\n",
       "3  300.0  0.019512   5.853603       3\n",
       "4  400.0  0.009437   3.774995       3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combining the outputs in one dataframe for Seaborn\n",
    "errors = []\n",
    "txerrors = []\n",
    "\n",
    "# errors_std = []\n",
    "# txerrors_std = []\n",
    "\n",
    "iterations = []\n",
    "methods_list = []\n",
    "for m in methods:\n",
    "    errors = np.append(errors, iter_avg_dict[m]  - arg.f_min)\n",
    "    txerrors = np.append(txerrors, (iter_avg_dict[m]- arg.f_min)*(arg.plot_every*np.arange(len(iter_avg_dict[m]))))\n",
    "\n",
    "#     errors_std = np.append(errors_std, iter_std_dict[m])\n",
    "#     txerrors_std = np.append(txerrors_std, iter_std_dict[m]*(arg.plot_every*np.arange(len(iter_std_dict[m]))))\n",
    "    \n",
    "    iterations = np.append(iterations, arg.plot_every*np.arange(len(iter_avg_dict[m])))\n",
    "#     methods_list += [plot_labels[m]]*len(iter_avg_dict[m])\n",
    "    methods_list += [m]*len(iter_avg_dict[m])\n",
    "\n",
    "\n",
    "iter_df = pd.DataFrame({'iter': iterations, 'error': errors, 'txerror': txerrors, 'method': methods_list}) #, 'std': errors_std,  'txstd': txerrors_std})\n",
    "iter_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_colors = {0:(0.1, 0.1, 1),\n",
    "               3:(1, 0.1, 0.1),\n",
    "               4: (0,.75,0),\n",
    "               5:(1,.5,0.1)}\n",
    "\n",
    "ax = sns.lineplot(x = 'iter', y= 'error', data = iter_df,\n",
    "                  hue = 'method',\n",
    "#                   palette = 'bright',\n",
    "                  palette = plot_colors,\n",
    "                  style = 'method',\n",
    "                  markers = True, dashes = False,   markevery=0.1)\n",
    "\n",
    "\n",
    "# plt.plot(arg.plot_every*np.arange(len(iter_error_cen)),iter_error_cen - arg.f_min)\n",
    "\n",
    "# plt.gca().set_prop_cycle(None)\n",
    "for m in methods:\n",
    "    iter_std = iter_std_dict[m]\n",
    "    plt.fill_between(\n",
    "        arg.plot_every*np.arange(len(iter_std)),\n",
    "        (iter_avg_dict[m] - arg.f_min - iter_std),\n",
    "        (iter_avg_dict[m] - arg.f_min + iter_std),\n",
    "        alpha=0.1,\n",
    "        color = plot_colors[m],\n",
    "    )\n",
    "\n",
    "plt.yscale('log')\n",
    "plt.grid(True)\n",
    "plt.xlabel(r'Iteration $(t)$')\n",
    "plt.ylabel(r'$E[F(\\bar x^t)] - F^*$')\n",
    "\n",
    "# plt.ylim([5e-4,1e0])\n",
    "plt.xlim([0,1000])\n",
    "\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "ax.legend(handles=handles[1:], labels=[plot_labels[int(m)] for m in labels[1:]])\n",
    "# plt.savefig(f\"figures/iteration_{arg.data}.png\", dpi=240, transparent=False, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>comm</th>\n",
       "      <th>error</th>\n",
       "      <th>method</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.259891</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.198220</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.324313</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.087955</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.035053</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   comm     error  method\n",
       "0   0.0  0.259891       3\n",
       "1   1.0  1.198220       3\n",
       "2   2.0  0.324313       3\n",
       "3   3.0  0.087955       3\n",
       "4   4.0  0.035053       3"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Combining the outputs in one dataframe for Seaborn\n",
    "errors = []\n",
    "comms = []\n",
    "methods_list = []\n",
    "for m in methods:\n",
    "    errors = np.append(errors, comm_dict[m] - arg.f_min)\n",
    "    comms = np.append(comms, np.arange(len(comm_dict[m])))\n",
    "    methods_list += [m]*len(comm_dict[m])\n",
    "\n",
    "comm_df = pd.DataFrame({'comm': comms, 'error': errors, 'method': methods_list})\n",
    "comm_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plt.figure(figsize=(8,6))\n",
    "ax = sns.lineplot(x = 'comm', y= 'error', data = comm_df, #.loc[comm_df['method'].isin([plot_labels[i] for i in [1,2,3,4]])],\n",
    "                  hue = 'method',\n",
    "#                   palette = 'bright',\n",
    "                  palette = plot_colors,\n",
    "                  style = 'method',  markers = True, dashes = False, markevery=.1)\n",
    "plt.yscale('log')\n",
    "plt.xscale('log')\n",
    "plt.grid(True)\n",
    "plt.xlabel(r'Communication round')\n",
    "plt.ylabel(r'$E[F(\\bar x^t)] - F^*$')\n",
    "plt.ylim([1e-3, 1e1])\n",
    "# plt.xlim([0,1000])\n",
    "\n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "ax.legend(handles=handles[1:], labels=[plot_labels[int(m)] for m in labels[1:]])\n",
    "# plt.savefig(f\"figures/communication_{arg.data}.png\", dpi=240, transparent=False, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3",
   "language": "python",
   "name": "py3"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}