epistemic uncertainty with variational layers working

This commit is contained in:
ritchie46 committed 2019-09-27 18:50:24 +02:00
1 parent 81f46a8b7b
commit cff18712b9
1 file changed
+345 -28
+345 -28
View File
@@ -14,21 +14,23 @@
"from torch import nn\n",
"from sklearn import datasets\n",
"from torch.utils.data import DataLoader, TensorDataset\n",
"from sklearn.preprocessing import StandardScaler"
"from sklearn.preprocessing import StandardScaler\n",
"import torch.distributions as dist\n",
"from dataclasses import dataclass"
]
},
{
"cell_type": "code",
"execution_count": 394,
"execution_count": 397,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<matplotlib.collections.PathCollection at 0x7f6d652fbfd0>"
"<matplotlib.collections.PathCollection at 0x7fa823b1cc50>"
]
},
"execution_count": 394,
"execution_count": 397,
"metadata": {},
"output_type": "execute_result"
},
@@ -74,7 +76,7 @@
},
{
"cell_type": "code",
"execution_count": 395,
"execution_count": 401,
"metadata": {},
"outputs": [],
"source": [
@@ -84,7 +86,7 @@
},
{
"cell_type": "code",
"execution_count": 396,
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
@@ -114,12 +116,12 @@
},
{
"cell_type": "code",
"execution_count": 397,
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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 truncated
"image/png": "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 truncated
"text/plain": [
"<Figure size 1152x432 with 1 Axes>"
]
@@ -139,14 +141,14 @@
},
{
"cell_type": "code",
"execution_count": 398,
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor(0.4997)\n"
"tensor(0.5057)\n"
]
}
],
@@ -166,7 +168,7 @@
},
{
"cell_type": "code",
"execution_count": 399,
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
@@ -177,7 +179,7 @@
},
{
"cell_type": "code",
"execution_count": 451,
"execution_count": 398,
"metadata": {},
"outputs": [],
"source": [
@@ -214,19 +216,20 @@
},
{
"cell_type": "code",
"execution_count": 452,
"execution_count": 411,
"metadata": {},
"outputs": [],
"source": [
"def elbo(y_pred, y, mu, log_var):\n",
" sigma = log_var.exp()**0.5\n",
" # likelihood of observing y given Variational mu and sigma\n",
" likelihood = ll_gaussian(y, mu, log_var)\n",
" likelihood = dist.Normal(mu, sigma).log_prob(y)\n",
" \n",
" # prior probability of y_pred\n",
" log_prior = ll_gaussian(y_pred, 0, torch.log(torch.tensor(1.)))\n",
" log_prior = dist.Normal(0, 1).log_prob(y_pred)\n",
" \n",
" # variational probability of y_pred\n",
" log_p_q = ll_gaussian(y_pred, mu, log_var)\n",
" log_p_q = dist.Normal(mu, sigma).log_prob(y_pred) \n",
" \n",
" # by taking the mean we approximate the expectation\n",
" return (likelihood + log_prior - log_p_q).mean()\n",
@@ -240,7 +243,7 @@
},
{
"cell_type": "code",
"execution_count": 453,
"execution_count": 412,
"metadata": {},
"outputs": [],
"source": [
@@ -259,14 +262,14 @@
},
{
"cell_type": "code",
"execution_count": 454,
"execution_count": 413,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor(0.5258)\n"
"tensor(0.5246)\n"
]
}
],
@@ -277,7 +280,7 @@
},
{
"cell_type": "code",
"execution_count": 455,
"execution_count": 414,
"metadata": {},
"outputs": [],
"source": [
@@ -291,22 +294,22 @@
},
{
"cell_type": "code",
"execution_count": 464,
"execution_count": 415,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<matplotlib.collections.PolyCollection at 0x7f6d648794e0>"
"<matplotlib.collections.PolyCollection at 0x7fa823623e80>"
]
},
"execution_count": 464,
"execution_count": 415,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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 truncated
"image/png": "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 truncated
"text/plain": [
"<Figure size 1152x432 with 1 Axes>"
]
@@ -326,7 +329,7 @@
},
{
"cell_type": "code",
"execution_count": 300,
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
@@ -334,7 +337,304 @@
" reconstruction_error = (0.5 * (y - y_pred)**2).sum()\n",
" kl_divergence = (-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp()))\n",
"\n",
" return (reconstruction_error + kl_divergence).sum()"
" return reconstruction_error + kl_divergence"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$ Q(w) = \\mathcal{N}(\\mu_{\\theta}, \\sigma^2_{\\theta}) $ "
]
},
{
"cell_type": "code",
"execution_count": 369,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# def f(x, sigma=0.07):\n",
"# return (x**2 + x) / 3500 + torch.randn_like(x) * sigma\n",
"\n",
"# plt.scatter(X, f(X))\n",
"\n",
"# Y = f(X)"
]
},
{
"cell_type": "code",
"execution_count": 372,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042],\n",
" [ 0.2131, 0.6623, -1.0420, -0.2947, -0.2779, -0.3666, -0.1316, -0.5020,\n",
" 1.4475, -0.7042]], grad_fn=<AddBackward0>)"
]
},
"execution_count": 372,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class LinearVariational(nn.Module):\n",
" \"\"\"\n",
" Mean field approximation of dense layer.\n",
" \"\"\"\n",
" def __init__(self, in_features, out_features, parent, bias=True):\n",
" super().__init__()\n",
" self.in_features = in_features\n",
" self.out_features = out_features\n",
" self.include_bias = bias \n",
" self.parent = parent\n",
" \n",
" if getattr(parent, 'accumulated_kl_div', None) is None:\n",
" parent.accumulated_kl_div = 0\n",
" \n",
" # Initialize the variational parameters.\n",
" # 𝑄(𝑤)=N(𝜇_𝜃,𝜎2_𝜃)\n",
" # Do some random initialization with 𝜎=0.01\n",
" self.w_mu = nn.Parameter(\n",
" torch.FloatTensor(in_features, out_features).normal_(mean=0, std=0.001)\n",
" )\n",
" # proxy for variance\n",
" # log(1 + exp(ρ))◦ eps\n",
" self.w_p = nn.Parameter(\n",
" torch.FloatTensor(in_features, out_features).normal_(mean=-2.5, std=0.001)\n",
" )\n",
" if self.include_bias:\n",
" self.b_mu = nn.Parameter(\n",
" torch.zeros(out_features)\n",
" )\n",
" # proxy for variance\n",
" self.b_p = nn.Parameter(\n",
" torch.zeros(out_features)\n",
" )\n",
" # learnable prior mixture parameters\n",
" # See 3.3. Scale mixture prior\n",
" # Weight Uncertainty in Neural Networks (Charles Blundell et al.)\n",
" # https://arxiv.org/pdf/1505.05424.pdf\n",
" self.pi = nn.Parameter(torch.FloatTensor([0.2]))\n",
" self.sigma_1 = nn.Parameter(torch.FloatTensor([1.]))\n",
" self.sigma_2 = nn.Parameter(torch.FloatTensor([.1]))\n",
" \n",
" def log_prior(self, z):\n",
" return (self.pi * dist.Normal(0, self.sigma_1).log_prob(z).exp() +\n",
" (1 - self.pi) * dist.Normal(0, self.sigma_2).log_prob(z).exp()).log()\n",
"\n",
" def reparameterize(self, mu, p):\n",
" sigma = torch.log(1 + torch.exp(p)) \n",
" eps = torch.randn_like(sigma)\n",
" return mu + (eps * sigma)\n",
" \n",
" def kl_divergence(self, z, mu_theta, p_theta, prior_sd=1):\n",
" log_prior = dist.Normal(0, prior_sd).log_prob(z) \n",
" log_p_q = dist.Normal(mu_theta, torch.log(1 + torch.exp(p_theta))).log_prob(z) \n",
"\n",
" # reverse the elbo, as we need to maximize the elbo\n",
" # - (log_prior - log_p_q) = log_p_q - log_prior\n",
" return (log_p_q - log_prior).sum()\n",
" \n",
"\n",
" def forward(self, x):\n",
" w = self.reparameterize(self.w_mu, self.w_p)\n",
" \n",
" if self.include_bias:\n",
" b = self.reparameterize(self.b_mu, self.b_p)\n",
" else:\n",
" b = 0\n",
" \n",
" z = x @ w + b\n",
" \n",
" self.parent.accumulated_kl_div += self.kl_divergence(w, \n",
" self.w_mu,\n",
" self.w_p, \n",
" 1.\n",
" )\n",
" if self.include_bias:\n",
" self.parent.accumulated_kl_div += self.kl_divergence(b, \n",
" self.b_mu, \n",
" self.b_p,\n",
" 1.\n",
" )\n",
" return z\n",
" \n",
"m = LinearVariational(2, 10, parent=d)\n",
"m.forward(torch.ones(10, 2))"
]
},
{
"cell_type": "code",
"execution_count": 416,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0.2831],\n",
" [0.2831],\n",
" [0.2828],\n",
" [0.2819],\n",
" [0.2813],\n",
" [0.2810],\n",
" [0.2799],\n",
" [0.2791],\n",
" [0.2789],\n",
" [0.2786]], grad_fn=<SliceBackward>)"
]
},
"execution_count": 416,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"@dataclass\n",
"class KL:\n",
" accumulated_kl_div = 0\n",
"\n",
"class Model(nn.Module):\n",
" def __init__(self, in_size, hidden_size, out_size):\n",
" super().__init__()\n",
" \n",
" self.kl_loss = KL\n",
" \n",
" self.layers = nn.Sequential(\n",
" LinearVariational(in_size, hidden_size, self.kl_loss),\n",
" nn.ReLU(),\n",
" LinearVariational(hidden_size, hidden_size, self.kl_loss),\n",
" nn.ReLU(),\n",
" LinearVariational(hidden_size, out_size, self.kl_loss)\n",
" )\n",
" \n",
" @property\n",
" def accumulated_kl_div(self):\n",
" return self.kl_loss.accumulated_kl_div\n",
" \n",
" def reset_kl_div(self):\n",
" self.kl_loss.accumulated_kl_div = 0\n",
" \n",
" def forward(self, x):\n",
" return self.layers(x)\n",
" \n",
"m = Model(1, 20, 1)\n",
"m(X)[:10]"
]
},
{
"cell_type": "code",
"execution_count": 417,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor(908.0202, grad_fn=<AddBackward0>)"
]
},
"execution_count": 417,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m.accumulated_kl_div"
]
},
{
"cell_type": "code",
"execution_count": 418,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"11374.8408203125\n",
"4694.74560546875\n",
"5758.109375\n",
"5817.72265625\n",
"4768.3720703125\n",
"4349.931640625\n",
"4380.0009765625\n",
"4547.62548828125\n"
]
}
],
"source": [
"epochs = 2000\n",
"\n",
"def det_loss(y, y_pred, model):\n",
" batch_size = y.shape[0]\n",
" reconstruction_error = -dist.Normal(y_pred, .1).log_prob(y).sum() \n",
" kl = model.accumulated_kl_div\n",
" model.reset_kl_div()\n",
" return (reconstruction_error + kl) \n",
" \n",
"m = Model(1, 20, 1)\n",
"optim = torch.optim.Adam(m.parameters(), lr=0.01)\n",
"\n",
"for epoch in range(epochs):\n",
" optim.zero_grad()\n",
" y_pred = m(X)\n",
" loss = det_loss(y_pred, Y, m)\n",
" loss.backward()\n",
" optim.step()\n",
" \n",
" if epoch % 250 == 0:\n",
" print(loss.data.item())"
]
},
{
"cell_type": "code",
"execution_count": 420,
"metadata": {},
"outputs": [],
"source": [
"with torch.no_grad():\n",
" trace = np.array([m(X).flatten().numpy() for _ in range(1000)]).T"
]
},
{
"cell_type": "code",
"execution_count": 421,
"metadata": {},
"outputs": [],
"source": [
"q_25, q_95 = np.quantile(trace, [0.05, 0.95], axis=1)"
]
},
{
@@ -345,15 +645,32 @@
{
"data": {
"text/plain": [
"tensor(0.5044, grad_fn=<MeanBackward0>)"
"<matplotlib.collections.PolyCollection at 0x7fa8234d16d8>"
]
},
"execution_count": 422,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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 truncated
"text/plain": [
"<Figure size 1152x432 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": []
"source": [
"plt.figure(figsize=(16, 6))\n",
"plt.plot(X, trace.mean(1))\n",
"plt.scatter(X, Y)\n",
"plt.fill_between(X.flatten(), q_25, q_95, alpha=0.2)\n"
]
},
{
"cell_type": "code",