{ "cells": [ { "cell_type": "markdown", "id": "53770daf", "metadata": {}, "source": [ "(convolution)=\n", "# Convolutional predictive coding networks\n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ComputationalPsychiatry/pyhgf/blob/master/docs/source/notebooks/0.8-Convolutional_networks.ipynb)\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "5fb33a27", "metadata": {}, "outputs": [], "source": [ "import sys\n", "\n", "from IPython.utils import io\n", "\n", "if \"google.colab\" in sys.modules:\n", " with io.capture_output() as captured:\n", " ! pip uninstall -y jax jaxlib\n", " ! pip install pyhgf watermark jax[cuda12]==0.4.31" ] }, { "cell_type": "code", "execution_count": 2, "id": "80faac0c", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/au646069/git/pyhgf/pyhgf/__init__.py:124: RuntimeWarning: pyhgf sets --xla_cpu_use_thunk_runtime=false to avoid a large slowdown in gradients through the belief propagation scan on jaxlib 0.6.2. jax was already imported, so the flag may arrive too late to take effect. Import pyhgf before jax, or set XLA_FLAGS yourself, to be sure of it.\n", " LEGACY_CPU_RUNTIME_FLAG = _use_legacy_cpu_runtime()\n" ] } ], "source": [ "import os\n", "import time\n", "import urllib.request\n", "\n", "import jax\n", "import jax.numpy as jnp\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import optax\n", "import seaborn as sns\n", "\n", "from pyhgf.model import (\n", " DeepNetwork,\n", " DeepNetworkAdapter,\n", " FusedPipeline,\n", " PCSequential,\n", ")\n", "from pyhgf.model.conv import (\n", " conv_block,\n", " flatten_adapter,\n", " im2col_adapter,\n", " spatial_reshape_adapter,\n", ")\n", "from pyhgf.plots.graphviz.plot_network import plot_deep_network\n", "\n", "plt.rcParams[\"figure.constrained_layout.use\"] = True" ] }, { "cell_type": "markdown", "id": "80530860", "metadata": {}, "source": [ "[Prospective configuration](0.6-Prospective_configuration.ipynb) showed that a `DeepNetwork` learns fully-connected layers with local, precision-weighted updates instead of backpropagation. A convolution is nothing more exotic than a *fully-connected layer shared across every spatial position of an image* — so the same machinery covers it, once the sharing is set up correctly.\n", "\n", "This notebook builds that sharing from the ground up, trains it on two synthetic toy tasks, and finishes on real photographs (CIFAR-10). Throughout, we use the **hybrid pipeline** (`pyhgf.model.hybrid`/`pyhgf.model.fused`): a small set of frozen (weightless) *adapters* for the purely geometric parts of a convolution (extracting patches, pooling) wrapped around one small `DeepNetwork` per convolutional layer. Pinning each layer's precision high and freezing its precision updates (the same *backprop-parity recipe* used for the Transformer in earlier notebooks) makes each local update mathematically equal to a backpropagation step, by construction." ] }, { "cell_type": "markdown", "id": "731922be", "metadata": {}, "source": [ "## From one shared layer to a convolution\n", "\n", "![One shared kernel stepping across every position of the input, writing one value per position into the output feature map.](https://computationalpsychiatry.github.io/pyhgf/_images/convolution.svg)\n", "\n", "*The same $k_h \\times k_w$ kernel is applied at every position, so the layer holds only $C_{out} \\times C_{in} \\cdot k_h \\cdot k_w$ weights however large the image gets. Drawn with stride 1 and no padding ($H' = H - k_h + 1$); `conv_block` below defaults to `padding=\"SAME\"`, which instead keeps $H' = H$.*\n", "\n", "A convolution kernel is a small weight matrix that is *reused* at every position it slides over: the same $3\\times 3\\times C_{in} \\to C_{out}$ linear map, applied independently to every patch of the image. That reuse can be split into three independent pieces:\n", "\n", "1. **Extract patches** (`im2col`) — turn every $k_h \\times k_w$ neighbourhood of the image into one row of a table. This is a pure reshuffle of the input, with no weights at all.\n", "2. **Apply one shared kernel** — a single small linear map (`out_channels ← in_channels·k_h·k_w`), applied identically to every row/patch. This is the *only* learned part.\n", "3. **Pool** — locally summarise (average or take the max over) small neighbourhoods to shrink the spatial size before the next layer.\n", "\n", "`pyhgf.model.conv` implements exactly this split:\n", "\n", "- `im2col_adapter` / `avg_pool_adapter` / `max_pool_adapter` / `spatial_reshape_adapter` are **frozen** `EquinoxAdapter`s: closed-form forward and backward passes, no learned parameters.\n", "- `conv_patch_network` builds the one learned piece, a tiny 2-layer `DeepNetwork`, the same object class used for any other fully-connected layer in this library.\n", "- `conv_block` wires all of the above into a single `PCSequential`: `im2col → shared kernel (as a DeepNetworkAdapter) → GELU → reshape → pool`.\n", "\n", "Before trusting that wiring, let's check it against a real convolution directly." ] }, { "cell_type": "code", "execution_count": 3, "id": "be3f6015", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "max abs difference vs. jax.lax.conv_general_dilated: 4.76837158203125e-07\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# A small synthetic image with a sharp vertical edge (bright on the right half).\n", "size = 12\n", "image = np.zeros((1, 1, size, size), dtype=\"float32\")\n", "image[0, 0, :, size // 2 :] = 1.0\n", "image += np.random.default_rng(0).normal(scale=0.05, size=image.shape).astype(\"float32\")\n", "\n", "# A hand-set vertical-edge (Sobel-x) kernel -- no training involved yet.\n", "sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=\"float32\")\n", "kernel = sobel_x[None, None, :, :] # (out_channels=1, in_channels=1, kh=3, kw=3)\n", "\n", "# Patch-extract by hand, then apply the shared kernel as one matrix product --\n", "# this *is* what conv_block's im2col_adapter + DeepNetworkAdapter do internally.\n", "patcher = im2col_adapter(filter_shape=(3, 3), strides=(1, 1), padding=\"SAME\")\n", "patches, _ = patcher.forward_fn(jnp.asarray(image)) # (1, n_patches, 9)\n", "by_hand = patches @ kernel.reshape(1, -1).T # (1, n_patches, out_channels)\n", "by_hand = spatial_reshape_adapter(size, size).forward_fn(by_hand)[0]\n", "\n", "# Ground truth: jax.lax's real convolution.\n", "reference = jax.lax.conv_general_dilated(\n", " jnp.asarray(image),\n", " jnp.asarray(kernel),\n", " window_strides=(1, 1),\n", " padding=\"SAME\",\n", " dimension_numbers=(\"NCHW\", \"OIHW\", \"NCHW\"),\n", ")\n", "\n", "print(\n", " \"max abs difference vs. jax.lax.conv_general_dilated:\",\n", " float(jnp.max(jnp.abs(by_hand - reference))),\n", ")\n", "\n", "fig, axs = plt.subplots(1, 2, figsize=(7, 3.2))\n", "axs[0].imshow(image[0, 0], cmap=\"gray\")\n", "axs[0].set_title(\"Input image\")\n", "axs[1].imshow(np.asarray(by_hand)[0, 0], cmap=\"RdBu_r\")\n", "axs[1].set_title(\"Patches @ kernel (= real convolution)\")\n", "for ax in axs:\n", " ax.axis(\"off\")" ] }, { "cell_type": "markdown", "id": "81bf6d8b", "metadata": {}, "source": [ "`im2col_adapter`'s patch table, multiplied by the flattened kernel, reproduces `jax.lax.conv_general_dilated` to floating-point precision — the two panels above show the same computation, one done \"by hand\" and one by JAX's own convolution primitive. `conv_block` replaces the hand-written matrix product with a `DeepNetworkAdapter` wrapping a trainable `conv_patch_network` (plus a GELU activation and a pooling step), so the kernel above becomes *learned* rather than hand-set — everything else about the wiring stays identical." ] }, { "cell_type": "code", "execution_count": 4, "id": "735a9409", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "conv_block parts: ['EquinoxAdapter', 'DeepNetworkAdapter', 'EquinoxAdapter', 'EquinoxAdapter', 'EquinoxAdapter']\n", "output shape (channels, height, width): (4, 6, 6)\n" ] }, { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "deep-network\n", "\n", "\n", "\n", "layer_0\n", "\n", "Prediction Layer (X)\n", "(9 units)\n", "\n", "\n", "\n", "layer_1\n", "\n", "Outcome Layer (Y) \n", "(4 units)\n", "\n", "\n", "\n", "layer_0->layer_1\n", "\n", "\n", "linear\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "part, out_shape = conv_block(\n", " in_channels=1,\n", " out_channels=4,\n", " in_height=size,\n", " in_width=size,\n", " filter_shape=(3, 3),\n", " padding=\"SAME\",\n", " pool_kind=\"max\",\n", " key=jax.random.key(0),\n", ")\n", "print(\"conv_block parts:\", [type(p).__name__ for p in part.parts])\n", "print(\"output shape (channels, height, width):\", out_shape)\n", "\n", "# The one learned piece is a plain DeepNetwork -- the same class used for any\n", "# fully-connected layer in this library.\n", "kernel_net = part.parts[1].net\n", "plot_deep_network(kernel_net, view=False)" ] }, { "cell_type": "markdown", "id": "d4449188", "metadata": {}, "source": [ "Two layers: the top one holds the flattened patch (`in_channels·k_h·k_w` nodes), the bottom one the output feature map (`out_channels` nodes), and small enough that training it costs about as much as training any other 2-layer `DeepNetwork`, no matter how large the image it gets applied to." ] }, { "cell_type": "markdown", "id": "dcffc888", "metadata": {}, "source": [ "## A reusable training recipe\n", "\n", "Every example below follows the same shape: stack one or more `conv_block`s, flatten the final feature map, and finish with a small `DeepNetwork` classifier whose bottom layer is `kind=\"categorical\"` (a softmax over the class logits for which the prediction error is exactly the cross-entropy gradient).\n", "\n", "```{hint}\n", "`PARITY`/`PARITY_LEAF` are the backprop-parity settings we use to recover the backpropagaion gradient: high, effectively-fixed precision and no volatility parent.\n", "```" ] }, { "cell_type": "code", "execution_count": 5, "id": "e845d0de", "metadata": {}, "outputs": [], "source": [ "PARITY = dict(volatility_parent=False, precision=1e4, expected_precision=1e4)\n", "PARITY_LEAF = dict(volatility_parent=False)\n", "\n", "\n", "def build_conv_classifier(\n", " conv_channels,\n", " in_channels,\n", " in_hw,\n", " n_classes,\n", " hidden=32,\n", " lr=1e-3,\n", " pool_kind=\"max\",\n", " key=None,\n", "):\n", " \"\"\"Build one conv_block per entry in ``conv_channels``, then a classifier.\n", "\n", " Returns the fused pipeline and the ``(channels, height, width)`` of the\n", " feature map reaching the classifier.\n", " \"\"\"\n", " key = jax.random.key(0) if key is None else key\n", " keys = list(jax.random.split(key, len(conv_channels) + 1))\n", "\n", " parts, c, h, w = [], in_channels, in_hw, in_hw\n", " for out_c, k in zip(conv_channels, keys[:-1]):\n", " block, (c, h, w) = conv_block(\n", " c,\n", " out_c,\n", " h,\n", " w,\n", " filter_shape=(3, 3),\n", " padding=\"SAME\",\n", " pool_kind=pool_kind,\n", " optimiser=optax.adam(lr),\n", " key=k,\n", " leaf_kwargs=PARITY_LEAF,\n", " layer_kwargs=PARITY,\n", " )\n", " parts.append(block)\n", "\n", " classifier_net = (\n", " DeepNetwork()\n", " .add_layer(\n", " size=n_classes, kind=\"categorical\", add_constant_input=False, **PARITY_LEAF\n", " )\n", " .add_layer(\n", " size=hidden, add_constant_input=False, coupling_fn=jax.nn.gelu, **PARITY\n", " )\n", " .add_layer(size=c * h * w, add_constant_input=False, **PARITY)\n", " ).weight_initialisation(\"he\", key=keys[-1])\n", " classifier = DeepNetworkAdapter(\n", " classifier_net,\n", " optimiser=optax.adam(lr),\n", " learning_kind=\"precision_weighted\",\n", " )\n", " parts += [flatten_adapter(c, h, w), classifier]\n", "\n", " fused = FusedPipeline(\n", " PCSequential(parts),\n", " error_fn=lambda probs, ids: probs - jax.nn.one_hot(ids, n_classes),\n", " )\n", " return fused, (c, h, w)\n", "\n", "\n", "def split(images, labels, train_fraction=0.8):\n", " \"\"\"Cut a dataset into a training and a test part.\n", "\n", " Returns them in the same ``(train, test)`` order as ``load_cifar10`` below.\n", " \"\"\"\n", " n = int(train_fraction * len(images))\n", " return images[:n], labels[:n], images[n:], labels[n:]\n", "\n", "\n", "def show_examples(images, labels, class_names):\n", " \"\"\"Draw the first six images of a dataset above their class names.\n", "\n", " One channel is drawn grey, three as RGB.\n", " \"\"\"\n", " _, axs = plt.subplots(1, 6, figsize=(10, 2))\n", " for ax, image, label in zip(axs, images, labels):\n", " if image.shape[0] == 1:\n", " ax.imshow(image[0], cmap=\"gray\")\n", " else:\n", " ax.imshow(np.clip(image.transpose(1, 2, 0), 0, 1))\n", " ax.set_title(class_names[label], fontsize=9)\n", " ax.axis(\"off\")\n", "\n", "\n", "def evaluate(fused, images, labels, batch=500):\n", " \"\"\"Return the accuracy over a dataset, predicting it in batches.\"\"\"\n", " hits = [\n", " np.asarray(fused.predict(jnp.asarray(images[s : s + batch]))).argmax(-1)\n", " == labels[s : s + batch]\n", " for s in range(0, len(images), batch)\n", " ]\n", " return float(np.mean(np.concatenate(hits)))\n", "\n", "\n", "def train_classifier(\n", " fused, X_tr, y_tr, X_te, y_te, epochs, batch_size, seed=0, log_every=1\n", "):\n", " \"\"\"Train for ``epochs`` passes, reporting loss and accuracy after each.\n", "\n", " Accuracy on the training rows is collected from the same forward pass that\n", " drives learning; accuracy on the test rows is measured separately after\n", " every epoch.\n", " \"\"\"\n", " rng = np.random.default_rng(seed)\n", " history = {\"train_loss\": [], \"train_acc\": [], \"test_acc\": []}\n", " for epoch in range(epochs):\n", " order = rng.permutation(len(X_tr))\n", " losses, accuracies = [], []\n", " # Every batch is full-size, so the epoch means below are unweighted.\n", " for start in range(0, len(order) - batch_size + 1, batch_size):\n", " batch = order[start : start + batch_size]\n", " labels = y_tr[batch]\n", " probs, _ = fused.step(jnp.asarray(X_tr[batch]), jnp.asarray(labels))\n", " probs = np.asarray(probs)\n", " p_true = probs[np.arange(len(labels)), labels]\n", " losses.append(-np.mean(np.log(np.clip(p_true, 1e-7, 1.0))))\n", " accuracies.append(np.mean(probs.argmax(-1) == labels))\n", " history[\"train_loss\"].append(float(np.mean(losses)))\n", " history[\"train_acc\"].append(float(np.mean(accuracies)))\n", " history[\"test_acc\"].append(evaluate(fused, X_te, y_te))\n", " if epoch % log_every == 0 or epoch == epochs - 1:\n", " print(\n", " f\"epoch {epoch:3d} | train loss {history['train_loss'][-1]:.3f} \"\n", " f\"acc {history['train_acc'][-1]:.3f} | \"\n", " f\"test acc {history['test_acc'][-1]:.3f}\"\n", " )\n", " return history\n", "\n", "\n", "def plot_history(history, title):\n", " \"\"\"Plot the training loss, and the training and test accuracy, per epoch.\"\"\"\n", " deep = sns.color_palette(\"deep\")\n", " _, axs = plt.subplots(1, 2, figsize=(12, 4))\n", "\n", " # Only the training rows have a loss recorded, so this panel carries one line.\n", " axs[0].plot(history[\"train_loss\"], alpha=0.8, color=deep[0])\n", " axs[0].set(xlabel=\"Epoch\", ylabel=\"Cross-entropy\", title=f\"{title} — Loss\")\n", " axs[0].grid(linestyle=\"--\")\n", "\n", " axs[1].plot(history[\"train_acc\"], label=\"Train\", alpha=0.8, color=deep[0])\n", " axs[1].plot(history[\"test_acc\"], label=\"Test\", alpha=0.8, color=deep[3])\n", " axs[1].set(xlabel=\"Epoch\", ylabel=\"Accuracy\", title=f\"{title} — Accuracy\")\n", " axs[1].legend()\n", " axs[1].grid(linestyle=\"--\")\n", "\n", " sns.despine()" ] }, { "cell_type": "markdown", "id": "e1e9a1b2", "metadata": {}, "source": [ "## Toy example 1: horizontal vs. vertical stripes\n", "\n", "The simplest possible spatial-pattern task: single-channel $16\\times 16$ images containing either horizontal or vertical stripes, buried in noise. One `conv_block` (1 input channel → 4 feature maps) followed by the classifier above is enough." ] }, { "cell_type": "code", "execution_count": 6, "id": "218b7c98", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train: 480 test: 120\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/MAAADFCAYAAAAYN6KOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAMAtJREFUeJzt3Ql8ldWd//EHSMKSEAgQlgQIS1iygAEEJAWUpSqLUFG0uOCC2o7tlNGOtThM1ZGO1laK1kK1U4GxI4ooiJRdVkUE2Q07hH1fsgJJgPt//e5rbhrSwP06PdX/A5/368VLkvvl5Hrvueec3/Oc50mlQCAQ8AAAAAAAgG9U/rafAAAAAAAA+Hoo5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZj3qVOnTnl33nmnd+bMmW/7qQCX+Pjjj71f/vKXvCr4/84zzzzjffLJJ9/208Df4ciRI8G5r6Sk5Jp5HZnv/eGDDz7wXn75Ze9awnzvD0899ZS3fPly71ryzDU031PM+3RCtjZs4iguLnby3HBtczkhb9u27ZqbNOCPCXnRokVedna2k7bw7SgoKAjOfRcuXLhmimXme3/YsmWLt2LFimuqWGa+94cFCxZ4e/fuvaaK5UXX0HxPMf8Pcvz48eDi4Ny5c6Xfq169uvf973/fi4yM/Ef9WCCsGTNmeC+99NIl32vTpo1344038urhW/X00097S5YsueR73/3ud72WLVt+a88JV79vcm6uaG0AXM43OTdXtDYALuebnJsrWhvgryjm/0EKCwuDZw/Onz9/yYLBJnGKeXybtm7d6n366aeXfK9169Ze9+7dv7XnBBg7yr9nz55LXoxevXp5zZo14wXCP8w3OTdXtDYALuebnJsrWhsAl/NNzs0VrQ3wVxFl/n5NX0vSp08f79Zbb72k49hRyt/97nfBr21L38SJE70vvvjCi4mJCR7F79q1a+k1fD/+8Y+DRzT/+7//29uxY4eXn58ffOz+++/3qlSp4j3wwAPed77zHe+xxx4LZmrUqBF83Cb0yZMne6tWrfJiY2OD7SQlJQWvBxw2bFgwU61aNS81NTX4mGVwbTh06JA3cuRI709/+tMl7/t//Md/BCd464Oh3H/91395u3fvDh4l/dGPfuTVqVMn+JgtGnft2uVlZGR4f/nLX7xAIOAtXrzYO3HiRHDxat58803vs88+8zZu3Oj927/9W+nPOXz4cGm79u8ff/zx4GLXjo6+/vrrwUzdunWDA3roueDa8OGHH3obNmzwnn/++Uu2Pz/88MPer3/96+AYZpYtW+Z99NFHXm5ubnBBauNgpUqVSsfdfv36eZs3b/bWrFkT7OPW137/+997s2bNCvbx//zP/wxu5bPx2f6EWLu2/TQnJ8cbOnSod/PNNwe/b2Pwl19+6VWuXDn4HO677z7vuuuu+8ZfH/zjHThwIDh32n8zMzO9ESNGBN/30Lb0CRMmeF999ZXXqFEj76GHHvJatWp12fna5vkf/vCHpXPzH/7wB2/hwoWX/Lzo6Ojgz1Pbt8/BW2+99TfP75//+Z//Zm1gaw/m+6tHaP1o68bhw4d7N9xwQ+ljNt5ZPzt69GhwbLJ+Z2u8iubrpk2bBsfBsnOz9ZuzZ89e8vNs/LO1pdp+p06d/ub5rVy50vuf//mfv1kb2M9mvr86WL0xfvz44Bxp49YTTzzh1atX75J53cY9m6NtTLrttttKHys/Xz/yyCPBPhqam9evX++NGTPmb37ms88+67Vr105u3w4olX9+48aNq3BtwHz/V5yZ9zyvZs2a3m9+85syL4vnjR07trTgvnjxote3b9/gAGmDnnWyAQMGeHPmzLnkGr7vfe97wSLqjjvuCD5u7O9W6NhWqfLXvdlA2rt372AHtcG7YcOG3u233x78eTbJ27+zP7fcckuwc9ti2OV1gvj/W0JCgpeVleVNnTq19HsnT54MXj9n/cnYwNq+fXvv2LFjwb5kRy47duxYejDJruF78cUXg/27Q4cOwX5sE3xiYmJp/7KzUuWve7NFakpKSnDi79mzZ/C6IxtYTfPmzUv/rf3sf//3fw8eYMC1o23btsF+ZVuGQ95//31v7dq1wQWoefXVV4N9xMY1K2ZCBVPZa/jscZukbWK3vhkXFxc8SGrfty18FV339sorrwTHWhu3LWtj9fz584OP9ejRI/hvbdyNiooK9l076ICrjx3EqV+/vtelS5fgGPTb3/42+P2ioqJgv5g9e3awP9hYaGPfunXrLjtfW3FUdm7u3Llz6Rhnfw4ePFh6Vkhtf8iQIRU+v4rWBsz3V4+lS5cGiw8rmO0AkG2RD41fdtDc+pb1M1vPTZs2LdiHQrs0ys/XdgKo/Nwc6jf2p3///t7cuXNL14Vq+xU9vyZNmlS4NmC+v3r8/Oc/D45jN910U/DgTdlietSoUcETQTa3JycnBw/Ml71XQ/n52g6Wl52brS4qO2Zaf7J52fqY2v4999xT4fPr1q1bhWsD5vsyAgjs2bMnUKVKleB/zaFDhwIRERGBLVu2BL+eMmVKICkpKXDu3LnSV+uPf/xj4IYbbgj+fceOHQF7KRcuXFj6eHZ2dvB7+fn5pd/bv39/8HunT58Ofv32228HGjRocEnm1KlTgYsXL/7Nu3LhwoVAmzZtAvPmzauwLVydXn755UBmZmbp16+++mogIyOj9OvBgwcHRo4cecm/6dOnT2DcuHHBv7/wwguBhISEQFFRUenjL774YmDAgAGX/Jtf//rXgVtuuaX0a3t8xIgRl2ROnjxZ4XNcs2ZNIC4u7rJt4erUpUuXwNixY0u/7tGjR2DMmDHBv+fm5gaqV68eWL58eenjx44dC0RFRQX27dsX/Pq6664L/PCHP7ykzU6dOgUmTpx4yfe6du0aHG9NTk5OoGrVqoE5c+ZckrFxsyKjRo0KPProoxW2BX8KzbcrVqy4ZMzp3bt38O9/+tOfAomJiZfM1w888EBg0KBBl52vrzSfjh8/PtC6devA8ePHv1b7l3t+Fa0NymO+9yebb1u0aBEoKSm5ZEx78803g3//7ne/G/jxj39c+pj1gbp16wbeeeedy87Xl5tPi4uLA3379g08/vjjpd9T2r/S86tobVAe870/2Xz75JNPln4dGods7jxx4kSw5lmyZEnp4x9//HFwrg2NUxXN15ebT7du3RqsbUL1itr+5Z7f5dYG5Y26hud7ttl7XvAIkx0Jsi10v/jFL4Jn4O1ouh1BMralxLa933vvvZfc/dbOmpZl/+brsCP5duTVtu2H2NGnkM8//zx4ZNW2O9uRVtuqamdKce2wLXW2zXj79u3BrUV2qYcd0Qyxvhn6VU0hdsfSsn3Tdn3YWcqv2zft6H1Zoa371henTJkS7J/2ObCvT58+HfxTtv/i6mZbi23Lnu3YsHHJ7uL8zjvvlJ4BsrOddjaybD+yM5D2mB21/7+MmbYTxc4y2Vn8skL9zi45mTRpUvDzYmdI7bPApUlXp7KXT9juDxuLQruK7ExO1apVSx+3+b387iGl782cOdN74YUXgtcRh7ajqu1f7vldDvP91SEtLc2LiIi4bN/8wQ9+UPqYrf2uv/56b9OmTaWXWajztV22YWc9Q5eCqu1f6flVhPn+6lF+TDL23tslGXYJZtl7M9iYZruQbC613Z7qmGnrUdsub1vgQ5e/2e4Spf3LPb/LrSuZ7/+KYr7MwtQKedsOZ4vBn/70p6Uvkm23ty3P5a8LDl2fF/J1b55j20RtwXm5a65sO9WTTz4Z3G5l1zxZp7eb5+DaYQOabWmyPnn33XcHixnbilS2b9qlH2UHSeunoWuWzf/lpk5X6pt2Pahd9mEHFeLj44OXj9h10dY3KeavHbY4tELettbbtXBWYDdu3Li0X9p1ceVvKmZ9Mz09/e8aM21LqfW58kW6HTywxYZdbmL3cbCFrG3ds2s+cfUpP//aYtFYgVN+nrSvyx40V/qe3R/Hrgu17fQtWrQo/b7a/uWeX0WY768e5d/3r9s3lTHRDvDbvR5sm3PZn6e0f6XnVxHm+6vH5d576zc2r9pv2Ahtiw/1o6/TN23NaJcRWT314IMPln5fbf/r9E3m+0txzfz/suvb7HrkX/3qV97+/fuDhVOIHWXauXNn8CYOtji1P3bE6UoDYK1atYL/zcvLu2zGijS7mZgtGkJs4WDXzNu1T3b03w4w2E2c7Ojqvn37LtsWrl42MNpuEbsZ3eDBg4M3nQuxgdPOdNq1RaG+addgVjQolu2bV+qXoT5v93IIXXtvZ0PnzZsX/LudpbIb89kkb58TO7qKa4/1I7vHh92g8e23375kx4jtarICyMbUUL+0P9ZX7ADQ/7VvWt+2dm2cDrHx2q6Lt2v3bBeT9Vv7zNhzY8y89tjBHCty7GxQaNFnN6IrewPFcGy+t2vqbSeUzb0u269obcB8f22wvmPjZejeDHYg1K4Ntu+r3njjjeCOTbsBqF3T7rL9isZf5vurn83Xds273fgzxG56aHeqL3sg80psjWj3MbGz7HZS1HX75fsm8/2lODP/v2xQtMJk9OjRweLZzgCF2JlP22pnxbXd8MsKJdtWeqWbftkZSjtbakW/dWS7Y62dYS/L2rUbQNgZLfsA2KKgQYMGwULKFqJ2oyf7mdaJ7ShsaNsJri1WqNvWObt7st3Jsyzrl7YV3wZF61+2xcnOiIa2O1fEFp0/+9nPgn3Tzm7aHWvLs7591113BW9UYu1a/7OzAcb6st3I5L333gsWa+UXFLh2WNFs45WNUXagqewRfOsftovE+pedsbeDTjYmhrZ7Xq6vW9+zYsl+g4fdsbYsa9fuuGxn+O1uzLZjyrba2Q3HrK/amGoHXe2P7WKxBQSuLbYr4yc/+Ulwl4b1B7s7sl3WYQfGVfabO2wctWLe/pS9m/3f235FawPm+2uDzdc2xoVuAmaFtt2lvuzd7q/Ebjhqc6/dvK7szURDd7P/e9uvaG3AfH/1s0uGbJyzS4ltl50V5nYjOrv5ctlLMq7EDmjaDe8GDRp0yWWfobvZ/73tl18b2N+Z7/+qkl04X+bra5r9Chkb/OxuoGW3KYfYNcF27ZG9ZFZ8hwp+2y5id7a3s/tlz4jadfZ2HZwNwNaZbcK3X+Vgi96y21XscdsKatck2/VSoV/dZD/PztpbZ7dOa2ef7KyWXTtthX9FbeHqZP3IihY7W2TXHZdndxi1yzDsgE/ogJOxhab1IzsoVJbd/d6O2oe2RdnZTfte+d9na//eBl1r0wqnEPtZdmbKiiXrs1ZYWTtW2NtjFbWFq4/tIpo+fXqw39n9P8qzMdCu47Rr8uxazdC18sZ+RY2NZaG734fY/R7szKgtJq1wsl+laHdULvv7bG27no2ZNvbaHW7L/uYRu3bf+rxdf2djtX02rB1TUVvwl4rmW9uBYeNO2Xsp2PfsgE75MbGif19+PrUdc/Yrusqy65htofp/ab/88yu/NrDPAfO9/1U039quC7vfQug30Nh2Yxu7bEy0S45ClyZd7t+XnU9D/bQ8+5W0oZNFX7f98s+v/NogNKcz3/tb+fnW5korrO1gfGjru535tvslWQ1i/ansSc2K5uuy86nN2fbr6cqz3yhjv9Xj67Zf0fMrvzZgvv8rinkAAAAAAHyGa+YBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn4lQg88//7yUy8zMlHJxcXFOf2737t3DZu6//36prZycHCn3/vvvS7kXXnhByn3++edS7ty5c1Ju6tSpUi4vL0/KPfroo1IuJiYmbOaNN96Q2powYULYTO/evaW2Ro8eHTZTubJ2fOuf/umfpFxGRoaUGzRokJRbvXq159LmzZudPr/Y2FgpN2vWrLCZ9PR0qa22bdtKufj4eCm3ZMkSKffss89e8fEHH3xQaqdXr15SrkWLFs5eW3Pq1CkpN2bMGCk3f/58KbdmzZqwmQMHDjj9HO7Zs0fKHTx4UMqpz+9f//Vfpdzs2bOl3LJly6Tchx9+eMXHGzZsKLXzxBNPSLnx48dLucaNG0u5yMhIZ2ONOr9Vr17d2XMzJSUlUi4qKkrKzZw5U8oNGzZMyn322WdS7siRI876yUsvvRQ289xzzzkbv5o1aya1FQgEpFxWVpaUU9cR6ns6cOBAKVdYWCjlVq5cKeVSU1Ol3HXXXRc285e//EVq66677nI6Bh89elTKzZgx44qPd+7cWWrn4sWLUk5d36jjiDoupaWlSblFixZJuZSUlLCZgoICqa0ePXpIuVdeeUXKJSQkSLkqVapIuS5duki5xYsXS7kBAwY4W0dwZh4AAAAAAJ+hmAcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfiVCD+/fvl3Lp6elS7pNPPpFyvXv3lnKHDx8Om1mxYoXUVq1ataTc5s2bpdxzzz0n5apUqSLlcnNzpdyBAwekXEpKipRLTEyUcnv37g2bqVevnudKy5YtpVz9+vXDZtauXSu11bdvXyl38OBBKdeuXTspd+zYMSn37rvvOv3/iI+Pl3IlJSVS7uLFi2Ez8+bNk9q65557pNz7778v5dQ+EM6hQ4ekXGRkpJTbvXu305+rjjerV6+WcpUqVZJyZ86cCZtp3bq109dEHbuWLl0q5WrXri3ltm/fLuWSk5Ol3MyZMz0XHnvsMadj68iRI532uVatWjn7nLZv395zqVGjRlJuw4YNUi4tLU3KjR07VsqdP39eyu3Zs8fZmD5w4EDPlY4dO0q55s2bh83MmjVLauupp56ScpMmTZJylStr58lGjx4t5fLy8qRcnTp1nI3BX2e9sXLlyrCZZ555RmqrQYMGUq6oqEjKLViwwHPhgw8+kHJHjx6Vcvn5+VJu+fLlUq5Lly5Sbs2aNVJu+PDhUi4uLs5ZzaLO+7/4xS+kXFZWltOaT+1z6vyakZHhucKZeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPCZCDVYubJW92dnZ0u5Bg0aSLnNmzdLufXr14fNPPjgg1Jbhw8flnItW7aUcvv375dygUBAyuXk5Ei53r17S7kPPvhAyqWnp0u55OTksJmmTZt6rhQXF0u57du3h80UFhZKba1atUrKpaWlSbmFCxdKua5du0q5cePGSblPP/1UynXp0kXK7d69W8rVrVs3bOb8+fNSWzNnzpRyZ8+elXIbNmzwXEhMTJRyBQUFUi41NdVpX1LHdHU87NSp0zf6+prhw4dLuQULFki51q1bS7lt27ZJudjYWKdjv/r8whk5cqSUmzx5stPxQR1flTmuTZs2UlsRERFO36t9+/ZJufj4eCkXHR0t5TZt2iTlqlWr5vT/t169emEza9ascTZGtG3b1tka8qGHHpLa+sMf/iDlOnbsKOWmTp0q5YYMGSLlxo8fL+UGDRok5RISEqRcUlKSs/FLXWvUrFnT6bpPfY1drW1KSkqk3Lp166Tcz3/+cyk3Z84cKff0009LuT/+8Y/O3ge19lLXre3bt5dyrVq1knK5ublS7uGHH5ZyEydOdDofKjgzDwAAAACAz1DMAwAAAADgMxTzAAAAAAD4DMU8AAAAAAA+QzEPAAAAAIDPUMwDAAAAAOAzFPMAAAAAAPgMxTwAAAAAAD5DMQ8AAAAAgM9EqMG6detKuTNnzki57OxsKZeXlyfl0tLSwmaaNm3qubR69Wop94Mf/EDKHT9+XMpFRUVJuerVq0u5jIwMp31Acfr0aWdtqX1u9+7dYTPnzp2T2oqPj5dyPXr0kHKNGzeWchER2ke2W7duTt/TTZs2STn1M6a25/K1i4mJkXKpqameC+prq+by8/OdtpecnCzlKlfWjvnOnDlTyu3atStspnbt2lJby5Ytk3KRkZGeS82bN3c6fxUUFEi5U6dOeS786Ec/knLFxcVSbsKECU7nms2bN3uudO7cWcodPXpUysXFxTmbb0xmZqbT9tS+mZOT4yx34sQJqa3ly5eHzUycOFFqq7CwMGymQ4cOUlvbt2+XcrNnz5Zyffv2lXL333+/lKtXr56Ue+ONN6TcBx98IOXuvvtu75te86nravU9a9++vZTr3r37FR+fP3++1M7SpUul3MGDB52+p+raa8aMGU7Xmsr4oH5u1LFr7969TufVffv2Sblt27Y5nafV92LRokVhM5yZBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGci1GB8fLyU27Nnj5QbMWKElPvtb38r5bZv3x42M3fuXKmt8+fPS7mMjAwpN3PmTCn3ve99T8p16NBByk2ePFnKnTlzRso1a9ZMytWpUyds5qWXXvJcOXDggJSrWbNm2Ezbtm2lturXry/ljhw5IuUGDx4s5VasWCHlGjRoIOUqVark9PO/efNmKVdUVBQ28/nnn0ttDR06VMqlpqZKuV/96leeC/v27ZNy3/nOd6Tc+vXrnf5c9XNz3333Sbm4uDgpV1BQEDazc+dOqa1Tp05JuSZNmki5rKwsKRcbG+t0nKhVq5azsVVRWFgo5Ro1aiTlevToIeWWL18u5W655ZawmW3btkltRUVFSbkTJ044HVtLSkqk3O7du6VcXl6elNuwYYOUO3v2rLO+vnXrVs8VdRxRfqb6vNQ137Bhw6Tc2LFjpdyAAQOk3KFDh6Rcz549pVzr1q2d9iVlblLX/OqaJDs72+kYHM7atWulXN++faVc3bp1pdycOXOcvldpaWlO2+vUqZOzMa5NmzZSbvHixVKuYcOGUm7dunVS7rXXXpNy9957r9OaSsGZeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHwmQg1u3LhRyj377LNSbseOHVLuxIkTUq5du3ZhM+fOnZPaKiwslHL79++Xck2aNJFygUDA6Wu3bds2KVejRg0pt3btWinXpk2bsJkuXbp4rjRu3FjKjRo1ytl7qr4Hx44dk3IXLlyQclWqVJFy0dHRUi4rK0vKtW/fXsr17t1byq1YsSJspm3btlJbZ8+elXKTJk2Sch07dvRciIjQhtfExEQpFxMTI+VWrVol5apVqybl9u7d67S9WbNmhc0kJydLbXXu3NlZfzNJSUlS7siRI1Juy5YtUq5Hjx5Ox+pwnnrqKSlXubJ2vP+rr76Scg0bNnSW+/73vy+1debMGSnXtWtXKde6dWspt3TpUilXq1YtKde8eXMpd/r0aSmXm5sr5ZYvXx42M2XKFM+VOnXqSLmBAweGzRw4cEBq66677pJyR48elXITJ06Ucs2aNZNyhw4dcrqOiIyMlHJxcXFS7uGHH/7G16MvvPCCs/Woy9pG/f9U+5I6Linr26/z3qempjpba6alpTl97e655x4pV69ePafriO3btzvtcxkZGZ4rnJkHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyLUYOXKWt2fnZ0t5QoLC6VctWrVpNzevXvDZh544AGprZkzZ0q55ORkp69dTEyMlEtMTJRy+fn5Um7YsGFS7vTp01Kudu3aYTNffPGF58pXX30l5TZt2hQ2c/3110tt7dq1y3OpoKBAytWsWVPKnTt3TsqdPXtWyqWlpUm59evXS7kLFy6EzaSmpnouPfroo1Juy5YtTn7exo0bpVyNGjWk3JdffinlqlevLuUaNmwo5Ro3buy0j+zevTtsZv78+VJbq1atknIJCQlS7v3335dy0dHRUq5du3bO5i91DHM5li9atEjK9e/fX8rFxsY67cOKrKwsKde+fXspV1RUJOUyMzOdfr7UPpKbmyvlBgwY4Kyv7Ny5U2qrb9++YTMPPvig1NaECRPCZrp37+50Po+Pj3e65tuxY4fTNY463qifrzp16jh7X9XPjbpuVddC6mvXqlUrJ/NbXl6elFNfj+PHj0u5JUuWSLn09HQp16JFCylXqVKlsJmcnByn86o673fq1EnKnTp1SsoNHTrU6TqiW7duniucmQcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnItRgRkaGlCspKZFy8fHxUi4vL0/KJSUlhc2sXLlSamvVqlVS7sSJE1KucePGUu7ixYtSLioqSsrdfPPNUm7x4sVSLj09XcrFxsaGzdx4442eK/n5+VLu+PHjYTOFhYVSWzVr1pRyaWlpUm7mzJlO34MdO3ZIudq1azv9HJ4+fdrZe5aYmCi11bRpUyl39OhRKTdjxgwpN3z48Cs+npmZKbWzfv16KXf+/Hkpt3//filXq1YtKVe1alUpt3v3bim3YsWKsJmUlBSn/U3tv9HR0VJu165dTt+zXr16Sbnp06d7LowePdrp3BUIBJz2pYMHD4bNZGdney5NnTpVynXo0EHKffbZZ1LuhhtucPq5Vl/jI0eOSLmlS5eGzfTp08dzpV27ds5yxcXFztYsZty4cVKuY8eOUu7QoUNSLjIy0tka5+uMh+qc+dprr4XNFBUVSW0lJyc7XYOp6+Xbb7/9io/fcccdUjvqukWlznFr1qyRcu3bt5dyPXv2lHLvvfde2ExOTo7TsVWtM2eIa7m4uDin6/QqVao4XadPnjw5bIYz8wAAAAAA+AzFPAAAAAAAPkMxDwAAAACAz1DMAwAAAADgMxTzAAAAAAD4DMU8AAAAAAA+QzEPAAAAAIDPUMwDAAAAAOAzFPMAAAAAAPhMhBrcvHmzlPvJT34i5ebPny/ldu/eLeVKSkrCZoYMGSK1dfr0ac+lDz/8UMq1bdtWyhUUFEi57OxsKdeyZUspFwgEnOXU56bo06ePlMvPz3fWLzMyMqTc9u3bpdydd94p5davXy/lOnbs6PTzFRkZKeUyMzOl3PTp08NmXn/9damtmJgYKXfPPfdIuVWrVnku7NixQ8rdeuutUm7//v1SrmHDhlKuatWqUq5evXpSbt26dVIuPT09bCYhIcHp52b27NlS7sSJE1IuLS1Nyql9WO0Dx44d81zIy8uTckeOHJFyGzZskHLq+5qamho2k5KS4nS+vHjxopT75JNPpFxxcbGUO3XqlLPPzdcZv959910pd/bs2bCZc+fOSW0999xzYTP9+vWT2oqKigqbeeaZZ6S2Ro4cKeVycnKcjq3K/4OJjo6WcsuXL5dyjRs3lnILFy6UciNGjHC2dpk2bZqUGzVqlJSrX7++54IyJpkzZ844XU/37NnT6Zz04osvSrmICK08VD77ycnJUltJSUlSbu/evVIuMTFRynXp0kXKTZ061el7oX6uFZyZBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGci1GBRUZGU27Ztm5Rr27atlOvatauUS05O9ly56aabpNyoUaOkXJMmTaRcYWGhlMvJyZFyNWvWlHInT56Ucg888ICU27x5c9jMuXPnPFeOHj0q5fr16xc2k56eLrX1zDPPSLkdO3ZIudjYWKf9fMSIEVLu1ltvddo3o6OjpVyzZs3CZqKiopy1Zb766isp9+WXX3ouxMXFSbmtW7dKuZSUFCm3bNkyKVe1alUpt3HjRinXoEEDZ+NXtWrVpLaeffZZKde7d28p16FDBym3e/duKdepUycpl5CQIOXq1KnjuTBv3jwpt3LlSil34MABKVerVi0pFxERfmnSsGFDqa19+/Y5XeMMHDhQytWrV0/KVa9eXcqVlJRIuRYtWjhdqzVu3NjZz3S5Nrz55pvDZlq3bu10zH/66aedjoXFxcVSLhAISLk777xTyl28eFHKDR48WMrl5+eHzXTs2NHpOrNyZe1c5MGDBz0X+vTp43TN17JlS6dzQ15enpTr1auX0z6n9OEtW7Y4rZVuu+02Kff66687G0tMt27dpFxWVpaUq1GjhucKZ+YBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwmQg1eO7cOSm3YcMGKZeZmSnljhw5IuUqVaoUNpOfny+1derUKSmXk5Mj5TIyMqRcbGyslCsqKpJye/bskXJ169aVctnZ2VIuEAiEzSxbtkxqy9XPM506dQqbmTt3rtRWcXGx0/6r5qKjo6Xco48+KuViYmKkXPXq1aVcSUmJs/bU/9e0tDQpt2bNGim3bds2z4WoqCgpV7NmTSmXm5vrdBxZt26dlIuMjPzGc+rYNWLECCkXEaFNdVWqVJFyt912m5RLTU2VckuWLJFyU6ZMkXLjx4+/4uN//vOfpXY6duwo5WrXru25pIzV+/fvl9rq1auXlJszZ47T91Sdp8eMGSPl7rvvPil34403Srk2bdo4Gw/VtZCiRo0aUm779u1hM8nJyVJb9evXl3IXLlyQclWrVpVycXFxTufV6dOnO50z1T6irIfU+aGgoMDpPD1o0CDPBfXz3KFDB6drPvXzoL5uO3bscPpz4+Pjw2a6d+/udC2vvnaPPPKI0/YSEhKcriNSUlI8VzgzDwAAAACAz1DMAwAAAADgMxTzAAAAAAD4DMU8AAAAAAA+QzEPAAAAAIDPUMwDAAAAAOAzFPMAAAAAAPgMxTwAAAAAAD5DMQ8AAAAAgM9EqMFAICDl6tWrJ+Wio6OlXNWqVaVcnTp1wmYSEhKktpo2bSrlnnrqKSmXnp4u5XJzc6VcamqqlKtWrZrT17igoEDK5efnh81cf/31nispKSnO+qbaz9XXVn3v9+zZI+Vq1aol5T777DMpl5SU5PTnqp+dVatWhc1ERkZKbU2aNEnKPfTQQ1KuV69engvq82/VqpWU27Fjh5SLi4uTcnl5eVLu5ptvlnLHjh2TcrGxsWEza9euldoqLCyUctWrV5dyCxYscPq52b59u5S78847pdySJUs8F6ZMmSLlNm/eLOWWLl0q5Ro1auSsr6ufhzNnzjgd09V1hDLGmRMnTki53bt3S7l33nnH6XuxZcsWZ2sDZQz+5S9/KbU1ePDgsJns7GypLXW8UcfqLl26SLlPP/1Uyh0/ftzpuLR48WKna9Ju3bqFzcTExEhtbdq0ScolJydLuenTp0u52bNnX/Hxn/3sZ07ny+LiYik3a9YsKbdo0SIp9+STT0q5nTt3SrmDBw86mfNNVlaW03V1s2bNpNy0adOk3NNPPy3l5s2bJ+XU8alHjx5hM5yZBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+JUIO1atWScu3atZNyWVlZUu7AgQNSLhAIhM1kZGRIbR06dEjKvfrqq1Luvffek3I33nijlIuI0N62I0eOSLmEhAQpl5mZ6eznvvXWW54rf/7zn6Vc+/btw2Zq1KghtXXy5Ekpd/jwYSnXpk0bKbdt2zYp17VrVylXpUoVKTd8+HApN2HCBCn30EMPhc3k5ORIbd1yyy1SrnXr1lLuzJkzngvnz5+Xcs2bN5dyVatWlXKbNm2ScklJSVJu9erVUq5JkyZSbuvWrc7GmgsXLki5ypW149YpKSlSbsWKFVJu6NChUm7ZsmVSrrCw0HOhd+/eUm7t2rVSrlmzZlKuc+fOUm7u3LlhM+fOnZPa6tmzp5T76KOPpNyJEyekXExMjJQ7deqUlJsyZYqU69atm5TLz8+XcgUFBc7WVoq0tDRna8OOHTtKbcXFxUm5NWvWSLmjR4867SPqmk9dlyQmJkq5Ro0aOXsvsrOznY5xDRo0kHJ169b1XFDnS6UWMRs3bpRyderUkXLqnLlw4UKnfbNVq1bOfqY6T+fm5kq5xYsXS7moqCgpN3PmTKdrv7y8PM8VzswDAAAAAOAzFPMAAAAAAPgMxTwAAAAAAD5DMQ8AAAAAgM9QzAMAAAAA4DMU8wAAAAAA+AzFPAAAAAAAPkMxDwAAAACAz1DMAwAAAADgMxFqsLCwUMqdP39eylWrVk3KNWjQQMpVr149bCY2NlZq6+DBg1Juy5YtUi4zM1PKnT17VsodPXpUyt12221SbtGiRVKuTp06Ui4uLs77Jt17771SrqSkJGymZ8+eUluffPKJ037erl07Kbdr1y4pl5eXJ+WKioqk3Pz58532uffeey9sJj8/X2pr0qRJUq5WrVpS7tSpU54L6vO/cOGClKtcWTv2GhMTI+UaNmwo5aKioqRcQkKCszkiJydHaqtp06ZSrkWLFlLu97//vZSrV6+elGvVqpWUmzFjhpRLSUnxXHjiiSek3LvvvivlUlNTpVz37t2l3JAhQ5z1yz179ki5jIwMKdejRw8pl5ub63Q+LygocLou6d+/v7P1kLo2UEybNk3KffTRR84+L5GRkVIuKytLyql98/Tp007fq1dffVXKdezY0elnYu3atc7G9MTERClXo0YNKVepUiXPhX/5l39xts40/fr1k3LNmzd3VgOZTZs2Oa2DlLWmWgM1a9bM6XvfUFzjrFy5Uso99thjTutlddxRcGYeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn4lQg3FxcVLu8OHDUm7fvn1S7vjx41KuqKgobKZSpUpSW5GRkVKuR48eUm7Tpk1SrmbNmlIuPT1dyi1fvlzKtWnTRsotXrxYyvXs2TNspl+/fp4rCxculHJ333132MzJkyeltrZu3SrlfvrTn0q51157TcqdPn1aym3btk3KDR06VMrVrVtXyu3fv1/KHTx40Nn/67333ivlVq1aJeVatGjhuRAdHS3lVqxYIeWaNm3qubRgwQIpN3r0aCl39uxZKVdSUhI2061bN6f9cvbs2VIuKipKyiUkJEi5tWvXSrkzZ85Iufr163suHDp0SMr17t1byl24cEHK1ahRw9l649NPP3X63B555BEpN3nyZKd9MzMzU8oFAgEpFxMTI+WqVKnibK1WXFzsubJ06VIpl5SU5Oy9nzt3rpRr1KiRlGvWrJmUi42NlXJffvmllOvfv7+Uq169upSbNWuWlCsoKHDW34YMGSLl3nrrLSmXmJjouZCbmyvlGjRoIOV27twp5Tp06CDlpk2bJuXi4+Ol3MCBA5319Y8++sjpPLhkyRIp99xzzzldq7355ptO19V5eXmeK5yZBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKOYBAAAAAPAZinkAAAAAAHyGYh4AAAAAAJ+hmAcAAAAAwGci1OCFCxek3MqVK6XcDTfcIOUKCgqk3IEDB8Jm9u/fL7XVsGFDKbdv3z7PpYSEBCn38ccfS7mTJ09KucjISCnXsmVLKbdu3bqwmUAg4LnSv39/KffFF1+EzaSlpUlt9ejRQ8r95je/kXJPPPGElIuKipJy58+fl3JZWVlOPxPt2rWTcpUqVQqbad68udRWzZo1pVxhYaGUO3z4sOdCjRo1pNwdd9wh5TZu3Oh0zFT7XE5OjpQ7cuSIlEtPTw+byc/Pl9pauHChlKtWrZqUS0pKknIvv/yylPvd734n5QYPHizlnn/+ec+FMWPGSLmYmBgpd+bMGSlXq1YtKXfTTTeFzaxevdrpWLhkyRIpV1xc7Kyfm5deeknKNW7cWMrt3btXyrVu3drZWH327FnPlXHjxkm5lJSUsJm3335baqtbt25SLjU11elYrY6Zx44dk3J9+vSRcq+88oqUGzZsmLM5onJl7dzh448/LuUuXrwo5Ro1aiTlbr/99is+/uGHHzodH9q0aeN0zK9ataqUU+fWXbt2OWuvqKhIauvzzz93ug4eO3aslCspKXE6l7zzzjtSbsuWLVJuzpw5YTOcmQcAAAAAwGco5gEAAAAA8BmKeQAAAAAAfIZiHgAAAAAAn6GYBwAAAADAZyjmAQAAAADwGYp5AAAAAAB8hmIeAAAAAACfoZgHAAAAAMBnKgUCgcC3/SQAAAAAAICOM/MAAAAAAPgMxTwAAAAAAD5DMQ8AAAAAgM9QzAMAAAAA4DMU8wAAAAAA+AzFPAAAAAAAPkMxDwAAAACAz1DMAwAAAADgMxTzAAAAAAB4/vL/AFofVlllPnDmAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def make_stripes(n_samples=600, size=16, period=4, noise=0.35, seed=0):\n", " \"\"\"Draw noisy images of horizontal (label 0) or vertical (label 1) stripes.\"\"\"\n", " rng = np.random.default_rng(seed)\n", " labels = rng.integers(0, 2, size=n_samples) # 0 = horizontal, 1 = vertical\n", " bars = (np.sin(2 * np.pi * np.arange(size) / period) > 0).astype(\"float32\")\n", " horizontal = np.broadcast_to(bars[:, None], (size, size))\n", " vertical = np.broadcast_to(bars[None, :], (size, size))\n", " images = np.where(labels[:, None, None, None] == 0, horizontal, vertical)\n", " images = images + rng.normal(scale=noise, size=images.shape)\n", " return images.astype(\"float32\"), labels.astype(\"int64\")\n", "\n", "\n", "X_stripes, y_stripes = make_stripes()\n", "X_tr_s, y_tr_s, X_te_s, y_te_s = split(X_stripes, y_stripes)\n", "\n", "show_examples(X_stripes, y_stripes, [\"horizontal\", \"vertical\"])\n", "print(f\"train: {len(X_tr_s)} test: {len(X_te_s)}\")" ] }, { "cell_type": "code", "execution_count": 7, "id": "48be0d7c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "feature map before the classifier: (4, 8, 8)\n", "epoch 0 | train loss 0.530 acc 0.815 | test acc 1.000\n", "epoch 2 | train loss 0.029 acc 1.000 | test acc 1.000\n", "epoch 4 | train loss 0.010 acc 1.000 | test acc 1.000\n", "epoch 6 | train loss 0.006 acc 1.000 | test acc 1.000\n", "epoch 7 | train loss 0.005 acc 1.000 | test acc 1.000\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fused_stripes, feature_map = build_conv_classifier(\n", " conv_channels=[4],\n", " in_channels=1,\n", " in_hw=16,\n", " n_classes=2,\n", " hidden=16,\n", " key=jax.random.key(1),\n", ")\n", "print(\"feature map before the classifier:\", feature_map)\n", "\n", "history_stripes = train_classifier(\n", " fused_stripes,\n", " X_tr_s,\n", " y_tr_s,\n", " X_te_s,\n", " y_te_s,\n", " epochs=8,\n", " batch_size=32,\n", " log_every=2,\n", ")\n", "plot_history(history_stripes, \"Stripes\")" ] }, { "cell_type": "markdown", "id": "f31b0b4c", "metadata": {}, "source": [ "## Toy example 2: circles, squares, and crosses\n", "\n", "A step up: three-way classification, three-channel $20\\times 20$ images, and **two** stacked `conv_block`s (with pooling shrinking the spatial size in between) — the same pattern real conv nets use to build up from local edges to whole-object detectors." ] }, { "cell_type": "code", "execution_count": 8, "id": "fcf81609", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train: 720 test: 180\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/MAAADFCAYAAAAYN6KOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPwtJREFUeJzt3QeUFFXe/vFfk4acc5AoDEmykpOCSJBoIKoYQDGAuuoqri/qmjOCYAAMmBAQCSpRkuScJWdmyDlT/3P7/Q9nZK3nsrL77jZ8P+dwFJ6+VT09t2/dW1Xdv0gQBIEBAAAAAICYkeI//QQAAAAAAMA/h8U8AAAAAAAxhsU8AAAAAAAxhsU8AAAAAAAxhsU8AAAAAAAxhsU8AAAAAAAxhsU8AAAAAAAxhsU8AAAAAAAxhsU8AADAJVixYoV17dqV1xD/dT788EP75JNP/tNPA/gHbsx0YycuDYt5AABwxevQoYNt2LDhT70Ou3fvth9++OGKfw3xrzdv3jx76KGH/nT7hQsX2qJFi/6lzwlw3nvvPRs6dOiffjHcmOnGTlyaVJfYHgAAIObdcsstli1btv/00wB+p0CBAtasWTNeFfzXqVGjhqVLl+4//TSueCzmAQDAFa9169ZX/GuA/z758+eP/gH+21SrVu0//RTAlfmLt3379uhnjjZu3GiVK1e2+++/31KlSmXffvutbd261cqWLWvjxo2zYsWKWc+ePaO3jvz8888WBIE1atTod5OE3377LbqtXbt2WYUKFeyBBx6wtGnTejNc2ZYvX26DBw+2vXv3WtWqVa1bt26WOnXqaOb6mes3v/76q1111VXRK0zPPfecffHFF9H+4z6X9MQTT1h8fHz08a5/Pfjgg/bVV19Ft/H888/b0qVLLWXKlFa4cGG74447on06ySOPPGJt2rSxxYsXR2/X69GjR/R98Omnn9rs2bMtffr0dtttt0XP0uLKM2zYMJswYUK0/7ixrnHjxucz11/ffffd6BhavXp1y507d7QvP/PMM9HPyr3zzjv20UcfnX/8999/b6tXr7annnrKjh07Zl26dIn+uzv7X65cuWjfy5gxY/Tf3Njbq1cve+2112zQoEHR8dnd8peQkBDd5rp166xo0aLRNjlz5vwPvDL4b/Tdd9/Z1KlTo/9/zz33RI+1SbfZv/jii9HjuNOuXTv729/+ZqNHj7ZVq1ZF+1nWrFmjfWvZsmXRK6bueB92Nd/1X/d5ZTe25sqVy+6++24rWbLk/+FPilhy6NChaH9ZuXJltA+6426mTJmit9l/9tln1rdv3+jjZs6cacOHD7f27dtH56CRSCTaN9246Y75O3bssHr16kWP42Fcf3aPdePyNddcw1wTkhvv3HzRzR3dmsb1vaTb7HPkyGEdO3aM/v3NN9+0QoUK2cmTJ2369Ol24403Wtu2baNrokmTJtmZM2fszjvvlCcBRo0aZRMnTow+9qabbrKbb76Z344Hn5m/CEuWLLEyZcrYpk2brG7durZ27Vp77LHHopkbdN3B301Iq1SpEl3M9OnTJzpBuPrqq61UqVLRhf+zzz57frB2jzl69Gj0DeEmnUmTVZXhyuYG0Jo1a1qKFCns+uuvt/Xr11v37t3P5+7zdC+//LJde+21liZNmugA6A72bjB03EC6Z8+e848/cuRIND979mz07w0aNLDbb789umB3+3D90B3sk7gTU7feeqtt27Ytum13lcAN0m4B5fbpJrVuwB0zZsz/6euC/7whQ4bYww8/HF1ouzHQLdzdgjxpMeP6hxtDa9euHT2433XXXdH/Ou6zcm6hlJybkM6YMSP6/+5Ek+uX7o8bE92/169fP3ryyjl48GC0H7sTCO4kgZs0uAW8ey5uktqwYcPoxLZixYp24MCB//PXBv993DHVndgsXrx49OSmOynqTgo5I0aMsH379p1/rOtbSRPJli1bRvudW/i7cc6dmHIn9N24+EcOHz5slSpVsmnTpkXnDa4vX3fdddETWcCFEhMTo/NM119q1aplp06dss6dO0czN5b9+OOP5x/r+qtb9LvjvptjupOnP/30U3SB5I7tderUsSlTptgbb7zxhy+0O/Hq9pF07P/ll1+i/z137hy/GPwDNy66+efp06ejfcsdsz/44INoNnfu3OhCP8msWbOic1O3cHfHandRyF2UdCfU3YUmd2x2J0Ddhcs/4uYSbnx2/dqNte6xr7/+Or8VnwBeN954Y9CtW7ff/dvevXuj/33uueeCQoUKBadOnYr+/dChQ0GaNGmCn3766fxjJ0yYEKROnTraZsWKFUFcXFxw8uTJ8/mePXui/1UZrmwzZ84McuTIEZw5c+Yf+saOHTuClClTBsuWLTuf9e/f3612gsOHD0f/7tpOnz79fL527dpofvz48T/cX69evYKHHnro/N9LlSoV9OzZ8/zfhw0bFhQsWPB37QcPHhxUrVr1X/YzIza4vnLPPff84fjYr1+/ID4+Pjh79uz5rGHDhtEx1ZkyZUqQJ0+e37V9+eWXg2bNmv3hvlz/L1KkSDB16tTo312fd/14xowZ5x9z2223/cN47bb3yiuvXPLPitg2e/bs6PF506ZN5//txIkTwdGjR6P/746/8+bNO5+5vjVgwIDzf3fH+0qVKv2uPyf1ddeX3Tib5IUXXghq1679u/0/+eSTQadOnf5NPx1i2SOPPBLUq1fvd/+W1LdGjhwZFC9e/Py/f/XVV9F+nJCQ8LtjtBs7/6i9Gw979Ohx/t/Lli0b9O3b9/zfT58+Hd3+mDFj/g0/GWKdm+sl7y/J+1bHjh2j41qStm3bBjfccMP5v7tjtJufrl69+vy/ufWSWys5bsx0Y6ezcuXK6Fpp69at5x/rxuMMGTL8bu6Lf8Rn5i+Cu63Ynb1PLnv27Of/3519T7rd2V21d2dU3S1OSdxZeXeF1F1xclc83S0m7gqWu8LpMneF0yldunRohiubu6LTpEmT6O31SX3DXalMujvE3Yrnzngmcfk/w11xd1dY3VVNd2bffaNzvnz5fvcYd4U1yYIFC6JX9Tt16nT+39yVT0qMXHncnUfu6mSLFi2iZ+JdP036iIY7Y++uyLu7PZL3TXf2/mK5q/gjR460nTt3Rq8MuDuX3J0pyfv4hX3T3QrtbpFO4vp18jEbVyb3rd7uarz7KFGSuLg42SZ533JzATfuJu/PYf3K9UN3tTV5P9yyZcv5u6WA5FzfcmNncmrMKlKkSPRupKQ7oNyVzgvni3/U/vjx49E5g7t7yl2RT+K24Y7ffNEeknN3z7n54cX0rbAx04237kp7ErdeSlozXTg+u393V+OTuLtF3DF/8+bN5z/+hH/EYv4iuIWSW+CESd4pM2TIcH5gTPqsuxs83Ul+9zlP99mmAQMGRG+pnzNnTvRzUO4zee5WFXfLnspw5XKfRXafb9u/f3+0b3z88cf20ksvRW/Jc33O9TE36CVNMt3gd2H75LfQuccnvx3UnSRo2rRp9CSU66fu+x/c54/D+rn7jLxb7Lvbn5NLfus/rgzu40TugO1OALmFt7vV3S3w3ec9Xd90t7knl7xvXtgvL+ybY8eOjd5q+uijj0a/o8GNqe425Qv794V9000m3G2jyRUsWPBf9jPj8jyW/5Hkfeufae/6oft8/IVjZObMmf+p/ePK8M/2zeT90p2Qch+vu5j2rp17rDsp5T5qksT1U3ebP5CcO4a7dcuf7Zv/7Jjp/lw4ZrrvMuE7bzQ+M38R3JXQ999//3yHdFeH3GeI/4gbHN3nQpI+T+K4tu4zxe7MlLs6774wzB3Q3WD6wgsvRCfC7jPRKsOVLemL59wXLbmz9717944unNxCvHz58tEB0538SeI+T5ec+0ISd6Uoyddff33+/93dJO5zov369Yt+nrlVq1bR74fwvSfc1VF38HdXntyfC68q4MrgrvC4k0zurLn7wiXXF5I+3+k+s+5ODLnPfCbdveG+sCl5v3Tf5eDOuict5JPX6nZf9OROMLn+7u4CcZ99d1cJFHdlyV1hat68+fm+6e4UcBMSXNlcX3LH0+R9cP78+Rd9jHXjnhs7k4+PYd8T4vqhO/Hk9pnUD91dKnwuGWF9y32hrLsDKfnJzIvhToq6OaP78jE3P3XcfDX5lfck7sKQ+4y9O36778hJ6pvuCxopMYYLucW1G8Pc59aTvmPJHceTvtfGx303w4kTJ6Lfr5TE3bHn7lK6kBsf3Z1L7gRCUr9081HXnpOgGpd7L4L7gjt3G6lbqLtb6t3iJ+kL7f7hBU2VKvqN4+7MkjvIuwmku/3JTQDc2VO36Lr33nujX9zkbj1x31LqvhXSXTVyE96wDFc2129cX3ADnfvyOXfSx10Fd//uDBw4MLqQcrfKu4H2wlvkn3zyyWjuFlnu28WT5+72fPdFI27B4/64hZDL/+g2qCTuSr77wj03+LpvwnWTCXcrs/sGfVxZ3LfWunHRLebdHUjuVjl3F4nj7vZwB2TXR9yXM7mx0N0emsT9v/sWXHcl3fUpN8HMmzfv+dy1dbfuuwmBu2Pkjz7+cSF3N5Pr624MdVfz3W2CbhLy+eef/xtfBcQCd/LIVf1wH5t76623olcoXd9wJ5wuhuur7s4o159dn3UnAdwJK3fi6ELuapL74kd3Et99dM6dqHKP79+//7/hJ0Osc8dzd8LdfdzS9S232HHzzou97d31K7c4L1GiRHQbbp4a1tfcHaCu+oyb0yZ9ubMbd5Of5AeSuDtBXd9yd+G5P+44nXxxrriTRO5Ck6uo5C5yuoW6u3P5j05Uuce6ajSu6ocbq93FKzcf5YvA/SLug/MX8Tj8/29ZdleQ3IE8aULpPnvkbot332ybnLti6q6kupfXTXQvPKvkzky5byR1A++FpWpUhiuXu6LjShy525bd5z4v/PyQq37gJo/uzhB3O7IryeX6YVIZLzc5cP3VHcDdCQG3sE/69no3oXVl7dyJJHf1033vg+uDSd/9MH78+OhC391hkpw7ceD6q2vvFk6cPb0yuatA7uSjG+/cwiVLliy/y90B2fVbd9LIHdhd2Rn37cvJr466vuTGSnel3v1J+rZld/LJbdudXHLfOeImvK7/un7sxl7XN5N/LjmJm6CuWbMm+rnSpBNOgOPGOTdWuj7lTjIlfYzNfTeDO3mUVGrOlbBzVzEvHNfc3SFuLE3+WVB30sidZHXfHXHhuOyu0LsrXK5/U2oWStK45eZ/SbfBu7HTHfuT7n5z/c9Vm0n63pzkcwR3PHZ9zo3DrmSY4+ai7sKSO7Yn57bh9ufmCklla4E/4i4kub7ljs1uzHTfS+O4Y3NS2Vgn6e7iCz+y4eaibsx1/dCdrEq6WOS+Gd+tn9xCPolb7Lt9ueO767PJM/wxFvPAZSjpAJ18MQ/8N3Dlki5czAMAAOCfx2fmAQAAAACIMXxmHrgMuVuLhw0bxhfa4L/OzTff/A8fSwIAAMA/j9vsAQAAAACIMdxmDwAAAABAjGExDwAAAABAjGExDwAAAABAjGExDwAAAADA5fpt9pH49jJvnXuKzKfEdZT5qxM/kPmgR/rLfM67b4WH6ZbJtkWOZ5b5xu49ZP7NBy/JfHq33TLPNzCXzJ+RqdmRAzrPlC2lZwvnPHlBHT/8Znj23s+ebX8v0yDY62lvVigSkfm2R68JzaosKSXbLii9UO/8fd13zI578tUyzWt6+7uyHpL5kw3SyPzVkadkPrR6F5l37PGZzBt2Ds8S8o6QbVfsek3mZpV0nFaPKV1f0M03High88kvrpV5CU+/bJVR7//NI6/oB+R4Ssbved46P2ROLfNd8/V746qSFWQ+Pe1QmfeIqxOaLT6ox4Wfrskh85pLZWzbPYPq5mH6PPdtmTPJ/Jv5B/UO6nkG7alZdd4om4yD8ftk3jZ7EZmPqLJZ73+ujq+LFJf5nIPrZZ7ZeoVmh6yQ3rl9p+Mcv8o4/sk4ma9ef1Lmd03Tu9+6SueHwg9XUbtaptXtXzgh85aWR+ZbLCE0W2a3yrbp39fHk809RppPxDNu1ropPJvZ6AHZNt/neh65c5F+bnrEda+PNtE6yPykfSnzr7Lp12bX/kDmvQo1kLll26DzLdeFZwe+tUuRPeMNMt93ZKfMmxXVc52xmdbJPFii51LNI/p4NzanPl5aAb1GGrVkj8xfan+dHlMjx2R+XU09Lix+UM9n9KinlwnZt+mmNXLrfGyizvNW1nnh/DqPHKgt89mpc+oN7F+g88V6vmKm9x8EfT3tuTIPAAAAAEDM4TZ7AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiTCQIguCiHhhpI/NMXXX90OOT0sm8y2Zdj/uWlrq+6WujwmtcTrHSsm2Nz3Th17fy6pfoRKPBMj9rN8r8evMUQfT5WMf33atrky42XVd3nqfCpKpWrSt1m60yXTszCGZ7tmDWMJ2u+VypcXhd4tE/tJBt19o8vW/TtUMPl5WxVV2h8wmevpvedN8t7Nn/6IMF9AO2bdf5jfr1i/s5vGZxS3tctl3rqWm8yG7SJXMz/ijz/fqlNTv4loyDNeG1sC+mXnLFAvEy3yrqtjp7bb9+QMZbdL7hfRmX3ah/tyvajNbb/1W3t3Oi7m9iStm0qul6yLddrWvu/uWMfmqmS/6ap+uZeUoud7LCMp9kus57oRy6887Zs1LmT/fXfTPV17oO/aEtm2T+rqdMfU9Puet3pjQJzW4Y8JNsmzg6l8yXptY/e9VJuqhxusMytumddJ7hC50f1bFNu0PndfWvxkpMzSrzHVfXC80aDckn246qNU3mQeA54F3EuNkjbbbQ7NAJPSZ+c41+351aqjuubm22eYTO27bRA8dw8xTcLv+pzpeV0Xku3XlTHN8q83Oq3Hb2+nrfd6uZolmjbyfIfIJnzE7nKQWeaqbOD+3W8/xIZKLMC+a+U+Y1yuu51NRJWWSe+MZBmdszOk7TupHMU3ydR+Yn7tMHxV4fzg/NlgxqKtsu6ap/9lt6zZD5gLcXyfwaTx36pYXTyzzjdj2fmLq+uswf3fusbl+jmcyDX/3LdK7MAwAAAAAQY1jMAwAAAAAQY1jMAwAAAAAQY1jMAwAAAAAQY1jMAwAAAAAQY1jMAwAAAAAQY1jMAwAAAAAQY1Jd7APfKjxW5o8O8dSY7P2LjCd830Pm143StWWnmKrjN0y2Ld1FxpbKU+KvvqWV+dQjOreMOj7pqUsbd/B5mX9kV+sN2FqZ1tIlIG3m7eFFg1cN1HXYzebYpTo7/YjM36oWXm+7tenXbu0r18l8o6fU98ZXda6r2Du6jnz90tllPnpFe5mnq9lP5screM73Nde1xl/8OTz7Sy1dR948dWNtuqeO/AOe9kN1e0vQdW99Uuoy8pZt52mZL16ma/5ee+yUzOeW0HXkO2+8W+af//0TvX9PXdsNpmtSl80f3nem6k3bfM+gOb+xZwPjPLmnlrhVvrRh7YujnkLse3Qx8Z2tytqlWKYPt1aomD5mjfI8fbPrZTqlqueg2jP8eD/7Y12L+/b8uk75lo/0L3e+eQbtgn107qlJ7Ksjb93Dj1dO3bF6PlO7dGaZz3rmgMzPjl0Xmp2pNUq2NWtul6r5Gzrv93iR0Cxi+oBcPrXuuEt117HNvnLPbXQ83PQxp5x9LPPDy3Sd+R22Uuand+u+la+ePuYcnRpeS/1A1qGyrfXQx7v1cbpOuz02RMblXgrvF868PpvsklTW79zyC3Ud+WGT9PvSTM9jrU9WnZ/UdeJv/lrPZ3borduazXoNOMrCa6XX771etp1si2U+aEotmRfxzDWWVtopc/tEj9ltOreUedW5+pjUyQbKvIMuc39RuDIPAAAAAECMYTEPAAAAAECMYTEPAAAAAECMYTEPAAAAAECMYTEPAAAAAECMYTEPAAAAAECMiQRBEFzUA5vpmh3dxpWW+cBUusSWndFx/7d1/kCvL0X6pmxbsFITmc9f2E3mW0YVknm1lrosg62dJuNFe++S+ay4BJn3aOEpY5Q+k87X6rx9lmWh2YiDetPFdGwrL6J7Vvtc9821ovTgwY562z2H6r6xrbyunzY8W0OZ18zQVeZNSuq+9dG7upTMFntQ5mmz6rKEqdP+rNvv0iXCGk4OL7cytZkuf7Xr+AmZm3lqJpbQZZIKrEst8+0ddCmcYKjum/0juWS+7c4Mev8JuozSuvEytl8/iNMPeOYGnafWfct2LLVL0ahCeDbB97ZP9OTndHx/c13mZ/MgXb5rXCFdiqbo1sdlvrHBSzKvMUXvf5OnLOCOF/ULGIl4anB5FPfkniOeWe5OOj8k6rEWTymb3rPirMw/vu0+ve9vPtR5fh1X26PzeaV0fnXHd2R+3+QlMu87V785thzQJaZur1IyNPt6geeNZRtkGgT6d+NEXtB9M9/HT4dmO7fo95VV9+x89iCdZ9KlXK3e/TKusljP9RZs8xQIu2qizrfovp3fdN/eUULX9MyybnZols7ayba7bJfM03TV9UKrDbpJ5jM9Zf8sY0UZB4cXyTxSU5c/s1kFdV5ovs633qhz03MxS/UXnXd/XefvN/Ls/5BMq4t6rLMtjd50PV1mN+9UPeju8hXWKx5eNi8qTs9F86cZLvMdrVbL/KH/0XWKK8nU7K6LWAdxZR4AAAAAgBjDYh4AAAAAgBjDYh4AAAAAgBjDYh4AAAAAgBjDYh4AAAAAgBjDYh4AAAAAgBjDYh4AAAAAgMu2zvzz5fQDntP1NS1O17tOfVK3P20f6O2n6RUatU2ji9RvDS+FHTXnqK6Paenz6NxEzdwoT81de1emO+0Rmef31BS+wXTN5YmNdM1jmxAeldEt7Zzp2parAk8xbVcvvFEqme9IIWrbnmkr27Y4o2uDLpmma4FveVLGZhs9r9C3K3VeTNdKt/K6HrYV2S7j1rokse28StcPnT05vGax2XK7FLmtjsx323SZB6Zrj7a3AjL/Mhgo80hFTy3vI57f/fqdOje9/dttn8y/vsRa4ma63vd68/TdhqJu8PrwWtJR7e+RcdlXMsj89GfXy/y3LpllXi6zHtOXvyxjSzm5qczbDK8i82ENXpB5MFkf1st2qCrzYxNLyHxTej3ufbxV9+2+53TN4mvtu9Dso5LlZdtemZfJ/K55L8o8fsQzMk9xzQT9uy2sj2kf9J8r8+961pD55CxdZW4HT8s4t30q80QrFZqVtzWy7TIr6akzr9s7fSP6mPWw7bY/q4bpeez6jnoulzg0k8yz2PcyP5gli8xTHawu8yb2ksxnXq3Hjf1rZWxmj+u47RuhUc5RumntM0/I/HvT74uedlLm75injrvp94VvKfRKRM8z/9pazDPNrP9IGdsD1lHmV2XTL3Cm43ohs0J3LfOVgrfxuk59LQuvc7/K9PE4o+k679cO3yvz7+6QsZlnjWddPPlnN3geoI+HZr43nh5XgkAfLx2uzAMAAAAAEGNYzAMAAAAAEGNYzAMAAAAAEGNYzAMAAAAAEGNYzAMAAAAAEGNYzAMAAAAAEGNYzAMAAAAAcLnWma/kqVW+2HTt1jzWW+YVTNf1HX+Pp85eC5H1ri+bPr6sssxfDxrIfKA1l/mhJTK2v1TQ+f61+2We7UQ2meeqrH93NSpWkvno+Z4aiwVmhkY5tv8qm57LHV7T1tmXsNrficu9px+w4pHQyFPp2xJ1OWirOy58286IHjP0Bn7Wtcwrr0uU+SqbLfMqaYrI/PSpTTIPrKjM53pqmZsdFFl23TSjrnWd7oiuS/uAp058OWsn87tMF4YNAl1bNPKEp858eCnt/6Xf1lZioc7X2fMyf8QSZD7NPpf5Crtd5g1N1/vOLeoKR0zXQf/UPK/tA3NkHEmtD3vBTXrz/Ztk1bsvcKvMs+z7UOYHj+v9m6cmcRB8IfMinuN5Wmss8zmeeuNZP/LU3X2og4z7ZfoyNCu84yPZttYSXYf9dBV9DWObTM0q2VGZB56ayht1uW0r9poe0yMRXYfeIvqYZDe9K+M3xt0Zmj1uQ/S2i+u5UrBusm4f/flSyzyXnQnNfNWYdaVyv8KeGcNmW6k30Eb/7oLh+n1rdxbTuX7b2o6W02Sef1tdmbeJD//97rGMsu30gmP0k9um3zdmOWVaP7f+7RdOvEvmQ4I3ZR6523PM0YcEM89UsEqlW2S+YOAvnh3slmlw1LPUSz9LxsdN992JYlgclUHP9bp45pGveo5X46rJ2B6cp8e89+39S6sT393TfOuzOk98QcbBXP8ynSvzAAAAAADEGBbzAAAAAADEGBbzAAAAAADEGBbzAAAAAADEGBbzAAAAAADEGBbzAAAAAADEGBbzAAAAAABcrnXmIxFd49FsrydvLdOUlkvmlU3X5Z13zVvh4dK/6KeW86yMh+/WL1GbleF11p3ea2vJ/MWWO2SeYHlk/j+fppR53Iv6nM3hdfrnG1S8k8wbFlwUmk2eelq2TXl1IZmf+W2i+UTu8dQrH7U/PHvHs/EBD+l8U18ZF7hB/262n9R9z76yS1LFk6fPdaPMD3rqzC/d/a3eQUFRPzSNblp0wzcy32gP6w2U1XXUS63QzZ9uEC/zLpNXyfyexro26iepmsg8XdufZF7gHhnbugd1HvTwDP2rdWytdM3pbfqtbwVTh9ezNs+QfeT19TJPPa64zD/NNl/m39ZsI/NJ12yV+Y1L08l88x26kHyNcXpcnLJbv7M3BiNlXmWw7psLu14vc8unazrn3jlP5old9OYHf7ohNOvy8RzZ9tvZcTK//WM9F/nynB4Y6sw+JvNC5XS97UmZlsn8+ullZW7l9Hzhlqa/ynz9nJ0yX9RmUGjWfsStsu1X2fWgEezV7zsnknmUzF9s1io06/21Z+N6mmm2u5eMqy3StdK/rfibzIsk6HrXs17pIPMab5+TuSXqueLy3Lp5aR1bStsUmi2zIrLtNZ5a4U1b1ZR5ju+zyTxd97Ey/3DAfTIPgoEyj6QK73fOQ2d135idT8/15um3pZkVk2lw7D3d/FQzGf98Qjcvvle/L5eXCZ/rVfBM9op6fraTVknmaYvq463otv9fBpk+UuqozN/VQ77ZAh23vkPnI4ZQZx4AAAAAgMsOt9kDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAAHC51pnP5KkReaR0I5nHr+oh86NTdQ3HrR1+kXnu7fVDs0RdGtXSf6tr9i4MwuuuOqUSdT1ry61fmwWeete+srM9Z+2WeZ6GurhoYrxnB4ur67zeJ6HRjTtqy6b7186Q+ZyL6J6Rm3XfLLqoa2i2cdtBz9aXy3TbY7qubty9euuHtui8WCNRp93MEiy7zP+6RxcPHTRuo34CXXTh3vcm9pT5I43U89N1ZauYrpe8oK6Mrck0nf9UShcdbtBcv68mv6H7ZsQzZo628jL/znQ96s9KytiC37LIfMTiAzJvXUFvf1/iGplnz71Ib8BaiOwH3XRYexkfb/ukzNO986rMWz2mf3ejdEllK+Cpa7u9aEWZ57pJFx1uE9HHnAHv67456FH98z32toxN9xyziUX7yPyGq3W98eDp98PDekv0znvomsaz+t0o86zD9eZLN9a5ZZqk893Xy/iMpxZ6Krvb8wR0PelX49vK/Cn1tu7t2fWLOr6Y6WahiK7FnlP0vsWmO26xm/RBI8uPc2XexfT7Lv/sqTJvdZ0uSJ3GKst8oi6lbgX1r95S2FKZj7ZrZP6Y+gW/2kXv/Mn0Mr4xUzuZj6/TRG//x7/apfD1zaci+nj6ahVdK73tguMy71XgKpnX2jZe5utG6LleiSwbZD47v57rllugF1IZO70Zms2wx2TbhfP0+q5xNf2+jZ+hr0tfW0cf7/ZZDZmvzzpL5oU8B8StOjarkVrGwa+nfFvgyjwAAAAAALGG2+wBAAAAAIgxLOYBAAAAAIgxLOYBAAAAAIgxLOYBAAAAAIgxLOYBAAAAAIgxLOYBAAAAALhc68zb6tk6L7Fexndv7ijzhqe/lHnHQh1kXlWU4ZuZTTa1n3RsLe3Sau5mNV1D0ZbU1/l6XR9ybH1d37JZdk8xc9P1LZ99R7euuiu8oHfLV3TdVDNf/URdR92JRK71PGJeaFLvvZtly7MPJ8p8+m5df/LYGf2+SL+huMztrK5bu6tOPZnntb0yf2NCDpnXayRjq6Zji0QKh2b5bL9su9MOy/xZ0wWZ3zRdJ/7YCzJ2O5B8Q+dVkdYy32rf2yVpXU7nI3Xd2CDwjXyZZfrMxJwy/7tdrTefdmBo9NykbrJpn/s/1NvOXUfnVlqmkc66Lq19oeOinr1v9OSPejrfN/115912v+6bkWz657shrYxtyy79gKymax7PWaaf376E8HrW2a/PrZ+chY85znrTdebP2nsyzzTgYZnn6y5js6GevOb7Oj92n85/OSPjXB9kkHkacUjc8bI+ng+spo939831zZbMIg963nv9wqPKntnawiyjZF7l4Fsyn3+spH5u6fTx+Ltv+sq83abpevu3/k3nRavrfMVgnX97l877iOzQZtl0d2ZdZz330hf14aKC742jnbhej5nBxN4yj0Qa6B3EZ9X56jl6/8EM3d5yXtLxuvBo3fc3t4iX+WLPOqF5kD40GzZnn2xbo/oqmR+xmjI/druMLf3Xz8i8ZB/9vtg5d6fewcbHdb7qDRl31a3tk4tYpnNlHgAAAACAGMNiHgAAAACAGMNiHgAAAACAGMNiHgAAAACAGMNiHgAAAACAGMNiHgAAAACAGMNiHgAAAACAy7XOfMLiJTLPU6aC3kAaHS+0BTI/95uuPVq1pK+euaJr4prpmrpL7GmZV/jkJZn/fLfee4nfdL6z5CKZL7ZKMn9w7BiZj2ym67gXXBRe97dapfGyrW1ufCklg6OKRiJ/uvrm0bpfybZ1p7WX+aCEXTJ/JGcemd+5QcZWqcRsmc8zXVe22iS9fbv+F7uUSvJzj+uaxde1E7/fvBP0rgd1knFJWyjz39Ku1Nt/Usc2WNcGDTY/JvNI5AmZd2vxusyPzmsj8y92jZC5tdBx8MNFDf3hzul4u+dU8a+2JzS7xQ7KtoMTT8v8rsO6b9i8DjLO2b6uzPcWWCvzwQ/rcaGbp++9rGP7zJMv9hzWn400k/mLZfQxsWG7yXr/nrf22sf188ve5rbwcNs3euNxOt6XS+fpV+h8yH6dV6utx9Ryk+vLPE6XZDYbu0bnNUvJOHJfbc8OZoYmRYrpOuSbdut6zcEh/5iT8/5WMm855OfQbNDVut+OPqTrTbfIrOe5wdLRMrc+7+i8Z0+dZ7FLo0up2yfP9pP5TQndZb54fo3QrGmzuXrnpieykTv1PDPNYT0mvzZT962eCXqe61sKFW/cWuYbJnwvc8uu42DvMP0AayfTAZ7WOxN0fniH7vtvVfKs8eQxW3fsJfpwb/vT6TzOs758yvTPlj5SUebnUurtjz+rc7OmMq2VdpzMZxynzjwAAAAAAJcdbrMHAAAAACDGsJgHAAAAACDGsJgHAAAAACDGsJgHAAAAACDGsJgHAAAAACDGsJgHAAAAAOByrTO/2FP3d96cv8i8c/4PZf7mTr3/8id1Ib+K8eGFALN56spu8dSZL+ypM59xvd6++cpHPqVrFtsavX8rVUjGn3vKUR9rowtG3+s557NlYni2+oYpsm0T266fnOla404khy5GX+HlLaFZyW562+mbPi7zIX08FaGrppLxYtN17ivO0XXuLdVxncd7+laGEjrvk17nuvSqRZ4WfXPsNt3YU7LXeuu4wZs3yfwv3X6UedN6evvBL3rofCASL/MPTL+28SMWyXxdG11c9YyllvnnK47IvFOZkXZJv3zTg/oxyxeapfccD3xFdaf30XkNz5hc7tZyMs9hBWW+0sJrYTuH9O7tGk/+m+eQcNRTlzbyaERv4Me8Ol/9qIwLp90k84HHdb3r2rY3NMtgOfRzM11L3FY30nm8rgPv5em7Z8K7fVSqyfp9ubq8Hrfiz+hxNZJ/oMxrtA3PZg1/TbY1aynTi5lu5ovUlPmpLLNCs7iDTWTbnbZf5tenmCPziSv0wNErvrzM37ZSMj9hep47xMJ/ducO069dOs9cbv42PW5VnX8yNDtcUW870+LmMj/dSsZWNm1Xmec7qZ/7qjI7ZJ64wjNm5iij979vlcx9h7QgOCrzVbv1fOHO7HqNNmeTrvVuG/V7Y/UNep0Qr8blmXrXVlHPJU6v0XOR1HqabXbN1zKuHdHzbN/Tt+w6TrHvBpm3yCcWUWb2/Q7qzAMAAAAAcNnhNnsAAAAAAGIMi3kAAAAAAGIMi3kAAAAAAGIMi3kAAAAAAGIMi3kAAAAAAGIMi3kAAAAAAC7XOvO+wrinXtd5mhfmynylFZH50b+vk3m1Z8IL/Q3ep+s9t8sgY0uM07VF89stMk+nN2/25WkZH22rf0UZpuh60zP1S2u14k/oB0zRr/2yBvlDs/K+AowP6dj6XkQnjuj6mwVyhT+HLrufl23ftHtkfvIZXXszGKbr1kaW75b566lzyfwvCZVl/tNBXWv8eEkZ25r5On8q43KZjyx9fWjWxmrrjbcZoXNPXNRTVrXMQV3Ne6wtlblv6Iz8tbd+Ah+/otsHuuZw0FFvvljiPJmv71ZF5ovq61rklabr/W+to/NCFj7uHffUq168/VaZ1xir29t9uhZ3jUhnmXeot0Tmj518R+anU/aUuRUuLOPSX26W+Upf34w01fu37jru8Z6M+83sJfPmi5rJfIyFDzwP2Er93H7uIuNTN+rmx7btkvkPBfPKvIsuF20//Hxc5je30ddYDm/RO8h0lZ7QRDKnlbmdDp8vFSq1WjbdGqc3HczxTzerRfS4s9BKh2Z5S+ta4res0rW43631jMyDx3Qd+7Yj9THtq8/0XDKNZy5p+m1vvxT+Uub1v+gg84Od9Paz2N/Dw+/0azfDc+mwdvivNSrSV/eLph/o9uN07D+e18mkN7BR1Fk3s6536F/ePS/qyVaNSJVLWaLZ+td0fri4/vnr1tWv/xkxVV1kG2Tbaj/ouY7dfLXOt+hYHE6iOretKPPjkU0yH+6Zq2Uqd0TmDy4vJvOXgvXmw5V5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAAAu1zrzU77eKPMGC4rKfOdzevvTvxop81uLtJb5lEWjw5/bEy3sUuz35NkOfaEfkFkX7zxgN8g8qzWU+fIhT8s8dbFfZF7qUH2Zd/LUNr2vR3hWVzc16+fJxbaTRPLq+pcWXyo0qjh1jWy6Mr+uh/zw9qEyr7RLFzvPnE2/AKXj9AuwwbbKvNE3H8n8xwq65nGxeN03Vs7Ur89LtcN/N/OtvWxr9pVMy6TPpp9bh/B6yVEfz5JxDd3afvXVpb3fM+4MGKPz23U96OJfn5C5rzLp7n0TZH7mtB6XcuXWxVsTZ1SV+ZaNa0Oz7Z11Xdk2tljm9ouuG3u2vq57mypSXOYvpBNFdc3s2ePXybyK6d/9ghIytjbrdD7c0zcbXKvHzF8W6e3nKanzBE8p+EY6tmZBeN+6336Qbc9ab5k/+VZqmd/y6AGZ17HwuYbz3SedZV63qYytUb5BMl9iXWU+zvTvvllE//x2m6iZ/I1uaoV0HGzxTzebeOrMVxfZEs+2p1bMI/N0ixNkPj/YI/Ngqa41nv8aGZvueWZZfcXSm17abHZ0QgaZp0g9NjTbkV3PdfLZNJm3qNJH5iVOpZT5uhpPytw+miPjIJgo80g63S/b1tS7P7Wwl8xfmPmEzEdPyivz3o31uLErlZ6P5P1ir8zvfW63zD+yOn/6jTm+gs5P6ti8K7xh22WcaXAbmTdaMFfmIw979v9hGRk/3VkfMP9+Ect0rswDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAAHC51pnf8p3Or2qn8+2/6fyNkt/K/O3Duta6ZcoZGo2zN2TTpo8/7nlyOl68dpTMKy7UtcjtNv2zW3hpz6gliTpP1VjnewroPNfjuv7kX2uH11YdtVAXLB56ta5527FzOf3kXGlbT11aVRn2hDWQbTPabJlP6HlM5tXftn+rhYd13ymS6aDMsyfcK/MHNug69n1q6MLCuSNiYKis675W3VZU5vMTp9ulaO7JPVXgzTd0XhvRRX/nvf2jzNO8r/d/yldIXtV9NbOPA10v+27Lckk1ixdaNpnn/HF8aHZV9dqy7ZPZ+sr8VdM1h9d6apXHR1rL/NzdaWVunxTRuem6sjU8rWfl1gW/g4RbZZ7XM2aWK6v3vyGTzjcWvFrmnSeulXn7/f1Ds3grLNvWXqTfd1s9NY1/S3FK5vFdd8p8rS73bMeO6edfIb1ub4d0HMmif7d+4TWRbzHdMYbVGSbzYJp/uhmJeN5b3UTV6YH6fRvXbZXM2w1cLfOP5ujnn+5afTx+yPT7Uo9qZrt+eF7meW/urjewL5XOU4S/75wpWXuHZg3kTMvMNunXNlJUH68q2R0yz/fwpzKf9l4HmR8O9Dw94hsz9SHLls8opR9ga2QafO9577TU8ST7QubXm57L2hk9ri45UTA0K5ZRb9pzOPGacSBB5i3K63lq3IHTMk9Iqfcf0dNsy1gmu8wP19on8+BD6swDAAAAAHDZ4TZ7AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAAAu1zrz5Tw1Fld42qfNo/MTBzPrB1TwFFftKLKHddPKOrYFiz0vUUZd43Bycf3DD7TXZH7PmidkXqjUOpl/GNE1f8d7zunsNV0zeVeVDeFhGv3qVpq1UOYLL6J7tmqs+2aKCeHZyAc9G5+kq5EHs3Wtbpuv41XDesi84Af6d5/JU3N5wj5dy71R9utkbqcnynhkyuoy794hvK7v/m/u17u2SjLPYB/L/KhdqnoyDYJfZB6J3Ks3X/9nnf+yVcbZTL+v96fUtbyDH/V76/vselxrVcVXHVYXzF4ihq24onrL8V/tlfmkwz/KfP/9nWR+y+2eWt2zdGxb7JLoisBmnSy1zIPAUyvdczw/ZLqw7s6GnsLBk3Xh3Vr2lsxn2meh2dZ9i2TbNJ4y5bl3vq4f0KGhzvvo952t0XOZke1189S59Jj7XeQBmU83/b4/ahVknmA1QrOnqn8n235xRvebrfN2mY+vnrdZGZGtlC0bWQuZTzDP8dwayTQIxnvaj/Hker4xYKmeUKRdXlXmd+pS62ZLl8u48YJyodn48Cgqcp3+vd4U6DHhkD0q811t9fF6/fASMg8CPZ+IRNrIvE4LPS5NH71J5p4fz15+82WZ9/jlKZlnGqm3b08NlvEb+e6Sed1h4Vn8LXrXmXcskPmKPFVkXtZXBz7ytn5ArcU637tGxllW75Z50HuD7tuv6t0Hp6gzDwAAAADAZYfb7AEAAAAAiDEs5gEAAAAAiDEs5gEAAAAAiDEs5gEAAAAAiDEs5gEAAAAAuFxL0/nLhTSQ6XvldZmlh5fp8mpmeXVcStSfW/O0bls7p4yDyrrsQN939eZL2dcyb7zmdpkPKaW3307HlikS53mELmNkdTzNfxNZbt20q6fi4Ceb/N0z0kWX/rtqeXgtoMgi/cvLX6eAzH+dNsLz7K6V6Qq7U+ZlTwyR+eK0uoxRxa01Zb5umS4ftqupjK22ju1vrcLHjRmjdNspqTwbr6LftzZnj4xzPVNQ5sf/vk3mhz1Dp3fMLK7j29br/JtLKgxndvRT/fzXe8rDFaqjy0p+4yn6OfCVs6HZkKf08aKEp1zmyZlDZT5W1jI1aztX/+7u9JQRGlJev+9TLJsrc0+lHe+QPMnXNyt5xq0NnXV+6JiMr9etbZ8nP2lXhWbde+m6f+9+10Tm67Z46gBZeDnN/1VWpn0SdI2uSnl0WcXXIrVk7juaT/bVuMqjf3eW8E5olEGWhTPLbLoU6o5A/+xO42v1e2+CemsN92w8MbzsXtQ5T83Jr3Vpu8yPnJH54l269F1Rzzu/+2YZ2x2Fp8v8YHc9cjQZoMunzRXjbudM+ve28chNMi9jupzoEl3J1tWz1I70k3Gw/oFLOp6X9bztVvgG9fG63Gjj50/LvH8OPeZ/rIcVe3nw8/oBd+m56iExZnsKj5tN8eR1p8o4ks5TTvT0ahlXjysp8988B9xKnmFl0gGdF1v2kMzXT3lPb4Ar8wAAAAAAxB5uswcAAAAAIMawmAcAAAAAIMawmAcAAAAAIMawmAcAAAAAIMawmAcAAAAAIMawmAcAAAAA4HKtM9/BU2PxK0/7Np58hLdI5A+efIDI4mXL4ql0bdTpCRtlni+7rnlsdlym28akk3n66nrrkWPfy7xL4dYyH2MZ9Q5StdJ51i9Co7t1qW/7pKyuLRos1zWDL6qet90bmrRpp+tXjvjuN5mf+UC/fb7tflTm7b9ZK/M5t1WUeQaZmpUzXTv1B7tH5nU9tcKzePp24cinodnt9pls+3oki8xLZf5J5msOytjMHpPpLQ/qeszf9u0v80gkm8xvM1189BsrIfNqV6+TeX7dtaxK+Ns2KlUnnT/tqb36kB42re82leoxLafpmsF7TP/wqdp0lXnREX+TeaEM1WQ+OTJP5ndMzifzL67deUl15qd4DutVu+gxc8HnvnFXv/ea5dgv87F79XsjrchOyJZm1lPH93yp8xT1n5b5h/e/JPMS7fT2N3tKrX/YNbxes3PX5w30Bk6P07k9KdMatiI0q5djsGz7iudnu5jppv94/kxoUsf+LltONz3XalJYH88W1dRzvYSv9Fwzned9czyD/t319dRqj+hh0Xro5hb5e16ZZ5uXEJrtX6a3nV3HpkcEs8NWV+btbJrM+9+ij6fBt/qYUdTTL/NZY5kftVUy31lsq8xzdZOxlRqp85FH9UJi0tKnZN5wbUuZT75atNVPzYZFbpf5M/aLzNNYVZm/0FS/79qM0y9uNtNzvfpf6HFlZyc9rmzqImPb+al/3OTKPAAAAAAAMYbFPAAAAAAAMYbFPAAAAAAAMYbFPAAAAAAAMYbFPAAAAAAAMYbFPAAAAAAAMYbFPAAAAAAAl2ud+UjelPoB156T8U3jJsv8x7SeSoRNdWzD0oRnxU/ptqV1PG20fokSRV1Wp62V1TtIHKbz3J7XZs0YGXeNv1Pmgz21Wa203n7ONqdDsz2J82XbrGf0rvcP8nfPGpGsMi/eJrzg+FBP3dX04SXqo17WZdwtjy5PaZ09NZGzvaP7TuLdut61fTJF5xZeN9Zp9bLuO9//dYD9WbU9pxJn6CHFWnbU+aihzWVewzbLfFZtXTg3mK775s2RKjKvn07XvX3suB4zy9pJma8w33vniF2K5nWulfmYHPr1tTWib+X7QLedfEjGI6ywzO/1VD3uV22RzG/PUV7mdlZXTe42S9dEHpjOU0m+jB7zgl9+kHnGiD6gFjTd96paLpkPTZ1D5nZa9428diA02zVUb9pGegbVzJ4xcVAqGWe3BTJvXELXPB65Th8TT3oO9+nWPS7zJplL6v0X/0rvYFT461MrfznZdOaO5f+COvNtZd4xS/gxa+jBCp6t6wPyhEqiWLaZvXZc1yKfoId0q7Uuj8zX1tTtEwfp4/XNHSvLPMXQhTL/Xv96rcBfw7M8nuPxwmKeifYG/dxr2WyZn7D1Ml9wld59sFn3zUjkZr0B2y3TIp7nf7yN3nrCCJ0Xvj9O5ps/0POFIXrz9qQuM28JoyqFh6n0XKr4mQIyz5xaHy8OlCsj86I7V8p88o0ytkxbdN5syq0yT5P/qMzH7NDvy73BDv0EuDIPAAAAAEDs4TZ7AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAABiDIt5AAAAAAAu2zrz1SIyf3OVbv/Y0VIyv8XWyDx/+iwyf/epSaFZuW913dcW4SVto17a6nmJBo7SeVVP+yqt7JIs1TWF07fXNRCPr/QUUy/5vs5vDK95/FbfYbLpo9boX1CX9gn9gJavh2cpPRvXT8/6pvsfmT90p87fN113dpCnDvxBayfz9bZC5nXtjMzb2E6Zj/fUuV/+SXh9zJ2WVratUGeJzFcf6izzI0uOybxhE108dPJP8y6pb5aO6DFztUzN7KpaMq7VXternvmT/t2kXzJD5i1kapY2fTqZbzl2XOa3XRteq7z7fv27tbV6XHk931aZv6dLAttW/bYw6z5Ixq2H6vzAYf3aT/lS7/6qDvp4uDnQB7VIset0fn11mZf8+D2Z66O5q9Wu7bM/r/nTOl//0mMyf/7NN2XeWzf3/uz2rY4L6cO1JT5aUObtg14yH/K2/gGKiGEjIbd+bnGFdb6/30UczzPocdOKhEcFVz4lm26zV2T+QI9rZd6/3xH93CybJ9f1tFOYfl9fY5/IfHGqc3r3ZzzFzO1XTy623zuVbNn8TV0re4ynjnmur3WeNu4+mb9/8lOZ3xyckHkkotcR5pmrPVR6jMz7rqqoN19EzGOdes/rfFIanW/bq/PuOs48InzgyNBOz6WK9dfbXtdT5wnv6Nw61tXxUP2+WVRVH69Xpimv9/+rnisVajZX5lvG+MdNrswDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAABBjWMwDAAAAAHDZ1plf4Kn9qcvWmukSkGYf6LiSvSTznfZaaNaw+WHZdvmYUjJfcp+u1X3HAw/K/NNsuk77Ql1u2yr/qHMrquPI9Z7CtWfC6z1HxXmKQIqXL68ulW0Nf9b50PX+7nnDAF3ftPPPZ0Ozb77X2/6xwUD9gCndZNy6kG4+sr4u3PvW54kyf7SH3n76fiVlnrvtbzJfs1C/tnEbb9NPwMaLTNe8rZx7msxbJq6S+XPmE+fJT8rUN3Q2ibwl859r6HrPNTLI2FYv1/n+XTo3y+fJn/Hkum6vVdC1ZW2byDwlb18z3S/fqaJ/th0LdB36Ehn1/jM31/kRXXLYyi/Q+fBDzWTewsbK/AdP34xEbtJPwH7Scfs7Zfza8iEyf2KZ3nzz1qVDszEjq+jG9oVM3zY9JvYyPSbeZh/L/BvTB5VyN+uawsvX63rXlkbPN6yinm/UCfQ1nB3fh+//eHCVbnvwPZkHwY3mExmTUz9gTvjg0OHFtrLpaRsu8wwdC8t8yNDN+rmZ3r959m9V++l8kX5ffXq2ps676r43efQsvf/darKZR7e1TDLN10DXuL/6t64yn7a9r8y76Gm+fbpaj5llI3oNtNLe1jtI20vG8elulvnqtzrr7R9+Q+cLW8q4zpCnZT7d8/vThehfly0/q6q3/K4ekm3pobwyz93smMw/3XNI5rfm0nXqH1+i56pP6+mGWSMdB+OpMw8AAAAAwGWH2+wBAAAAAIgxLOYBAAAAAIgxLOYBAAAAAIgxLOYBAAAAAIgxLOYBAAAAAIgxLOYBAAAAALhc68wDAAAAAID/DlyZBwAAAAAgxrCYBwAAAAAgxrCYBwAAAAAgxrCYBwAAAAAgxrCYBwAAAAAgxrCYBwAAAAAgxrCYBwAAAAAgxrCYBwAAAAAgxrCYBwAAAADAYsv/A34j/RnYLmvmAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def make_shapes(n_samples=900, size=20, noise=0.3, seed=0):\n", " \"\"\"Draw noisy three-channel images of a circle, a square or a cross.\"\"\"\n", " rng = np.random.default_rng(seed)\n", " labels = rng.integers(0, 3, size=n_samples) # 0 circle, 1 square, 2 cross\n", " yy, xx = np.meshgrid(np.arange(size), np.arange(size), indexing=\"ij\")\n", " # Each shape sits at the centre, jittered a couple of pixels per sample.\n", " cy, cx = size / 2 + rng.uniform(-2.0, 2.0, (2, n_samples, 1, 1))\n", " radius, thickness = size * 0.3, size * 0.15\n", " circle = (yy - cy) ** 2 + (xx - cx) ** 2 <= radius**2\n", " square = (np.abs(yy - cy) <= radius * 0.8) & (np.abs(xx - cx) <= radius * 0.8)\n", " cross = (np.abs(yy - cy) <= thickness) | (np.abs(xx - cx) <= thickness)\n", " shape = labels[:, None, None]\n", " masks = np.select([shape == 0, shape == 1], [circle, square], default=cross)\n", " # The same mask in all three channels; the noise below differs between them.\n", " images = np.broadcast_to(\n", " masks[:, None].astype(\"float32\"), (n_samples, 3, size, size)\n", " )\n", " images = images + rng.normal(scale=noise, size=images.shape)\n", " return images.astype(\"float32\"), labels.astype(\"int64\")\n", "\n", "\n", "X_shapes, y_shapes = make_shapes()\n", "X_tr_sh, y_tr_sh, X_te_sh, y_te_sh = split(X_shapes, y_shapes)\n", "\n", "show_examples(X_shapes, y_shapes, [\"circle\", \"square\", \"cross\"])\n", "print(f\"train: {len(X_tr_sh)} test: {len(X_te_sh)}\")" ] }, { "cell_type": "code", "execution_count": 9, "id": "fc3ebc68", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "feature map before the classifier: (16, 5, 5)\n", "epoch 0 | train loss 0.655 acc 0.658 | test acc 0.778\n", "epoch 3 | train loss 0.117 acc 0.983 | test acc 0.978\n", "epoch 6 | train loss 0.025 acc 0.999 | test acc 0.983\n", "epoch 9 | train loss 0.009 acc 1.000 | test acc 0.989\n", "epoch 11 | train loss 0.006 acc 1.000 | test acc 0.983\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fused_shapes, feature_map = build_conv_classifier(\n", " conv_channels=[8, 16],\n", " in_channels=3,\n", " in_hw=20,\n", " n_classes=3,\n", " hidden=32,\n", " key=jax.random.key(2),\n", ")\n", "print(\"feature map before the classifier:\", feature_map)\n", "\n", "history_shapes = train_classifier(\n", " fused_shapes,\n", " X_tr_sh,\n", " y_tr_sh,\n", " X_te_sh,\n", " y_te_sh,\n", " epochs=12,\n", " batch_size=32,\n", " log_every=3,\n", ")\n", "plot_history(history_shapes, \"Shapes\")" ] }, { "cell_type": "markdown", "id": "b211dcea", "metadata": {}, "source": [ "## CIFAR-10: real photographs\n", "\n", "Finally, the same recipe on real, natural images: CIFAR-10, $32\\times 32$ RGB photographs of ten everyday subjects. We fetch a small excerpt of the collection (3,000 training and 1,000 test photographs, cached under `data/`) rather than the full 170 MB archive, and train on it for a handful of epochs. The network is made of two convolutional blocks, uses max-pooling and a GELU-coupled classifier." ] }, { "cell_type": "code", "execution_count": 10, "id": "7bc5f952", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train: 2000 test: 1000\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "CIFAR10_URL = (\n", " \"https://raw.githubusercontent.com/ilabcode/hgf-data/main/datasets/\"\n", " \"cifar10_subset.npz\"\n", ")\n", "CIFAR10_FILE = os.path.join(\"..\", \"..\", \"..\", \"data\", \"cifar10_subset.npz\")\n", "# Colour channel means and standard deviations of the full CIFAR-10 training set.\n", "CIFAR10_MEAN = np.array([0.4914, 0.4822, 0.4465], dtype=\"float32\")\n", "CIFAR10_STD = np.array([0.2023, 0.1994, 0.2010], dtype=\"float32\")\n", "\n", "\n", "def _normalise(images):\n", " \"\"\"Scale bytes to the unit interval, then centre each colour channel.\"\"\"\n", " images = images.astype(\"float32\") / 255.0\n", " images -= CIFAR10_MEAN[None, :, None, None]\n", " images /= CIFAR10_STD[None, :, None, None]\n", " return images\n", "\n", "\n", "def load_cifar10(path, n_train=2000, n_test=1000):\n", " \"\"\"Return a normalised CIFAR-10 excerpt, downloading it on first use.\n", "\n", " The file holds 3,000 training and 1,000 test photographs stored as unsigned\n", " bytes, 300 and 100 of each of the ten classes. Its rows keep the shuffled\n", " order of the source collection, so the leading ``n_train`` of them stay\n", " close to evenly spread across the classes.\n", " \"\"\"\n", " if not os.path.exists(path):\n", " # Download to a partial name first, so an interrupted run is not cached.\n", " print(f\"Downloading {CIFAR10_URL} ...\")\n", " os.makedirs(os.path.dirname(path), exist_ok=True)\n", " urllib.request.urlretrieve(CIFAR10_URL, path + \".part\")\n", " os.replace(path + \".part\", path)\n", "\n", " with np.load(path) as data:\n", " train_images, train_labels = data[\"train_images\"], data[\"train_labels\"]\n", " test_images, test_labels = data[\"test_images\"], data[\"test_labels\"]\n", " class_names = [str(name) for name in data[\"class_names\"]]\n", "\n", " if n_train > len(train_images) or n_test > len(test_images):\n", " raise ValueError(\n", " f\"the file holds {len(train_images)} training and {len(test_images)} \"\n", " f\"test images, too few for n_train={n_train}, n_test={n_test}.\"\n", " )\n", "\n", " return (\n", " _normalise(train_images[:n_train]),\n", " train_labels[:n_train],\n", " _normalise(test_images[:n_test]),\n", " test_labels[:n_test],\n", " class_names,\n", " )\n", "\n", "\n", "X_tr_c, y_tr_c, X_te_c, y_te_c, CLASS_NAMES = load_cifar10(CIFAR10_FILE)\n", "\n", "# Undo the normalisation for display only; the network trains on normalised images.\n", "shown = X_tr_c * CIFAR10_STD[:, None, None] + CIFAR10_MEAN[:, None, None]\n", "show_examples(shown, y_tr_c, CLASS_NAMES)\n", "print(f\"train: {len(X_tr_c)} test: {len(X_te_c)}\")" ] }, { "cell_type": "code", "execution_count": 11, "id": "1b320af5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "feature map before the classifier: (32, 8, 8)\n", "epoch 0 | train loss 2.422 acc 0.205 | test acc 0.236\n", "epoch 4 | train loss 1.244 acc 0.575 | test acc 0.401\n", "epoch 8 | train loss 0.633 acc 0.818 | test acc 0.405\n", "epoch 12 | train loss 0.244 acc 0.953 | test acc 0.433\n", "epoch 16 | train loss 0.095 acc 0.993 | test acc 0.444\n", "epoch 19 | train loss 0.037 acc 0.999 | test acc 0.445\n", "total training time: 11.0s\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fused_cifar, feature_map = build_conv_classifier(\n", " conv_channels=[16, 32],\n", " in_channels=3,\n", " in_hw=32,\n", " n_classes=10,\n", " hidden=64,\n", " key=jax.random.key(3),\n", ")\n", "print(\"feature map before the classifier:\", feature_map)\n", "\n", "t0 = time.time()\n", "history_cifar = train_classifier(\n", " fused_cifar,\n", " X_tr_c,\n", " y_tr_c,\n", " X_te_c,\n", " y_te_c,\n", " epochs=20,\n", " batch_size=64,\n", " log_every=4,\n", ")\n", "print(f\"total training time: {time.time() - t0:.1f}s\")\n", "plot_history(history_cifar, \"CIFAR-10\")" ] }, { "cell_type": "markdown", "id": "ffd297d5", "metadata": {}, "source": [ "Even this reduced-scale run climbs well above the 10% chance level, using nothing but the local, precision-weighted belief updates from earlier notebooks.\n", "\n", "```{note}\n", "What the run does *not* show is generalisation. In the right-hand panel above the training and test curves separate partway through, and the run ends with training accuracy far ahead of test accuracy: the network is fitting the 2,000 images it was shown rather than learning to classify photographs in general. That gap is what a subset this small buys, and it is the expected behaviour of any conv net of this size trained on so few images.\n", "```\n", "\n", "The building blocks used here (`im2col_adapter`, `conv_block`, `from_conv` for transplanting externally-trained kernels) scale directly to deeper, wider architectures and the full training set, at a proportional compute cost." ] }, { "cell_type": "markdown", "id": "0ae8c75f", "metadata": {}, "source": [ "# System configuration" ] }, { "cell_type": "code", "execution_count": 12, "id": "b83c74e0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Last updated: Tue, 01 Sep 2026\n", "\n", "Python implementation: CPython\n", "Python version : 3.12.13\n", "IPython version : 9.16.1\n", "\n", "pyhgf : 0.3.0\n", "jax : 0.6.2\n", "jaxlib: 0.6.2\n", "\n", "IPython : 9.16.1\n", "jax : 0.6.2\n", "matplotlib: 3.11.1\n", "numpy : 2.4.6\n", "optax : 0.2.8\n", "platform : 1.0.8\n", "pyhgf : 0.3.0\n", "seaborn : 0.13.2\n", "\n", "Watermark: 2.6.0\n", "\n" ] } ], "source": [ "%load_ext watermark\n", "%watermark -n -u -v -iv -w -p pyhgf,jax,jaxlib" ] } ], "metadata": { "kernelspec": { "display_name": "pyhgf", "language": "python", "name": "pyhgf" }, "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.12.13" } }, "nbformat": 4, "nbformat_minor": 5 }