├── README.md
├── data.py
├── demo.ipynb
└── utils.py


/README.md:
--------------------------------------------------------------------------------
1 | # EWC.pytorch
2 | 
3 | An implementation of Elastic Weight Consolidation (EWC), proposed in James Kirkpatrick et al. *Overcoming catastrophic forgetting in neural networks* 2016(10.1073/pnas.1611835114).
4 | 
5 | * [demo.ipynb](demo.ipynb) demonstrates EWC with supervised learning. 


--------------------------------------------------------------------------------
/data.py:
--------------------------------------------------------------------------------
 1 | import random
 2 | import torch
 3 | from torchvision import datasets
 4 | 
 5 | 
 6 | class PermutedMNIST(datasets.MNIST):
 7 | 
 8 |     def __init__(self, root="~/.torch/data/mnist", train=True, permute_idx=None):
 9 |         super(PermutedMNIST, self).__init__(root, train, download=True)
10 |         assert len(permute_idx) == 28 * 28
11 |         if self.train:
12 |             self.train_data = torch.stack([img.float().view(-1)[permute_idx] / 255
13 |                                            for img in self.train_data])
14 |         else:
15 |             self.test_data = torch.stack([img.float().view(-1)[permute_idx] / 255
16 |                                           for img in self.test_data])
17 | 
18 |     def __getitem__(self, index):
19 | 
20 |         if self.train:
21 |             img, target = self.train_data[index], self.train_labels[index]
22 |         else:
23 |             img, target = self.test_data[index], self.test_labels[index]
24 | 
25 |         return img, target
26 | 
27 |     def get_sample(self, sample_size):
28 |         sample_idx = random.sample(range(len(self)), sample_size)
29 |         return [img for img in self.train_data[sample_idx]]
30 | 


