From 01de04361ef53ea91a24a72a1b0aab0580018684 Mon Sep 17 00:00:00 2001 From: ASEM000 Date: Mon, 27 Nov 2023 13:57:41 +0900 Subject: [PATCH] loss landscape doc --- docs/index.rst | 1 + docs/notebooks/loss_landscape.ipynb | 531 ++++++++++++++++++++++++++++ 2 files changed, 532 insertions(+) create mode 100644 docs/notebooks/loss_landscape.ipynb diff --git a/docs/index.rst b/docs/index.rst index f6b8fb4..b99eb67 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -81,6 +81,7 @@ Install from github:: notebooks/hyperparam notebooks/model_surgery notebooks/distributed_training + notebooks/loss_landscape notebooks/common_recipes diff --git a/docs/notebooks/loss_landscape.ipynb b/docs/notebooks/loss_landscape.ipynb new file mode 100644 index 0000000..48e0137 --- /dev/null +++ b/docs/notebooks/loss_landscape.ipynb @@ -0,0 +1,531 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# πŸ”οΈ Loss Landscape visualization\n", + "\n", + "In this notebook, a simplified loss [landscape](https://losslandscape.com/) visualization for neural networks is implemented. The notebook will visualize the effect of using a skip connection." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quick recap\n", + "\n", + "\n", + "For a loss function $L(\\theta)$ the technique construct $f(\\alpha,\\beta) = L(\\theta+\\alpha \\delta+\\beta \\eta)$, where :\n", + "\n", + "$\\theta$: is the optimized neural network parameters.\n", + "\n", + "$\\delta, \\eta$: The random direction in the parameter space.\n", + "\n", + "$\\alpha, \\beta$: The grid coordinates.\n", + "\n", + "In essence, for a neural network parameters, the method perturb the weights in random direction with different scale on a grid, then evaluate the loss function at each grid point." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install git+https://github.com/ASEM000/serket --quiet\n", + "!pip install optax --quiet\n", + "!pip install tqdm --quiet\n", + "!pip install ml_collections --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "from io import BytesIO\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.random as jr\n", + "import jax.tree_util as jtu\n", + "import functools as ft\n", + "import optax # for gradient optimization\n", + "import serket as sk\n", + "import matplotlib.pyplot as plt # for plotting the predictions\n", + "from tqdm import tqdm # for progress bar\n", + "from ml_collections import ConfigDict # for configuration\n", + "from typing import TypeVar, Generic\n", + "from typing_extensions import Annotated, Callable\n", + "\n", + "T = TypeVar(\"T\")\n", + "\n", + "\n", + "class Batched(Generic[T]):\n", + " ...\n", + "\n", + "\n", + "CHWArray = Annotated[jax.Array, \"CHW\"]\n", + "\n", + "config = ConfigDict()\n", + "config.EPOCHS = 1\n", + "config.LR = 1e-3\n", + "config.BATCH_SIZE = 128\n", + "config.seed = 0\n", + "config.optim = optax.adam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data preparation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "url = \"https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\"\n", + "data = jnp.load(BytesIO(requests.get(url).content))\n", + "\n", + "x_train = data[\"x_train\"].reshape(-1, 1, 28, 28).astype(\"float32\") / 255.0\n", + "x_train = jnp.array_split(x_train, x_train.shape[0] // config.BATCH_SIZE)\n", + "y_train = jnp.array_split(data[\"y_train\"], len(data[\"y_train\"]) // config.BATCH_SIZE)\n", + "\n", + "x_test = data[\"x_test\"].reshape(-1, 1, 28, 28).astype(\"float32\") / 255.0\n", + "y_test = data[\"y_test\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the data\n", + "fig, axes = plt.subplots(2, 5, figsize=(10, 5))\n", + "for i, ax in enumerate(axes.flat):\n", + " ax.imshow(x_train[0][i].squeeze(), cmap=\"gray\")\n", + " ax.set_title(y_train[0][i])\n", + " ax.axis(\"off\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model preparation\n", + "\n", + "Construct two convnets, one with skip connections and one without it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class ResBlock(sk.TreeClass):\n", + " def __init__(self, in_features: int, out_features: int, *, key: jax.Array):\n", + " k1, k2 = jr.split(key)\n", + " self.conv1 = sk.nn.Conv2D(in_features, out_features, 3, key=k1)\n", + " self.conv2 = sk.nn.Conv2D(out_features, out_features, 3, key=k2)\n", + "\n", + " def __call__(self, input: jax.Array) -> jax.Array:\n", + " out = jax.nn.relu(self.conv1(input))\n", + " out = jax.nn.relu(self.conv2(out))\n", + " return jax.nn.relu(out + input)\n", + "\n", + "\n", + "class SansResBlock(sk.TreeClass):\n", + " def __init__(self, in_features: int, out_features: int, *, key: jax.Array):\n", + " k1, k2 = jr.split(key)\n", + " self.conv1 = sk.nn.Conv2D(in_features, out_features, 3, key=k1)\n", + " self.conv2 = sk.nn.Conv2D(out_features, out_features, 3, key=k2)\n", + "\n", + " def __call__(self, input: jax.Array) -> jax.Array:\n", + " out = jax.nn.relu(self.conv1(input))\n", + " out = jax.nn.relu(self.conv2(out))\n", + " return out\n", + "\n", + "\n", + "class ResConvNet(sk.TreeClass):\n", + " def __init__(self, in_features: int, out_features: int, *, key: jax.Array):\n", + " k1, k2, k3, k4 = jr.split(key, 4)\n", + " self.conv1 = ResBlock(in_features, out_features, key=k1)\n", + " self.conv2 = ResBlock(out_features, out_features, key=k2)\n", + " self.conv3 = ResBlock(out_features, out_features, key=k3)\n", + " self.pool = sk.nn.MaxPool2D(2, 2)\n", + " self.final = sk.nn.Conv2D(out_features, 10, 1, key=k4)\n", + "\n", + " def __call__(self, input: jax.Array) -> jax.Array:\n", + " out = self.conv1(input)\n", + " out = self.pool(out)\n", + " out = self.conv2(out)\n", + " out = self.pool(out)\n", + " out = self.conv3(out)\n", + " out = self.pool(out)\n", + " out = self.final(out)\n", + " out = jnp.mean(out, axis=(1, 2))\n", + " return out\n", + "\n", + "\n", + "class SansConvNet(sk.TreeClass):\n", + " def __init__(self, in_features: int, out_features: int, *, key: jax.Array):\n", + " k1, k2, k3, k4 = jr.split(key, 4)\n", + " self.conv1 = SansResBlock(in_features, out_features, key=k1)\n", + " self.conv2 = SansResBlock(out_features, out_features, key=k2)\n", + " self.conv3 = SansResBlock(out_features, out_features, key=k3)\n", + " self.pool = sk.nn.MaxPool2D(2, 2)\n", + " self.final = sk.nn.Conv2D(out_features, 10, 1, key=k4)\n", + "\n", + " def __call__(self, input: jax.Array) -> jax.Array:\n", + " out = self.conv1(input)\n", + " out = self.pool(out)\n", + " out = self.conv2(out)\n", + " out = self.pool(out)\n", + " out = self.conv3(out)\n", + " out = self.pool(out)\n", + " out = self.final(out)\n", + " out = jnp.mean(out, axis=(1, 2))\n", + " return out" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train on `MNIST`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def softmax_cross_entropy(logits, onehot):\n", + " assert onehot.shape == logits.shape == (10,)\n", + " return -jnp.sum(jax.nn.log_softmax(logits) * onehot)\n", + "\n", + "\n", + "def accuracy_func(logits, y):\n", + " assert logits.shape == (10,)\n", + " return jnp.argmax(logits) == y\n", + "\n", + "\n", + "def train(net, config: ConfigDict):\n", + " # visualize the network\n", + " print(sk.tree_summary(net, depth=1))\n", + " net = sk.tree_mask(net)\n", + " optim = config.optim(config.LR)\n", + " optim_state = optim.init(net)\n", + "\n", + " def loss_func(net, x, y):\n", + " logits = jax.vmap(sk.tree_unmask(net))(x)\n", + " onehot = jax.nn.one_hot(y, 10)\n", + " loss = jnp.mean(jax.vmap(softmax_cross_entropy)(logits, onehot))\n", + " metric = jnp.mean(jax.vmap(accuracy_func)(logits, y))\n", + " return loss, (loss, metric)\n", + "\n", + " @jax.jit\n", + " def train_step(net, optim_state, x, y):\n", + " grads, (loss, metric) = jax.grad(loss_func, has_aux=True)(net, x, y)\n", + " updates, optim_state = optim.update(grads, optim_state)\n", + " net = optax.apply_updates(net, updates)\n", + " return net, optim_state, (loss, metric)\n", + "\n", + " for i in (pbar := tqdm(range(1, config.EPOCHS + 1))):\n", + " epoch_loss = []\n", + " epoch_accuracy = []\n", + "\n", + " for j, (xb, yb) in enumerate(zip(x_train, y_train)):\n", + " net, optim_state, (loss, accuracy) = train_step(net, optim_state, xb, yb)\n", + "\n", + " desc = [f\"Epoch: {i:003d}/{config.EPOCHS:003d}\"]\n", + " desc += [f\"Batch: {j:003d}/{len(x_train):003d}\"]\n", + " desc += [f\"loss: {loss:3e}\\taccuracy: {accuracy:3f}\"]\n", + " pbar.set_description(\"\\t\".join(desc))\n", + "\n", + " epoch_loss.append(loss)\n", + " epoch_accuracy.append(accuracy)\n", + "\n", + " desc = [f\"Epoch: {i:003d}/{config.EPOCHS:003d}\"]\n", + " desc += [f\"loss: {jnp.mean(jnp.stack(epoch_loss)):3e}\"]\n", + " desc += [f\"accuracy: {jnp.mean(jnp.stack(epoch_accuracy)):3f}\"]\n", + "\n", + " pbar.set_description(\"\\t\".join(desc))\n", + "\n", + " return sk.tree_unmask(net)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "β”Œβ”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”\n", + "β”‚Name β”‚Type β”‚Count β”‚Size β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.conv1β”‚ResBlock β”‚9,592 β”‚37.38KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.conv2β”‚ResBlock β”‚18,520β”‚72.25KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.conv3β”‚ResBlock β”‚18,520β”‚72.25KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.pool β”‚MaxPool2D β”‚5 β”‚ β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.finalβ”‚Conv2D[32,10,1x1]β”‚342 β”‚1.29KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚Ξ£ β”‚ResConvNet β”‚46,979β”‚183.16KBβ”‚\n", + "β””β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”˜\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch: 001/001\tloss: 6.124917e-01\taccuracy: 0.806603: 100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 1/1 [00:59<00:00, 59.65s/it] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "β”Œβ”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”\n", + "β”‚Name β”‚Type β”‚Count β”‚Size β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.conv1β”‚SansResBlock β”‚9,592 β”‚37.38KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.conv2β”‚SansResBlock β”‚18,520β”‚72.25KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.conv3β”‚SansResBlock β”‚18,520β”‚72.25KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.pool β”‚MaxPool2D β”‚5 β”‚ β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚.finalβ”‚Conv2D[32,10,1x1]β”‚342 β”‚1.29KB β”‚\n", + "β”œβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€\n", + "β”‚Ξ£ β”‚SansConvNet β”‚46,979β”‚183.16KBβ”‚\n", + "β””β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”˜\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch: 001/001\tloss: 8.296877e-01\taccuracy: 0.716814: 100%|β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ| 1/1 [01:06<00:00, 66.24s/it] \n" + ] + } + ], + "source": [ + "# train with and without skip connections\n", + "key = jr.PRNGKey(config.seed)\n", + "res_net = ResConvNet(1, 32, key=key)\n", + "sans_net = SansConvNet(1, 32, key=key)\n", + "\n", + "res_net = train(res_net, config)\n", + "sans_net = train(sans_net, config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loss landscape utils" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def tree_filter_norm(tree: T, dir: T):\n", + " \"\"\"Rescale direction of Conv2D to have same norm as the input.\"\"\"\n", + "\n", + " @jax.vmap\n", + " def normalize_array(input, dir):\n", + " eps = jnp.finfo(input.dtype).eps\n", + " return dir * (jnp.linalg.norm(input) / (jnp.linalg.norm(dir) + eps))\n", + "\n", + " def normalize_direction(input: jax.Array, dir: jax.Array):\n", + " \"\"\"Rescale direction to have same norm as the input.\"\"\"\n", + " return normalize_array(input, dir) if isinstance(input, jax.Array) else input\n", + "\n", + " return jax.tree_map(normalize_direction, tree, dir)\n", + "\n", + "\n", + "def loss_landscape_2d(\n", + " loss_func: Callable,\n", + " *,\n", + " key: jax.Array,\n", + " min: float = -1.0,\n", + " max: float = 1.0,\n", + " num: int = 100,\n", + "):\n", + " \"\"\"Returns a function that computes the loss landscape of a given loss function\n", + "\n", + " Args:\n", + " loss_func: the loss function to compute the landscape for.\n", + " key: the random key to use for sampling the directions.\n", + " min: the minimum value of the landscape used in the meshgrid.\n", + " max: the maximum value of the landscape used in the meshgrid.\n", + " num: the number of points in the linspace used in the meshgrid.\n", + "\n", + " Returns:\n", + " A function that computes the loss landscape of the given loss function.\n", + " the modfied loss function takes the same arguments as the original loss\n", + " function and returns a tuple of (X, Y, LOSS) where X and Y are the\n", + " coordinates of the meshgrid and LOSS is the loss landscape.\n", + "\n", + " Reference:\n", + " - https://arxiv.org/pdf/1712.09913.pdf\n", + " - https://github.com/tomgoldstein/loss-landscape\n", + " \"\"\"\n", + "\n", + " linspace = jnp.linspace(min, max, num)\n", + " X, Y = jnp.meshgrid(linspace, linspace, indexing=\"ij\")\n", + " x = jnp.reshape(X, (-1, 1))\n", + " y = jnp.reshape(Y, (-1, 1))\n", + "\n", + " def generate_direction(key: jax.Array, tree) -> tuple[jax.Array, jax.Array]:\n", + " def func(leaf, key):\n", + " if isinstance(leaf, jax.Array):\n", + " return (\n", + " # dont perturb the bias\n", + " jnp.zeros_like(leaf)\n", + " if leaf.ndim <= 1\n", + " else jr.normal(key, leaf.shape)\n", + " )\n", + " return leaf\n", + "\n", + " leaves, treedef = jax.tree_util.tree_flatten(tree)\n", + " keys = jr.split(key, len(leaves))\n", + " return jtu.tree_unflatten(treedef, [func(L, K) for L, K in zip(leaves, keys)])\n", + "\n", + " def wrapper(tree: T, *args, **kwargs):\n", + " dir1, dir2 = generate_direction(key, (tree, tree))\n", + " dir1, dir2 = tree_filter_norm((tree, tree), (dir1, dir2))\n", + "\n", + " def tree_perturb(scale1: float, scale2: float):\n", + " def scale(leaf, dir1, dir2):\n", + " return leaf + (scale1 * dir1) + (scale2 * dir2)\n", + "\n", + " out = jax.tree_map(scale, tree, dir1, dir2)\n", + " return loss_func(out, *args, **kwargs)\n", + "\n", + " LOSS = jax.vmap(tree_perturb)(x, y).reshape(X.shape)\n", + " return X, Y, LOSS\n", + "\n", + " return wrapper" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize loss landscape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def loss_func(net, inputs: Batched[CHWArray], labels: Batched[int]):\n", + " logits = jax.vmap(sk.tree_unmask(net))(inputs)\n", + " onehot = jax.nn.one_hot(labels, 10)\n", + " loss = jnp.mean(jax.vmap(softmax_cross_entropy)(logits, onehot))\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = jr.PRNGKey(1)\n", + "x_sample = x_test[:10]\n", + "y_sample = y_test[:10]\n", + "\n", + "# 20x20 grid in [-1, 1] x [-1, 1]\n", + "visualize = loss_landscape_2d(loss_func, key=key, min=-1, max=1, num=20)\n", + "\n", + "X, Y, LOSS_RES = visualize(sk.tree_mask(res_net), x_sample, y_sample)\n", + "X, Y, LOSS_SANS = visualize(sk.tree_mask(sans_net), x_sample, y_sample)\n", + "# visualize the loss landscape\n", + "fig = plt.figure(figsize=(10, 5))\n", + "ax1 = fig.add_subplot(1, 2, 1, projection=\"3d\")\n", + "ax2 = fig.add_subplot(1, 2, 2, projection=\"3d\")\n", + "ax1.plot_surface(X, Y, LOSS_RES, cmap=\"viridis\", label=\"Res connections\")\n", + "ax2.plot_surface(X, Y, LOSS_SANS, cmap=\"viridis\", label=\"Sans res connections\")\n", + "ax1.legend()\n", + "ax2.legend()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "py311", + "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.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}