entropy_change_s2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "848bed77",
   "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(2)\n",
    "np.random.seed(2)\n",
    "random.seed(2)\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_s2/train_data.pt')\n",
    "training_labels = torch.load('synthetic_data_s2/train_labels.pt')\n",
    "\n",
    "test_data = torch.load('synthetic_data_s2/test_data.pt')\n",
    "test_labels = torch.load('synthetic_data_s2/test_labels.pt')\n",
    "\n",
    "centers = torch.load('synthetic_data_s2/centers.pt')\n",
    "features = torch.load('synthetic_data_s2/features.pt')\n",
    "\n",
    "with open(\"synthetic_data_s2/train_cluster\", \"rb\") as fp:  \n",
    "    train_cluster_idx = pickle.load(fp)\n",
    "    \n",
    "with open(\"synthetic_data_s2/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"
   ]
  },
  {
   "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: 98.0187 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.5187 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.6625 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 97.4875 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.5563 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.7500 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.1750 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 97.5625 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.4437 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 98.6750 %\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: 90.9250 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.4000 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.8375 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 92.8375 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.2438 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 89.8812 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.8750 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.0563 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.8500 %\n",
      "Finished Training\n",
      "Accuracy of the network on the 16000 test images: 91.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 0x1fc4d375208>"
      ]
     },
     "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_s2.pt')\n",
    "torch.save(entropy_avg_noise_linear.cpu(), 'entropy_change_records/MoE_linear_s2.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "071af1cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(ci_noise.cpu(), 'entropy_change_records/MoE_ci_s2.pt')\n",
    "torch.save(ci_noise_linear.cpu(), 'entropy_change_records/MoE_ci_linear_s2.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
}