--------------------------------------------------------------------------------
/demo.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "% matplotlib inline\n",
 10 |     "import matplotlib.pyplot as plt\n",
 11 |     "\n",
 12 |     "plt.style.use(\"seaborn-white\")\n",
 13 |     "\n",
 14 |     "import random\n",
 15 |     "import torch\n",
 16 |     "from torch import nn\n",
 17 |     "from torch.nn import functional as F\n",
 18 |     "from torch import optim\n",
 19 |     "from tqdm import tqdm\n",
 20 |     "\n",
 21 |     "from data import PermutedMNIST\n",
 22 |     "from utils import EWC, ewc_train, normal_train, test\n"
 23 |    ]
 24 |   },
 25 |   {
 26 |    "cell_type": "code",
 27 |    "execution_count": 2,
 28 |    "metadata": {},
 29 |    "outputs": [],
 30 |    "source": [
 31 |     "epochs = 50\n",
 32 |     "lr = 1e-3\n",
 33 |     "batch_size = 128\n",
 34 |     "sample_size = 200\n",
 35 |     "hidden_size = 200\n",
 36 |     "num_task = 3\n"
 37 |    ]
 38 |   },
 39 |   {
 40 |    "cell_type": "code",
 41 |    "execution_count": 3,
 42 |    "metadata": {},
 43 |    "outputs": [],
 44 |    "source": [
 45 |     "class MLP(nn.Module):\n",
 46 |     "    def __init__(self, hidden_size=400):\n",
 47 |     "        super(MLP, self).__init__()\n",
 48 |     "        self.fc1 = nn.Linear(28 * 28, hidden_size)\n",
 49 |     "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
 50 |     "        self.fc3 = nn.Linear(hidden_size, hidden_size)\n",
 51 |     "        self.fc4 = nn.Linear(hidden_size, 10)\n",
 52 |     "\n",
 53 |     "    def forward(self, input):\n",
 54 |     "        x = F.relu(self.fc1(input))\n",
 55 |     "        x = F.relu(self.fc2(x))\n",
 56 |     "        x = F.relu(self.fc3(x))\n",
 57 |     "        x = F.relu(self.fc4(x))\n",
 58 |     "        return x\n"
 59 |    ]
 60 |   },
 61 |   {
 62 |    "cell_type": "code",
 63 |    "execution_count": 4,
 64 |    "metadata": {},
 65 |    "outputs": [],
 66 |    "source": [
 67 |     "def get_permute_mnist():\n",
 68 |     "    train_loader = {}\n",
 69 |     "    test_loader = {}\n",
 70 |     "    idx = list(range(28 * 28))\n",
 71 |     "    for i in range(num_task):\n",
 72 |     "        train_loader[i] = torch.utils.data.DataLoader(PermutedMNIST(train=True, permute_idx=idx),\n",
 73 |     "                                                      batch_size=batch_size,\n",
 74 |     "                                                      num_workers=4)\n",
 75 |     "        test_loader[i] = torch.utils.data.DataLoader(PermutedMNIST(train=False, permute_idx=idx),\n",
 76 |     "                                                     batch_size=batch_size)\n",
 77 |     "        random.shuffle(idx)\n",
 78 |     "    return train_loader, test_loader\n",
 79 |     "\n",
 80 |     "\n",
 81 |     "train_loader, test_loader = get_permute_mnist()\n"
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 5,
 87 |    "metadata": {},
 88 |    "outputs": [],
 89 |    "source": [
 90 |     "def standard_process(epochs, use_cuda=True, weight=True):\n",
 91 |     "    model = MLP(hidden_size)\n",
 92 |     "    if torch.cuda.is_available() and use_cuda:\n",
 93 |     "        model.cuda()\n",
 94 |     "    optimizer = optim.SGD(params=model.parameters(), lr=lr)\n",
 95 |     "\n",
 96 |     "    loss, acc = {}, {}\n",
 97 |     "    for task in range(num_task):\n",
 98 |     "        loss[task] = []\n",
 99 |     "        acc[task] = []\n",
100 |     "        for _ in tqdm(range(epochs)):\n",
101 |     "            loss[task].append(normal_train(model, optimizer, train_loader[task]))\n",
102 |     "            for sub_task in range(task + 1):\n",
103 |     "                acc[sub_task].append(test(model, test_loader[sub_task]))\n",
104 |     "        if task == 0 and weight:\n",
105 |     "            weight = model.state_dict()\n",
106 |     "    return loss, acc, weight\n",
107 |     "\n",
108 |     "\n",
109 |     "def ewc_process(epochs, importance, use_cuda=True, weight=None):\n",
110 |     "    model = MLP(hidden_size)\n",
111 |     "    if torch.cuda.is_available() and use_cuda:\n",
112 |     "        model.cuda()\n",
113 |     "    optimizer = optim.SGD(params=model.parameters(), lr=lr)\n",
114 |     "\n",
115 |     "    loss, acc, ewc = {}, {}, {}\n",
116 |     "    for task in range(num_task):\n",
117 |     "        loss[task] = []\n",
118 |     "        acc[task] = []\n",
119 |     "\n",
120 |     "        if task == 0:\n",
121 |     "            if weight:\n",
122 |     "                model.load_state_dict(weight)\n",
123 |     "            else:\n",
124 |     "                for _ in tqdm(range(epochs)):\n",
125 |     "                    loss[task].append(normal_train(model, optimizer, train_loader[task]))\n",
126 |     "                    acc[task].append(test(model, test_loader[task]))\n",
127 |     "        else:\n",
128 |     "            old_tasks = []\n",
129 |     "            for sub_task in range(task):\n",
130 |     "                old_tasks = old_tasks + train_loader[sub_task].dataset.get_sample(sample_size)\n",
131 |     "            old_tasks = random.sample(old_tasks, k=sample_size)\n",
132 |     "            for _ in tqdm(range(epochs)):\n",
133 |     "                loss[task].append(ewc_train(model, optimizer, train_loader[task], EWC(model, old_tasks), importance))\n",
134 |     "                for sub_task in range(task + 1):\n",
135 |     "                    acc[sub_task].append(test(model, test_loader[sub_task]))\n",
136 |     "\n",
137 |     "    return loss, acc\n"
138 |    ]
139 |   },
140 |   {
141 |    "cell_type": "code",
142 |    "execution_count": 6,
143 |    "metadata": {},
144 |    "outputs": [],
145 |    "source": [
146 |     "def loss_plot(x):\n",
147 |     "    for t, v in x.items():\n",
148 |     "        plt.plot(list(range(t * epochs, (t + 1) * epochs)), v)\n",
149 |     "\n",
150 |     "def accuracy_plot(x):\n",
151 |     "    for t, v in x.items():\n",
152 |     "        plt.plot(list(range(t * epochs, num_task * epochs)), v)\n",
153 |     "    plt.ylim(0, 1)"
154 |    ]
155 |   },
156 |   {
157 |    "cell_type": "code",
158 |    "execution_count": 7,
159 |    "metadata": {},
160 |    "outputs": [
161 |     {
162 |      "name": "stderr",
163 |      "output_type": "stream",
164 |      "text": [
165 |       "100%|██████████| 50/50 [01:01<00:00,  1.22s/it]\n",
166 |       "100%|██████████| 50/50 [01:05<00:00,  1.31s/it]\n",
167 |       "100%|██████████| 50/50 [01:08<00:00,  1.38s/it]\n"
168 |      ]
169 |     }
170 |    ],
171 |    "source": [
172 |     "loss, acc, weight = standard_process(epochs)"
173 |    ]
174 |   },
175 |   {
176 |    "cell_type": "code",
177 |    "execution_count": 8,
178 |    "metadata": {},
179 |    "outputs": [
180 |     {
181 |      "data": {
182 |       "image/png": "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\n",
183 |       "text/plain": [
184 |        "<matplotlib.figure.Figure at 0x7f44e1d69668>"
185 |       ]
186 |      },
187 |      "metadata": {},
188 |      "output_type": "display_data"
189 |     }
190 |    ],
191 |    "source": [
192 |     "loss_plot(loss)"
193 |    ]
194 |   },
195 |   {
196 |    "cell_type": "code",
197 |    "execution_count": 9,
198 |    "metadata": {},
199 |    "outputs": [
200 |     {
201 |      "data": {
202 |       "image/png": "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\n",
203 |       "text/plain": [
204 |        "<matplotlib.figure.Figure at 0x7f44e1d16630>"
205 |       ]
206 |      },
207 |      "metadata": {},
208 |      "output_type": "display_data"
209 |     }
210 |    ],
211 |    "source": [
212 |     "accuracy_plot(acc)"
213 |    ]
214 |   },
215 |   {
216 |    "cell_type": "code",
217 |    "execution_count": 10,
218 |    "metadata": {
219 |     "scrolled": true
220 |    },
221 |    "outputs": [
222 |     {
223 |      "name": "stderr",
224 |      "output_type": "stream",
225 |      "text": [
226 |       "100%|██████████| 50/50 [01:01<00:00,  1.23s/it]\n",
227 |       "100%|██████████| 50/50 [01:52<00:00,  2.25s/it]\n",
228 |       "100%|██████████| 50/50 [02:04<00:00,  2.49s/it]\n"
229 |      ]
230 |     }
231 |    ],
232 |    "source": [
233 |     "loss_ewc, acc_ewc = ewc_process(epochs, importance=1000, \n",
234 |     "#                                 weight=weight\n",
235 |     "                               )"
236 |    ]
237 |   },
238 |   {
239 |    "cell_type": "code",
240 |    "execution_count": 11,
241 |    "metadata": {},
242 |    "outputs": [
243 |     {
244 |      "data": {
245 |       "image/png": "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\n",
246 |       "text/plain": [
247 |        "<matplotlib.figure.Figure at 0x7f44e1c9c2e8>"
248 |       ]
249 |      },
250 |      "metadata": {},
251 |      "output_type": "display_data"
252 |     }
253 |    ],
254 |    "source": [
255 |     "loss_plot(loss_ewc)"
256 |    ]
257 |   },
258 |   {
259 |    "cell_type": "code",
260 |    "execution_count": 12,
261 |    "metadata": {},
262 |    "outputs": [
263 |     {
264 |      "data": {
265 |       "image/png": "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\n",
266 |       "text/plain": [
267 |        "<matplotlib.figure.Figure at 0x7f44e1665630>"
268 |       ]
269 |      },
270 |      "metadata": {},
271 |      "output_type": "display_data"
272 |     }
273 |    ],
274 |    "source": [
275 |     "accuracy_plot(acc_ewc)"
276 |    ]
277 |   },
278 |   {
279 |    "cell_type": "code",
280 |    "execution_count": 13,
281 |    "metadata": {},
282 |    "outputs": [
283 |     {
284 |      "data": {
285 |       "text/plain": [
286 |        "<matplotlib.legend.Legend at 0x7f44e19abcc0>"
287 |       ]
288 |      },
289 |      "execution_count": 13,
290 |      "metadata": {},
291 |      "output_type": "execute_result"
292 |     },
293 |     {
294 |      "data": {
295 |       "image/png": "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\n",
296 |       "text/plain": [
297 |        "<matplotlib.figure.Figure at 0x7f44e165a5f8>"
298 |       ]
299 |      },
300 |      "metadata": {},
301 |      "output_type": "display_data"
302 |     }
303 |    ],
304 |    "source": [
305 |     "plt.plot(acc[0], label=\"sgd\")\n",
306 |     "plt.plot(acc_ewc[0], label=\"ewc\")\n",
307 |     "plt.legend()"
308 |    ]
309 |   },
310 |   {
311 |    "cell_type": "code",
312 |    "execution_count": null,
313 |    "metadata": {},
314 |    "outputs": [],
315 |    "source": []
316 |   }
317 |  ],
318 |  "metadata": {
319 |   "kernelspec": {
320 |    "display_name": "Python 3",
321 |    "language": "python",
322 |    "name": "python3"
323 |   },
324 |   "language_info": {
325 |    "codemirror_mode": {
326 |     "name": "ipython",
327 |     "version": 3
328 |    },
329 |    "file_extension": ".py",
330 |    "mimetype": "text/x-python",
331 |    "name": "python",
332 |    "nbconvert_exporter": "python",
333 |    "pygments_lexer": "ipython3",
334 |    "version": "3.6.3"
335 |   }
336 |  },
337 |  "nbformat": 4,
338 |  "nbformat_minor": 2
339 | }
340 | 


