Skip to content

Instantly share code, notes, and snippets.

@jcreinhold
Last active June 20, 2020 19:41
Show Gist options
  • Save jcreinhold/745385337944dbcc98b47578b5a769f9 to your computer and use it in GitHub Desktop.
Save jcreinhold/745385337944dbcc98b47578b5a769f9 to your computer and use it in GitHub Desktop.
Toy classification example with uncertainty
Display the source blob
Display the rendered blob
Raw
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Finding uncertainty in a toy classification example\n",
"\n",
"Calculate uncertainty with dropout-based methods on one-dimensional source and target."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup notebook"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from typing import Callable, List, Optional, Tuple, Union\n",
"\n",
"from glob import glob\n",
"import os\n",
"import random\n",
"import sys\n",
"import warnings\n",
"\n",
"gpu_id = 1\n",
"os.environ[\"CUDA_VISIBLE_DEVICES\"] = f'{gpu_id}'\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"\n",
"import torch\n",
"from torch import nn\n",
"import torch.nn.functional as F\n",
"from torch.utils.data.dataset import Dataset\n",
"from torch.utils.data import DataLoader"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Support in-notebook plotting"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Report versions"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"numpy version: 1.17.2\n",
"matplotlib version: 3.1.3\n",
"pytorch version: 1.5.0\n"
]
}
],
"source": [
"print('numpy version: {}'.format(np.__version__))\n",
"from matplotlib import __version__ as mplver\n",
"print('matplotlib version: {}'.format(mplver))\n",
"print(f'pytorch version: {torch.__version__}')"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"python version: 3.7.7\n"
]
}
],
"source": [
"pv = sys.version_info\n",
"print('python version: {}.{}.{}'.format(pv.major, pv.minor, pv.micro))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Reload packages where content for package development"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"%load_ext autoreload\n",
"%autoreload 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Check GPU(s)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sat Jun 20 15:38:32 2020 \n",
"+-----------------------------------------------------------------------------+\n",
"| NVIDIA-SMI 430.40 Driver Version: 430.40 CUDA Version: 10.1 |\n",
"|-------------------------------+----------------------+----------------------+\n"
]
}
],
"source": [
"!nvidia-smi | head -n 4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Set seeds for better reproducibility"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"seed = 1337\n",
"random.seed(seed)\n",
"np.random.seed(seed)\n",
"torch.manual_seed(seed)\n",
"torch.cuda.manual_seed(seed)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup training and validation data\n",
"\n",
"Make up some toy data for our classification experiments, e.g., a mixture of 2 Gaussians."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"class ToyClassificationData(Dataset):\n",
" def __init__(self, n:int, x_locs:Tuple[float,float]=(-1.,1.), \n",
" noise_std:float=0.1, dist:Optional=torch.distributions.Normal):\n",
" self.n = n\n",
" self.x_locs = x_locs\n",
" self.noise_std = noise_std\n",
" self.x0_dist = dist(x_locs[0], noise_std)\n",
" self.x1_dist = dist(x_locs[1], noise_std)\n",
" x0 = self.x0_dist.sample((n//2,1))\n",
" y0 = torch.zeros((n//2,1))\n",
" x1 = self.x1_dist.sample((n//2,1))\n",
" y1 = torch.ones((n//2,1))\n",
" self.x = torch.cat((x0, x1))\n",
" self.y = torch.cat((y0, y1))\n",
"\n",
" def __len__(self):\n",
" return self.x.size(0)\n",
"\n",
" def __getitem__(self, idx):\n",
" return (self.x[idx], self.y[idx])"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"N = 1024\n"
]
}
],
"source": [
"dim = 1\n",
"N = 2**10\n",
"train_dist = torch.distributions.Normal\n",
"valid_dist = torch.distributions.Normal\n",
"xt_locs, xv_locs = (-1.,1.), (-1., 1.)\n",
"train_std, valid_std = 0.5, 0.5\n",
"print(f'N = {N}')\n",
"\n",
"train_ds_params = dict(x_locs=xt_locs, noise_std=train_std, dist=train_dist)\n",
"valid_ds_params = dict(x_locs=xv_locs, noise_std=valid_std, dist=valid_dist)\n",
"train_ds = ToyClassificationData(N, **train_ds_params)\n",
"valid_ds = ToyClassificationData(N//2, **valid_ds_params)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plot_data = N <= 2**12 and dim == 1\n",
"if plot_data:\n",
" ix0 = train_ds.y[:,0] == 0\n",
" ix1 = train_ds.y[:,0] == 1\n",
" f, ax = plt.subplots(1,1)\n",
" ax.hist(train_ds.x[ix0,0], bins=20, label='0', alpha=0.7)\n",
" ax.hist(train_ds.x[ix1,0], bins=20, label='1', alpha=0.7)\n",
" ax.legend()\n",
" ax.set_title('Training data');"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup model"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"activation = nn.ReLU\n",
"\n",
"class UncertainLinear(nn.Module):\n",
" def __init__(self, dim:int, mid:int, n_layers:int=1, dropout_rate:float=0.2, \n",
" mid_bias:bool=True, out_bias:bool=False):\n",
" super().__init__()\n",
" self.p = dropout_rate\n",
" layers = [nn.Sequential(nn.Linear(dim, mid, bias=mid_bias), activation())]\n",
" for _ in range(n_layers-1):\n",
" layers.append(nn.Sequential(nn.Linear(mid,mid,bias=mid_bias), activation()))\n",
" self.m = nn.ModuleList(layers)\n",
" self.out = nn.Linear(mid, 1, bias=out_bias)\n",
" self.var = nn.Linear(mid, 1, bias=out_bias)\n",
" \n",
" def forward(self, x:torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n",
" for m in self.m:\n",
" x = F.dropout(m(x), p=self.p, training=True)\n",
" return self.out(x), self.var(x)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"class BCELoss(nn.Module):\n",
" \"\"\" use just BCE loss with UncertainLinear network \"\"\"\n",
" def forward(self, out:torch.Tensor, y:torch.Tensor) -> torch.Tensor:\n",
" logit, _ = out\n",
" loss = F.binary_cross_entropy_with_logits(logit, y)\n",
" return loss\n",
"\n",
"class ExtendedBCELoss(nn.Module):\n",
" \"\"\" use modified BCE loss for variance calculation with UncertainLinear network \"\"\"\n",
" def forward(self, out:torch.Tensor, y:torch.Tensor, n_samp:int=10) -> torch.Tensor:\n",
" logit, sigma = out\n",
" dist = torch.distributions.Normal(logit, torch.exp(sigma))\n",
" mc_logs = dist.rsample((n_samp,))\n",
" loss = 0.\n",
" for mc_log in mc_logs:\n",
" loss += F.binary_cross_entropy_with_logits(mc_log, y)\n",
" loss /= n_samp\n",
" return loss"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"def calc_uncertainty(logits:torch.Tensor, sigmas:torch.Tensor, eps:float=1e-6) -> Tuple[torch.Tensor, torch.Tensor]:\n",
" \"\"\" calculate epistemic, entropy, and aleatory uncertainty quantities \"\"\"\n",
" probits = torch.sigmoid(logits)\n",
" epistemic = probits.var(dim=0, unbiased=True)\n",
" probit = probits.mean(dim=0)\n",
" entropy = -1 * (probit * (probit + eps).log2() + ((1 - probit) * (1 - probit + eps).log2()))\n",
" aleatory = torch.exp(sigmas).mean(dim=0)\n",
" return epistemic, entropy, aleatory\n",
"\n",
"def predict(model, x:torch.Tensor, n_samp:int=25):\n",
" \"\"\" return predictions of the model and the predicted model uncertainties \"\"\"\n",
" out = [model.forward(x) for _ in range(n_samp)]\n",
" logits = torch.stack([o[0] for o in out]).detach().cpu()\n",
" sigmas = torch.stack([o[1] for o in out]).detach().cpu()\n",
" ep, en, al = calc_uncertainty(logits, sigmas)\n",
" return (torch.mean(logits, dim=0), torch.mean(sigmas, dim=0), ep, en, al)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Helper functions"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def get_metrics(model, x:torch.Tensor, y:torch.Tensor, n_samp:int, eps:float):\n",
" \"\"\" get uncertainties and other metrics during training for analysis \"\"\"\n",
" state = model.training\n",
" model.eval()\n",
" with torch.no_grad():\n",
" out, s, ep, en, al = predict(model, x, n_samp)\n",
" loss = criterion((out, s), y.detach().cpu())\n",
" sb = ep / (al + eps)\n",
" eu, nu, au = ep.numpy().mean(), en.numpy().mean(), al.numpy().mean()\n",
" su = sb.numpy().mean()\n",
" model.train(state)\n",
" return loss, (out, ep, en, al, sb), eu, nu, au, su"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup training"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Set training and model hyperparameters"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"# system setup\n",
"use_jit = False\n",
"load_model = False\n",
"\n",
"# logging setup\n",
"log_rate = 100 # print losses and uncertainty measures every log_rate epoch\n",
"unc_rate = 5 # get uncertainties in training every unc_rate iteration\n",
"version = 'toy_classification_v1' # naming scheme of model to load\n",
"\n",
"# model, optimizer, loss, and training parameters\n",
"batch_size = 64\n",
"n_jobs = 0\n",
"n_epochs = 200\n",
"n_samp = 5 # number of samples to take in validation\n",
"model_kwargs = dict(dim=dim, mid=1024, n_layers=1, dropout_rate=0.25, mid_bias=True, out_bias=False)\n",
"use_adam = True\n",
"optim_kwargs = dict(lr=0.001, betas=(0.8,0.99), weight_decay=1e-6) if use_adam else \\\n",
" dict(lr=0.001, momentum=0., weight_decay=1e-6)\n",
"use_scheduler = False\n",
"scheduler_kwargs = dict(step_size=1000, gamma=0.5)\n",
"extended = True # use modified loss for variance estimation\n",
"eps = 1e-6 # add this value to denominator in scibilic uncertainty calc"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True,\n",
" num_workers=n_jobs, pin_memory=True)\n",
"valid_loader = DataLoader(valid_ds, batch_size=batch_size,\n",
" num_workers=n_jobs, pin_memory=True)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"assert torch.cuda.is_available()\n",
"device = torch.device(f'cuda')\n",
"torch.backends.cudnn.benchmark = True"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"model = UncertainLinear(**model_kwargs)\n",
"if use_jit: model = torch.jit.script(model)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"def num_params(model):\n",
" return sum(p.numel() for p in model.parameters() if p.requires_grad)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Number of trainable parameters in model: 4096\n"
]
}
],
"source": [
"print(f'Number of trainable parameters in model: {num_params(model)}')"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"if load_model:\n",
" if use_jit:\n",
" model = torch.jit.load(f'trained_jit_{version}.pth')\n",
" else:\n",
" state_dict = torch.load(f'trained_{version}.pth')\n",
" model.load_state_dict(state_dict);"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"model.cuda(device=device)\n",
"optim_cls = torch.optim.AdamW if use_adam else torch.optim.SGD\n",
"optimizer = optim_cls(model.parameters(), **optim_kwargs)\n",
"if use_scheduler: \n",
" scheduler = torch.optim.lr_scheduler.StepLR(optimizer, **scheduler_kwargs)\n",
"criterion = ExtendedBCELoss() if extended else BCELoss()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Train model"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"train_losses, valid_losses = [], []\n",
"t_ep_unc, t_en_unc, t_al_unc, t_sb_unc = [], [], [], []\n",
"v_ep_unc, v_en_unc, v_al_unc, v_sb_unc = [], [], [], []\n",
"n_batches = len(train_loader)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 100 - TL: 6.64e-02, VL: 4.52e-02, tEU: 1.02e-04, vEU: 1.25e-04, tAU: 3.35e-03, vAU: 2.84e-03\n",
"Epoch: 200 - TL: 6.55e-02, VL: 4.36e-02, tEU: 1.22e-04, vEU: 9.21e-05, tAU: 2.05e-03, vAU: 2.06e-03\n"
]
}
],
"source": [
"for t in range(1, n_epochs+1):\n",
" # training\n",
" t_losses, t_ep, t_en, t_al, t_sb = [], [], [], [], []\n",
" model.train()\n",
" for i, (x, y) in enumerate(train_loader):\n",
" x, y = x.to(device), y.to(device)\n",
" optimizer.zero_grad()\n",
" out = model(x)\n",
" loss = criterion(out, y)\n",
" t_losses.append(loss.item())\n",
" loss.backward()\n",
" optimizer.step()\n",
" if i % unc_rate == 0:\n",
" _, _, ep, en, al, sb = get_metrics(model, x, y, n_samp, eps)\n",
" t_ep.append(ep); t_en.append(en)\n",
" t_al.append(al); t_sb.append(sb)\n",
" train_losses.append(t_losses)\n",
" t_ep_unc.append(t_ep); t_en_unc.append(t_en)\n",
" t_al_unc.append(t_al); t_sb_unc.append(t_sb)\n",
"\n",
" # validation\n",
" v_losses, v_ep, v_en, v_al, v_sb = [], [], [], [], []\n",
" model.eval()\n",
" with torch.no_grad():\n",
" for i, (x, y) in enumerate(valid_loader):\n",
" x = x.to(device)\n",
" loss, out, ep, en, al, sb = get_metrics(model, x, y, n_samp, eps)\n",
" v_losses.append(loss.item())\n",
" v_ep.append(ep); v_en.append(en)\n",
" v_al.append(al); v_sb.append(sb)\n",
" valid_losses.append(v_losses)\n",
" v_ep_unc.append(v_ep); v_en_unc.append(v_en)\n",
" v_al_unc.append(v_al); v_sb_unc.append(v_sb)\n",
"\n",
" if not np.all(np.isfinite(t_losses)): \n",
" raise RuntimeError('NaN or Inf in training loss, cannot recover. Exiting.')\n",
" if t % log_rate == 0:\n",
" log = (f'Epoch: {t} - TL: {np.mean(t_losses):.2e}, VL: {np.mean(v_losses):.2e}, ' \n",
" f'tEU: {np.mean(t_ep):.2e}, vEU: {np.mean(v_ep):.2e}, '\n",
" f'tAU: {np.mean(t_al):.2e}, vAU: {np.mean(v_al):.2e}')\n",
" print(log)\n",
" if use_scheduler: scheduler.step()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* TL/VL = mean training/validation loss\n",
"* tEU/vEU = mean epistemic uncert. over training/validation set\n",
"* tAU/vAU = mean aleatory uncert. over training/validation set"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Analyze training"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create tidy datasets from training and validation losses for plotting purposes."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"def tidy_losses(train:List[List[float]], valid:List[List[float]]) -> pd.DataFrame:\n",
" out = {'epoch': [], 'type': [], 'value': [], 'phase': []}\n",
" for i, (tl,vl) in enumerate(zip(train,valid),1):\n",
" for tli in tl:\n",
" out['epoch'].append(i)\n",
" out['type'].append('loss')\n",
" out['value'].append(tli)\n",
" out['phase'].append('train')\n",
" for vli in vl:\n",
" out['epoch'].append(i)\n",
" out['type'].append('loss')\n",
" out['value'].append(vli)\n",
" out['phase'].append('valid')\n",
" return pd.DataFrame(out)\n",
"\n",
"def tidy_uncertainty(ep:List[List[float]], al:List[List[float]], sb:List[List[float]]) -> pd.DataFrame:\n",
" out = {'epoch': [], 'type': [], 'value': [], 'phase': []}\n",
" for i, (epi, ali, sbi) in enumerate(zip(ep, al, sb)):\n",
" phase = 'train' if i == 0 else 'valid'\n",
" for j, (epij,alij,sbij) in enumerate(zip(epi,ali,sbi),1):\n",
" for epijk in epij:\n",
" out['epoch'].append(j)\n",
" out['type'].append('epistemic')\n",
" out['value'].append(epijk)\n",
" out['phase'].append(phase)\n",
" for alijk in alij:\n",
" out['epoch'].append(j)\n",
" out['type'].append('aleatory')\n",
" out['value'].append(alijk)\n",
" out['phase'].append(phase)\n",
" return pd.DataFrame(out)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"losses = tidy_losses(train_losses, valid_losses)\n",
"uncert = tidy_uncertainty((t_ep_unc, v_ep_unc), \n",
" (t_al_unc, v_al_unc), \n",
" (t_sb_unc, v_sb_unc))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"version = version # naming scheme of model to save"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"load_tidy = False\n",
"if load_tidy:\n",
" losses = pd.read_csv(f'losses_{version}.csv')\n",
" uncert = pd.read_csv(f'uncert_{version}.csv')"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 864x576 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"f, ax1 = plt.subplots(1,1,figsize=(12, 8),sharey=True)\n",
"sns.lineplot(x='epoch',y='value',hue='phase',data=losses,ci='sd',ax=ax1,lw=3);\n",
"ax1.set_title('Losses');\n",
"ax1.set_ylim((0.,0.1))\n",
"f.savefig(f'losses_{version}.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The output of the validation is averaged over 5 samples before the loss is computed which is why it is lower than the training loss (which is not averaged)."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"use_log = False\n",
"save_plots = False"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 864x576 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"f, ax1 = plt.subplots(1,1,figsize=(12,8),sharey=True) \n",
"if use_log: ax1.set(yscale='log')\n",
"sns.lineplot(x='epoch',y='value',hue='type',style='phase',ci='sd',data=uncert,ax=ax1,lw=3);\n",
"ax1.set_title('Uncertainty');\n",
"ax1.set_ylim((-0.01, 0.2))\n",
"if save_plots: f.savefig(f'uncert_{version}.pdf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is not immediately clear to me why aleatory uncertainty is jumping all over the place. My guess would be that the loss function is fairly sensitive because of the trade-off between the normal loss and variance term."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [],
"source": [
"save_tidy = False\n",
"if save_tidy:\n",
" losses.to_csv(f'losses_{version}.csv')\n",
" uncert.to_csv(f'uncert_{version}.csv')"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
"save_model = False\n",
"if save_model:\n",
" if use_jit:\n",
" torch.jit.save(model, f'trained_jit_{version}.pth')\n",
" else:\n",
" torch.save(model.state_dict(), f'trained_{version}.pth')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Examine and evaluate results"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [],
"source": [
"xt, yt = train_ds.x, train_ds.y\n",
"xv, yv = valid_ds.x, valid_ds.y\n",
"xtn, ytn = xt.numpy(), yt.numpy()\n",
"xvn, yvn = xv.numpy(), yv.numpy()"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
"def list_to_np(lst:List[torch.Tensor]) -> List[np.ndarray]:\n",
" return list(map(lambda x: x.detach().cpu().numpy(), lst)) "
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"model.eval()\n",
"with torch.no_grad():\n",
" logittn, sigmatn, etn, ntn, atn = list_to_np(predict(model, xt.to(device), 50))\n",
" logitvn, sigmavn, evn, ntn, avn = list_to_np(predict(model, xv.to(device), 50))"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 1080x360 with 4 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"fig,(ax1,ax2,ax3,ax4) = plt.subplots(1,4,figsize=(15,5),sharex=True,sharey=True)\n",
"with warnings.catch_warnings():\n",
" warnings.simplefilter(\"ignore\") \n",
" ax1.hist(train_ds.x[train_ds.y[:,0] == 0,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax1.hist(train_ds.x[train_ds.y[:,0] == 1,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax2.hist(valid_ds.x[valid_ds.y[:,0] == 0,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax2.hist(valid_ds.x[valid_ds.y[:,0] == 1,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax3.hist(train_ds.x[logittn[:,0] < 0.,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax3.hist(train_ds.x[logittn[:,0] >= 0.,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax4.hist(valid_ds.x[logitvn[:,0] < 0.,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax4.hist(valid_ds.x[logitvn[:,0] >= 0.,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax4.legend()\n",
"ax1.set_title('Training data');\n",
"ax2.set_title('Validation data');\n",
"ax3.set_title('Predicted training');\n",
"ax4.set_title('Predicted validation');"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Examine the function fit by the neural network as well as the estimates of uncertainty"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 1152x432 with 6 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"if plot_data:\n",
" fig, (ax1,ax2,ax3) = plt.subplots(1,3,figsize=(16,6))\n",
" x_start = 2.\n",
" x_range = (-x_start, x_start)\n",
" xs = torch.linspace(*x_range, 100).unsqueeze(1)\n",
" with torch.no_grad():\n",
" ys, _, ep, en, al = list_to_np(predict(model, xs.to(device), 1000))\n",
" x, y, ep, en, al = xs[:,0], ys[:,0], ep[:,0], en[:,0], al[:,0]\n",
" sc = ep / (al + eps) # scibilic uncertainty\n",
" ixs0 = train_ds.y[:,0] == 0\n",
" ixs1 = train_ds.y[:,0] == 1\n",
" pal = sns.color_palette()\n",
" ax1_2 = ax1.twinx()\n",
" ax1_2.hist(train_ds.x[ixs0,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax1_2.hist(train_ds.x[ixs1,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax1.plot(x, ep, label='Ep.', lw=3, color=pal[0])\n",
" ax1.set_title('Epistemic')\n",
" ax1.set_ylim((0.,None))\n",
" ax2_2 = ax2.twinx()\n",
" ax2_2.hist(train_ds.x[ixs0,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax2_2.hist(train_ds.x[ixs1,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax2.plot(x, al, label='Al.', lw=3, color=pal[1])\n",
" ax2.set_title('Aleatory')\n",
" ax2.set_ylim((0.,None))\n",
" ax3_2 = ax3.twinx()\n",
" ax3_2.hist(train_ds.x[ixs0,0], bins=20, label='0', alpha=0.7, density=True)\n",
" ax3_2.hist(train_ds.x[ixs1,0], bins=20, label='1', alpha=0.7, density=True)\n",
" ax3.plot(x, en, label='En.', lw=3, color=pal[2])\n",
" ax3.set_title('Entropy')\n",
" ax3.set_ylim((0.,None))\n",
" fig.tight_layout()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see the epistemic and aleatory uncertainty (and entropy) plotted over the histograms of the true data. We see that epistemic uncertainty is highly correlated with aleatory uncertainty and entropy (albeit, aleatory is wider). In fact, this behavior—under these circumstances-is expected. Because we are fitting a hyperplane to the data, the value of the output probability will not go back to 0.5 far to the right or the left of the in-distribution data. Aleatory uncertainty is high in the overlapped region because high aleatory uncertainty in that region lowers the loss.\n",
"\n",
"This example is too trivial to show useful differences between epistemic and aleatory uncertainty for classification tasks, but perhaps it will lead to a better understanding of what is going on, as well as instructive for implementation."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python [conda env:synthtorch] *",
"language": "python",
"name": "conda-env-synthtorch-py"
},
"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.7"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment