entropy_change_s1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "06a6370d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implementation of MoE follows the code below\n",
    "# https://github.com/lucidrains/mixture-of-experts/blob/master/mixture_of_experts/mixture_of_experts.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fe808bcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.nn.parameter import Parameter\n",
    "import math\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from math import log, e\n",
    "import torch.optim as optim\n",
    "import pickle\n",
    "import random\n",
    "\n",
    "torch.manual_seed(14)\n",
    "np.random.seed(14)\n",
    "random.seed(14)\n",
    "\n",
    "plt.rcParams.update({'font.size': 13})\n",
    "\n",
    "DATA_NUM = 16000\n",
    "CLUSTER_NUM = 4\n",
    "EXPERT_NUM = 8\n",
    "PATCH_NUM = 4\n",
    "PATCH_LEN = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "28b9a354",
   "metadata": {},
   "outputs": [],
   "source": [
    "#utils\n",
    "\n",
    "def entropy(dispatch, base=None):\n",
    "    \"\"\" Computes entropy of label distribution. \"\"\"\n",
    "    n_expert = torch.sum(dispatch, axis=0)\n",
    "    n_total = torch.sum(dispatch)\n",
    "    \n",
    "    prob = dispatch / n_expert\n",
    "    ent = - torch.nansum(prob*torch.log(prob), axis=0)\n",
    "    ent = torch.sum((n_expert / n_total) * ent)\n",
    "    \n",
    "    return ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4a519c55",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvNet(nn.Module):\n",
    "    def __init__(self, input_dim, out_channel, patch_num, small=True, nonlinear=True):\n",
    "        super(ConvNet, self).__init__()\n",
    "        self.conv1 = nn.Conv1d(1, out_channel*2, int(input_dim/patch_num), int(input_dim/patch_num))        \n",
    "        # small initialization\n",
    "        if small:\n",
    "            self.conv1.weight = torch.nn.Parameter(self.conv1.weight*0.001) \n",
    "            self.conv1.bias = torch.nn.Parameter(self.conv1.bias*0.001) \n",
    "        self.out_channel = out_channel\n",
    "        self.nonlinear = nonlinear\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        if self.nonlinear:\n",
    "            x = x**3\n",
    "        x = torch.sum(x,2)\n",
    "        output = torch.stack([torch.sum(x[:,:self.out_channel],1), torch.sum(x[:,self.out_channel:],1)]).transpose(1,0)\n",
    "        return output\n",
    "    \n",
    "\n",
    "# top 1 hard routing\n",
    "def top1(t):\n",
    "    values, index = t.topk(k=1, dim=-1)\n",
    "    values, index = map(lambda x: x.squeeze(dim=-1), (values, index))\n",
    "    return values, index\n",
    "\n",
    "\n",
    "def cumsum_exclusive(t, dim=-1):\n",
    "    num_dims = len(t.shape)\n",
    "    num_pad_dims = - dim - 1\n",
    "    pre_padding = (0, 0) * num_pad_dims\n",
    "    pre_slice   = (slice(None),) * num_pad_dims\n",
    "    padded_t = F.pad(t, (*pre_padding, 1, 0)).cumsum(dim=dim)\n",
    "    return padded_t[(..., slice(None, -1), *pre_slice)]\n",
    "\n",
    "\n",
    "def safe_one_hot(indexes, max_length):\n",
    "    max_index = indexes.max() + 1\n",
    "    return F.one_hot(indexes, max(max_index + 1, max_length))[..., :max_length]\n",
    "\n",
    "\n",
    "class Router(nn.Module):\n",
    "    def __init__(self, input_dim, out_dim, patch_num, strategy='top1',noise=None):\n",
    "        super(Router, self).__init__()\n",
    "        self.conv1 = nn.Conv1d(1, out_dim, int(input_dim/patch_num), int(input_dim/patch_num),bias=False)\n",
    "        self.out_dim = out_dim\n",
    "        self.strategy = strategy\n",
    "        if self.strategy == 'top1':\n",
    "            if noise is None:\n",
    "                self.noise = torch.rand(DATA_NUM,out_dim).cuda()\n",
    "            else:\n",
    "                self.noise = noise\n",
    "        # zero initialization\n",
    "        self.reset_parameters()\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        self.conv1.weight = torch.nn.Parameter(self.conv1.weight * 0)\n",
    "            \n",
    "    def forward(self, x):      \n",
    "        x = self.conv1(x)\n",
    "        x = torch.sum(x,2)\n",
    "        if self.strategy == 'top1':\n",
    "            output = x + self.noise\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4033d481",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MoE(nn.Module):\n",
    "    def __init__(self, input_dim, out_channel, patch_num, expert_num, strategy='top1', nonlinear=True, noise=None):\n",
    "        super(MoE, self).__init__()\n",
    "        self.router = Router(input_dim, expert_num, patch_num, strategy=strategy, noise=noise)\n",
    "        self.models = nn.ModuleList()\n",
    "        for i in range(expert_num):\n",
    "            self.models.append(ConvNet(input_dim, out_channel, patch_num, nonlinear=nonlinear))\n",
    "        self.strategy = strategy\n",
    "        self.expert_num = expert_num\n",
    "\n",
    "    def forward(self, x):\n",
    "        select = self.router(x)\n",
    "        # top 1 or choose 1 according to probability\n",
    "        if self.strategy == 'top1':\n",
    "            gate, index = top1(select)\n",
    "        else:\n",
    "            gate, index = choose1(select)\n",
    "        \n",
    "        mask = F.one_hot(index, self.expert_num).float()\n",
    "\n",
    "        density = mask.mean(dim=-2)\n",
    "        density_proxy = select.mean(dim=-2)\n",
    "        loss = (density_proxy * density).mean() * float(self.expert_num ** 2)\n",
    "\n",
    "        mask_count = mask.sum(dim=-2, keepdim=True)\n",
    "        mask_flat = mask.sum(dim=-1)\n",
    "\n",
    "        combine_tensor = (gate[..., None, None] * mask_flat[..., None, None]\n",
    "                          * F.one_hot(index, self.expert_num)[..., None])\n",
    "                          \n",
    "        dispatch_tensor = combine_tensor.bool().to(combine_tensor)\n",
    "        dispatch_result = dispatch_tensor.squeeze(-1)\n",
    "        \n",
    "        expert_inputs = torch.einsum('bnd,ben->ebd', x, dispatch_tensor).unsqueeze(2)\n",
    "        \n",
    "        output = []\n",
    "        for i in range(self.expert_num):\n",
    "            output.append(self.models[i](expert_inputs[i]))\n",
    "        \n",
    "        output = torch.stack(output)\n",
    "        output = torch.einsum('ijk,jil->il', combine_tensor, output)\n",
    "        output = F.softmax(output,dim=1)\n",
    "\n",
    "        return output, dispatch_result, loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "93f390d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, criterion, data, labels, optimizers, epochs, \n",
    "          load_balancing=False, verbose=True, early_stopping=True, eps=0.02):\n",
    "    \n",
    "    expert_acc_train = [[[] for x in range(CLUSTER_NUM)] for x in range(EXPERT_NUM)]\n",
    "    expert_inner_train = [[[] for x in range(CLUSTER_NUM)] for x in range(EXPERT_NUM)]\n",
    "    \n",
    "    router_acc_train = [[] for x in range(CLUSTER_NUM)]\n",
    "    router_inner_train = [[] for x in range(CLUSTER_NUM)]\n",
    "\n",
    "    entropy_record = []\n",
    "    min_loss = float(\"inf\")\n",
    "\n",
    "    for epoch in range(epochs):  \n",
    "        \n",
    "        for optimizer in optimizers:\n",
    "            optimizer.zero_grad()\n",
    "        outputs, dispatch, load_balancing_loss = model(data)\n",
    "        \n",
    "        e = entropy(torch.stack([dispatch[train_cluster_idx[0]].squeeze(-1).sum(dim=0),\n",
    "                                 dispatch[train_cluster_idx[1]].squeeze(-1).sum(dim=0),\n",
    "                                 dispatch[train_cluster_idx[2]].squeeze(-1).sum(dim=0),\n",
    "                                 dispatch[train_cluster_idx[3]].squeeze(-1).sum(dim=0)]))\n",
    "        entropy_record.append(e)\n",
    "        \n",
    "        if load_balancing:\n",
    "            loss = criterion(outputs, labels) + 0.001 * load_balancing_loss\n",
    "        else:\n",
    "            loss = criterion(outputs, labels)\n",
    "            \n",
    "        if early_stopping:\n",
    "            if loss.item() <= min_loss:\n",
    "                min_loss = loss.item()\n",
    "            elif loss > min_loss+eps or loss <= 0.314:\n",
    "                break\n",
    "        loss.backward()\n",
    "                \n",
    "        for optimizer in optimizers:\n",
    "            optimizer.step()\n",
    "        \n",
    "        if epoch%100 == 0:\n",
    "            if verbose:\n",
    "                print('Epoch %d --- loss: %.3f' % (epoch + 1, loss.item()))\n",
    "            \n",
    "    print('Finished Training')\n",
    "    return expert_acc_train,expert_inner_train,router_acc_train,router_inner_train, dispatch, entropy_record\n",
    "\n",
    "\n",
    "def test(model, criterion, data, labels, verbose=True):\n",
    "    correct = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        outputs,_,_ = model(data) \n",
    "        predicted = torch.max(outputs.data, 1).indices\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "    if verbose:\n",
    "        print('Accuracy of the network on the %d test images: %.4f %%' % (data.shape[0],\n",
    "            100 * correct / data.shape[0]))\n",
    "    \n",
    "    return 100 * correct / data.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "48c37673",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_data = torch.load('synthetic_data_s1/train_data.pt')\n",
    "training_labels = torch.load('synthetic_data_s1/train_labels.pt')\n",
    "\n",
    "test_data = torch.load('synthetic_data_s1/test_data.pt')\n",
    "test_labels = torch.load('synthetic_data_s1/test_labels.pt')\n",
    "\n",
    "centers = torch.load('synthetic_data_s1/centers.pt')\n",
    "features = torch.load('synthetic_data_s1/features.pt')\n",
    "\n",
    "with open(\"synthetic_data_s1/train_cluster\", \"rb\") as fp:  \n",
    "    train_cluster_idx = pickle.load(fp)\n",
    "    \n",
    "with open(\"synthetic_data_s1/test_cluster\", \"rb\") as fp:  \n",
    "    test_cluster_idx = pickle.load(fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "93ce68fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.optim.optimizer import Optimizer, required\n",
    "from torch.optim import _functional\n",
    "\n",
    "class NormalizedGD(Optimizer):\n",
    "    def __init__(self, params, lr=required, momentum=0, dampening=0,\n",
    "                 weight_decay=0, nesterov=False):\n",
    "        if lr is not required and lr < 0.0:\n",
    "            raise ValueError(\"Invalid learning rate: {}\".format(lr))\n",
    "        if momentum < 0.0:\n",
    "            raise ValueError(\"Invalid momentum value: {}\".format(momentum))\n",
    "        if weight_decay < 0.0:\n",
    "            raise ValueError(\"Invalid weight_decay value: {}\".format(weight_decay))\n",
    "\n",
    "        defaults = dict(lr=lr, momentum=momentum, dampening=dampening,\n",
    "                        weight_decay=weight_decay, nesterov=nesterov)\n",
    "        if nesterov and (momentum <= 0 or dampening != 0):\n",
    "            raise ValueError(\"Nesterov momentum requires a momentum and zero dampening\")\n",
    "        super(NormalizedGD, self).__init__(params, defaults)\n",
    "\n",
    "    def __setstate__(self, state):\n",
    "        super(NormalizedGD, self).__setstate__(state)\n",
    "        for group in self.param_groups:\n",
    "            group.setdefault('nesterov', False)\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def step(self, closure=None):\n",
    "        loss = None\n",
    "        if closure is not None:\n",
    "            with torch.enable_grad():\n",
    "                loss = closure()\n",
    "\n",
    "        for group in self.param_groups:\n",
    "            params_with_grad = []\n",
    "            d_p_list = []\n",
    "            momentum_buffer_list = []\n",
    "            weight_decay = group['weight_decay']\n",
    "            momentum = group['momentum']\n",
    "            dampening = group['dampening']\n",
    "            nesterov = group['nesterov']\n",
    "            lr = group['lr']\n",
    "\n",
    "            for p in group['params']:\n",
    "                if p.grad is not None:\n",
    "                    # Normalizing \n",
    "                    if p.grad.norm() != 0:\n",
    "                        p.grad /= p.grad.norm()\n",
    "                        \n",
    "                    params_with_grad.append(p)\n",
    "                    d_p_list.append(p.grad)\n",
    "\n",
    "                    state = self.state[p]\n",
    "                    if 'momentum_buffer' not in state:\n",
    "                        momentum_buffer_list.append(None)\n",
    "                    else:\n",
    "                        momentum_buffer_list.append(state['momentum_buffer'])\n",
    "\n",
    "            _functional.sgd(params_with_grad,\n",
    "                  d_p_list,\n",
    "                  momentum_buffer_list,\n",
    "                  weight_decay=weight_decay,\n",
    "                  momentum=momentum,\n",
    "                  lr=lr,\n",
    "                  dampening=dampening,\n",
    "                  nesterov=nesterov,\n",
    "                  maximize=False\n",
    "                  ) \n",
    "\n",
    "            # update momentum_buffers in state\n",
    "            for p, momentum_buffer in zip(params_with_grad, momentum_buffer_list):\n",
    "                state = self.state[p]\n",
    "                state['momentum_buffer'] = momentum_buffer\n",
    "\n",
    "        return loss"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e773d81c",
   "metadata": {},
   "source": [
    "## Entropy change during training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1c134a00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.6750 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.7875 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.6688 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.0187 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 100.0000 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.8625 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.9562 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.8875 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.9813 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 99.6500 %\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 501\n",
    "entropy_records = []\n",
    "for i in range(10):\n",
    "\n",
    "    nonlinear_mixture = MoE(200, 8, PATCH_NUM, EXPERT_NUM, strategy='top1').cuda()\n",
    "    criterion = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "    optimizer = NormalizedGD(nonlinear_mixture.models.parameters(), lr=0.001)\n",
    "    optimizer2 = torch.optim.SGD(nonlinear_mixture.router.parameters(), lr=0.1) \n",
    "\n",
    "    _, _, _, _, _, entropy_record = train(nonlinear_mixture, criterion, training_data, training_labels, \n",
    "                                          [optimizer,optimizer2], num_epochs, \n",
    "                                          load_balancing=False, verbose=False, early_stopping=False)\n",
    "\n",
    "    entropy_records.append(torch.stack(entropy_record))\n",
    "    test(nonlinear_mixture, criterion, test_data, test_labels)\n",
    "    \n",
    "entropy_avg_noise = torch.mean(torch.stack(entropy_records),dim=0)\n",
    "entropy_std_noise = torch.std(torch.stack(entropy_records),dim=0)\n",
    "\n",
    "ci_noise = 1.96 * entropy_std_noise/np.sqrt(len(entropy_records))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7380c82e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 97.2062 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 94.3187 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 92.8187 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 95.6937 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 95.0687 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 93.9313 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 93.6688 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.3625 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 95.9625 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 93.2500 %\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 501\n",
    "entropy_records = []\n",
    "for i in range(10):\n",
    "\n",
    "    linear_mixture = MoE(200, 8, PATCH_NUM, EXPERT_NUM, strategy='top1', nonlinear=False).cuda()\n",
    "    criterion = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "    optimizer = NormalizedGD(linear_mixture.models.parameters(), lr=0.001)\n",
    "    optimizer2 = torch.optim.SGD(linear_mixture.router.parameters(), lr=0.1) \n",
    "\n",
    "    _, _, _, _, _, entropy_record = train(linear_mixture, criterion, training_data, training_labels, \n",
    "                                          [optimizer,optimizer2], num_epochs,\n",
    "                                          load_balancing=False, verbose=False, early_stopping=False)\n",
    "\n",
    "    entropy_records.append(torch.stack(entropy_record))\n",
    "    test(linear_mixture, criterion, test_data, test_labels)\n",
    "    \n",
    "entropy_avg_noise_linear = torch.mean(torch.stack(entropy_records),dim=0)\n",
    "entropy_std_noise_linear = torch.std(torch.stack(entropy_records),dim=0)\n",
    "\n",
    "ci_noise_linear = 1.96 * entropy_std_noise_linear/np.sqrt(len(entropy_records))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "212dc1b1",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1f253377308>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams.update({'font.size': 18, 'figure.figsize': (8,8), 'font.family':'Arial', 'axes.axisbelow':True})\n",
    "x = np.arange(0,501,1)\n",
    "\n",
    "plt.plot(x,entropy_avg_noise.cpu(), label='MoE (nonlinear)')\n",
    "plt.fill_between(x, (entropy_avg_noise.cpu()-ci_noise.cpu()), (entropy_avg_noise.cpu()+ci_noise.cpu()),\n",
    "                alpha=.1)\n",
    "\n",
    "plt.plot(x,entropy_avg_noise_linear.cpu(), label='MoE (linear)',linestyle='dashed')\n",
    "plt.fill_between(x, (entropy_avg_noise_linear.cpu()-ci_noise_linear.cpu()), \n",
    "                 (entropy_avg_noise_linear.cpu()+ci_noise_linear.cpu()), alpha=.1)\n",
    "\n",
    "plt.xlabel('Training Epochs')\n",
    "plt.ylabel('Entropy')\n",
    "plt.legend(bbox_to_anchor=(1, 1)) \n",
    "\n",
    "# plt.savefig('entropy_toy.pdf',bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8a92bd96",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(entropy_avg_noise.cpu(), 'entropy_change_records/MoE_s1.pt')\n",
    "torch.save(entropy_avg_noise_linear.cpu(), 'entropy_change_records/MoE_linear_s1.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "071af1cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(ci_noise.cpu(), 'entropy_change_records/MoE_ci_s1.pt')\n",
    "torch.save(ci_noise_linear.cpu(), 'entropy_change_records/MoE_ci_linear_s1.pt')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}