diff --git a/README.md b/README.md index 576241d..2c81120 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,11 @@ poetry install You are free to install the best version of [`jaxlib`](https://jax.readthedocs.io/en/latest/installation.html) that is consistent with your hardware. +## Philosophy + +HAMUX v0.2.0 is designed to be as minimal, barebones, and close to the underlying JAX infrastructure as possible. At its simplest, HAMs are energy functions that are defined by assembling smaller energy functions together in a hypergraph. That is all this library provides in `src/hamux.py`. This is in contrast to HAMUX v0.1.0 which tried to be a batteries included library reimplementing many common layers in Deep Learning. + +Extensibility will be provided through tutorials and code snippets in the documentation (in development). Contributions to the main library will be limited fundamental improvements to the hypergraph abstraction. See [Contributing](#Contributing) for more details. ## A Universal Abstraction for Hopfield Networks @@ -333,3 +338,8 @@ Hoover](https://www.bhoov.com/) (IBM & GATech) - [Polo Chau](https://faculty.cc.gatech.edu/~dchau/) (GATech) - [Hendrik Strobelt](http://hendrik.strobelt.com/) (IBM) - [Dmitry Krotov](https://mitibmwatsonailab.mit.edu/people/dmitry-krotov/) (IBM) + + +## Contributing + +Work in progress. \ No newline at end of file diff --git a/assets/HAMUX YoutubeThumbnail.png b/assets/HAMUX YoutubeThumbnail.png new file mode 100644 index 0000000..92a1e1c Binary files /dev/null and b/assets/HAMUX YoutubeThumbnail.png differ diff --git a/nbs/HAM.ipynb b/nbs/HAM.ipynb new file mode 100644 index 0000000..462e68e --- /dev/null +++ b/nbs/HAM.ipynb @@ -0,0 +1,1252 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "18ceb168-3a83-4fe7-aa89-8ed76107b495", + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f8414905-9daf-4f04-87fc-50a13e0d8138", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "83426342-2bd5-48ac-b084-a4c986e5241f", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import treex as tx\n", + "from einops import rearrange\n", + "from flax import linen as nn\n", + "from abc import ABC, abstractmethod\n", + "from typing import *\n", + "from dataclasses import dataclass\n", + "import optax\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import jax.tree_util as jtu\n", + "from hamux.utils import pytree_load, pytree_save" + ] + }, + { + "cell_type": "markdown", + "id": "3b5d635a-a8a3-4b00-a081-0c4b3b1ce260", + "metadata": { + "tags": [] + }, + "source": [ + "# HAM Energy Assembly" + ] + }, + { + "cell_type": "markdown", + "id": "51685a5b-ab15-4eac-bbfb-2ce8bad60f77", + "metadata": { + "tags": [] + }, + "source": [ + "# Lagrangians\n", + "\n", + "Because lagrangian functions of common activation functions can be used in both layers and synapses, it is helpful to define the operations outside the classes in which they operate." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e7fc6f5b-1403-4ab5-988d-27e3dac27ce7", + "metadata": {}, + "outputs": [], + "source": [ + "def LIdentity(x):\n", + " return 1/2 * jnp.power(x, 2).sum()\n", + "\n", + "def LRelu(x):\n", + " return 1/2 * jnp.power(jnp.maximum(x, 0), 2).sum()\n", + "\n", + "def LSoftmax(x, beta=1., axis=-1):\n", + " return 1/beta * jax.nn.logsumexp(beta * x, axis=axis)" + ] + }, + { + "cell_type": "markdown", + "id": "ee47cbac-61e6-4206-b121-167515509350", + "metadata": {}, + "source": [ + "## Layers" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ecdb977e-e555-4c6e-8136-19be9fbd9693", + "metadata": {}, + "outputs": [], + "source": [ + "class Layer(tx.Module, ABC):\n", + " shape: Tuple\n", + " \n", + " def __init__(self, shape):\n", + " self.shape = shape\n", + " \n", + " @abstractmethod\n", + " def lagrangian(self, x):\n", + " pass\n", + " \n", + " def activation(self, x):\n", + " return self.g(x)\n", + " \n", + " def energy(self, x):\n", + " \n", + " # When jitted, this is no slower than the optimized `@` vector multiplication\n", + " # This is also more universal in case `x` is not a vector\n", + " return jnp.multiply(self.g(x), x).sum() - self.lagrangian(x) \n", + " \n", + " def g(self, x):\n", + " return jax.grad(self.lagrangian)(x)\n", + " \n", + " def init_state(self, bs:int=None):\n", + " if bs is not None:\n", + " return jnp.zeros((bs, *self.shape))\n", + " return jnp.zeros(self.shape)\n", + " \n", + "class IdentityLayer(Layer):\n", + " def lagrangian(self, x):\n", + " return LIdentity(x)\n", + " \n", + "class RELULayer(Layer):\n", + " def lagrangian(self, x):\n", + " return LRelu(x)\n", + " \n", + "class SoftmaxLayer(Layer):\n", + " beta: jnp.ndarray = tx.Parameter.node(default=jnp.array(1.))\n", + " \n", + " def lagrangian(self, x):\n", + " return LSoftmax(x, self.beta.clip(1e-6))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3485a74d-764e-43a1-ac0a-0a3d3223a39c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Identity: [0. 1. 2. 3. 4. 5. 6. 7. 8.]\n", + "RELU: [0. 0. 0. 0. 0. 0. 1. 2. 3.])\n", + "Softmax: [2.1207899e-04 5.7649048e-04 1.5670636e-03 4.2597204e-03 1.1579121e-02\n", + " 3.1475313e-02 8.5558772e-02 2.3257288e-01 6.3219857e-01])\n" + ] + } + ], + "source": [ + "layer = IdentityLayer((9,))\n", + "x = jnp.arange(9, dtype=jnp.float32)\n", + "print(f\"Identity: {layer.g(x)}\")\n", + "\n", + "layer = RELULayer((9,))\n", + "x = jnp.arange(9, dtype=jnp.float32) - 5\n", + "print(f\"RELU: {layer.g(x)})\")\n", + "\n", + "layer = SoftmaxLayer((9,))\n", + "x = jnp.arange(9, dtype=jnp.float32) - 2\n", + "print(f\"Softmax: {layer.g(x)})\")" + ] + }, + { + "cell_type": "markdown", + "id": "d7b39fe7-0716-4224-8711-e3dbe8c64d37", + "metadata": {}, + "source": [ + "## Synapses" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2868c466-a412-4992-a2df-4a9da1dfda82", + "metadata": {}, + "outputs": [], + "source": [ + "class Synapse(tx.Module, ABC):\n", + " @abstractmethod\n", + " def energy(self, *gs):\n", + " pass\n", + " \n", + " def __call__(self, *gs):\n", + " return self.energy(*gs)\n", + "\n", + "class DenseSynapse(Synapse):\n", + " stdinit:float = 0.02\n", + " weight: jnp.ndarray = tx.Parameter.node()\n", + " \n", + " def energy(self, g1, g2):\n", + " if self.initializing():\n", + " key = tx.next_key() \n", + " self.weight = nn.initializers.normal(self.stdinit)(key, (g1.shape[0], g2.shape[0]))\n", + " return -g1 @ self.weight @ g2\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8e1a5ba0-f12e-4ad5-a010-63902378ac23", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DeviceArray(-15.429065, dtype=float32)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fin, fout = 44, 33\n", + "g1 = jnp.arange(fin)\n", + "g2 = jnp.ones(fout)\n", + "synapse = DenseSynapse().init(key=jax.random.PRNGKey(5), inputs=(g1, g2))\n", + "synapse.energy(g1, g2)" + ] + }, + { + "cell_type": "markdown", + "id": "dcbdec70-6242-45f0-a0c0-9b43d155277c", + "metadata": {}, + "source": [ + "## HAM" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "54ebc057-a1d9-45c2-81ed-27c984b84d59", + "metadata": {}, + "outputs": [], + "source": [ + "class HAM(tx.Module):\n", + " layers: List[Layer]\n", + " synapses: List[Synapse]\n", + " connections: List[Tuple[Tuple, int]]\n", + "\n", + " def __init__(self, layers, synapses, connections):\n", + " self.layers = layers\n", + " self.synapses = synapses\n", + " self.connections = connections\n", + " \n", + " @property\n", + " def n_layers(self):\n", + " return len(self.layers)\n", + " \n", + " @property\n", + " def n_synapses(self):\n", + " return len(self.synapses)\n", + " \n", + " @property\n", + " def n_connections(self):\n", + " return len(self.connections)\n", + " \n", + " def layer_energy(self, states):\n", + " energies = jnp.stack([\n", + " self.layers[i].energy(x) for i, x in enumerate(states)\n", + " ])\n", + " return jnp.sum(energies)\n", + " \n", + " def synapse_energy(self, states):\n", + " def get_energy(lset, k):\n", + " gs = [self.layers[i].g(states[i]) for i in lset]\n", + " synapse = self.synapses[k]\n", + " return synapse(*gs)\n", + "\n", + " energies = jnp.stack([\n", + " get_energy(lset, k) for lset,k in self.connections\n", + " ])\n", + " return jnp.sum(energies)\n", + " \n", + " def energy(self, states):\n", + " energy = self.layer_energy(states) + self.synapse_energy(states)\n", + " return energy\n", + " \n", + " def venergy(self, states):\n", + " return jax.vmap(self.energy, in_axes=self._statelist_batch_axes())(states)\n", + " \n", + " def __call__(self, states):\n", + " return self.energy(states)\n", + " \n", + " def grad(self, states):\n", + " return jax.grad(self.energy)(states)\n", + " \n", + " def vgrad(self, states):\n", + " return jax.vmap(self.grad, in_axes=self._statelist_batch_axes())(states)\n", + " \n", + " def _statelist_batch_axes(self):\n", + " return ([0 for _ in range(self.n_layers)],)\n", + " \n", + " def init_states(self, bs=None):\n", + " return [layer.init_state(bs) for layer in self.layers]\n", + " \n", + " def init_states_and_params(self, key, bs=None):\n", + " # params don't need a batch size to initialize\n", + " params = self.init(key, self.init_states(), call_method=\"energy\")\n", + " states = self.init_states(bs)\n", + " return states, params\n", + " \n", + " @classmethod\n", + " def load_from_state_dict(cls, outdict):\n", + " me = cls(outdict[\"layers\"], outdict[\"synapses\"], outdict[\"connections\"])\n", + " return me" + ] + }, + { + "cell_type": "markdown", + "id": "77165f8b-22a4-43df-a5be-43c6699fcc89", + "metadata": { + "tags": [] + }, + "source": [ + "# Dataloaders" + ] + }, + { + "cell_type": "markdown", + "id": "27bfa96f-e4e0-4d5e-923a-5b8fd6460067", + "metadata": {}, + "source": [ + "# Loading from lib" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "acb61024-d956-4699-b863-40621e046041", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hoo/miniconda3/envs/hamux/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from hamux.datasets import *" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e7d981ef-c8fa-44ea-9286-5c67a455b888", + "metadata": {}, + "outputs": [], + "source": [ + "args = DataloadingArgs(\n", + " dataset=\"torch/MNIST\",\n", + " aa=None,\n", + " reprob=0.0,\n", + " vflip=0.,\n", + " hflip=0.,\n", + " scale=(0.8,1.),\n", + " batch_size=10,\n", + " color_jitter=0.,\n", + " validation_batch_size=10_000,\n", + ")\n", + "data_config = DataConfigMNIST(input_size=(1,28,28))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "91aa12ed-e66f-4126-8113-60f25800907a", + "metadata": {}, + "outputs": [], + "source": [ + "loader_train, loader_eval = create_dataloaders(args, data_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bb70888c-bae9-42a4-bed1-3900447a18cb", + "metadata": {}, + "outputs": [], + "source": [ + "for b in loader_train:\n", + " imgs, labels = b\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "735de2d8-83f0-453e-95c9-4328e3d19028", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(data_config.show(imgs[7]))" + ] + }, + { + "cell_type": "markdown", + "id": "a0f31b2c-a862-4edc-bbf8-b5e6c05d75d1", + "metadata": {}, + "source": [ + "# Example target pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5ab521f5-a502-43cd-bd58-d49eb0c8285f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 10)\n" + ] + } + ], + "source": [ + "# All non-visible layers are encoded in a relationship\n", + "class HiddenRelationship(Synapse):\n", + " \"\"\"Combine my labels and pixels in the case of MNIST\"\"\"\n", + " W1: jnp.ndarray = tx.Parameter.node()\n", + " W2: jnp.ndarray = tx.Parameter.node()\n", + " \n", + " def __init__(self, nhid:int, stdinit:float = 0.02):\n", + " self.nhid = nhid\n", + " self.stdinit = 0.02\n", + "\n", + " def energy(self, g1, g2):\n", + " if self.initializing():\n", + " key = tx.next_key() \n", + " self.W1 = nn.initializers.normal(self.stdinit)(key, (g1.shape[0], self.nhid))\n", + " self.W2 = nn.initializers.normal(self.stdinit)(key, (g2.shape[0], self.nhid))\n", + " return LRelu(g1 @ self.W1 + g2 @ self.W2)\n", + " \n", + "\n", + "init_key = jax.random.PRNGKey(0)\n", + "\n", + "layers = [\n", + " IdentityLayer((784,)),\n", + " IdentityLayer((10,)),\n", + "]\n", + "synapses = [\n", + " HiddenRelationship(200),\n", + "]\n", + "\n", + "connections = [\n", + " ((0,1), 0),\n", + "]\n", + "\n", + "bs = 5\n", + "states, ham = HAM(layers, synapses, connections).init_states_and_params(jax.random.PRNGKey(0), bs=bs)\n", + "\n", + "@jax.jit\n", + "def forward_classification_mnist(model, x):\n", + " depth = 1\n", + " alpha = 0.1\n", + " \n", + " bs = x.shape[0]\n", + " xs = model.init_states(bs)\n", + " xs[0] = jnp.array(x)\n", + " for i in range(depth):\n", + " updates = model.vgrad(xs)\n", + " xs = jtu.tree_map(lambda x, u: x - alpha * u, xs, updates)\n", + " \n", + " logits = xs[1]\n", + " return logits\n", + "\n", + "batch = {\n", + " \"images\": jnp.array(b[0][:10]),\n", + " \"labels\": jnp.array(b[1][:10])\n", + "}\n", + "x = rearrange(batch[\"images\"], \"bs ... -> bs (...)\")\n", + "\n", + "logits = forward_classification_mnist(ham, x)\n", + "print(logits.shape)\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "f5c89f1b-cd6a-499a-ac86-be0fe07b6e91", + "metadata": {}, + "source": [ + "# Training Logic" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "cef6e47b-b229-464e-9cff-471f8f6af39f", + "metadata": {}, + "outputs": [], + "source": [ + "class TrainState(tx.Module):\n", + " model: tx.Module\n", + " optimizer: tx.Optimizer\n", + " apply_fn: Callable\n", + " \n", + " def __init__(self, model, optimizer, apply_fn):\n", + " self.model = model\n", + " self.optimizer = tx.Optimizer(optimizer).init(self.params)\n", + " self.apply_fn = apply_fn\n", + " \n", + " @property\n", + " def params(self):\n", + " return self.model.filter(tx.Parameter)\n", + " \n", + " def apply_updates(self, grads):\n", + " new_params = self.optimizer.update(grads, self.params)\n", + " self.model = self.model.merge(new_params)\n", + " return self" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7a7984df-7ecc-470c-a93e-760d0a9ccab5", + "metadata": {}, + "outputs": [], + "source": [ + "def cross_entropy_loss(*, logits, labels):\n", + " n_classes = logits.shape[-1]\n", + " labels_onehot = jax.nn.one_hot(labels, num_classes=n_classes)\n", + " return optax.softmax_cross_entropy(logits=logits, labels=labels_onehot).mean()\n", + "\n", + "def compute_metrics(*, logits, labels):\n", + " loss = cross_entropy_loss(logits=logits, labels=labels)\n", + " accuracy = jnp.mean(jnp.argmax(logits, -1) == labels)\n", + " metrics = {\n", + " 'loss': loss,\n", + " 'accuracy': accuracy,\n", + " }\n", + " return metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9da397d3-f6af-4a1d-b084-d3a6482409be", + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def train_step(state, batch):\n", + " def loss_fn(params):\n", + " state.model = state.model.merge(params)\n", + " x = rearrange(batch[\"image\"], \"bs ... -> bs (...)\")\n", + " logits = state.apply_fn(state.model, x)\n", + " loss = cross_entropy_loss(logits=logits, labels=batch[\"label\"])\n", + " return loss, (logits, state)\n", + " \n", + " grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\n", + " (_, (logits, state)), grads = grad_fn(state.params)\n", + " \n", + " state = state.apply_updates(grads)\n", + " metrics = compute_metrics(logits=logits, labels=batch['label'])\n", + " return state, metrics\n", + "\n", + "@jax.jit\n", + "def eval_step(state, batch):\n", + " x = rearrange(batch[\"image\"], \"bs ... -> bs (...)\")\n", + " logits = state.apply_fn(state.model, x)\n", + " logit_pred = jnp.argmax(logits, axis=-1)\n", + " return compute_metrics(logits=logits, labels=batch['label'])\n", + "\n", + "def train_epoch(state, train_dl, epoch):\n", + " \"\"\"Train for a single epoch.\"\"\"\n", + " batch_metrics = []\n", + " bs = train_dl.batch_size\n", + " for i, batch in enumerate(train_dl):\n", + " if (i % 100) == 0:\n", + " print(\"Starting example: \", i*bs)\n", + " batch = {\n", + " \"image\": jnp.array(batch[0]),\n", + " \"label\": jnp.array(batch[1])\n", + " }\n", + " state, metrics = train_step(state, batch)\n", + " batch_metrics.append(metrics)\n", + " \n", + "\n", + " # compute mean of metrics across each batch in epoch.\n", + " batch_metrics_np = jax.device_get(batch_metrics)\n", + " epoch_metrics_np = {\n", + " k: np.mean([metrics[k] for metrics in batch_metrics_np])\n", + " for k in batch_metrics_np[0]}\n", + "\n", + " print('train epoch: %d, loss: %.4f, accuracy: %.2f' % (\n", + " epoch, epoch_metrics_np['loss'], epoch_metrics_np['accuracy'] * 100))\n", + "\n", + " return state, epoch_metrics_np['loss'], epoch_metrics_np['accuracy'] * 100\n", + "\n", + "def eval_model(params, test_dl):\n", + " batch_metrics = []\n", + " bs = test_dl.batch_size\n", + "\n", + " for i, batch in enumerate(test_dl):\n", + " if (i % 1000) == 0:\n", + " print(\"Starting example: \", i*bs)\n", + " batch = {\n", + " \"image\": jnp.array(batch[0]),\n", + " \"label\": jnp.array(batch[1])\n", + " }\n", + " \n", + " metrics = eval_step(params, batch)\n", + " batch_metrics.append(metrics)\n", + " batch_metrics_np = jax.device_get(batch_metrics)\n", + " summary = {\n", + " k: np.mean([metrics[k] for metrics in batch_metrics_np])\n", + " for k in batch_metrics_np[0]\n", + " }\n", + "\n", + " return summary['loss'], summary['accuracy']" + ] + }, + { + "cell_type": "markdown", + "id": "88c9e77e-f9bc-4606-933b-318453f431fe", + "metadata": {}, + "source": [ + "## Convolutional MNIST" + ] + }, + { + "cell_type": "markdown", + "id": "77d4d3e9-a82a-411c-9851-b6ae42bc72a0", + "metadata": {}, + "source": [ + "### Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "fd49ec10-2a0e-4e7b-8194-9737284af8bb", + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def train_step(state, batch):\n", + " def loss_fn(params):\n", + " state.model = state.model.merge(params)\n", + " x = batch[\"image\"]\n", + " logits = state.apply_fn(state.model, x)\n", + " loss = cross_entropy_loss(logits=logits, labels=batch[\"label\"])\n", + " return loss, (logits, state)\n", + " \n", + " grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\n", + " (_, (logits, state)), grads = grad_fn(state.params)\n", + " \n", + " state = state.apply_updates(grads)\n", + " metrics = compute_metrics(logits=logits, labels=batch['label'])\n", + " return state, metrics\n", + "\n", + "@jax.jit\n", + "def eval_step(state, batch):\n", + " x = batch[\"image\"]\n", + " logits = state.apply_fn(state.model, x)\n", + " logit_pred = jnp.argmax(logits, axis=-1)\n", + " return compute_metrics(logits=logits, labels=batch['label'])\n", + "\n", + "# # Example loading CIFAR. We need an \"args\" and a \"data_config\"\n", + "# args = DataloadingArgs(\n", + "# dataset=\"torch/CIFAR10\",\n", + "# # aa=\"rand\",\n", + "# aa=None,\n", + "# reprob=0.2,\n", + "# vflip=0.2,\n", + "# hflip=0.5,\n", + "# batch_size=128,\n", + "# validation_batch_size=10_000, # Get the entire validation set at once\n", + "# )\n", + "# data_config = DataConfigCIFAR10()\n", + "\n", + "# ## Example loading ImageNet. We need an \"args\" and a \"data_config\"\n", + "# args = DataloadingArgs(\n", + "# data_dir=Path.home()/\"datasets/timm-datasets/ImageNet100\",\n", + "# aa=None,\n", + "# reprob=0.1,\n", + "# vflip=0.0,\n", + "# hflip=0.5,\n", + "# batch_size=256,\n", + "# validation_batch_size=500\n", + "# )\n", + "# data_config = DataConfigImageNet(input_size=(3,128,128)) # Feel free to change the input size of our dataset!\n", + "\n", + "## Example loading MNIST\n", + "args = DataloadingArgs(\n", + " dataset=\"torch/MNIST\",\n", + " aa=None,\n", + " reprob=0.0,\n", + " vflip=0.,\n", + " hflip=0.,\n", + " scale=(0.8,1.),\n", + " batch_size=2000,\n", + " color_jitter=0.,\n", + " validation_batch_size=10_000,\n", + ")\n", + "data_config = DataConfigMNIST(input_size=(1,28,28))\n", + "\n", + "train_dl, eval_dl = create_dataloaders(args, data_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5ab29940-8979-4c47-b915-4197f5874981", + "metadata": {}, + "outputs": [], + "source": [ + "# All non-visible layers are encoded in a relationship\n", + "class HiddenRelationship(Synapse):\n", + " \"\"\"Combine my labels and pixels in the case of MNIST\"\"\"\n", + " W1: jnp.ndarray = tx.Parameter.node()\n", + " W2: jnp.ndarray = tx.Parameter.node()\n", + " \n", + " def __init__(self, nhid:int, stdinit:float = 0.02):\n", + " self.nhid = nhid\n", + " self.stdinit = 0.02\n", + "\n", + " def energy(self, g1, g2):\n", + " if self.initializing():\n", + " key = tx.next_key() \n", + " self.W1 = nn.initializers.normal(self.stdinit)(key, (g1.shape[0], self.nhid))\n", + " self.W2 = nn.initializers.normal(self.stdinit)(key, (g2.shape[0], self.nhid))\n", + " return LRelu(g1 @ self.W1 + g2 @ self.W2)\n", + "\n", + "\n", + "class ConvSynapse(Synapse):\n", + " conv: tx.Module \n", + " \n", + " def __init__(self, conv:tx.Module):\n", + " self.conv = conv\n", + "\n", + " def energy(self, g1, g2):\n", + " if self.initializing():\n", + " key = tx.next_key()\n", + " features_in = g1.shape[0]\n", + " features_out = g2.shape[0]\n", + " self.conv = self.conv.init(key, g1)\n", + " return jnp.multiply(g2, self.conv(g1)).sum()\n", + " \n", + "init_key = jax.random.PRNGKey(0)\n", + "\n", + "# layers = [\n", + "# IdentityLayer((1,28,28)),\n", + "# ReluLayer(),\n", + "# IdentityLayer((10,)),\n", + "# ]\n", + "# synapses = [\n", + "# HiddenRelationship(200),\n", + "# ]\n", + "\n", + "# connections = [\n", + "# ((0,1), 0),\n", + "# ]\n", + "\n", + "\n", + "# @jax.jit\n", + "# def forward_classification_mnist(model, x):\n", + "# depth = 4\n", + "# alpha = 1.\n", + " \n", + "# bs = x.shape[0]\n", + "# xs = model.init_states(bs)\n", + "# masks = jtu.tree_map(lambda x: jnp.ones_like(x, dtype=jnp.int8), xs)\n", + "# xs[0] = jnp.array(x)\n", + "# masks[0] = jnp.zeros_like(masks[0], dtype=jnp.int8)\n", + "\n", + "# for i in range(depth):\n", + "# updates = model.vgrad(xs)\n", + "# xs = jtu.tree_map(lambda x, u, m: x - alpha * u * m, xs, updates, masks)\n", + " \n", + "# logits = xs[1]\n", + "# return logits\n", + "\n", + "\n", + "# bs = 1\n", + "# states, ham = HAM(layers, synapses, connections).init_states_and_params(jax.random.PRNGKey(0), bs=bs)\n", + "\n", + "# optimizer = optax.adamw(0.001)\n", + "# state = TrainState(ham, optimizer, forward_classification_mnist)" + ] + }, + { + "cell_type": "markdown", + "id": "9225fc5e-02f9-4281-9609-d509681a542b", + "metadata": {}, + "source": [ + "### Training Cell" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "df4a0b55-d0c7-40a6-8395-e49d1c9d580b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# num_epochs = 100\n", + "# train_acc_list=[]\n", + "# test_acc_list=[]\n", + "\n", + "# for epoch in range(1, num_epochs + 1):\n", + "# # Use a separate PRNG key to permute image data during shuffling\n", + "# state, train_loss, train_acc = train_epoch(state, train_dl, epoch)\n", + "\n", + "# # Evaluate on the test set after each training epoch \n", + "# test_loss, test_acc = eval_model(state, eval_dl)\n", + "# train_acc_list.append(train_acc)\n", + "# test_acc_list.append(100*test_acc)\n", + "# print(f\"Max acc test: {np.max(test_acc_list)}\")\n", + "# print(f\"Acc epoch {epoch} [train/tst]: [{train_acc}/{test_acc}]\")\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "0cd285c3-0a83-4867-9341-822faa559d4e", + "metadata": {}, + "source": [ + "## Vectorized MNIST" + ] + }, + { + "cell_type": "markdown", + "id": "a9c931ca-35d0-4b77-b7e4-bc1a46f37f2f", + "metadata": {}, + "source": [ + "### Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e9b38124-80fa-401a-97af-8b6759e481aa", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# # Example loading CIFAR. We need an \"args\" and a \"data_config\"\n", + "# args = DataloadingArgs(\n", + "# dataset=\"torch/CIFAR10\",\n", + "# # aa=\"rand\",\n", + "# aa=None,\n", + "# reprob=0.2,\n", + "# vflip=0.2,\n", + "# hflip=0.5,\n", + "# batch_size=128,\n", + "# validation_batch_size=10_000, # Get the entire validation set at once\n", + "# )\n", + "# data_config = DataConfigCIFAR10()\n", + "\n", + "# ## Example loading ImageNet. We need an \"args\" and a \"data_config\"\n", + "# args = DataloadingArgs(\n", + "# data_dir=Path.home()/\"datasets/timm-datasets/ImageNet100\",\n", + "# aa=None,\n", + "# reprob=0.1,\n", + "# vflip=0.0,\n", + "# hflip=0.5,\n", + "# batch_size=256,\n", + "# validation_batch_size=500\n", + "# )\n", + "# data_config = DataConfigImageNet(input_size=(3,128,128)) # Feel free to change the input size of our dataset!\n", + "\n", + "## Example loading MNIST\n", + "args = DataloadingArgs(\n", + " dataset=\"torch/MNIST\",\n", + " aa=None,\n", + " reprob=0.1,\n", + " vflip=0.,\n", + " hflip=0.,\n", + " scale=(0.7,1.),\n", + " batch_size=100,\n", + " # batch_size=2000,\n", + " color_jitter=0.4,\n", + " validation_batch_size=1000,\n", + ")\n", + "data_config = DataConfigMNIST(input_size=(1,28,28))\n", + "\n", + "train_dl, eval_dl = create_dataloaders(args, data_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "805cec70-b576-44c8-ac98-dd4a978e4b66", + "metadata": {}, + "outputs": [], + "source": [ + "# All non-visible layers are encoded in a relationship\n", + "class HiddenRelationship(Synapse):\n", + " \"\"\"Combine my labels and pixels in the case of MNIST\"\"\"\n", + " W1: jnp.ndarray = tx.Parameter.node()\n", + " W2: jnp.ndarray = tx.Parameter.node()\n", + " beta: jnp.ndarray = tx.Parameter.node()\n", + " \n", + " def __init__(self, nhid:int, stdinit:float = 0.02, beta_init=1.):\n", + " self.nhid = nhid\n", + " self.stdinit = 0.02\n", + " self.beta = jnp.array(beta_init)\n", + "\n", + " def energy(self, g1, g2):\n", + " if self.initializing():\n", + " key = tx.next_key() \n", + " self.W1 = nn.initializers.normal(self.stdinit)(key, (g1.shape[0], self.nhid))\n", + " self.W2 = nn.initializers.normal(self.stdinit)(key, (g2.shape[0], self.nhid))\n", + " # return LSoftmax(g1 @ self.W1 + g2 @ self.W2, self.beta.clip(1e-6))\n", + " return LRelu(g1 @ self.W1 + g2 @ self.W2)\n", + "\n", + " \n", + "## This wasn't particularly useful\n", + "# class Hidden2LayerRelationship(Synapse):\n", + "# \"\"\"Combine my labels and pixels in the case of MNIST\"\"\"\n", + "# W1: jnp.ndarray = tx.Parameter.node()\n", + "# W2: jnp.ndarray = tx.Parameter.node()\n", + "# W3: jnp.ndarray = tx.Parameter.node()\n", + " \n", + "# def __init__(self, nhid:int, stdinit:float = 0.02):\n", + "# self.nhid = nhid\n", + "# self.stdinit = 0.02\n", + "\n", + "# def energy(self, g1, g2):\n", + "# if self.initializing():\n", + "# key = tx.next_key() \n", + "# self.W1 = nn.initializers.normal(self.stdinit)(key, (g1.shape[0], self.nhid))\n", + "# self.W2 = nn.initializers.normal(self.stdinit)(key, (g2.shape[0], self.nhid))\n", + "# self.W3 = nn.initializers.normal(self.stdinit)(key, (self.nhid, self.nhid))\n", + "# x = g1 @ self.W1 + g2 @ self.W2\n", + "# return LRelu(x)\n", + "# # x = jax.nn.tanh(g1 @ self.W1 + g2 @ self.W2)\n", + "# # return LRelu(x @ self.W3)\n", + " \n", + " \n", + "init_key = jax.random.PRNGKey(0)\n", + "\n", + "layers = [\n", + " IdentityLayer((784,)),\n", + " IdentityLayer((10,)),\n", + "]\n", + "synapses = [\n", + " HiddenRelationship(30),\n", + "]\n", + "\n", + "connections = [\n", + " ((0,1), 0),\n", + "]\n", + "\n", + "\n", + "@jax.jit\n", + "def forward_classification_mnist(model, x):\n", + " depth = 4\n", + " alpha = 1.\n", + " \n", + " bs = x.shape[0]\n", + " x = rearrange(x, \"... h w -> ... (h w)\")\n", + " xs = model.init_states(bs)\n", + " masks = jtu.tree_map(lambda x: jnp.ones_like(x, dtype=jnp.int8), xs)\n", + " xs[0] = jnp.array(x)\n", + " masks[0] = jnp.zeros_like(masks[0], dtype=jnp.int8)\n", + "\n", + " for i in range(depth):\n", + " updates = model.vgrad(xs)\n", + " xs = jtu.tree_map(lambda x, u, m: x - alpha * u * m, xs, updates, masks)\n", + " \n", + " logits = xs[1]\n", + " return logits\n", + "\n", + "\n", + "bs = 1\n", + "states, ham = HAM(layers, synapses, connections).init_states_and_params(jax.random.PRNGKey(0), bs=bs)\n", + "\n", + "optimizer = optax.adamw(0.001)\n", + "state = TrainState(ham, optimizer, forward_classification_mnist)" + ] + }, + { + "cell_type": "markdown", + "id": "1a844f8e-ab30-4088-9f30-f7d905d25835", + "metadata": {}, + "source": [ + "### Training Cell" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "ec3e4882-eb26-46f9-83e3-cf481b9b1637", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "DataLoader worker (pid(s) 2397599, 2397635, 2397671, 2397707) exited unexpectedly", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mEmpty\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniconda3/envs/energy-ham/lib/python3.9/site-packages/torch/utils/data/dataloader.py:1163\u001b[0m, in \u001b[0;36m_MultiProcessingDataLoaderIter._try_get_data\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 1162\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1163\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data_queue\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1164\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (\u001b[38;5;28;01mTrue\u001b[39;00m, data)\n", + "File \u001b[0;32m~/miniconda3/envs/energy-ham/lib/python3.9/multiprocessing/queues.py:114\u001b[0m, in \u001b[0;36mQueue.get\u001b[0;34m(self, block, timeout)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_poll(timeout):\n\u001b[0;32m--> 114\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m Empty\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_poll():\n", + "\u001b[0;31mEmpty\u001b[0m: ", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [26]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m test_acc_list\u001b[38;5;241m=\u001b[39m[]\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, num_epochs \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# Use a separate PRNG key to permute image data during shuffling\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m state, train_loss, train_acc \u001b[38;5;241m=\u001b[39m \u001b[43mtrain_epoch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepoch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# Evaluate on the test set after each training epoch \u001b[39;00m\n\u001b[1;32m 10\u001b[0m test_loss, test_acc \u001b[38;5;241m=\u001b[39m eval_model(state, eval_dl)\n", + "Input \u001b[0;32mIn [18]\u001b[0m, in \u001b[0;36mtrain_epoch\u001b[0;34m(state, train_dl, epoch)\u001b[0m\n\u001b[1;32m 26\u001b[0m batch_metrics \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 27\u001b[0m bs \u001b[38;5;241m=\u001b[39m train_dl\u001b[38;5;241m.\u001b[39mbatch_size\n\u001b[0;32m---> 28\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, batch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrain_dl\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[1;32m 29\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (i \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m100\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 30\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mStarting example: \u001b[39m\u001b[38;5;124m\"\u001b[39m, i\u001b[38;5;241m*\u001b[39mbs)\n", + "File \u001b[0;32m~/miniconda3/envs/energy-ham/lib/python3.9/site-packages/torch/utils/data/dataloader.py:441\u001b[0m, in \u001b[0;36mDataLoader.__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_iterator \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_iterator()\n\u001b[1;32m 440\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 441\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_iterator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_reset\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 442\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_iterator\n\u001b[1;32m 443\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/miniconda3/envs/energy-ham/lib/python3.9/site-packages/torch/utils/data/dataloader.py:1142\u001b[0m, in \u001b[0;36m_MultiProcessingDataLoaderIter._reset\u001b[0;34m(self, loader, first_iter)\u001b[0m\n\u001b[1;32m 1140\u001b[0m resume_iteration_cnt \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_workers\n\u001b[1;32m 1141\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m resume_iteration_cnt \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m-> 1142\u001b[0m return_idx, return_data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1143\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(return_idx, _utils\u001b[38;5;241m.\u001b[39mworker\u001b[38;5;241m.\u001b[39m_ResumeIteration):\n\u001b[1;32m 1144\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m return_data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/miniconda3/envs/energy-ham/lib/python3.9/site-packages/torch/utils/data/dataloader.py:1325\u001b[0m, in \u001b[0;36m_MultiProcessingDataLoaderIter._get_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1321\u001b[0m \u001b[38;5;66;03m# In this case, `self._data_queue` is a `queue.Queue`,. But we don't\u001b[39;00m\n\u001b[1;32m 1322\u001b[0m \u001b[38;5;66;03m# need to call `.task_done()` because we don't use `.join()`.\u001b[39;00m\n\u001b[1;32m 1323\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1324\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m-> 1325\u001b[0m success, data \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_try_get_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1326\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m success:\n\u001b[1;32m 1327\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m data\n", + "File \u001b[0;32m~/miniconda3/envs/energy-ham/lib/python3.9/site-packages/torch/utils/data/dataloader.py:1176\u001b[0m, in \u001b[0;36m_MultiProcessingDataLoaderIter._try_get_data\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m 1174\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(failed_workers) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 1175\u001b[0m pids_str \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;28mstr\u001b[39m(w\u001b[38;5;241m.\u001b[39mpid) \u001b[38;5;28;01mfor\u001b[39;00m w \u001b[38;5;129;01min\u001b[39;00m failed_workers)\n\u001b[0;32m-> 1176\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDataLoader worker (pid(s) \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m) exited unexpectedly\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(pids_str)) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m 1177\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(e, queue\u001b[38;5;241m.\u001b[39mEmpty):\n\u001b[1;32m 1178\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m (\u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m)\n", + "\u001b[0;31mRuntimeError\u001b[0m: DataLoader worker (pid(s) 2397599, 2397635, 2397671, 2397707) exited unexpectedly" + ] + } + ], + "source": [ + "num_epochs = 100\n", + "train_acc_list=[]\n", + "test_acc_list=[]\n", + "\n", + "for epoch in range(1, num_epochs + 1):\n", + " # Use a separate PRNG key to permute image data during shuffling\n", + " state, train_loss, train_acc = train_epoch(state, train_dl, epoch)\n", + "\n", + " # Evaluate on the test set after each training epoch \n", + " test_loss, test_acc = eval_model(state, eval_dl)\n", + " train_acc_list.append(train_acc)\n", + " test_acc_list.append(100*test_acc)\n", + " print(f\"Max acc test: {np.max(test_acc_list)}\")\n", + " print(f\"Acc epoch {epoch} [train/tst]: [{train_acc}/{test_acc}]\")\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a45ace6-dc78-47a5-94b2-fc5279ce5746", + "metadata": {}, + "outputs": [], + "source": [ + "# pytree_save(ham.to_dict(), \"./mnist_model\")\n", + "# outmodel = pytree_load(\"./mnist_model.pckl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60db9351-cadb-449f-8a31-a6d2b3faabe6", + "metadata": {}, + "outputs": [], + "source": [ + "# pytree_save(ham, \"./mnist_model_ham\")" + ] + }, + { + "cell_type": "markdown", + "id": "2edfe63c-a6c7-409b-af13-d4037bfca78b", + "metadata": {}, + "source": [ + "## Quick interpretation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "761a86d5-3584-4afc-98e3-be03d4f8df2d", + "metadata": {}, + "outputs": [], + "source": [ + "def forward_interpretability(model:tx.Module, logit_state:jnp.ndarray):\n", + " depth = 12\n", + " alpha = 1.\n", + " \n", + " \n", + " xs = model.init_states()\n", + " xs_list = np.empty((depth, xs[0].shape[0]))\n", + "\n", + " assert logit_state.shape == xs[1].shape\n", + " xs[1] = logit_state\n", + " masks = jtu.tree_map(lambda x: jnp.ones_like(x, dtype=jnp.int8), xs)\n", + " masks[1] = jnp.zeros_like(masks[1], dtype=jnp.int8)\n", + " \n", + " mgrad = jax.jit(model.grad)\n", + " \n", + " @jax.jit\n", + " def step(model, xs):\n", + " updates = model.grad(xs)\n", + " xs = jtu.tree_map(lambda x, u, m: x - alpha * u * m, xs, updates, masks)\n", + " return xs\n", + "\n", + " for i in range(depth):\n", + " xs = step(model, xs)\n", + " xs_list[i] = xs[0]\n", + " \n", + " # Return the pixels, vectorized\n", + " return xs_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df7b3a1c-7d3a-44cf-a52e-5bad9c94338c", + "metadata": {}, + "outputs": [], + "source": [ + "frz_logits = jnp.zeros(10, dtype=jnp.float32).at[0].set(50)\n", + "xs_list = forward_interpretability(ham, frz_logits)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b1cf04a-e422-406b-a8f4-d4611e3592ae", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ba40cf6-0e35-4986-8ab6-4925a125ca0b", + "metadata": {}, + "outputs": [], + "source": [ + "def restore_mnist_imgs(x):\n", + " return rearrange(x, \"... (h w) -> ... h w\", h=28, w=28)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c2bdd53-0246-4071-8a06-e59ffd680ba8", + "metadata": {}, + "outputs": [], + "source": [ + "trajectory = restore_mnist_imgs(xs_list) + 0.5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5e10173-a1f3-42e8-84e5-333766abd68a", + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(trajectory[-1])" + ] + }, + { + "cell_type": "markdown", + "id": "ffb806b4-d088-48c4-a084-c05b2fe2e2e0", + "metadata": {}, + "source": [ + "So that trajectory isn't displaying what I want it to. What is the issue?\n", + "\n", + "Visualize the weights?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b7a03dd-2ae3-4dca-84e3-2388dba66869", + "metadata": {}, + "outputs": [], + "source": [ + "immems = ham.synapses[0].W1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0b217db-957f-47e8-84da-e5b747771239", + "metadata": {}, + "outputs": [], + "source": [ + "mems = restore_mnist_imgs(immems.T)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8a88e7b-293b-4000-87ee-8b2cdaee2605", + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(mems[40])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:hamux]", + "language": "python", + "name": "conda-env-hamux-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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/demo.ipynb b/src/demo.ipynb new file mode 100644 index 0000000..d9c17f7 --- /dev/null +++ b/src/demo.ipynb @@ -0,0 +1,621 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "2ceb9bac-bdb1-4ca7-9eb0-5c9e51816bc3", + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "5ce7e3a3", + "metadata": {}, + "source": [ + "Uncomment the following cell to install necessary dependencies for the demo" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a34b988-38b7-4072-85d5-115895e08e76", + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install seaborn optax datasets einops" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8d0912d-a768-4f2e-b3bf-5a566a22cb75", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "# Choose which gpu to use for JAX and how much memory to reserve\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", + "os.environ[\"XLA_PYTHON_CLIENT_MEM_FRACTION\"]=\"0.5\" # Defaults to 0.9 * TOTAL_MEM" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a06cba11-855d-4908-8276-c035a2c14254", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import *\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "import jax.random as jr\n", + "import equinox as eqx\n", + "import hamux as hmx\n", + "from hamux import Neurons, HAM" + ] + }, + { + "cell_type": "markdown", + "id": "c5e65f52-badb-49cd-8e12-6564c9a9e593", + "metadata": {}, + "source": [ + "# Quick testing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96080942-2484-4ee8-95e1-fde33de0c306", + "metadata": {}, + "outputs": [], + "source": [ + "class SimpleSynapse(eqx.Module):\n", + " W: jax.Array\n", + " shape: Tuple[int]\n", + " \n", + " def __init__(self, key, shape):\n", + " self.shape = shape\n", + " self.W = jax.random.normal(key, shape)\n", + " \n", + " def __call__(self, g1, g2):\n", + " return g1 @ self.W @ g2\n", + "\n", + "key = jax.random.PRNGKey(0)\n", + "nhid = 9\n", + "nlabel = 8\n", + "ninput = 7\n", + "\n", + "neurons = {\n", + " \"input\": Neurons(hmx.lagr_identity, ninput),\n", + " \"labels\": Neurons(hmx.lagr_softmax, nlabel),\n", + " \"hidden\": Neurons(hmx.lagr_softmax, nhid)\n", + "}\n", + "\n", + "synapses = {\n", + " \"dense1\": SimpleSynapse(key, (ninput, nhid)),\n", + " \"dense2\": SimpleSynapse(key, (nlabel, nhid))\n", + "}\n", + "\n", + "connections = [\n", + " ((\"input\", \"hidden\"), \"dense1\"),\n", + " ((\"labels\", \"hidden\"), \"dense2\")\n", + "]\n", + "\n", + "ham = HAM(neurons, synapses, connections)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da1037c0-4980-4838-a9e3-8104b684d557", + "metadata": {}, + "outputs": [], + "source": [ + "xs = ham.init_states() # Batch size 1\n", + "gs = ham.activations(xs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c2bbe24-e93d-4929-a72e-4abc88f71490", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-4.276666\n", + "-0.015219256\n", + "-4.2918854\n", + "{'hidden': Array([ 0.00857786, -0.01086294, -0.7327656 , -0.1682093 , -0.09888899,\n", + " -0.1372438 , 0.25161353, 0.4361781 , 0.31462795], dtype=float32), 'input': Array([-0.50213444, -0.0414146 , -0.3533067 , 0.6524952 , -0.05215456,\n", + " 0.15784311, 0.14437576], dtype=float32), 'labels': Array([-0.14198227, -0.6397187 , -0.04356105, 0.4698938 , 0.17022012,\n", + " -0.11528518, 0.14597854, 0.03270065], dtype=float32)}\n" + ] + } + ], + "source": [ + "print(ham.neuron_energy(gs, xs))\n", + "print(ham.synapse_energy(gs))\n", + "print(ham.energy(gs, xs))\n", + "print(ham.dEdg(gs, xs))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9e0125da-eee6-4dc5-a508-7aa035e3c2ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-4.276666 -4.276666 -4.276666]\n", + "[-0.01522616 -0.01522616 -0.01522616]\n", + "[-4.2918925 -4.2918925 -4.2918925]\n", + "{'hidden': Array([[ 0.00868225, -0.010849 , -0.7329712 , -0.16827393, -0.09884644,\n", + " -0.137249 , 0.25164795, 0.43621826, 0.3146057 ],\n", + " [ 0.00868225, -0.010849 , -0.7329712 , -0.16827393, -0.09884644,\n", + " -0.137249 , 0.25164795, 0.43621826, 0.3146057 ],\n", + " [ 0.00868225, -0.010849 , -0.7329712 , -0.16827393, -0.09884644,\n", + " -0.137249 , 0.25164795, 0.43621826, 0.3146057 ]], dtype=float32), 'input': Array([[-0.50206107, -0.04136157, -0.3533344 , 0.6524692 , -0.05208418,\n", + " 0.1578255 , 0.14430612],\n", + " [-0.50206107, -0.04136157, -0.3533344 , 0.6524692 , -0.05208418,\n", + " 0.1578255 , 0.14430612],\n", + " [-0.50206107, -0.04136157, -0.3533344 , 0.6524692 , -0.05208418,\n", + " 0.1578255 , 0.14430612]], dtype=float32), 'labels': Array([[-0.14194667, -0.63945156, -0.0436905 , 0.46972713, 0.17019227,\n", + " -0.11524014, 0.14593333, 0.03269669],\n", + " [-0.14194667, -0.63945156, -0.0436905 , 0.46972713, 0.17019227,\n", + " -0.11524014, 0.14593333, 0.03269669],\n", + " [-0.14194667, -0.63945156, -0.0436905 , 0.46972713, 0.17019227,\n", + " -0.11524014, 0.14593333, 0.03269669]], dtype=float32)}\n" + ] + } + ], + "source": [ + "vham = ham.vectorize()\n", + "xs = vham.init_states(3) # Batch size 3\n", + "gs = vham.activations(xs)\n", + "\n", + "print(vham.neuron_energy(gs, xs))\n", + "print(vham.synapse_energy(gs))\n", + "print(vham.energy(gs, xs))\n", + "print(vham.dEdg(gs, xs))\n", + "\n", + "ham = vham.unvectorize()" + ] + }, + { + "cell_type": "markdown", + "id": "3d0b458a-2949-4f92-bd6f-97a875617124", + "metadata": {}, + "source": [ + "# Check energy descent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69258f8e-a362-4c5d-850b-2e02ebe8a91b", + "metadata": {}, + "outputs": [], + "source": [ + "import optax" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26eeca70-f385-4575-8d72-21d1c8a81c92", + "metadata": {}, + "outputs": [], + "source": [ + "class DenseSynapse(eqx.Module):\n", + " W: jax.Array\n", + " def __init__(self, key, d1:int, d2:int):\n", + " super().__init__()\n", + " self.W = jax.random.normal(key, (d1, d2)) * 0.4\n", + " \n", + " def __call__(self, g1, g2):\n", + " \"\"\"Compute the energy of the synapse\"\"\"\n", + " return -jnp.einsum(\"...k,...k->...\", g1 @ self.W, g2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1e153c0-7b61-469c-a68c-ad9b04f5a5fb", + "metadata": {}, + "outputs": [], + "source": [ + "key = jax.random.PRNGKey(0)\n", + "neurons = {\n", + " \"input\": hmx.Neurons(hmx.lagr_layernorm, (33,)),\n", + " \"hidden\": hmx.Neurons(hmx.lagr_softmax, (22,))\n", + "}\n", + "synapses = {\n", + " \"s1\": DenseSynapse(key, 33, 22),\n", + "}\n", + "connections = [\n", + " ([\"input\", \"hidden\"], \"s1\")\n", + "]\n", + "ham = hmx.HAM(neurons, synapses, connections)\n", + "\n", + "xs = ham.init_states()\n", + "xs = {k: 30*jax.random.normal(key, xs[k].shape) for k in xs.keys()}\n", + "gs = ham.activations(xs)\n", + "\n", + "xopt = optax.sgd(5e-1)\n", + "optstate = xopt.init(xs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e47dd36-7c07-4e2b-9496-12c27c64ec41", + "metadata": {}, + "outputs": [], + "source": [ + "@eqx.filter_jit\n", + "def new_dedg(ham, xs):\n", + " gs = ham.activations(xs)\n", + " energy, dEdg = ham.dEdg(gs, xs, return_energy=True)\n", + " return energy, dEdg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a23aa156-3ed1-44fe-afd8-ccfb3ff20bd1", + "metadata": {}, + "outputs": [], + "source": [ + "nsteps = 50\n", + "energies = jnp.empty(nsteps)\n", + "for i in range(nsteps):\n", + " energy, dEdg = new_dedg(ham, xs)\n", + " energies = energies.at[i].set(energy)\n", + "\n", + " # xs = jtu.tree_map(lambda x, u: x - 0.5 * u, xs, dEdg)\n", + " updates, optstate = xopt.update(dEdg, optstate, xs)\n", + " xs = optax.apply_updates(xs, updates)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9aca6dee-4c60-429c-93c7-cf943ccaec80", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "caa95483-a55c-42b8-bbe3-c9d46563324f", + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "sns.set_theme()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebf25596-dedf-4510-ac3e-d6c361eddca5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(x=jnp.arange(nsteps), y=jnp.stack(energies))" + ] + }, + { + "cell_type": "markdown", + "id": "d2dae481-0f81-42bf-8a08-eff1dfbd23cf", + "metadata": {}, + "source": [ + "# Train on MNIST\n", + "\n", + "A quick training run to confirm that things work. A lot of optimization needed." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "662ef54e-9da4-4222-9d5b-bd7ca5fb0036", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/nethome/bhoover30/miniconda3/envs/eqx-hamux/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import datasets\n", + "from einops import rearrange\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2275c7b3-698d-49fa-b877-11155f6adfab", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Found cached dataset mnist (/home/bhoover30/.cache/huggingface/datasets/mnist/mnist/1.0.0/9d494b7f466d6931c64fb39d58bb1249a4d85c9eb9865d9bc20960b999e2a332)\n", + "100%|████████████████████████████████████████████| 2/2 [00:00<00:00, 629.26it/s]\n" + ] + } + ], + "source": [ + "mnist = datasets.load_dataset(\"mnist\").with_format(\"jax\")\n", + "train_set = mnist['train']\n", + "test_set = mnist['test']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d7eb0de7-21d0-4ae3-963a-c0bbcfcd2bbe", + "metadata": {}, + "outputs": [], + "source": [ + "Xtest = next(test_set.iter(len(test_set)))['image']\n", + "Xtrain = next(train_set.iter(len(train_set)))['image']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e18835ed-2d3f-497f-b410-d43e08917245", + "metadata": {}, + "outputs": [], + "source": [ + "def transform(x):\n", + " x = x / 255.\n", + " x = rearrange(x, \"... h w -> ... (h w)\") \n", + " x = x / jnp.sqrt((x ** 2).sum(-1, keepdims=True))\n", + " return x\n", + "\n", + "Xtest = transform(Xtest)\n", + "Xtrain = transform(Xtrain)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9517f271-2091-4bae-8d79-d5168226811e", + "metadata": {}, + "outputs": [], + "source": [ + "# set the colormap and centre the colorbar\n", + "class MidpointNormalize(mpl.colors.Normalize):\n", + " \"\"\"Normalise the colorbar.\"\"\"\n", + " def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):\n", + " self.midpoint = midpoint\n", + " mpl.colors.Normalize.__init__(self, vmin, vmax, clip)\n", + "\n", + " def __call__(self, value, clip=None):\n", + " x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]\n", + " return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))\n", + " \n", + "cnorm=MidpointNormalize(midpoint=0.)\n", + "\n", + "def show_img(img):\n", + " vmin, vmax = img.min(), img.max()\n", + " vscale = max(np.abs(vmin), np.abs(vmax))\n", + " cnorm = MidpointNormalize(midpoint=0., vmin=-vscale, vmax=vscale)\n", + " \n", + " fig, ax = plt.subplots(1,1)\n", + " pcm = ax.imshow(img, cmap=\"seismic\", norm=cnorm)\n", + " ax.axis(\"off\")\n", + " \n", + " fig.subplots_adjust(right=0.8)\n", + " cbar_ax = fig.add_axes([0.83, 0.15, 0.03, 0.7])\n", + " fig.colorbar(pcm, cax=cbar_ax);\n", + " return fig" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02b4d15a-ed46-4618-ba47-973da0114035", + "metadata": {}, + "outputs": [], + "source": [ + "from tqdm.auto import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5d37466-95b4-40ff-9ae5-bdc90f0f17f7", + "metadata": {}, + "outputs": [], + "source": [ + "class DenseSynapseHid(eqx.Module):\n", + " W: jax.Array\n", + " def __init__(self, key, d1:int, d2:int):\n", + " super().__init__()\n", + " self.W = jax.random.normal(key, (d1, d2)) * 0.02 + 0.2\n", + " \n", + " @property\n", + " def nW(self):\n", + " nc = jnp.sqrt(jnp.sum(self.W ** 2, axis=0, keepdims=True))\n", + " return self.W / nc\n", + " \n", + " def __call__(self, g1):\n", + " \"\"\"Compute the energy of the synapse\"\"\"\n", + " x2 = g1 @ self.nW\n", + " beta = 1e1\n", + " return - 1/beta * jax.nn.logsumexp(beta * x2, axis=-1)\n", + " \n", + "key = jax.random.PRNGKey(0)\n", + "neurons = {\n", + " \"input\": hmx.Neurons(hmx.lagr_spherical_norm, (784,)),\n", + "}\n", + "synapses = {\n", + " \"s1\": DenseSynapseHid(key, 784, 900),\n", + "}\n", + "connections = [\n", + " ([\"input\"], \"s1\")\n", + "]\n", + "\n", + "ham = hmx.HAM(neurons, synapses, connections)\n", + "xs = ham.init_states()\n", + "gs = ham.activations(xs)\n", + "opt = optax.adam(4e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ea24e4e-cfff-4c5c-af02-b159ce5d2f83", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "epoch = 010/010, loss = 0.000761: 100%|█████████| 10/10 [00:14<00:00, 1.44s/it]\n" + ] + } + ], + "source": [ + "n_epochs = 10\n", + "pbar = tqdm(range(n_epochs), total=n_epochs)\n", + "img = Xtrain[:]\n", + "batch_size = 100\n", + "\n", + "ham = ham.vectorize()\n", + "opt_state = opt.init(eqx.filter(ham, eqx.is_array))\n", + "\n", + "\n", + "def lossf(ham, xs,key, nsteps=1, alpha=1.):\n", + " \"\"\"Given a noisy initial image, descend the energy and try to reconstruct the original image at the end of the dynamics.\n", + " \n", + " Works best with fewer steps due to the vanishing gradient problem\"\"\"\n", + " img = xs['input']\n", + " xs['input'] = img + jr.normal(key, img.shape) * 0.3\n", + " gs = ham.activations(xs)\n", + " \n", + " for i in range(nsteps):\n", + " # Construct noisy image to final prediction\n", + " evalue, egrad = ham.dEdg(gs, xs, return_energy=True)\n", + " xs = jtu.tree_map(lambda x, dEdg: x - alpha * dEdg, xs, egrad)\n", + " gs = ham.activations(xs)\n", + "\n", + " # 1step prediction means gradient == image\n", + " img_final = gs['input']\n", + " loss = ((img_final - img)**2).mean()\n", + " \n", + " logs = {\n", + " \"loss\": loss,\n", + " }\n", + " \n", + " return loss, logs\n", + "\n", + "@eqx.filter_jit\n", + "def step(img, ham, opt_state, key):\n", + " xs = ham.init_states(bs=img.shape[0])\n", + " xs[\"input\"] = img\n", + "\n", + " (loss, logs), grads = eqx.filter_value_and_grad(lossf, has_aux=True)(ham, xs, key)\n", + " updates, opt_state = opt.update(grads, opt_state, ham)\n", + " newparams = optax.apply_updates(eqx.filter(ham, eqx.is_array), updates)\n", + " ham = eqx.combine(newparams, ham)\n", + " return ham, opt_state, logs\n", + " \n", + "noise_rng = jr.PRNGKey(100)\n", + "batch_rng = jr.PRNGKey(10)\n", + "for e in pbar:\n", + " batch_key, batch_rng = jr.split(batch_rng)\n", + " idxs = jr.permutation(batch_key, jnp.arange(img.shape[0]))\n", + " i = 0\n", + "\n", + " while i < img.shape[0]:\n", + " noise_key, noise_rng = jr.split(noise_rng)\n", + " batch = img[idxs[i: i+batch_size]]\n", + " ham, opt_state, logs = step(batch, ham, opt_state, noise_key)\n", + " i = i+batch_size\n", + "\n", + " pbar.set_description(f'epoch = {e+1:03d}/{n_epochs:03d}, loss = {logs[\"loss\"].item():2.6f}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6e54b96-6a7d-46b5-a605-d122725e96d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The above architecture trains ok, learns some decent prototypes. Not perfect\n", + "myW = ham.synapses[\"s1\"].nW\n", + "kh = kw = int(np.sqrt(myW.shape[-1]))\n", + "show_img(rearrange(myW, \"(h w) (kh kw) -> (kh h) (kw w)\", h=28, w=28, kh=kh, kw=kw));" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:eqx-hamux]", + "language": "python", + "name": "conda-env-eqx-hamux-py" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/hamux.py b/src/hamux.py new file mode 100644 index 0000000..64513ea --- /dev/null +++ b/src/hamux.py @@ -0,0 +1,220 @@ +# %% +import equinox as eqx +from typing import * +import jax +import jax.numpy as jnp +import jax.tree_util as jtu + + +class Neurons(eqx.Module): + """Neurons represent dynamic variables in the HAM that are evolved during inference (i.e., memory retrieval/error correction) + + They have an evolving state (created using the `.init` function) that is stored outside the neuron layer itself + """ + + lagrangian: Union[Callable, eqx.Module] + shape: Tuple[int] + + def __init__( + self, lagrangian: Union[Callable, eqx.Module], shape: Union[int, Tuple[int]] + ): + self.lagrangian = lagrangian + if isinstance(shape, int): + shape = (shape,) + self.shape = shape + + def activations(self, x: jax.Array) -> jax.Array: + """Compute the activations of the neuron layer""" + return jax.grad(self.lagrangian)(x) + + def g(self, x: jax.Array) -> jax.Array: + """Alias for the activations""" + return self.activations(x) + + def energy(self, g: jax.Array, x: jax.Array) -> jax.Array: + """Assume vectorized""" + return jnp.multiply(g, x).sum() - self.lagrangian(x) + + def init(self, bs: Optional[int] = None) -> jax.Array: + """Return an empty state of the correct shape""" + if bs is None or bs == 0: + return jnp.zeros(self.shape) + return jnp.zeros((bs, *self.shape)) + + def __repr__(self: jax.Array): + return f"Neurons(lagrangian={self.lagrangian}, shape={self.shape})" + + +class HAM(eqx.Module): + """The Hierarchical Associative Memory + + A wrapper for all dynamic states (neurons) and learnable parameters (synapses) of our memory + """ + + neurons: Dict[str, Neurons] + synapses: Dict[str, eqx.Module] + connections: List[Tuple[Tuple, str]] + + def __init__( + self, + neurons: Dict[ + str, Neurons + ], # Neurons are the dynamical variables expressing the state of the HAM + synapses: Dict[ + str, eqx.Module + ], # Synapses are the learnable relationships between dynamic variables. + connections: List[ + Tuple[Tuple[str, ...], str] + ], # Connections expressed as [(['ni', 'nj'], 'sk'), ...]. Read as "Connect neurons 'ni' and 'nj' via synapse 'sk' + ): + """An HAM is a hypergraph that connects neurons and synapses together via connections""" + self.neurons = neurons + self.synapses = synapses + self.connections = connections + + @property + def n_neurons(self) -> int: + return len(self.neurons) + + @property + def n_synapses(self) -> int: + return len(self.synapses) + + @property + def n_connections(self) -> int: + return len(self.connections) + + def activations( + self, + xs, # The expected collection of neurons states + ) -> Dict[str, jax.Array]: + """Convert hidden states of each neuron into activations""" + gs = {k: v.g(xs[k]) for k, v in self.neurons.items()} + return gs + + def init_states( + self, + bs: Optional[int] = None, # If provided, each neuron in the HAM has this batch size + ): + """Initialize neuron states""" + xs = {k: v.init(bs) for k, v in self.neurons.items()} + return xs + + def connection_energies( + self, + gs: Dict[str, jax.Array], # The collection of neuron activations + ): + """Get the energy for each connection""" + + def get_energy(neuron_set, s): + mygs = [gs[k] for k in neuron_set] + return self.synapses[s](*mygs) + + return [get_energy(neuron_set, s) for neuron_set, s in self.connections] + + def neuron_energies(self, gs, xs): + """Return the energies of each neuron in the HAM""" + return {k: self.neurons[k].energy(gs[k], xs[k]) for k in self.neurons.keys()} + + def energy_tree(self, gs, xs): + """Return energies for each individual component""" + neuron_energies = self.neuron_energies(gs, xs) + connection_energies = self.connection_energies(gs) + return {"neurons": neuron_energies, "connections": connection_energies} + + def energy(self, gs, xs): + """The complete energy of the HAM""" + energy_tree = self.energy_tree(gs, xs) + return jtu.tree_reduce(lambda E, acc: acc + E, energy_tree, 0) + + def dEdg(self, gs, xs, return_energy=False): + """Calculate gradient of system energy wrt activations using cute trick: + + The derivative of the neuron energy w.r.t. the activations is the neuron state itself. + This is a property of the Legendre Transform. + """ + dEdg = jtu.tree_map(lambda x, s: x + s, xs, jax.grad(self.synapse_energy)(gs)) + if return_energy: + return dEdg, self.energy(gs, xs) + return jax.grad(self.energy)(gs, xs) + + def vectorize(self): + """Compute new HAM with same API, except all methods expect a batch dimension""" + return VectorizedHAM(self) + + def unvectorize(self): + return self + + +class VectorizedHAM(eqx.Module): + """Re-expose HAM API with vectorized inputs""" + + _ham: eqx.Module + + def __init__(self, ham): + self._ham = ham + + @property + def neurons(self): + return self._ham.neurons + + @property + def synapses(self): + return self._ham.synapses + + @property + def connections(self): + return self._ham.connections + + @property + def n_neurons(self): + return self._ham.n_neurons + + @property + def n_synapses(self): + return self._ham.n_synapses + + @property + def n_connections(self): + return self._ham.n_connections + + @property + def _batch_axes(self: HAM): + """A helper function to tell vmap to batch along the 0'th dimension of each state in the HAM.""" + return {k: 0 for k in self._ham.neurons.keys()} + + def init_states(self, bs=None): + return self._ham.init_states(bs) + + def activations(self, xs): + return jax.vmap(self._ham.activations, in_axes=(self._batch_axes,))(xs) + + def connection_energies(self, gs): + return jax.vmap(self._ham.connection_energies, in_axes=(self._batch_axes,))(gs) + + def neuron_energies(self, gs, xs): + return jax.vmap( + self._ham.neuron_energies, in_axes=(self._batch_axes, self._batch_axes) + )(gs, xs) + + def energy_tree(self, gs, xs): + """Return energies for each individual component""" + return jax.vmap( + self._ham.energy_tree, in_axes=(self._batch_axes, self._batch_axes) + )(gs, xs) + + def energy(self, gs, xs): + return jax.vmap(self._ham.energy, in_axes=(self._batch_axes, self._batch_axes))( + gs, xs + ) + + def dEdg(self, gs, xs, return_energy=False): + return jax.vmap(self._ham.dEdg, in_axes=(self._batch_axes, self._batch_axes, None))( + gs, xs, return_energy + ) + + def unvectorize(self): + return self._ham + + def vectorize(self): + return self \ No newline at end of file diff --git a/src/hamux_jax.py b/src/hamux_jax.py new file mode 100644 index 0000000..67fd542 --- /dev/null +++ b/src/hamux_jax.py @@ -0,0 +1,173 @@ +"""A minimal implementation of HAMs in JAX. Unlike pytorch, this implementation operates on individual samples.""" + +import jax.numpy as jnp +import jax +import numpy as np +import functools as ft +from typing import * +from dataclasses import dataclass +import equinox as eqx +import jax.tree_util as jtu + +from lagrangians import * + +## HAM +class HAM(eqx.Module): + neurons: Dict[str, Neurons] + synapses: Dict[str, eqx.Module] + connections: List[Tuple[Tuple, str]] + + def __init__(self, neurons, synapses, connections): + self.neurons = neurons + self.synapses = synapses + self.connections = connections + + @property + def n_neurons(self): return len(self.neurons) + @property + def n_synapses(self): return len(self.synapses) + @property + def n_connections(self): return len(self.connections) + + def activations(self, xs): + """Convert hidden states to activations""" + gs = {k: v.g(xs[k]) for k,v in self.neurons.items()} + return gs + + def init_states(self, bs:Optional[int]=None): + """Initialize states""" + xs = {k: v.init(bs) for k,v in self.neurons.items()} + return xs + + def connection_energies(self, gs): + """Get the energy for each connection""" + def get_energy(neuron_set, s): + mygs = [gs[k] for k in neuron_set] + return self.synapses[s](*mygs) + + return [get_energy(neuron_set, s) for neuron_set, s in self.connections] + + def energy_tree(self, gs, xs): + """Return energies for each individual component""" + + neuron_energies = jtu.tree_map(lambda neuron, g, x: neuron.energy(g, x), self.neurons, gs, xs) + connection_energies = self.connection_energies(gs) + + return { + "neurons": neuron_energies, + "connections": connection_energies + } + + def neuron_energy(self, gs, xs): + """The sum of all neuron energies""" + energies = [self.neurons[k].energy(gs[k], xs[k]) for k in self.neurons.keys()] + return jnp.sum(jnp.stack(energies)) + + def synapse_energy(self, gs): + """The sum of all synapse energies""" + def get_energy(neuron_set, s): + mygs = [gs[k] for k in neuron_set] + return self.synapses[s](*mygs) + energies = [get_energy(neuron_set, s) for neuron_set, s in self.connections] + return jnp.sum(jnp.stack(energies)) + + def energy(self, gs, xs): + """The complete energy of the HAM""" + return self.neuron_energy(gs, xs) + self.synapse_energy(gs) + + def dEdg(self, gs, xs, return_energy=False): + """Calculate gradient of system energy wrt activations using cute trick""" + if return_energy: + return jax.value_and_grad(self.energy)(gs, xs) + return jax.grad(self.energy)(gs, xs) + + def dEdg_manual(self, gs, xs, return_energy=False): + """Calculate gradient of system energy wrt activations using cute trick""" + dEdg = jtu.tree_map(lambda x, s: x + s, xs, jax.grad(self.synapse_energy)(gs)) + if return_energy: + return dEdg, self.energy(gs, xs) + return dEdg + + def energy_tree(self, gs, xs): + """Return energies for each individual component""" + neuron_energies = {k: self.neurons[k].energy(gs[k], xs[k]) for k in self.neurons.keys()} + connection_energies = self.connection_energies(gs) + + return { + "neurons": neuron_energies, + "connections": connection_energies + } + + def scaled_energy_f(self, gs, xs, energy_scales): + """Compute energy after scaling each component down by energy scales, a pytree of the same structure as the output of `energy_tree`""" + etree = self.energy_tree(gs, xs) + etree = jtu.tree_map(lambda E, s: E * s, etree, energy_scales) + return energy_from_tree(etree) + + def vectorize(self): + """Compute new HAM with same API, except all methods expect a batch dimension""" + return VectorizedHAM(self) + + def unvectorize(self): + return self + +class VectorizedHAM(eqx.Module): + """Re-expose HAM API with vectorized inputs""" + _ham: eqx.Module + + def __init__(self, ham): + self._ham = ham + + @property + def neurons(self): return self._ham.neurons + @property + def synapses(self): return self._ham.synapses + @property + def connections(self): return self._ham.connections + @property + def n_neurons(self): return self._ham.n_neurons + @property + def n_synapses(self): return self._ham.n_synapses + @property + def n_connections(self): return self._ham.n_connections + @property + def _batch_axes(self:HAM): + """A helper function to tell vmap to batch along the 0'th dimension of each state in the HAM.""" + return {k: 0 for k in self._ham.neurons.keys()} + + def init_states(self, bs=None): + return self._ham.init_states(bs) + + def activations(self, xs): + return jax.vmap(self._ham.activations, in_axes=(self._batch_axes,))(xs) + + def connection_energies(self, gs): + return jax.vmap(self._ham.connection_energies, in_axes=(self._batch_axes,))(gs) + + def synapse_energy(self, gs): + return jax.vmap(self._ham.synapse_energy, in_axes=(self._batch_axes,))(gs) + + def neuron_energy(self, gs, xs): + return jax.vmap(self._ham.neuron_energy, in_axes=(self._batch_axes, self._batch_axes))(gs, xs) + + def energy(self, gs, xs): + return jax.vmap(self._ham.energy, in_axes=(self._batch_axes, self._batch_axes))(gs, xs) + + def dEdg(self, gs, xs, return_energy=False): + return jax.vmap(self._ham.dEdg, in_axes=(self._batch_axes, self._batch_axes, None))(gs, xs, return_energy) + + def dEdg_manual(self, gs, xs, return_energy=False): + return jax.vmap(self._ham.dEdg, in_axes=(self._batch_axes, self._batch_axes, None))(gs, xs, return_energy) + + def energy_tree(self, gs, xs): + return jax.vmap(self._ham.energy_tree, in_axes=(self._batch_axes, self._batch_axes))(gs, xs) + + def scaled_energy_f(self, gs, xs, etree): + return jax.vmap(self._ham.scaled_energy_f, in_axes=(self._batch_axes, self._batch_axes, None))(gs, xs, etree) + + def unvectorize(self): + return self._ham + + def vectorize(self): + return self + diff --git a/src/hamux_old.py b/src/hamux_old.py new file mode 100644 index 0000000..fe4d448 --- /dev/null +++ b/src/hamux_old.py @@ -0,0 +1,280 @@ +"""A minimal implementation of HAMs in JAX. Unlike pytorch, this implementation operates on individual samples.""" + +import jax.numpy as jnp +import jax +import numpy as np +import functools as ft +from typing import * +from dataclasses import dataclass +import equinox as eqx +import jax.tree_util as jtu + +## LAGRANGIANS +def lagr_identity(x): + """The Lagrangian whose activation function is simply the identity.""" + return 0.5 * jnp.power(x, 2).sum() + +def lagr_repu(x, + n): # Degree of the polynomial in the power unit + """Rectified Power Unit of degree `n`""" + return 1 / n * jnp.power(jnp.maximum(x, 0), n).sum() + +def lagr_relu(x): + """Rectified Linear Unit. Same as repu of degree 2""" + return lagr_repu(x, 2) + +def lagr_softmax(x, + beta:float=1.0, # Inverse temperature + axis:int=-1): # Dimension over which to apply logsumexp + """The lagrangian of the softmax -- the logsumexp""" + return (1/beta * jax.nn.logsumexp(beta * x, axis=axis, keepdims=False)) + +def lagr_exp(x, + beta:float=1.0): # Inverse temperature + """Exponential activation function, as in [Demicirgil et al.](https://arxiv.org/abs/1702.01929). Operates elementwise""" + return 1 / beta * jnp.exp(beta * x).sum() + +def lagr_rexp(x, + beta:float=1.0): # Inverse temperature + """Rectified exponential activation function""" + xclipped = jnp.maximum(x, 0) + return 1 / beta * (jnp.exp(beta * xclipped)-xclipped).sum() + +@jax.custom_jvp +def _lagr_tanh(x, beta=1.0): + return 1 / beta * jnp.log(jnp.cosh(beta * x)) + +@_lagr_tanh.defjvp +def _lagr_tanh_defjvp(primals, tangents): + x, beta = primals + x_dot, beta_dot = tangents + primal_out = _lagr_tanh(x, beta) + tangent_out = jnp.tanh(beta * x) * x_dot + return primal_out, tangent_out + +def lagr_tanh(x, + beta=1.0): # Inverse temperature + """Lagrangian of the tanh activation function""" + return _lagr_tanh(x, beta) + +@jax.custom_jvp +def _lagr_sigmoid(x, + beta=1.0, # Inverse temperature + scale=1.0): # Amount to stretch the range of the sigmoid's lagrangian + """The lagrangian of a sigmoid that we can define custom JVPs of""" + return scale / beta * jnp.log(jnp.exp(beta * x) + 1) + +def _tempered_sigmoid(x, + beta=1.0, # Inverse temperature + scale=1.0): # Amount to stretch the range of the sigmoid + """The basic sigmoid, but with a scaling factor""" + return scale / (1 + jnp.exp(-beta * x)) + +@_lagr_sigmoid.defjvp +def _lagr_sigmoid_jvp(primals, tangents): + x, beta, scale = primals + x_dot, beta_dot, scale_dot = tangents + primal_out = _lagr_sigmoid(x, beta, scale) + tangent_out = _tempered_sigmoid(x, beta=beta, scale=scale) * x_dot # Manually defined sigmoid + return primal_out, tangent_out + +def lagr_sigmoid(x, + beta=1.0, # Inverse temperature + scale=1.0): # Amount to stretch the range of the sigmoid's lagrangian + """The lagrangian of the sigmoid activation function""" + return _lagr_sigmoid(x, beta=beta, scale=scale) + +def _simple_layernorm(x:jnp.ndarray, + gamma:float=1.0, # Scale the stdev + delta:Union[float, jnp.ndarray]=0., # Shift the mean + axis=-1, # Which axis to normalize + eps=1e-5, # Prevent division by 0 + ): + """Layer norm activation function""" + xmean = x.mean(axis, keepdims=True) + xmeaned = x - xmean + denominator = jnp.sqrt(jnp.power(xmeaned, 2).mean(axis, keepdims=True) + eps) + return gamma * xmeaned / denominator + delta + +def lagr_layernorm(x:jnp.ndarray, + gamma:float=1.0, # Scale the stdev + delta:Union[float, jnp.ndarray]=0., # Shift the mean + axis=-1, # Which axis to normalize + eps=1e-5, # Prevent division by 0 + ): + """Lagrangian of the layer norm activation function""" + D = x.shape[axis] if axis is not None else x.size + xmean = x.mean(axis, keepdims=True) + xmeaned = x - xmean + y = jnp.sqrt(jnp.power(xmeaned, 2).mean(axis, keepdims=True) + eps) + return (D * gamma * y + (delta * x).sum()).sum() + + +def _simple_spherical_norm(x:jnp.ndarray, + axis=-1, # Which axis to normalize + ): + """Spherical norm activation function""" + xmean = x.mean(axis, keepdims=True) + xmeaned = x - xmean + denominator = jnp.sqrt(jnp.power(xmeaned, 2).mean(axis, keepdims=True) + eps) + return gamma * xmeaned / denominator + delta + +def lagr_spherical_norm(x:jnp.ndarray, + gamma:float=1.0, # Scale the stdev + delta:Union[float, jnp.ndarray]=0., # Shift the mean + axis=-1, # Which axis to normalize + eps=1e-5, # Prevent division by 0 + ): + """Lagrangian of the spherical norm activation function""" + y = jnp.sqrt(jnp.power(x, 2).sum(axis, keepdims=True) + eps) + return (gamma * y + (delta * x).sum()).sum() + +## Neurons +class Neurons(eqx.Module): + lagrangian: Callable + shape: Tuple[int] + def __init__(self, + lagrangian:Union[Callable, eqx.Module], + shape:Union[int, Tuple[int]] + ): + super().__init__() + self.lagrangian = lagrangian + if isinstance(shape, int): + shape = (shape,) + self.shape = shape + + def activations(self, x): + return jax.grad(self.lagrangian)(x) + + def g(self, x): + return self.activations(x) + + def energy(self, g, x): + """Assume vectorized""" + return jnp.multiply(g, x).sum() - self.lagrangian(x) + + def init(self, bs:Optional[int]=None): + """Return an empty state of the correct shape""" + if bs is None or bs == 0: + return jnp.zeros(*self.shape) + return jnp.zeros((bs, *self.shape)) + + def __repr__(self): + return f"Neurons(lagrangian={self.lagrangian}, shape={self.shape})" + + +## HAM +class HAM(eqx.Module): + neurons: Dict[str, Neurons] + synapses: Dict[str, eqx.Module] + connections: List[Tuple[Tuple, str]] + + def __init__(self, neurons, synapses, connections): + self.neurons = neurons + self.synapses = synapses + self.connections = connections + + @property + def n_neurons(self): return len(self.neurons) + @property + def n_synapses(self): return len(self.synapses) + @property + def n_connections(self): return len(self.connections) + + def activations(self, xs): + """Convert hidden states to activations""" + gs = {k: v.g(xs[k]) for k,v in self.neurons.items()} + return gs + + def init_states(self, bs:Optional[int]=None): + """Initialize states""" + xs = {k: v.init(bs) for k,v in self.neurons.items()} + return xs + + def neuron_energy(self, gs, xs): + """The sum of all neuron energies""" + energies = [self.neurons[k].energy(gs[k], xs[k]) for k in self.neurons.keys()] + return jnp.sum(jnp.stack(energies)) + + def synapse_energy(self, gs): + """The sum of all synapse energies""" + def get_energy(neuron_set, s): + mygs = [gs[k] for k in neuron_set] + return self.synapses[s](*mygs) + energies = [get_energy(neuron_set, s) for neuron_set, s in self.connections] + return jnp.sum(jnp.stack(energies)) + + def energy(self, gs, xs): + """The complete energy of the HAM""" + return self.neuron_energy(gs, xs) + self.synapse_energy(gs) + + def dEdg(self, gs, xs, return_energy=False): + """Calculate gradient of system energy wrt activations using cute trick""" + if return_energy: + return jax.value_and_grad(self.energy)(gs, xs) + return jax.grad(self.energy)(gs, xs) + + def dEdg_manual(self, gs, xs, return_energy=False): + """Calculate gradient of system energy wrt activations using cute trick""" + dEdg = jtu.tree_map(lambda x, s: x + s, xs, jax.grad(self.synapse_energy)(gs)) + if return_energy: + return dEdg, self.energy(gs, xs) + return dEdg + + def vectorize(self): + """Compute new HAM with same API, except all methods expect a batch dimension""" + return VectorizedHAM(self) + + def unvectorize(self): + return self + +class VectorizedHAM(eqx.Module): + """Re-expose HAM API with vectorized inputs""" + _ham: eqx.Module + + def __init__(self, ham): + self._ham = ham + + @property + def neurons(self): return self._ham.neurons + @property + def synapses(self): return self._ham.synapses + @property + def connections(self): return self._ham.connections + @property + def n_neurons(self): return self._ham.n_neurons + @property + def n_synapses(self): return self._ham.n_synapses + @property + def n_connections(self): return self._ham.n_connections + @property + def _batch_axes(self:HAM): + """A helper function to tell vmap to batch along the 0'th dimension of each state in the HAM.""" + return {k: 0 for k in self._ham.neurons.keys()} + + def init_states(self, bs=None): + return self._ham.init_states(bs) + + def activations(self, xs): + return jax.vmap(self._ham.activations, in_axes=(self._batch_axes,))(xs) + + def synapse_energy(self, gs): + return jax.vmap(self._ham.synapse_energy, in_axes=(self._batch_axes,))(gs) + + def neuron_energy(self, gs, xs): + return jax.vmap(self._ham.neuron_energy, in_axes=(self._batch_axes, self._batch_axes))(gs, xs) + + def energy(self, gs, xs): + return jax.vmap(self._ham.energy, in_axes=(self._batch_axes, self._batch_axes))(gs, xs) + + def dEdg(self, gs, xs, return_energy=False): + return jax.vmap(self._ham.dEdg, in_axes=(self._batch_axes, self._batch_axes, None))(gs, xs, return_energy) + + def dEdg_manual(self, gs, xs, return_energy=False): + return jax.vmap(self._ham.dEdg, in_axes=(self._batch_axes, self._batch_axes, None))(gs, xs, return_energy) + + def unvectorize(self): + return self._ham + + def vectorize(self): + return self \ No newline at end of file diff --git a/src/neurons.py b/src/neurons.py deleted file mode 100644 index a210ccf..0000000 --- a/src/neurons.py +++ /dev/null @@ -1,40 +0,0 @@ -import jax -import jax.numpy as jnp -import equinox as eqx -from typing import * - -class Neurons(eqx.Module): - """Neurons represent dynamic variables in the HAM that are evolved during inference (i.e., memory retrieval/error correction) - - They have an evolving state (created using the `.init` function) that is stored outside the neuron layer itself - """ - lagrangian: Callable - shape: Tuple[int] - - def __init__( - self, lagrangian: Union[Callable, eqx.Module], shape: Union[int, Tuple[int]] - ): - super().__init__() - self.lagrangian = lagrangian - if isinstance(shape, int): - shape = (shape,) - self.shape = shape - - def activations(self, x: jax.Array) -> jax.Array: - return jax.grad(self.lagrangian)(x) - - def g(self, x: jax.Array) -> jax.Array: - return self.activations(x) - - def energy(self, g: jax.Array, x: jax.Array) -> jax.Array: - """Assume vectorized""" - return jnp.multiply(g, x).sum() - self.lagrangian(x) - - def init(self, bs: Optional[int] = None) -> jax.Array: - """Return an empty state of the correct shape""" - if bs is None or bs == 0: - return jnp.zeros(self.shape) - return jnp.zeros((bs, *self.shape)) - - def __repr__(self: jax.Array): - return f"Neurons(lagrangian={self.lagrangian}, shape={self.shape})" diff --git a/tests/conftest.py b/tests/conftest.py index e69de29..59c6cac 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -0,0 +1,34 @@ +import pytest + +import equinox as eqx +import jax +import jax.numpy as jnp +from typing import * +from hamux import Neurons, HAM +import jax.random as jr +from src.lagrangians import lagr_identity, lagr_softmax + +class SimpleSynapse(eqx.Module): + W: jax.Array + def __init__(self, key:jax.Array, shape:Tuple[int, int]): + self.W = 0.1 * jr.normal(key, shape) + + def __call__(self, g1, g2): + return -jnp.einsum("...d,de,...e->...", g1, self.W, g2) + +@pytest.fixture +def simple_ham(): + d1, d2 = (5,7) + neurons = { + "image": Neurons(lagr_identity, (d1,)), + "hidden": Neurons(lagr_softmax, (d2,)) + } + synpases = { + "s1": SimpleSynapse(jr.PRNGKey(0), (d1, d2)) + } + connections = [ + # (vertices, hyperedge) + (("image", "hidden"), "s1") + ] + ham = HAM(neurons, synpases, connections) + return ham \ No newline at end of file diff --git a/tests/test_neurons.py b/tests/test_hamux.py similarity index 73% rename from tests/test_neurons.py rename to tests/test_hamux.py index 63662e8..9a0874a 100644 --- a/tests/test_neurons.py +++ b/tests/test_hamux.py @@ -1,4 +1,7 @@ -from neurons import Neurons +from hamux import Neurons +import pytest +import jax +import jax.numpy as jnp from lagrangians import lagr_softmax import jax.numpy as jnp import jax @@ -15,4 +18,7 @@ def test_init(): def test_activations(): x = neuron.init() assert jnp.all(neuron.activations(x) == neuron.g(x)) - assert jnp.allclose(act_fn(x), neuron.g(x)) \ No newline at end of file + assert jnp.allclose(act_fn(x), neuron.g(x)) + +def test_energies(simple_ham): + pass \ No newline at end of file