--------------------------------------------------------------------------------
/utils.py:
--------------------------------------------------------------------------------
 1 | from copy import deepcopy
 2 | 
 3 | import torch
 4 | from torch import nn
 5 | from torch.nn import functional as F
 6 | from torch.autograd import Variable
 7 | import torch.utils.data
 8 | 
 9 | 
10 | def variable(t: torch.Tensor, use_cuda=True, **kwargs):
11 |     if torch.cuda.is_available() and use_cuda:
12 |         t = t.cuda()
13 |     return Variable(t, **kwargs)
14 | 
15 | 
16 | class EWC(object):
17 |     def __init__(self, model: nn.Module, dataset: list):
18 | 
19 |         self.model = model
20 |         self.dataset = dataset
21 | 
22 |         self.params = {n: p for n, p in self.model.named_parameters() if p.requires_grad}
23 |         self._means = {}
24 |         self._precision_matrices = self._diag_fisher()
25 | 
26 |         for n, p in deepcopy(self.params).items():
27 |             self._means[n] = variable(p.data)
28 | 
29 |     def _diag_fisher(self):
30 |         precision_matrices = {}
31 |         for n, p in deepcopy(self.params).items():
32 |             p.data.zero_()
33 |             precision_matrices[n] = variable(p.data)
34 | 
35 |         self.model.eval()
36 |         for input in self.dataset:
37 |             self.model.zero_grad()
38 |             input = variable(input)
39 |             output = self.model(input).view(1, -1)
40 |             label = output.max(1)[1].view(-1)
41 |             loss = F.nll_loss(F.log_softmax(output, dim=1), label)
42 |             loss.backward()
43 | 
44 |             for n, p in self.model.named_parameters():
45 |                 precision_matrices[n].data += p.grad.data ** 2 / len(self.dataset)
46 | 
47 |         precision_matrices = {n: p for n, p in precision_matrices.items()}
48 |         return precision_matrices
49 | 
50 |     def penalty(self, model: nn.Module):
51 |         loss = 0
52 |         for n, p in model.named_parameters():
53 |             _loss = self._precision_matrices[n] * (p - self._means[n]) ** 2
54 |             loss += _loss.sum()
55 |         return loss
56 | 
57 | 
58 | def normal_train(model: nn.Module, optimizer: torch.optim, data_loader: torch.utils.data.DataLoader):
59 |     model.train()
60 |     epoch_loss = 0
61 |     for input, target in data_loader:
62 |         input, target = variable(input), variable(target)
63 |         optimizer.zero_grad()
64 |         output = model(input)
65 |         loss = F.cross_entropy(output, target)
66 |         epoch_loss += loss.data[0]
67 |         loss.backward()
68 |         optimizer.step()
69 |     return epoch_loss / len(data_loader)
70 | 
71 | 
72 | def ewc_train(model: nn.Module, optimizer: torch.optim, data_loader: torch.utils.data.DataLoader,
73 |               ewc: EWC, importance: float):
74 |     model.train()
75 |     epoch_loss = 0
76 |     for input, target in data_loader:
77 |         input, target = variable(input), variable(target)
78 |         optimizer.zero_grad()
79 |         output = model(input)
80 |         loss = F.cross_entropy(output, target) + importance * ewc.penalty(model)
81 |         epoch_loss += loss.data[0]
82 |         loss.backward()
83 |         optimizer.step()
84 |     return epoch_loss / len(data_loader)
85 | 
86 | 
87 | def test(model: nn.Module, data_loader: torch.utils.data.DataLoader):
88 |     model.eval()
89 |     correct = 0
90 |     for input, target in data_loader:
91 |         input, target = variable(input), variable(target)
92 |         output = model(input)
93 |         correct += (F.softmax(output, dim=1).max(dim=1)[1] == target).data.sum()
94 |     return correct / len(data_loader.dataset)
95 | 


--------------------------------------------------------------------------------