draw.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "dataSetConfigs = [\n",
    "    {\n",
    "        'name': 'ijcnn1',\n",
    "\n",
    "        'dataSet' : 'ijcnn1',\n",
    "        'dataSetSize': 49990,\n",
    "        'maxFeature': 22,\n",
    "        'findingType': '1',\n",
    "\n",
    "        'honestNodeSize': 50,\n",
    "        'byzantineNodeSize': 20,\n",
    "\n",
    "        'rounds': 10,\n",
    "        'displayInterval': 4000,\n",
    "    },\n",
    "    {\n",
    "        'name': 'covtype',\n",
    "\n",
    "        'dataSet' : 'covtype.libsvm.binary.scale',\n",
    "        'dataSetSize': 581012,\n",
    "        'maxFeature': 54,\n",
    "        'findingType': '1',\n",
    "\n",
    "        'honestNodeSize': 50,\n",
    "        'byzantineNodeSize': 20,\n",
    "\n",
    "        'rounds': 10,\n",
    "        'displayInterval': 4000,\n",
    "    }\n",
    "]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 多聚合方式比较图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(4, 2)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "for axColumn, dataSetConfig in zip(axs, dataSetConfigs):\n",
    "    \n",
    "    CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "    with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "        obj = pickle.load(f)\n",
    "        Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "    x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "\n",
    "    attackNames = [\n",
    "        ('baseline', 'without attack'), \n",
    "        ('white', 'Gaussian attack'), \n",
    "        ('maxValue', 'max-value attack'), \n",
    "        ('zeroGradient', 'zero-gradient attack'),\n",
    "    ]\n",
    "    # 文件名 图片中显示的名称 颜色\n",
    "    aggregations = [\n",
    "        ('mean', 'mean', 'royalblue'), \n",
    "        ('gm', 'geometric median', 'darkorange'), \n",
    "        ('Krum', 'Krum', 'darkgreen'), \n",
    "        ('median', 'median', 'darkmagenta'),\n",
    "    ]\n",
    "    \n",
    "    for ax, (attackName, title) in zip(axColumn, attackNames):\n",
    "        # 画曲线\n",
    "        for (aggregationName, showName, color) in aggregations:\n",
    "            with open(CACHE_DIR + '_SAGA_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                ax.plot(x_axis, path, 'v-', color=color, label=showName)\n",
    "    \n",
    "        # 填小标题\n",
    "        ax.set_title('{} ({})'.format(title, dataSetConfig['name'].upper()))\n",
    "        \n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "#         ax.set_ylim(top=1e2, bottom=1e-6)\n",
    "\n",
    "# 图例\n",
    "axs[0][-1].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "                  borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# for ax in axs[1]:\n",
    "#     ax.set_ylim(top=1e10)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*8))\n",
    "plt.subplots_adjust(hspace=0.4, wspace=0.35)\n",
    "plt.savefig('./attack_ijc_cov.eps', format='eps', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 4)\n",
    "# axs = tuple(zip(*axs))\n",
    "\n",
    "for axColumn, dataSetConfig in zip(axs, dataSetConfigs):\n",
    "    \n",
    "    CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "    with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "        obj = pickle.load(f)\n",
    "        Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "    x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "\n",
    "    attackNames = [\n",
    "        ('baseline', 'without attack'), \n",
    "        ('white', 'Gaussian attack'), \n",
    "        ('maxValue', 'sign-flipping attack'), \n",
    "        ('zeroGradient', 'zero-gradient attack'),\n",
    "    ]\n",
    "    # 文件名 图片中显示的名称 颜色\n",
    "    aggregations = [\n",
    "        ('mean', 'mean', 'royalblue'), \n",
    "        ('gm', 'geometric median', 'darkorange'), \n",
    "        ('Krum', 'Krum', 'darkgreen'), \n",
    "        ('median', 'median', 'darkmagenta'),\n",
    "    ]\n",
    "    \n",
    "    for ax, (attackName, title) in zip(axColumn, attackNames):\n",
    "        # 画曲线\n",
    "        for (aggregationName, showName, color) in aggregations:\n",
    "            with open(CACHE_DIR + '_SAGA_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                ax.plot(x_axis, path, 'v-', color=color, label=showName)\n",
    "    \n",
    "        # 填小标题\n",
    "        ax.set_title('{} ({})'.format(title, dataSetConfig['name'].upper()))\n",
    "        \n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "#         ax.set_ylim(top=1e2, bottom=1e-6)\n",
    "\n",
    "# 图例\n",
    "# 两行\n",
    "axs[1][0].legend(loc='lower left', bbox_to_anchor=(1.2,-0.4), \n",
    "                  borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*9, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "plt.savefig('./attack_ijc_cov.eps', format='eps', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 多聚合方式比较图（SGD-SAGA）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(4, 2)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "for axColumn, dataSetConfig in zip(axs, dataSetConfigs):\n",
    "    \n",
    "    CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "    with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "        obj = pickle.load(f)\n",
    "        Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "    x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "\n",
    "    attackNames = [\n",
    "        ('baseline', 'without attack'), \n",
    "        ('white', 'Gaussian attack'), \n",
    "        ('maxValue', 'max-value attack'), \n",
    "        ('zeroGradient', 'zero-gradient attack'),\n",
    "    ]\n",
    "    # 文件名 图片中显示的名称 颜色\n",
    "    aggregations = [\n",
    "        ('mean', 'mean', 'royalblue'), \n",
    "        ('gm', 'GM', 'darkorange'), \n",
    "        ('Krum', 'Krum', 'darkgreen'), \n",
    "        ('median', 'median', 'darkmagenta'),\n",
    "    ]\n",
    "    \n",
    "    algorithms = [\n",
    "        ('SGD', ':'),\n",
    "        ('SAGA', '-'),\n",
    "    ]\n",
    "    \n",
    "    for ax, (attackName, title) in zip(axColumn, attackNames):\n",
    "        # 画曲线\n",
    "        for (aggregationName, showName, color) in aggregations:\n",
    "            for algorithm, line in algorithms:\n",
    "                try:\n",
    "                    with open(CACHE_DIR + '_' + algorithm + '_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                        record = pickle.load(f)\n",
    "                        path = record['path']\n",
    "                        path = logAxis(path, Fmin)\n",
    "                        ax.plot(x_axis, path, 'v'+line, color=color, label=algorithm + ' ' + showName)\n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "    \n",
    "        # 填小标题\n",
    "        ax.set_title('{} ({})'.format(title, dataSetConfig['name'].upper()))\n",
    "        \n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "#         ax.set_ylim(top=1e2, bottom=1e-6)\n",
    "\n",
    "# 图例\n",
    "axs[0][-1].legend(loc='lower left', bbox_to_anchor=(0.01,-0.6), \n",
    "                  borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# for ax in axs[1]:\n",
    "#     ax.set_ylim(top=1e10)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*8))\n",
    "plt.subplots_adjust(hspace=0.4, wspace=0.35)\n",
    "# plt.savefig('./attack_ijc_cov.jpg', format='jpg', bbox_inches='tight')\n",
    "# plt.savefig('./attack_ijc_cov.eps', format='eps', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(4, 2)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "for axColumn, dataSetConfig in zip(axs, dataSetConfigs):\n",
    "    \n",
    "    CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "    with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "        obj = pickle.load(f)\n",
    "        Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "    x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "\n",
    "    attackNames = [\n",
    "        ('baseline', 'without attack'), \n",
    "        ('white', 'Gaussian attack'), \n",
    "        ('maxValue', 'max-value attack'), \n",
    "        ('zeroGradient', 'zero-gradient attack'),\n",
    "    ]\n",
    "    # 文件名 图片中显示的名称 颜色\n",
    "    aggregations = [\n",
    "        ('mean', 'mean', 'royalblue'), \n",
    "        ('gm', 'GM', 'darkorange'), \n",
    "        ('Krum', 'Krum', 'darkgreen'), \n",
    "        ('median', 'median', 'darkmagenta'),\n",
    "    ]\n",
    "    \n",
    "    algorithms = [\n",
    "        ('SGD', ':'),\n",
    "        ('SAGA', '-'),\n",
    "    ]\n",
    "    \n",
    "    for ax, (attackName, title) in zip(axColumn, attackNames):\n",
    "        # 画曲线\n",
    "        for (aggregationName, showName, color) in aggregations:\n",
    "            for algorithm, line in algorithms:\n",
    "                try:\n",
    "                    with open(CACHE_DIR + '_' + algorithm + '_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                        record = pickle.load(f)\n",
    "                        path = record['path']\n",
    "                        path = logAxis(path, Fmin)\n",
    "                        ax.plot(x_axis, path, 'v'+line, color=color, label=algorithm + ' ' + showName)\n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "    \n",
    "        # 填小标题\n",
    "        ax.set_title('{} ({})'.format(title, dataSetConfig['name'].upper()))\n",
    "        \n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "#         ax.set_ylim(top=1e2, bottom=1e-6)\n",
    "\n",
    "# 图例\n",
    "axs[0][-1].legend(loc='lower left', bbox_to_anchor=(0.01,-0.6), \n",
    "                  borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# for ax in axs[1]:\n",
    "#     ax.set_ylim(top=1e10)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*8))\n",
    "plt.subplots_adjust(hspace=0.4, wspace=0.35)\n",
    "# plt.savefig('./attack_ijc_cov.jpg', format='jpg', bbox_inches='tight')\n",
    "# plt.savefig('./attack_ijc_cov.eps', format='eps', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 神经网络对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for optimizer in ['SAGA', 'SGD', 'BatchSGD']:\n",
    "    for attack in ['baseline', 'white', 'maxValue', 'zeroGradient']:\n",
    "        for aggegate in ['mean', 'gm']:\n",
    "            file = optimizer + '_' + attack + '_' + aggegate\n",
    "            try:\n",
    "                with open('./cache/mnist_' + file, 'rb') as f:\n",
    "                    record = pickle.load(f)\n",
    "                    print('{:>4} {:>4f} {}'.format(record['gamma'], record['accPath'][-1]*100, file))\n",
    "            except:\n",
    "                print(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 步长比较"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ijcnn1 步长比较"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for optimizer in ['SAGA', 'SVRG', 'SGD', 'BatchSGD']:\n",
    "    for attack in ['baseline', 'white', 'maxValue', 'zeroGradient']:\n",
    "        for aggegate in ['mean', 'gm']:\n",
    "            file = optimizer + '_' + attack + '_' + aggegate\n",
    "            try:\n",
    "                with open('./cache/ijcnn1_' + file, 'rb') as f:\n",
    "                    record = pickle.load(f)\n",
    "                    print(record['gamma'], file)\n",
    "            except Exception as e:\n",
    "                print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "covtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for optimizer in ['SAGA', 'SVRG', 'SARAH', 'SGD', 'BatchSGD']:\n",
    "    for attack in ['baseline', 'white', 'maxValue', 'zeroGradient']:\n",
    "        for aggegate in ['mean', 'gm', 'median', 'Krum']:\n",
    "            file = optimizer + '_' + attack + '_' + aggegate\n",
    "            try:\n",
    "                with open('./cache/covtype_' + file, 'rb') as f:\n",
    "                    record = pickle.load(f)\n",
    "                    print(record['gamma'], file)\n",
    "            except Exception as e:\n",
    "                print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mnist 步长比较"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./cache/mnist_SAGA_baseline_mean', 'rb') as f:\n",
    "    record = pickle.load(f)\n",
    "print('[SAGA] gamma={}'.format(record['gamma']))\n",
    "with open('./cache/mnist_SGD_baseline_mean', 'rb') as f:\n",
    "    record = pickle.load(f)\n",
    "print('[SGD] gamma={}'.format(record['gamma']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 方差比较图（竖）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ijcnn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = {\n",
    "    'name': 'ijcnn1',\n",
    "\n",
    "    'dataSet' : 'ijcnn1',\n",
    "    'dataSetSize': 49990,\n",
    "    'maxFeature': 22,\n",
    "    'findingType': '1',\n",
    "\n",
    "    'honestNodeSize': 50,\n",
    "    'byzantineNodeSize': 20,\n",
    "\n",
    "    'rounds': 10,\n",
    "    'displayInterval': 4000,\n",
    "}\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(4, 2)\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'max-value attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA', 'SAGA', 'darkorange'),\n",
    "]\n",
    "# 文件名 图片中显示的名称 纹理\n",
    "aggregations = [\n",
    "    ('mean', 'mean',  'v-'), \n",
    "    ('gm', 'geomed','v--'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        for (aggregationName, showName, fmt) in aggregations:\n",
    "            # 标签\n",
    "            label = optimizerName + ' ' + showName\n",
    "            \n",
    "            # 画曲线\n",
    "            with open(CACHE_DIR + '_' + optimizer+'_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                # 损失函数\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "                # variance\n",
    "                variancePath = record['variancePath']\n",
    "                axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimality gap ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "    \n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.1,-0.6), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*8))\n",
    "plt.subplots_adjust(hspace=0.4, wspace=0.35)\n",
    "plt.savefig('./attack_loss_variance.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./attack_loss_variance.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "covtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[1]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(4, 2)\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'max-value attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD','royalblue'), \n",
    "    ('BatchSGD', 'darkgreen'), \n",
    "    ('SAGA', 'darkorange'),\n",
    "]\n",
    "# 文件名 图片中显示的名称 纹理\n",
    "aggregations = [\n",
    "    ('mean', 'mean',  'v-'), \n",
    "    ('gm', 'gm','v--'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, color in optimizers:\n",
    "        for (aggregationName, showName, fmt) in aggregations:\n",
    "            # 标签\n",
    "            label = optimizer + ' ' + showName\n",
    "            \n",
    "            # 画曲线\n",
    "            try:\n",
    "                with open(CACHE_DIR + '_' + optimizer+'_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                    record = pickle.load(f)\n",
    "                    # 损失函数\n",
    "                    path = record['path']\n",
    "                    path = logAxis(path, Fmin)\n",
    "                    axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "                    # variance\n",
    "                    variancePath = record['variancePath']\n",
    "                    axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "            except Exception as e:\n",
    "                print(e)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimal error ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "    \n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.1,-0.6), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*8))\n",
    "plt.subplots_adjust(hspace=0.4, wspace=0.35)\n",
    "# plt.savefig('./attack_loss_variance.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./attack_loss_variance.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 方差比较图（横）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ijcnn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[0]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 4)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'sign-flipping attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA', 'SAGA', 'darkorange'),\n",
    "]\n",
    "# 文件名 图片中显示的名称 纹理\n",
    "aggregations = [\n",
    "    ('mean', 'mean',  'v-'), \n",
    "    ('gm', 'geomed','v--'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        for (aggregationName, showName, fmt) in aggregations:\n",
    "            # 标签\n",
    "            label = optimizerName + ' ' + showName\n",
    "            \n",
    "            # 画曲线\n",
    "            with open(CACHE_DIR + '_' + optimizer+'_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                # 损失函数\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "                # variance\n",
    "                variancePath = record['variancePath']\n",
    "                axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimality gap ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[0][1].legend(loc='lower left', bbox_to_anchor=(1.2,-0.5), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*9, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "plt.savefig('./attack_loss_variance.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./attack_loss_variance.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[1]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 4)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'sign-flipping attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA', 'SAGA', 'darkorange'),\n",
    "]\n",
    "# 文件名 图片中显示的名称 纹理\n",
    "aggregations = [\n",
    "    ('mean', 'mean',  'v-'), \n",
    "    ('gm', 'geomed','v--'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        for (aggregationName, showName, fmt) in aggregations:\n",
    "            # 标签\n",
    "            label = optimizerName + ' ' + showName\n",
    "            \n",
    "            # 画曲线\n",
    "            with open(CACHE_DIR + '_' + optimizer+'_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                # 损失函数\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "                # variance\n",
    "                variancePath = record['variancePath']\n",
    "                axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimality gap ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[0][1].legend(loc='lower left', bbox_to_anchor=(1.2,-0.5), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*9, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "plt.savefig('./attack_loss_variance_covtype.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./attack_loss_variance.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[0]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 4)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'max-value attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA', 'SAGA', 'darkorange'),\n",
    "    ('SVRG', 'SVRG', 'blueviolet'),\n",
    "    ('SARAH', 'SARAH', 'k'),\n",
    "]\n",
    "# 文件名 图片中显示的名称 纹理\n",
    "aggregations = [\n",
    "    ('mean', 'mean',  'v-'), \n",
    "    ('gm', 'geomed','v--'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        for (aggregationName, showName, fmt) in aggregations:\n",
    "            # 标签\n",
    "            label = optimizerName + ' ' + showName\n",
    "            \n",
    "            # 画曲线\n",
    "            with open(CACHE_DIR + '_' + optimizer+'_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                # 损失函数\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "                # variance\n",
    "                variancePath = record['variancePath']\n",
    "                axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimality gap ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[0][1].legend(loc='lower left', bbox_to_anchor=(1.0,-0.5), \n",
    "                  borderaxespad = 0., ncol=5, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*9, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "# plt.savefig('./attack_loss_variance.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./attack_loss_variance.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[1]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 4)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'max-value attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA', 'SAGA', 'darkorange'),\n",
    "    ('SVRG', 'SVRG', 'blueviolet'),\n",
    "]\n",
    "# 文件名 图片中显示的名称 纹理\n",
    "aggregations = [\n",
    "    ('mean', 'mean',  'v-'), \n",
    "    ('gm', 'geomed','v--'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        for (aggregationName, showName, fmt) in aggregations:\n",
    "            # 标签\n",
    "            label = optimizerName + ' ' + showName\n",
    "            \n",
    "            # 画曲线\n",
    "            with open(CACHE_DIR + '_' + optimizer+'_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "                record = pickle.load(f)\n",
    "                # 损失函数\n",
    "                path = record['path']\n",
    "                path = logAxis(path, Fmin)\n",
    "                axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "                # variance\n",
    "                variancePath = record['variancePath']\n",
    "                axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimality gap ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[0][1].legend(loc='lower left', bbox_to_anchor=(1.0,-0.5), \n",
    "                  borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*9, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "# plt.savefig('./attack_loss_variance.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./attack_loss_variance.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 比较GM error, bias, variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "dataSetConfig = {\n",
    "    'name': 'ijcnn1',\n",
    "\n",
    "    'dataSet' : 'ijcnn1',\n",
    "    'dataSetSize': 49990,\n",
    "    'maxFeature': 22,\n",
    "    'findingType': '1',\n",
    "\n",
    "    'honestNodeSize': 50,\n",
    "    'byzantineNodeSize': 20,\n",
    "\n",
    "    'rounds': 10,\n",
    "    'displayInterval': 4000,\n",
    "}\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'sign-flipping attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "\n",
    "fig, axs = plt.subplots(2, 2)\n",
    "axs = sum(axs.tolist(), [])\n",
    "for ax, (attackName, title) in zip(axs, attackNames):\n",
    "    with open(CACHE_DIR + '_SGD_SAGA_cmpVar_' + attackName, 'rb') as f:\n",
    "        record = pickle.load(f)\n",
    "\n",
    "#     SAGA_biasPath = record['SAGA_biasPath']\n",
    "    SAGA_variencePath = record['SAGA_variencePath']\n",
    "    SAGA_error_Path = record['SAGA_error_Path']\n",
    "#     SGD_biasPath = record['SGD_biasPath']\n",
    "    SGD_variencePath = record['SGD_variencePath']\n",
    "    SGD_error_Path = record['SGD_error_Path']\n",
    "\n",
    "    # SAGA / SGD\n",
    "#     biasPro = [b_saga / b_sgd for b_saga, b_sgd in zip(SAGA_biasPath, SGD_biasPath)]\n",
    "    varPro = [v_saga / v_sgd for v_saga, v_sgd in zip(SAGA_variencePath, SGD_variencePath)]\n",
    "    errPro = [e_saga / e_sgd for e_saga, e_sgd in zip(SAGA_error_Path, SGD_error_Path)]\n",
    "\n",
    "#     ax.plot(x_axis_minus_1, biasPro, label='error')\n",
    "    ax.plot(x_axis_minus_1, varPro, label='variance')\n",
    "    ax.plot(x_axis_minus_1, errPro, label='geomed error')\n",
    "\n",
    "    # plt.plot(x_axis_minus_1, SAGA_biasPath, label='SAGA_biasPath')\n",
    "    # plt.plot(x_axis_minus_1, SAGA_variencePath, label='SAGA_variencePath')\n",
    "    # plt.plot(x_axis_minus_1, SAGA_error_Path, label='SAGA_error_Path')\n",
    "    # plt.plot(x_axis_minus_1, SGD_biasPath, label='SGD_biasPath')\n",
    "    # plt.plot(x_axis_minus_1, SGD_variencePath, label='SGD_variencePath')\n",
    "    # plt.plot(x_axis_minus_1, SGD_error_Path, label='SGD_error_Path')\n",
    "\n",
    "    # 填小标题\n",
    "    ax.set_title('{}'.format(title))\n",
    "\n",
    "    # 坐标轴\n",
    "    ax.set_xlabel(r'iteration $k$ / ${}$'.format(dataSetConfig['displayInterval']), fontsize=FONT_SIZE)\n",
    "    ax.set_ylabel(r'ratio', fontsize=FONT_SIZE)\n",
    "    labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "    [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "    \n",
    "#     ax.set_yscale('log')\n",
    "\n",
    "# 两行\n",
    "axs[-2].legend(loc='lower left', bbox_to_anchor=(0.6,-0.4), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.3)\n",
    "plt.savefig('./cmp_variance.eps', format='eps', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 单个精度影响聚合精度示意图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def aggregate_geometric(wList):\n",
    "    max_iter = 1000\n",
    "    tol = 1e-7\n",
    "    guess = np.mean(wList, axis=0)\n",
    "    for _ in range(max_iter):\n",
    "        dist_li = [np.linalg.norm(w - guess) for w in wList]\n",
    "        dist_li = [d if d != 0 else 1 for d in dist_li]\n",
    "        temp1 = np.sum([w / dist for w, dist in zip(wList, dist_li)], axis=0)\n",
    "        temp2 = np.sum([1.0 / dist for dist in dist_li])\n",
    "        guess_next = temp1 / temp2\n",
    "        guess_movement = np.linalg.norm(guess - guess_next)\n",
    "        guess = guess_next\n",
    "        if guess_movement <= tol:\n",
    "            break\n",
    "    return guess\n",
    "\n",
    "fig, axs = plt.subplots(1, 2)\n",
    "\n",
    "bias = 1\n",
    "pointCount = 20\n",
    "\n",
    "mean = [4, 2]\n",
    "largeVar = 1.0\n",
    "smallVar = 0.1\n",
    "\n",
    "MARKER_SIZE = 10\n",
    "\n",
    "np.random.seed(500)\n",
    "largeList = np.random.multivariate_normal(mean, largeVar*np.array([[1, 0], [0, 1]]), pointCount)\n",
    "smallList = np.random.multivariate_normal(mean, smallVar*np.array([[1, 0], [0, 1]]), pointCount)\n",
    "\n",
    "byzantineNode = np.array([\n",
    "    [1, 4],\n",
    "    [1, 3],\n",
    "    [1, 2],\n",
    "    [1, 1],\n",
    "    [1.5, 4],\n",
    "    [1.5, 3],\n",
    "    [1.5, 2],\n",
    "    [1.5, 1],\n",
    "    [2, 4],\n",
    "    [2, 3],\n",
    "    [2, 2],\n",
    "    [2, 1]\n",
    "])\n",
    "[*byzantineXY] = zip(*byzantineNode)\n",
    "\n",
    "largeAll = np.vstack([largeList, byzantineNode])\n",
    "smallAll = np.vstack([smallList, byzantineNode])\n",
    "\n",
    "largeGM = aggregate_geometric(largeAll)\n",
    "smallGM = aggregate_geometric(smallAll)\n",
    "\n",
    "[*largeXY] = zip(*largeList)\n",
    "[*smallXY] = zip(*smallList)\n",
    "\n",
    "# 画好节点\n",
    "fmt = '.'\n",
    "axs[0].plot(largeXY[0], largeXY[1], fmt, label='honest gradient')\n",
    "axs[1].plot(smallXY[0], smallXY[1], fmt)\n",
    "\n",
    "# 画拜占庭节点\n",
    "bfmt = 'r.'\n",
    "for ax in axs:\n",
    "    ax.plot(byzantineXY[0], byzantineXY[1], bfmt, label='Byzantine gradient')\n",
    "    \n",
    "# GM\n",
    "GMfmt = 'k+'\n",
    "axs[0].plot([largeGM[0]], [largeGM[1]], GMfmt, label='geometric median', markersize=MARKER_SIZE)\n",
    "axs[1].plot([smallGM[0]], [smallGM[1]], GMfmt, markersize=MARKER_SIZE)\n",
    "\n",
    "# 真实梯度\n",
    "trueFmt = 'k*'\n",
    "for ax in axs:\n",
    "    ax.plot([mean[0]], [mean[1]], trueFmt, label='true gradient', markersize=MARKER_SIZE)\n",
    "\n",
    "for ax in axs:\n",
    "    ax.set_xlim(0, 6)\n",
    "    ax.set_ylim(0, 5)\n",
    "    ax.set_axis_off()\n",
    "\n",
    "axs[0].set_title('gradients with large variance')\n",
    "axs[1].set_title('gradients with small variance')\n",
    "SCALE = 1\n",
    "FONT_SIZE = 12\n",
    "fig.set_size_inches((SCALE*8, SCALE*4))\n",
    "axs[0].legend(loc='lower left', bbox_to_anchor=(0.3,-0.2), \n",
    "                  borderaxespad = 0., ncol=2, fontsize=FONT_SIZE)\n",
    "# plt.savefig('./sketchMap_howVarianceAffectGM.eps', format='eps', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 零方差SAGA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[0]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 4)\n",
    "axs = tuple(zip(*axs))\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'sign-flipping attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD_ZV', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD_ZV', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA_ZV', 'SAGA', 'darkorange'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for axline, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        aggregationName = 'gm'\n",
    "        showName = 'geomed'\n",
    "        fmt = 'v--'\n",
    "\n",
    "        # 标签\n",
    "        label = optimizerName + ' ' + showName\n",
    "\n",
    "        # 画曲线\n",
    "        with open(CACHE_DIR + '_' + optimizer + '_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "            record = pickle.load(f)\n",
    "            # 损失函数\n",
    "            path = record['path']\n",
    "            path = logAxis(path, Fmin)\n",
    "            axline[0].plot(x_axis, path, fmt, color=color, label=label)\n",
    "            # variance\n",
    "            variancePath = record['variancePath']\n",
    "            axline[1].plot(x_axis_minus_1, variancePath, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        axline[0].set_title('optimality gap ({})'.format(title))\n",
    "        axline[1].set_title('variance ({})'.format(title))\n",
    "    for ax in axline:\n",
    "        # 坐标轴\n",
    "        ax.set_yscale('log')\n",
    "        ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']*50), fontsize=FONT_SIZE)\n",
    "        labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "        [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    axline[0].set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_ylabel(r'$D_{w\\notin B} [m_w^k]$', fontsize=FONT_SIZE)\n",
    "    axline[1].set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[0][1].legend(loc='lower left', bbox_to_anchor=(1.2,-0.5), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*9, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "plt.savefig('./zeroOuterVariation.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./zeroOuterVariation.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[0]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 2)\n",
    "axs = list(axs[0]) + list(axs[1])\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'sign-flipping'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD_ZV', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD_ZV', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA_ZV', 'SAGA', 'darkorange'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for ax, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        aggregationName = 'gm'\n",
    "        showName = 'geomed'\n",
    "        fmt = 'v--'\n",
    "\n",
    "        # 标签\n",
    "        label = optimizerName + ' ' + showName\n",
    "\n",
    "        # 画曲线\n",
    "        with open(CACHE_DIR + '_' + optimizer + '_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "            record = pickle.load(f)\n",
    "            # 损失函数\n",
    "            path = record['path']\n",
    "            path = logAxis(path, Fmin)\n",
    "            ax.plot(x_axis, path, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        ax.set_title('optimality gap ({})'.format(title))\n",
    "for ax in axs:\n",
    "    # 坐标轴\n",
    "    ax.set_yscale('log')\n",
    "    ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']*50), fontsize=FONT_SIZE)\n",
    "    labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "    [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    ax.set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    ax.set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[2].legend(loc='lower left', bbox_to_anchor=(0.15,-0.5), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "# plt.savefig('./zeroOuterVariation_small.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./zeroOuterVariation.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "import math\n",
    "\n",
    "def logAxis(path, Fmin):\n",
    "    return [p-Fmin for p in path]\n",
    "\n",
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "dataSetConfig = dataSetConfigs[0]\n",
    "\n",
    "SCALE = 2.0\n",
    "FONT_SIZE = 12\n",
    "\n",
    "fig, axs = plt.subplots(2, 2)\n",
    "axs = list(axs[0]) + list(axs[1])\n",
    "\n",
    "attackNames = [\n",
    "    ('baseline', 'without attack'), \n",
    "    ('white', 'Gaussian attack'), \n",
    "    ('maxValue', 'max-value attack'), \n",
    "    ('zeroGradient', 'zero-gradient attack'),\n",
    "]\n",
    "# 名称 颜色\n",
    "optimizers = [\n",
    "    ('SGD_ZV', 'SGD', 'royalblue'), \n",
    "    ('BatchSGD_ZV', 'BSGD', 'darkgreen'), \n",
    "    ('SAGA_ZV', 'SAGA', 'darkorange'),\n",
    "]\n",
    "\n",
    "CACHE_DIR = './cache/' + dataSetConfig['name']\n",
    "with open(CACHE_DIR + '_Fmin', 'rb') as f:\n",
    "    obj = pickle.load(f)\n",
    "    Fmin, w_min = obj['Fmin'], obj['w_min']\n",
    "\n",
    "x_axis = list(range(dataSetConfig['rounds']+1))\n",
    "x_axis_minus_1 = list(range(1, dataSetConfig['rounds']+1))\n",
    "\n",
    "for ax, (attackName, title) in zip(axs, attackNames):\n",
    "    for optimizer, optimizerName, color in optimizers:\n",
    "        aggregationName = 'gm'\n",
    "        showName = 'geomed'\n",
    "        fmt = 'v--'\n",
    "\n",
    "        # 标签\n",
    "        label = optimizerName + ' ' + showName\n",
    "\n",
    "        # 画曲线\n",
    "        with open(CACHE_DIR + '_' + optimizer + '_' + attackName + '_' + aggregationName, 'rb') as f:\n",
    "            record = pickle.load(f)\n",
    "            # 损失函数\n",
    "            path = record['path']\n",
    "            path = logAxis(path, Fmin)\n",
    "            ax.plot(x_axis, path, fmt, color=color, label=label)\n",
    "        \n",
    "        # 填小标题\n",
    "        ax.set_title('optimality gap ({})'.format(title))\n",
    "for ax in axs:\n",
    "    # 坐标轴\n",
    "    ax.set_yscale('log')\n",
    "    ax.set_xlabel(r'iteration k / ${}$'.format(dataSetConfig['displayInterval']*50), fontsize=FONT_SIZE)\n",
    "    labels = ax.get_xticklabels() + ax.get_yticklabels()\n",
    "    [label.set_fontsize(FONT_SIZE) for label in labels]\n",
    "\n",
    "    ax.set_ylabel(r'$f(x^k)-f(x^*)$', fontsize=FONT_SIZE)\n",
    "    ax.set_xlim(left=0)\n",
    "\n",
    "# 图例\n",
    "# 一行\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(0.01,-0.4), \n",
    "#                   borderaxespad = 0., ncol=4, fontsize=FONT_SIZE)\n",
    "# 两行\n",
    "axs[2].legend(loc='lower left', bbox_to_anchor=(0.15,-0.5), \n",
    "                  borderaxespad = 0., ncol=3, fontsize=FONT_SIZE)\n",
    "# 右侧\n",
    "# axs[-1][0].legend(loc='lower left', bbox_to_anchor=(1.2, 0.3), \n",
    "#                   borderaxespad = 0., ncol=1, fontsize=FONT_SIZE)\n",
    "\n",
    "fig.set_size_inches((SCALE*4, SCALE*4))\n",
    "plt.subplots_adjust(hspace=0.35, wspace=0.35)\n",
    "# plt.savefig('./zeroOuterVariation_small.eps', format='eps', bbox_inches='tight')\n",
    "# plt.savefig('./zeroOuterVariation.jpg', format='jpg', bbox_inches='tight')\n",
    "plt.show()"
   ]
  }
 ],
 "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.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}