diff --git a/week05_explore/bayes.py b/week05_explore/bayes.py index ffb9b9adc..ea464301f 100644 --- a/week05_explore/bayes.py +++ b/week05_explore/bayes.py @@ -1,153 +1,81 @@ -""" -A single-file module that makes your lasagne network into a bayesian neural net. -Originally created by github.com/ferrine , rewritten by github.com/justheuristic for simplicity +import torch +import numpy as np +import torch.nn as nn +import torch.nn.functional as F +from torch.nn import Parameter +import math -See example in the notebook -""" -import numpy as np +def calculate_kl(log_alpha): + return 0.5 * torch.sum(torch.log1p(torch.exp(-log_alpha))) + + +class ModuleWrapper(nn.Module): + """Wrapper for nn.Module with support for arbitrary flags and a universal forward pass""" + + def __init__(self): + super(ModuleWrapper, self).__init__() + + def set_flag(self, flag_name, value): + setattr(self, flag_name, value) + for m in self.children(): + if hasattr(m, 'set_flag'): + m.set_flag(flag_name, value) + + def forward(self, x): + for module in self.children(): + x = module(x) + + kl = 0.0 + for module in self.modules(): + if hasattr(module, 'kl_loss'): + kl = kl + module.kl_loss() + + return x, kl + + + +class BBBLinear(ModuleWrapper): + + def __init__(self, in_features, out_features, alpha_shape=(1, 1), bias=True, name='BBBLinear'): + super(BBBLinear, self).__init__() + self.in_features = in_features + self.out_features = out_features + self.alpha_shape = alpha_shape + self.W = Parameter(torch.Tensor(out_features, in_features)) + self.log_alpha = Parameter(torch.Tensor(*alpha_shape)) + if bias: + self.bias = Parameter(torch.Tensor(1, out_features)) + else: + self.register_parameter('bias', None) + self.reset_parameters() + self.kl_value = calculate_kl + self.name = name + def reset_parameters(self): + stdv = 1. / math.sqrt(self.W.size(1)) + self.W.data.uniform_(-stdv, stdv) + self.log_alpha.data.fill_(-5.0) + if self.bias is not None: + self.bias.data.zero_() + + def forward(self, x): + + mean = F.linear(x, self.W) + if self.bias is not None: + mean = mean + self.bias + + sigma = torch.exp(self.log_alpha) * self.W * self.W + + std = torch.sqrt(1e-16 + F.linear(x * x, sigma)) + if self.training: + epsilon = std.data.new(std.size()).normal_() + else: + epsilon = 0.0 + # Local reparameterization trick + out = mean + std * epsilon + + + return out -from theano import tensor as T -from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams - -import lasagne -from lasagne import init -from lasagne.random import get_rng - -from functools import wraps - -__all__ = ['NormalApproximation', 'get_var_cost', 'bbpwrap'] - - -class NormalApproximation(object): - def __init__(self, mu=0, std=np.exp(-3), seed=None): - """ - Approximation that samples network weights from factorized normal distribution. - - :param mu: prior mean for gaussian weights - :param std: prior std for gaussian weights - :param seed: random seed - """ - self.prior_mu = mu - self.prior_std = std - self.srng = RandomStreams(seed or get_rng().randint(1, 2147462579)) - - def log_normal(self, x, mean, std, eps=0.0): - """computes log-proba of normal distribution""" - std += eps - return - 0.5 * np.log(2 * np.pi) - T.log(T.abs_(std)) - \ - (x - mean) ** 2 / (2 * std ** 2) - - def log_prior(self, weights): - """ - Logarithm of prior probabilities for weights: - log P(weights) aka log P(theta) - """ - return self.log_normal(weights, self.prior_mu, self.prior_std) - - def log_posterior_approx(self, weights, mean, rho): - """ - Logarithm of ELBO on posterior probabilities: - log q(weights|learned mu and rho) aka log q(theta|x) - """ - std = T.log1p(T.exp(rho)) # rho to std - return self.log_normal(weights, mean, std) - - def __call__(self, layer, spec, shape, name=None, **tags): - # case when user uses default init specs - assert tags.get( - 'variational', False), "Please declare param as variational to avoid confusion" - - if not isinstance(spec, dict): - initial_rho = np.log(np.expm1(self.prior_std)) # std to rho - assert np.isfinite(initial_rho), "too small std to initialize correctly. Please pass explicit"\ - " initializer (dict with {'mu':mu_init, 'rho':rho_init})." - spec = {'mu': spec, 'rho': init.Constant(initial_rho)} - - mu_spec, rho_spec = spec['mu'], spec['rho'] - - rho = layer.add_param( - rho_spec, shape, name=( - name or 'unk') + '.rho', **tags) - mean = layer.add_param( - mu_spec, shape, name=( - name or 'unk') + '.mu', **tags) - - # Reparameterization trick - e = self.srng.normal(shape, std=1) - W = mean + T.log1p(T.exp(rho)) * e - - # KL divergence KL(q,p) = E_(w~q(w|x)) [log q(w|x) - log P(w)] aka - # variational cost - q_p = T.sum( - self.log_posterior_approx(W, mean, rho) - - self.log_prior(W) - ) - - # accumulate variational cost - layer._bbwrap_var_cost += q_p - return W - - -def get_var_cost(layer_or_layers, treat_as_input=None): - """ - Returns total variational cost aka KL(q(theta|x)||p(theta)) for all layers in the network - - :param layer_or_layers: top layer(s) of your network, just like with lasagne.layers.get_output - :param treat_as_input: don't accumulate over layers below these layers. See same param for lasagne.layers.get_all_layers - - Alternatively, one can manually get weights for one layer via layer.get_var_cost() - """ - cost = 0 - for layer in lasagne.layers.get_all_layers( - layer_or_layers, treat_as_input): - if hasattr(layer, 'get_var_cost'): - # if layer is bayesian or pretends so - cost += layer.get_var_cost() - return cost - - -def bbpwrap(approximation=NormalApproximation()): - """ - A decorator that makes arbitrary lasagne layer into a bayesian network layer: - BayesDenseLayer = bbwrap()(DenseLayer) - or more verbosely, - @bbpwrap(NormalApproximation(pstd=0.01)) - BayesDenseLayer(DenseLayer): - pass - - """ - - def decorator(cls): - def add_param_wrap(add_param): - @wraps(add_param) - def wrapped(self, spec, shape, name=None, **tags): - # we should take care about some user specification - # to avoid bbp hook just set tags['variational'] = True - if not tags.get('trainable', True) or \ - tags.get('variational', False): - return add_param(self, spec, shape, name, **tags) - else: - # we declare that params we add next - # are the ones we need to fit the distribution - # they don't need to be regularized, strictly - tags['variational'] = True - tags['regularizable'] = False - param = self.approximation(self, spec, shape, name, **tags) - return param - return wrapped - - def get_var_cost(self): - """ - Returns total variational cost aka KL(q(theta|x)||p(theta)) for this layer. - Alternatively, use function get_var_cost(layer) to get total cost for all layers below this one. - """ - return self._bbwrap_var_cost - - cls.approximation = approximation - cls._bbwrap_var_cost = 0 - cls.add_param = add_param_wrap(cls.add_param) - cls.get_var_cost = get_var_cost - return cls - - return decorator + def kl_loss(self): + return self.W.nelement() * self.kl_value(self.log_alpha) / self.log_alpha.nelement() \ No newline at end of file diff --git a/week05_explore/week5.ipynb b/week05_explore/week5.ipynb index fb95bb698..f6457b410 100644 --- a/week05_explore/week5.ipynb +++ b/week05_explore/week5.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -533,7 +533,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -560,15 +560,12 @@ "metadata": {}, "outputs": [], "source": [ - "import theano\n", - "import theano.tensor as T\n", - "import lasagne\n", - "from lasagne import init\n", - "from lasagne.layers import *\n", - "import bayes\n", - "\n", - "as_bayesian = bayes.bbpwrap(bayes.NormalApproximation(std=0.1))\n", - "BayesDenseLayer = as_bayesian(DenseLayer)" + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "\n", + "from bayes import BBBLinear" ] }, { @@ -580,6 +577,20 @@ "Let's implement epsilon-greedy BNN agent" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_kl(model):\n", + " kl = 0\n", + " for module in model.modules():\n", + " if hasattr(module, 'kl_loss'):\n", + " kl = kl + module.kl_loss()\n", + " return kl/10000" + ] + }, { "cell_type": "code", "execution_count": null, @@ -590,51 +601,13 @@ " \"\"\"a bandit with bayesian neural net\"\"\"\n", "\n", " def __init__(self, state_size, n_actions):\n", - " input_states = T.matrix(\"states\")\n", - " target_actions = T.ivector(\"actions taken\")\n", - " target_rewards = T.vector(\"rewards\")\n", - "\n", - " self.total_samples_seen = theano.shared(\n", - " np.int32(0), \"number of training samples seen so far\")\n", - " batch_size = target_actions.shape[0] # por que?\n", - "\n", - " # Network\n", - " inp = InputLayer((None, state_size), name='input')\n", - " # YOUR NETWORK HERE\n", - " out = \n", - "\n", - " # Prediction\n", - " prediction_all_actions = get_output(out, inputs=input_states)\n", - " self.predict_sample_rewards = theano.function(\n", - " [input_states], prediction_all_actions)\n", - "\n", - " # Training\n", - "\n", - " # select prediction for target action\n", - " prediction_target_actions = prediction_all_actions[T.arange(\n", - " batch_size), target_actions]\n", - "\n", - " # loss = negative log-likelihood (mse) + KL\n", - " negative_llh = T.sum((prediction_target_actions - target_rewards)**2)\n", - "\n", - " kl = bayes.get_var_cost(out) / (self.total_samples_seen+batch_size)\n", - "\n", - " loss = (negative_llh + kl)/batch_size\n", - "\n", - " self.weights = get_all_params(out, trainable=True)\n", - " self.out = out\n", - "\n", - " # gradient descent\n", - " updates = lasagne.updates.adam(loss, self.weights)\n", - " # update counts\n", - " updates[self.total_samples_seen] = self.total_samples_seen + \\\n", - " batch_size.astype('int32')\n", - "\n", - " self.train_step = theano.function([input_states, target_actions, target_rewards],\n", - " [negative_llh, kl],\n", - " updates=updates,\n", - " allow_input_downcast=True)\n", + " self.n_actions = n_actions\n", + " self.model = < Your network here> # Use BBBLinear instead of Linear layers\n", + " self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)\n", "\n", + " def predict_sample_rewards(self, states):\n", + " return self.model(torch.Tensor(states))\n", + " \n", " def sample_prediction(self, states, n_samples=1):\n", " \"\"\"Samples n_samples predictions for rewards,\n", "\n", @@ -671,8 +644,20 @@ " \"\"\"\n", " loss_sum = kl_sum = 0\n", " for _ in range(n_iters):\n", - " loss, kl = self.train_step(states, actions, rewards)\n", - " loss_sum += loss\n", + " self.optimizer.zero_grad()\n", + " rewards_for_actions = self.predict_sample_rewards(states)\n", + " kl = calc_kl(self.model)\n", + "\n", + " # Prediction\n", + " pred_rewards = rewards_for_actions.gather(1, torch.tensor(actions, dtype=torch.long).unsqueeze(1)).squeeze()\n", + " \n", + " mse = torch.mean((pred_rewards-torch.tensor(rewards))**2)\n", + " \n", + " # loss = MSE + KL\n", + " (mse+kl).backward()\n", + " self.optimizer.step()\n", + "\n", + " loss_sum += mse\n", " kl_sum += kl\n", "\n", " return loss_sum / n_iters, kl_sum / n_iters\n", @@ -712,7 +697,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -766,50 +751,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration #90\tmean reward=0.560\tmse=0.457\tkl=0.044\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Q(s,a) std: 0.178;0.011;0.000;0.000;0.195;0.000;0.000;0.124;0.023;0.000\n", - "correct 4\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:37: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n" - ] - } - ], + "outputs": [], "source": [ "bnn_agent = BNNAgent(state_size=state_size, n_actions=n_actions)\n", "greedy_agent_rewards = train_contextual_agent(\n", @@ -1433,9 +1375,22 @@ } ], "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", - "pygments_lexer": "ipython3" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" } }, "nbformat": 4,