Growing_Neural_Cellular_Automata.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Growing Neural Cellular Automata",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/neelsoumya/butterfly_detector/blob/master/Growing_Neural_Cellular_Automata.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "28S76DVlfCMZ"
      },
      "source": [
        "# Growing Neural Cellular Automata\n",
        "\n",
        "This notebook contains code to reproduce experiments and figures for the [\"Growing Neural Cellular Automata\"](http://distill.pub/2020/growing-ca) article.\n",
        "\n",
        "Copyright 2020 Google LLC\n",
        "\n",
        "Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "you may not use this file except in compliance with the License.\n",
        "You may obtain a copy of the License at\n",
        "\n",
        "    https://www.apache.org/licenses/LICENSE-2.0\n",
        "\n",
        "Unless required by applicable law or agreed to in writing, software\n",
        "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "See the License for the specific language governing permissions and\n",
        "limitations under the License."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "i5wi_r4gyzFr",
        "colab": {}
      },
      "source": [
        "#@title Imports and Notebook Utilities\n",
        "%tensorflow_version 2.x\n",
        "\n",
        "import os\n",
        "import io\n",
        "import PIL.Image, PIL.ImageDraw\n",
        "import base64\n",
        "import zipfile\n",
        "import json\n",
        "import requests\n",
        "import numpy as np\n",
        "import matplotlib.pylab as pl\n",
        "import glob\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "from IPython.display import Image, HTML, clear_output\n",
        "import tqdm\n",
        "\n",
        "import os\n",
        "os.environ['FFMPEG_BINARY'] = 'ffmpeg'\n",
        "import moviepy.editor as mvp\n",
        "from moviepy.video.io.ffmpeg_writer import FFMPEG_VideoWriter\n",
        "clear_output()\n",
        "\n",
        "def np2pil(a):\n",
        "  if a.dtype in [np.float32, np.float64]:\n",
        "    a = np.uint8(np.clip(a, 0, 1)*255)\n",
        "  return PIL.Image.fromarray(a)\n",
        "\n",
        "def imwrite(f, a, fmt=None):\n",
        "  a = np.asarray(a)\n",
        "  if isinstance(f, str):\n",
        "    fmt = f.rsplit('.', 1)[-1].lower()\n",
        "    if fmt == 'jpg':\n",
        "      fmt = 'jpeg'\n",
        "    f = open(f, 'wb')\n",
        "  np2pil(a).save(f, fmt, quality=95)\n",
        "\n",
        "def imencode(a, fmt='jpeg'):\n",
        "  a = np.asarray(a)\n",
        "  if len(a.shape) == 3 and a.shape[-1] == 4:\n",
        "    fmt = 'png'\n",
        "  f = io.BytesIO()\n",
        "  imwrite(f, a, fmt)\n",
        "  return f.getvalue()\n",
        "\n",
        "def im2url(a, fmt='jpeg'):\n",
        "  encoded = imencode(a, fmt)\n",
        "  base64_byte_string = base64.b64encode(encoded).decode('ascii')\n",
        "  return 'data:image/' + fmt.upper() + ';base64,' + base64_byte_string\n",
        "\n",
        "def imshow(a, fmt='jpeg'):\n",
        "  display(Image(data=imencode(a, fmt)))\n",
        "\n",
        "def tile2d(a, w=None):\n",
        "  a = np.asarray(a)\n",
        "  if w is None:\n",
        "    w = int(np.ceil(np.sqrt(len(a))))\n",
        "  th, tw = a.shape[1:3]\n",
        "  pad = (w-len(a))%w\n",
        "  a = np.pad(a, [(0, pad)]+[(0, 0)]*(a.ndim-1), 'constant')\n",
        "  h = len(a)//w\n",
        "  a = a.reshape([h, w]+list(a.shape[1:]))\n",
        "  a = np.rollaxis(a, 2, 1).reshape([th*h, tw*w]+list(a.shape[4:]))\n",
        "  return a\n",
        "\n",
        "def zoom(img, scale=4):\n",
        "  img = np.repeat(img, scale, 0)\n",
        "  img = np.repeat(img, scale, 1)\n",
        "  return img\n",
        "\n",
        "class VideoWriter:\n",
        "  def __init__(self, filename, fps=30.0, **kw):\n",
        "    self.writer = None\n",
        "    self.params = dict(filename=filename, fps=fps, **kw)\n",
        "\n",
        "  def add(self, img):\n",
        "    img = np.asarray(img)\n",
        "    if self.writer is None:\n",
        "      h, w = img.shape[:2]\n",
        "      self.writer = FFMPEG_VideoWriter(size=(w, h), **self.params)\n",
        "    if img.dtype in [np.float32, np.float64]:\n",
        "      img = np.uint8(img.clip(0, 1)*255)\n",
        "    if len(img.shape) == 2:\n",
        "      img = np.repeat(img[..., None], 3, -1)\n",
        "    self.writer.write_frame(img)\n",
        "\n",
        "  def close(self):\n",
        "    if self.writer:\n",
        "      self.writer.close()\n",
        "\n",
        "  def __enter__(self):\n",
        "    return self\n",
        "\n",
        "  def __exit__(self, *kw):\n",
        "    self.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "zR6I1JONmWBb",
        "colab": {}
      },
      "source": [
        "#@title Cellular Automata Parameters\n",
        "CHANNEL_N = 16        # Number of CA state channels\n",
        "TARGET_PADDING = 16   # Number of pixels used to pad the target image border\n",
        "TARGET_SIZE = 40\n",
        "BATCH_SIZE = 8\n",
        "POOL_SIZE = 1024\n",
        "CELL_FIRE_RATE = 0.5\n",
        "\n",
        "TARGET_EMOJI = \"🦎\" #@param {type:\"string\"}\n",
        "\n",
        "EXPERIMENT_TYPE = \"Regenerating\" #@param [\"Growing\", \"Persistent\", \"Regenerating\"]\n",
        "EXPERIMENT_MAP = {\"Growing\":0, \"Persistent\":1, \"Regenerating\":2}\n",
        "EXPERIMENT_N = EXPERIMENT_MAP[EXPERIMENT_TYPE]\n",
        "\n",
        "USE_PATTERN_POOL = [0, 1, 1][EXPERIMENT_N]\n",
        "DAMAGE_N = [0, 0, 3][EXPERIMENT_N]  # Number of patterns to damage in a batch"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "lCbPFbI_zosW",
        "outputId": "3d7f9038-fa5e-449e-95d3-0dd4a9e42aad",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        }
      },
      "source": [
        "#@title CA Model and Utilities\n",
        "\n",
        "from tensorflow.keras.layers import Conv2D\n",
        "\n",
        "def load_image(url, max_size=TARGET_SIZE):\n",
        "  r = requests.get(url)\n",
        "  img = PIL.Image.open(io.BytesIO(r.content))\n",
        "  img.thumbnail((max_size, max_size), PIL.Image.ANTIALIAS)\n",
        "  img = np.float32(img)/255.0\n",
        "  # premultiply RGB by Alpha\n",
        "  img[..., :3] *= img[..., 3:]\n",
        "  return img\n",
        "\n",
        "def load_emoji(emoji):\n",
        "  code = hex(ord(emoji))[2:].lower()\n",
        "  url = 'https://github.com/googlefonts/noto-emoji/raw/master/png/128/emoji_u%s.png'%code\n",
        "  return load_image(url)\n",
        "\n",
        "\n",
        "def to_rgba(x):\n",
        "  return x[..., :4]\n",
        "\n",
        "def to_alpha(x):\n",
        "  return tf.clip_by_value(x[..., 3:4], 0.0, 1.0)\n",
        "\n",
        "def to_rgb(x):\n",
        "  # assume rgb premultiplied by alpha\n",
        "  rgb, a = x[..., :3], to_alpha(x)\n",
        "  return 1.0-a+rgb\n",
        "\n",
        "def get_living_mask(x):\n",
        "  alpha = x[:, :, :, 3:4]\n",
        "  return tf.nn.max_pool2d(alpha, 3, [1, 1, 1, 1], 'SAME') > 0.1\n",
        "\n",
        "def make_seed(size, n=1):\n",
        "  x = np.zeros([n, size, size, CHANNEL_N], np.float32)\n",
        "  x[:, size//2, size//2, 3:] = 1.0\n",
        "  return x\n",
        "\n",
        "\n",
        "class CAModel(tf.keras.Model):\n",
        "\n",
        "  def __init__(self, channel_n=CHANNEL_N, fire_rate=CELL_FIRE_RATE):\n",
        "    super().__init__()\n",
        "    self.channel_n = channel_n\n",
        "    self.fire_rate = fire_rate\n",
        "\n",
        "    self.dmodel = tf.keras.Sequential([\n",
        "          Conv2D(128, 1, activation=tf.nn.relu),\n",
        "          Conv2D(self.channel_n, 1, activation=None,\n",
        "              kernel_initializer=tf.zeros_initializer),\n",
        "    ])\n",
        "\n",
        "    self(tf.zeros([1, 3, 3, channel_n]))  # dummy call to build the model\n",
        "\n",
        "  @tf.function\n",
        "  def perceive(self, x, angle=0.0):\n",
        "    identify = np.float32([0, 1, 0])\n",
        "    identify = np.outer(identify, identify)\n",
        "    dx = np.outer([1, 2, 1], [-1, 0, 1]) / 8.0  # Sobel filter\n",
        "    dy = dx.T\n",
        "    c, s = tf.cos(angle), tf.sin(angle)\n",
        "    kernel = tf.stack([identify, c*dx-s*dy, s*dx+c*dy], -1)[:, :, None, :]\n",
        "    kernel = tf.repeat(kernel, self.channel_n, 2)\n",
        "    y = tf.nn.depthwise_conv2d(x, kernel, [1, 1, 1, 1], 'SAME')\n",
        "    return y\n",
        "\n",
        "  @tf.function\n",
        "  def call(self, x, fire_rate=None, angle=0.0, step_size=1.0):\n",
        "    pre_life_mask = get_living_mask(x)\n",
        "\n",
        "    y = self.perceive(x, angle)\n",
        "    dx = self.dmodel(y)*step_size\n",
        "    if fire_rate is None:\n",
        "      fire_rate = self.fire_rate\n",
        "    update_mask = tf.random.uniform(tf.shape(x[:, :, :, :1])) <= fire_rate\n",
        "    x += dx * tf.cast(update_mask, tf.float32)\n",
        "\n",
        "    post_life_mask = get_living_mask(x)\n",
        "    life_mask = pre_life_mask & post_life_mask\n",
        "    return x * tf.cast(life_mask, tf.float32)\n",
        "\n",
        "\n",
        "CAModel().dmodel.summary()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv2d (Conv2D)              multiple                  6272      \n",
            "_________________________________________________________________\n",
            "conv2d_1 (Conv2D)            multiple                  2064      \n",
            "=================================================================\n",
            "Total params: 8,336\n",
            "Trainable params: 8,336\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "xDX5HL7VLd0z"
      },
      "source": [
        "# Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "IeWf6HeTe8kM",
        "colab": {}
      },
      "source": [
        "#@title Train Utilities (SamplePool, Model Export, Damage)\n",
        "from google.protobuf.json_format import MessageToDict\n",
        "from tensorflow.python.framework import convert_to_constants\n",
        "\n",
        "class SamplePool:\n",
        "  def __init__(self, *, _parent=None, _parent_idx=None, **slots):\n",
        "    self._parent = _parent\n",
        "    self._parent_idx = _parent_idx\n",
        "    self._slot_names = slots.keys()\n",
        "    self._size = None\n",
        "    for k, v in slots.items():\n",
        "      if self._size is None:\n",
        "        self._size = len(v)\n",
        "      assert self._size == len(v)\n",
        "      setattr(self, k, np.asarray(v))\n",
        "\n",
        "  def sample(self, n):\n",
        "    idx = np.random.choice(self._size, n, False)\n",
        "    batch = {k: getattr(self, k)[idx] for k in self._slot_names}\n",
        "    batch = SamplePool(**batch, _parent=self, _parent_idx=idx)\n",
        "    return batch\n",
        "\n",
        "  def commit(self):\n",
        "    for k in self._slot_names:\n",
        "      getattr(self._parent, k)[self._parent_idx] = getattr(self, k)\n",
        "\n",
        "@tf.function\n",
        "def make_circle_masks(n, h, w):\n",
        "  x = tf.linspace(-1.0, 1.0, w)[None, None, :]\n",
        "  y = tf.linspace(-1.0, 1.0, h)[None, :, None]\n",
        "  center = tf.random.uniform([2, n, 1, 1], -0.5, 0.5)\n",
        "  r = tf.random.uniform([n, 1, 1], 0.1, 0.4)\n",
        "  x, y = (x-center[0])/r, (y-center[1])/r\n",
        "  mask = tf.cast(x*x+y*y < 1.0, tf.float32)\n",
        "  return mask\n",
        "\n",
        "def export_model(ca, base_fn):\n",
        "  ca.save_weights(base_fn)\n",
        "\n",
        "  cf = ca.call.get_concrete_function(\n",
        "      x=tf.TensorSpec([None, None, None, CHANNEL_N]),\n",
        "      fire_rate=tf.constant(0.5),\n",
        "      angle=tf.constant(0.0),\n",
        "      step_size=tf.constant(1.0))\n",
        "  cf = convert_to_constants.convert_variables_to_constants_v2(cf)\n",
        "  graph_def = cf.graph.as_graph_def()\n",
        "  graph_json = MessageToDict(graph_def)\n",
        "  graph_json['versions'] = dict(producer='1.14', minConsumer='1.14')\n",
        "  model_json = {\n",
        "      'format': 'graph-model',\n",
        "      'modelTopology': graph_json,\n",
        "      'weightsManifest': [],\n",
        "  }\n",
        "  with open(base_fn+'.json', 'w') as f:\n",
        "    json.dump(model_json, f)\n",
        "\n",
        "def generate_pool_figures(pool, step_i):\n",
        "  tiled_pool = tile2d(to_rgb(pool.x[:49]))\n",
        "  fade = np.linspace(1.0, 0.0, 72)\n",
        "  ones = np.ones(72) \n",
        "  tiled_pool[:, :72] += (-tiled_pool[:, :72] + ones[None, :, None]) * fade[None, :, None] \n",
        "  tiled_pool[:, -72:] += (-tiled_pool[:, -72:] + ones[None, :, None]) * fade[None, ::-1, None]\n",
        "  tiled_pool[:72, :] += (-tiled_pool[:72, :] + ones[:, None, None]) * fade[:, None, None]\n",
        "  tiled_pool[-72:, :] += (-tiled_pool[-72:, :] + ones[:, None, None]) * fade[::-1, None, None]\n",
        "  imwrite('train_log/%04d_pool.jpg'%step_i, tiled_pool)\n",
        "\n",
        "def visualize_batch(ca, step_i):\n",
        "  vis0 = np.hstack(to_rgb(x0).numpy())\n",
        "  vis1 = np.hstack(to_rgb(x).numpy())\n",
        "  vis = np.vstack([vis0, vis1])\n",
        "  imwrite('train_log/batches_%04d.jpg'%step_i, vis)\n",
        "  export_model(ca, 'train_log/%04d'%step_i)\n",
        "  clear_output()\n",
        "  print('batch (before/after):')\n",
        "  imshow(vis)\n",
        "  pl.figure(figsize=(10, 4))\n",
        "  pl.title('Loss history (log10)')\n",
        "  pl.plot(np.log10(loss_log), '.', alpha=0.1)\n",
        "  pl.show()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "zKlA50h0jlvl",
        "outputId": "8b74eeb2-50b6-4765-d271-721b0b735cd0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 97
        }
      },
      "source": [
        "#@title Choose Target Image { vertical-output: true}\n",
        "#url = 'https://github.com/google-research/self-organising-systems/blob/master/assets/growing_ca/planaria2_48.png?raw=true'\n",
        "#target_img = load_image(url, 48)\n",
        "\n",
        "target_img = load_emoji(TARGET_EMOJI)\n",
        "imshow(zoom(to_rgb(target_img), 2), fmt='png')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFAAAABQCAIAAAABc2X6AAANj0lEQVR4nO3ceZhddX3H8de529yZ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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "ak5rBmbxmHV7",
        "colab": {}
      },
      "source": [
        "#@title Initialize Training { vertical-output: true}\n",
        "\n",
        "p = TARGET_PADDING\n",
        "pad_target = tf.pad(target_img, [(p, p), (p, p), (0, 0)])\n",
        "h, w = pad_target.shape[:2]\n",
        "seed = np.zeros([h, w, CHANNEL_N], np.float32)\n",
        "seed[h//2, w//2, 3:] = 1.0\n",
        "\n",
        "def loss_f(x):\n",
        "  return tf.reduce_mean(tf.square(to_rgba(x)-pad_target), [-2, -3, -1])\n",
        "\n",
        "ca = CAModel()\n",
        "\n",
        "loss_log = []\n",
        "\n",
        "lr = 2e-3\n",
        "lr_sched = tf.keras.optimizers.schedules.PiecewiseConstantDecay(\n",
        "    [2000], [lr, lr*0.1])\n",
        "trainer = tf.keras.optimizers.Adam(lr_sched)\n",
        "\n",
        "loss0 = loss_f(seed).numpy()\n",
        "pool = SamplePool(x=np.repeat(seed[None, ...], POOL_SIZE, 0))\n",
        "\n",
        "!mkdir -p train_log && rm -f train_log/*"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "QzP_vDchq0d9",
        "outputId": "254e4b4b-c099-4c01-d4ac-3c394d2dcb67",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 480
        }
      },
      "source": [
        "#@title Training Loop {vertical-output: true}\n",
        "\n",
        "@tf.function\n",
        "def train_step(x):\n",
        "  iter_n = tf.random.uniform([], 64, 96, tf.int32)\n",
        "  with tf.GradientTape() as g:\n",
        "    for i in tf.range(iter_n):\n",
        "      x = ca(x)\n",
        "    loss = tf.reduce_mean(loss_f(x))\n",
        "  grads = g.gradient(loss, ca.weights)\n",
        "  grads = [g/(tf.norm(g)+1e-8) for g in grads]\n",
        "  trainer.apply_gradients(zip(grads, ca.weights))\n",
        "  return x, loss\n",
        "\n",
        "for i in range(8000+1):\n",
        "  if USE_PATTERN_POOL:\n",
        "    batch = pool.sample(BATCH_SIZE)\n",
        "    x0 = batch.x\n",
        "    loss_rank = loss_f(x0).numpy().argsort()[::-1]\n",
        "    x0 = x0[loss_rank]\n",
        "    x0[:1] = seed\n",
        "    if DAMAGE_N:\n",
        "      damage = 1.0-make_circle_masks(DAMAGE_N, h, w).numpy()[..., None]\n",
        "      x0[-DAMAGE_N:] *= damage\n",
        "  else:\n",
        "    x0 = np.repeat(seed[None, ...], BATCH_SIZE, 0)\n",
        "\n",
        "  x, loss = train_step(x0)\n",
        "\n",
        "  if USE_PATTERN_POOL:\n",
        "    batch.x[:] = x\n",
        "    batch.commit()\n",
        "\n",
        "  step_i = len(loss_log)\n",
        "  loss_log.append(loss.numpy())\n",
        "  \n",
        "  if step_i%10 == 0:\n",
        "    generate_pool_figures(pool, step_i)\n",
        "  if step_i%100 == 0:\n",
        "    visualize_batch(ca, step_i)\n",
        "\n",
        "  print('\\r step: %d, log10(loss): %.3f'%(len(loss_log), np.log10(loss)), end='')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "batch (before/after):\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAIBAQEBAQIBAQECAgICAgQDAgICAgUEBAMEBgUGBgYF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\nUUUUAf/Z\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAEICAYAAABoNzG1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nuUT+f+nOv8VKoaFAAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 720x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            " step: 5453, log10(loss): -3.408"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "QAscSKkRaFwp"
      },
      "source": [
        "# Figures"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "nqvkfl9W4ODI",
        "colab": {}
      },
      "source": [
        "#@title Training Progress (Checkpoints)\n",
        "\n",
        "models = []\n",
        "for i in [100, 500, 1000, 4000]:\n",
        "  ca = CAModel()\n",
        "  ca.load_weights('train_log/%04d'%i)\n",
        "  models.append(ca)\n",
        "\n",
        "out_fn = 'train_steps_damage_%d.mp4'%DAMAGE_N\n",
        "x = np.zeros([len(models), 72, 72, CHANNEL_N], np.float32)\n",
        "x[..., 36, 36, 3:] = 1.0\n",
        "with VideoWriter(out_fn) as vid:\n",
        "  for i in tqdm.trange(500):\n",
        "    vis = np.hstack(to_rgb(x))\n",
        "    vid.add(zoom(vis, 2))\n",
        "    for ca, xk in zip(models, x):\n",
        "      xk[:] = ca(xk[None,...])[0]\n",
        "mvp.ipython_display(out_fn)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "QeXZKb5v2gxj",
        "colab": {}
      },
      "source": [
        "#@title Training Progress (Batches)\n",
        "frames = sorted(glob.glob('train_log/batches_*.jpg'))\n",
        "mvp.ImageSequenceClip(frames, fps=10.0).write_videofile('batches.mp4')\n",
        "mvp.ipython_display('batches.mp4')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "B4JAbAJf6Alw",
        "colab": {}
      },
      "source": [
        "#@title Pool Contents\n",
        "frames = sorted(glob.glob('train_log/*_pool.jpg'))[:80]\n",
        "mvp.ImageSequenceClip(frames, fps=20.0).write_videofile('pool.mp4')\n",
        "mvp.ipython_display('pool.mp4')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "lyxeGm6dJX8D"
      },
      "source": [
        "## Pretrained Models and Figures\n",
        "\n",
        "Please run the cell below to download pretrained models that are used to generate the subsequent figures. The figures generated after this are generated using the pretrained CAs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "wiGl7S0E6-OA",
        "colab": {}
      },
      "source": [
        "!wget -O models.zip 'https://github.com/google-research/self-organising-systems/blob/master/assets/growing_ca/models.zip?raw=true'\n",
        "!unzip -oq models.zip\n",
        "\n",
        "EMOJI = '🦎😀💥👁🐠🦋🐞🕸🥨🎄'\n",
        "\n",
        "def get_model(emoji='🦋', fire_rate=0.5, use_pool=1, damage_n=3, run=0,\n",
        "              prefix='models/', output='model'):\n",
        "  path = prefix\n",
        "  assert fire_rate in [0.5, 1.0]\n",
        "  if fire_rate==0.5:\n",
        "    path += 'use_sample_pool_%d damage_n_%d '%(use_pool, damage_n)\n",
        "  elif fire_rate==1.0:\n",
        "    path += 'fire_rate_1.0 '\n",
        "  code = hex(ord(emoji))[2:].upper()\n",
        "  path += 'target_emoji_%s run_index_%d/08000'%(code, run)\n",
        "  assert output in ['model', 'json']\n",
        "  if output == 'model':\n",
        "    ca = CAModel(channel_n=16, fire_rate=fire_rate)\n",
        "    ca.load_weights(path)\n",
        "    return ca\n",
        "  elif output == 'json':\n",
        "    return open(path+'.json', 'r').read()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "YyMms2wKwX9x",
        "colab": {}
      },
      "source": [
        "atlas = np.hstack([load_emoji(e) for e in EMOJI])\n",
        "imshow(atlas)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "mqgtL5VpLEeL",
        "colab": {}
      },
      "source": [
        "#@title Teaser\n",
        "models = [get_model(emoji, run=1) for emoji in EMOJI]\n",
        "\n",
        "with VideoWriter('teaser.mp4') as vid:\n",
        "  x = np.zeros([len(EMOJI), 64, 64, CHANNEL_N], np.float32)\n",
        "  # grow\n",
        "  for i in tqdm.trange(200):\n",
        "    k = i//20\n",
        "    if i%20==0 and k<len(EMOJI):\n",
        "      x[k, 32, 32, 3:] = 1.0\n",
        "    vid.add(zoom(tile2d(to_rgb(x), 5), 2))\n",
        "    for ca, xk in zip(models, x):\n",
        "      xk[:] = ca(xk[None,...])[0]\n",
        "  # damage\n",
        "  mask = PIL.Image.new('L', (64*5, 64*2))\n",
        "  draw = PIL.ImageDraw.Draw(mask)\n",
        "  for i in tqdm.trange(400):\n",
        "    cx, r = i*3-20, 6\n",
        "    y1, y2 = 32+np.sin(i/5+np.pi)*8, 32+64+np.sin(i/5)*8\n",
        "    draw.rectangle((0, 0, 64*5, 64*2), fill=0)\n",
        "    draw.ellipse((cx-r, y1-r, cx+r, y1+r), fill=255)\n",
        "    draw.ellipse((cx-r, y2-r, cx+r, y2+r), fill=255)\n",
        "    x *= 1.0-(np.float32(mask).reshape(2, 64, 5, 64)\n",
        "        .transpose([0, 2, 1, 3]).reshape(10, 64, 64, 1))/255.0\n",
        "    if i<200 or i%2 == 0:\n",
        "      vid.add(zoom(tile2d(to_rgb(x), 5), 2))\n",
        "    for ca, xk in zip(models, x):\n",
        "      xk[:] = ca(xk[None,...])[0]\n",
        "  # fade out\n",
        "  last = zoom(tile2d(to_rgb(x), 5), 2)\n",
        "  for t in np.linspace(0, 1, 30):\n",
        "    vid.add(last*(1.0-t)+t)\n",
        "\n",
        "mvp.ipython_display('teaser.mp4', loop=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "4O4tzfe-GRJ7",
        "colab": {}
      },
      "source": [
        "#@title Unstable Patterns\n",
        "!wget -O slider.png 'https://github.com/google-research/self-organising-systems/raw/master/assets/growing_ca/slider.png?raw=true'\n",
        "\n",
        "import PIL.ImageFont\n",
        "from matplotlib import font_manager as fm\n",
        "font_fn = fm.findfont(fm.FontProperties())\n",
        "font = PIL.ImageFont.truetype(font_fn, 20)\n",
        "\n",
        "models = [get_model(ch, use_pool=0, damage_n=0) for ch in EMOJI]\n",
        "fn = 'unstable.mp4'\n",
        "with VideoWriter(fn) as vid:\n",
        "  x = np.zeros([len(EMOJI), 64, 64, CHANNEL_N], np.float32)\n",
        "  x[:, 32, 32, 3:] = 1.0\n",
        "  # grow\n",
        "  slider = PIL.Image.open(\"slider.png\")\n",
        "  for i in tqdm.trange(1000):\n",
        "    if i<200 or i%5 == 0:\n",
        "      vis = zoom(tile2d(to_rgb(x), 5), 4).clip(0, 1)\n",
        "      vis_extended = np.concatenate((vis, np.ones((164, vis.shape[1], 3))), axis=0) \n",
        "      im = np.uint8(vis_extended*255)\n",
        "      im = PIL.Image.fromarray(im)\n",
        "      im.paste(slider, box=(20, vis.shape[0]+20))\n",
        "      draw = PIL.ImageDraw.Draw(im)\n",
        "      p_x = (14 + (610/1000)*i)*2.0\n",
        "      draw.rectangle([p_x, vis.shape[0]+20+55, p_x+10, vis.shape[0]+20+82], fill=\"#434343bd\")\n",
        "      vid.add(np.uint8(im))\n",
        "    for ca, xk in zip(models, x):\n",
        "      xk[:] = ca(xk[None,...])[0]\n",
        "  # fade out\n",
        "  for t in np.linspace(0, 1, 30):\n",
        "    vid.add(vis_extended*(1.0-t)+t)\n",
        "\n",
        "mvp.ipython_display(fn, loop=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "1CVR9MeYnjuY",
        "colab": {}
      },
      "source": [
        "#@title Rotation\n",
        "row_size = 4\n",
        "models_of_interest = [\"🦋\",\"🦎\",\"🐠\",\"😀\"]\n",
        "num_images = 16\n",
        "imgs = []\n",
        "start_angle = np.random.randint(13, 76)\n",
        "\n",
        "for i in np.arange(num_images):\n",
        "  ang = start_angle + i * np.random.randint(36, 111)\n",
        "  ang = ang/360.0 * 2 * np.pi\n",
        "  if i % row_size == 0:\n",
        "    ca = get_model(models_of_interest[i // row_size])\n",
        "  x = np.zeros([1, 56, 56, CHANNEL_N], np.float32)\n",
        "  x[:, 28, 28, 3:] = 1.0\n",
        "  for i in range(500):\n",
        "    ang = tf.constant(ang, tf.float32)\n",
        "    x = ca(x, angle=ang)\n",
        "  imgs.append(to_rgb(x)[0])\n",
        "# Assumes the result is a multiple of row_size\n",
        "assert len(imgs) % row_size == 0\n",
        "imgs = zip(*(iter(imgs),) * row_size)\n",
        "\n",
        "imgs_arr = np.concatenate([np.hstack(im_row) for im_row in imgs])\n",
        "vis = zoom(imgs_arr, 4)\n",
        "\n",
        "imshow(vis, fmt='png')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "S5JRLGxX1dnX",
        "colab": {}
      },
      "source": [
        "#@title Regeneration (trained without damage)\n",
        "models = [get_model(ch, damage_n=0) for ch in '😀🦋🦎']\n",
        "with VideoWriter('regen1.mp4') as vid:\n",
        "  x = np.zeros([len(models), 5, 56, 56, CHANNEL_N], np.float32)\n",
        "  cx, cy = 28, 28\n",
        "  x[:, :, cy, cx, 3:] = 1.0\n",
        "  for i in tqdm.trange(2000):\n",
        "    if i == 200:\n",
        "      x[:, 0, cy:] = x[:, 1, :cy] = 0\n",
        "      x[:, 2, :, cx:] = x[:, 3, :, :cx] = 0\n",
        "      x[:, 4, cy-8:cy+8, cx-8:cx+8] = 0\n",
        "    vis = to_rgb(x)\n",
        "    vis = np.vstack([np.hstack(row) for row in vis])\n",
        "    vis = zoom(vis, 2)\n",
        "    if (i < 400 and i%2==0) or i%8 == 0:\n",
        "      vid.add(vis)\n",
        "    if i == 200:\n",
        "      for _ in range(29):\n",
        "        vid.add(vis)\n",
        "    for ca, row in zip(models, x):\n",
        "      row[:] = ca(row)\n",
        "\n",
        "mvp.ipython_display('regen1.mp4')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "TDzJM69u4_8p",
        "colab": {}
      },
      "source": [
        "#@title Regeneration (trained with damage)\n",
        "models = [get_model(ch, damage_n=3) for ch in '😀🦋🦎']\n",
        "with VideoWriter('regen2.mp4') as vid:\n",
        "  x = np.zeros([len(models), 5, 56, 56, CHANNEL_N], np.float32)\n",
        "  cx, cy = 28, 28\n",
        "  x[:, :, cy, cx, 3:] = 1.0\n",
        "  for i in tqdm.trange(2000):\n",
        "    if i == 200:\n",
        "      x[:, 0, cy:] = x[:, 1, :cy] = 0\n",
        "      x[:, 2, :, cx:] = x[:, 3, :, :cx] = 0\n",
        "      x[:, 4, cy-8:cy+8, cx-8:cx+8] = 0\n",
        "    vis = to_rgb(x)\n",
        "    vis = np.vstack([np.hstack(row) for row in vis])\n",
        "    vis = zoom(vis, 2)\n",
        "    if (i < 400 and i%2==0) or i%8 == 0:\n",
        "      vid.add(vis)\n",
        "    if i == 200:\n",
        "      for _ in range(29):\n",
        "        vid.add(vis)\n",
        "    for ca, row in zip(models, x):\n",
        "      row[:] = ca(row)\n",
        "\n",
        "mvp.ipython_display('regen2.mp4')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "fQ1u2MqFy7Ni",
        "colab": {}
      },
      "source": [
        "#@title Planarian\n",
        "!wget -O planarian.zip 'https://github.com/google-research/self-organising-systems/blob/master/assets/growing_ca/planarian.zip?raw=true'\n",
        "!unzip -oq planarian.zip -d planarian\n",
        "\n",
        "ca = CAModel()\n",
        "ca.load_weights('planarian/train_log/8000')\n",
        "\n",
        "x = np.zeros([1, 64, 96, CHANNEL_N], np.float32)\n",
        "x[:, 32, 48, 3:] = 1.0\n",
        "with VideoWriter('planarian.mp4', 30.0) as vid:\n",
        "  for i in range(400):\n",
        "    vid.add(zoom(to_rgb(x[0])))\n",
        "    x = ca(x, angle=np.pi/2.0)\n",
        "    if i==150:\n",
        "      x = x.numpy()\n",
        "      for k in range(24):\n",
        "        x[:,:24] = np.roll(x[:,:24], 1, 2)\n",
        "        x[:,-24:] = np.roll(x[:,-24:], -1, 2)\n",
        "        vid.add(zoom(to_rgb(x[0])))\n",
        "      for k in range(20):\n",
        "        vid.add(zoom(to_rgb(x[0])))\n",
        "\n",
        "mvp.ipython_display('planarian.mp4')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "9M-oDuhea7bR"
      },
      "source": [
        "# Interactive Demos\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "D7ypa-b7_fTn",
        "colab": {}
      },
      "source": [
        "#@title TensorFlow.js Demo {run:\"auto\", vertical-output: true}\n",
        "#@markdown Select \"CHECKPOINT\" model to load the checkpoint created by running cells from the \"Training\" section of this notebook\n",
        "import IPython.display\n",
        "\n",
        "model = \"CHECKPOINT\"  #@param ['CHECKPOINT', '😀 1F600', '💥 1F4A5', '👁 1F441', '🦎 1F98E', '🐠 1F420', '🦋 1F98B', '🐞 1F41E', '🕸 1F578', '🥨 1F968', '🎄 1F384']\n",
        "model_type = '3 regenerating'  #@param ['1 naive', '2 persistent', '3 regenerating']\n",
        "\n",
        "#@markdown Shift-click to seed the pattern\n",
        "\n",
        "if model != 'CHECKPOINT':\n",
        "  code = model.split(' ')[1]\n",
        "  emoji = chr(int(code, 16))\n",
        "  experiment_i = int(model_type.split()[0])-1\n",
        "  use_pool = (0, 1, 1)[experiment_i]\n",
        "  damage_n = (0, 0, 3)[experiment_i]\n",
        "  model_str = get_model(emoji, use_pool=use_pool, damage_n=damage_n, output='json')\n",
        "else:\n",
        "  last_checkpoint_fn = sorted(glob.glob('train_log/*.json'))[-1]\n",
        "  model_str = open(last_checkpoint_fn).read()\n",
        "\n",
        "data_js = '''\n",
        "  window.GRAPH_URL = URL.createObjectURL(new Blob([`%s`], {type: 'application/json'}));\n",
        "'''%(model_str)\n",
        "\n",
        "display(IPython.display.Javascript(data_js))\n",
        "\n",
        "\n",
        "IPython.display.HTML('''\n",
        "<script src=\"https://unpkg.com/@tensorflow/tfjs-core@latest/dist/tf-core.js\"></script>\n",
        "<script src=\"https://unpkg.com/@tensorflow/tfjs-layers@latest/dist/tf-layers.js\"></script>\n",
        "<script src=\"https://unpkg.com/@tensorflow/tfjs-converter@latest/dist/tf-converter.js\"></script>\n",
        "<script src=\"https://unpkg.com/@tensorflow/tfjs-backend-wasm@latest/dist/tf-backend-wasm.js\"></script>\n",
        "\n",
        "<canvas id='canvas' style=\"border: 1px solid black; image-rendering: pixelated;\"></canvas>\n",
        "\n",
        "<script>\n",
        "  \"use strict\";\n",
        "  \n",
        "  const sleep = (ms)=>new Promise(resolve => setTimeout(resolve, ms));\n",
        "  \n",
        "  const parseConsts = model_graph=>{\n",
        "    const dtypes = {'DT_INT32':['int32', 'intVal', Int32Array],\n",
        "                    'DT_FLOAT':['float32', 'floatVal', Float32Array]};\n",
        "    \n",
        "    const consts = {};\n",
        "    model_graph.modelTopology.node.filter(n=>n.op=='Const').forEach((node=>{\n",
        "      const v = node.attr.value.tensor;\n",
        "      const [dtype, field, arrayType] = dtypes[v.dtype];\n",
        "      if (!v.tensorShape.dim) {\n",
        "        consts[node.name] = [tf.scalar(v[field][0], dtype)];\n",
        "      } else {\n",
        "        const shape = v.tensorShape.dim.map(d=>parseInt(d.size));\n",
        "        let arr;\n",
        "        if (v.tensorContent) {\n",
        "          const data = atob(v.tensorContent);\n",
        "          const buf = new Uint8Array(data.length);\n",
        "          for (var i=0; i<data.length; ++i) {\n",
        "            buf[i] = data.charCodeAt(i);\n",
        "          }\n",
        "          arr = new arrayType(buf.buffer);\n",
        "        } else {\n",
        "          const size = shape.reduce((a, b)=>a*b);\n",
        "          arr = new arrayType(size);\n",
        "          arr.fill(v[field][0]);\n",
        "        }\n",
        "        consts[node.name] = [tf.tensor(arr, shape, dtype)];\n",
        "      }\n",
        "    }));\n",
        "    return consts;\n",
        "  }\n",
        "  \n",
        "  const run = async ()=>{\n",
        "    const r = await fetch(GRAPH_URL);\n",
        "    const consts = parseConsts(await r.json());\n",
        "    \n",
        "    const model = await tf.loadGraphModel(GRAPH_URL);\n",
        "    Object.assign(model.weights, consts);\n",
        "    \n",
        "    let seed = new Array(16).fill(0).map((x, i)=>i<3?0:1);\n",
        "    seed = tf.tensor(seed, [1, 1, 1, 16]);\n",
        "    \n",
        "    const D = 96;\n",
        "    const initState = tf.tidy(()=>{\n",
        "      const D2 = D/2;\n",
        "      const a = seed.pad([[0, 0], [D2-1, D2], [D2-1, D2], [0,0]]);\n",
        "      return a;\n",
        "    });\n",
        "    \n",
        "    const state = tf.variable(initState);\n",
        "    const [_, h, w, ch] = state.shape;\n",
        "    \n",
        "    const damage = (x, y, r)=>{\n",
        "      tf.tidy(()=>{\n",
        "        const rx = tf.range(0, w).sub(x).div(r).square().expandDims(0);\n",
        "        const ry = tf.range(0, h).sub(y).div(r).square().expandDims(1);\n",
        "        const mask = rx.add(ry).greater(1.0).expandDims(2);\n",
        "        state.assign(state.mul(mask));\n",
        "      });\n",
        "    }\n",
        "    \n",
        "    const plantSeed = (x, y)=>{\n",
        "      const x2 = w-x-seed.shape[2];\n",
        "      const y2 = h-y-seed.shape[1];\n",
        "      if (x<0 || x2<0 || y2<0 || y2<0)\n",
        "        return;\n",
        "      tf.tidy(()=>{\n",
        "        const a = seed.pad([[0, 0], [y, y2], [x, x2], [0,0]]);\n",
        "        state.assign(state.add(a));\n",
        "      });\n",
        "    }\n",
        "    \n",
        "    const scale = 4;\n",
        "    \n",
        "    const canvas = document.getElementById('canvas');\n",
        "    const ctx = canvas.getContext('2d');\n",
        "    canvas.width = w;\n",
        "    canvas.height = h;\n",
        "    canvas.style.width = `${w*scale}px`;\n",
        "    canvas.style.height = `${h*scale}px`;\n",
        "    \n",
        "    canvas.onmousedown = e=>{\n",
        "      const x = Math.floor(e.clientX/scale);\n",
        "        const y = Math.floor(e.clientY/scale);\n",
        "        if (e.buttons == 1) {\n",
        "          if (e.shiftKey) {\n",
        "            plantSeed(x, y);  \n",
        "          } else {\n",
        "            damage(x, y, 8);\n",
        "          }\n",
        "        }\n",
        "    }\n",
        "    canvas.onmousemove = e=>{\n",
        "      const x = Math.floor(e.clientX/scale);\n",
        "      const y = Math.floor(e.clientY/scale);\n",
        "      if (e.buttons == 1 && !e.shiftKey) {\n",
        "        damage(x, y, 8);\n",
        "      }\n",
        "    }\n",
        "    \n",
        "    for (let i=0;; ++i) {\n",
        "      if (i%2==0) {\n",
        "        const imageData = tf.tidy(()=>{\n",
        "          const rgba = state.slice([0, 0, 0, 0], [-1, -1, -1, 4]);\n",
        "          const a = state.slice([0, 0, 0, 3], [-1, -1, -1, 1]);\n",
        "          const img = tf.tensor(1.0).sub(a).add(rgba).mul(255);\n",
        "          const rgbaBytes = new Uint8ClampedArray(img.dataSync());\n",
        "          return new ImageData(rgbaBytes, w, h);\n",
        "        });\n",
        "        ctx.putImageData(imageData, 0, 0);\n",
        "        await sleep(1);\n",
        "      }\n",
        "      tf.tidy(()=>{\n",
        "        state.assign(model.execute(\n",
        "            {x:state, fire_rate:tf.tensor(0.5),\n",
        "            angle:tf.tensor(0.0), step_size:tf.tensor(1.0)}, ['Identity']));\n",
        "      });\n",
        "    }\n",
        "  }\n",
        "  //tf.setBackend('wasm').then(run);\n",
        "  run();\n",
        "  \n",
        "</script>\n",
        "''')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab_type": "code",
        "id": "POma99rMIfV4",
        "colab": {}
      },
      "source": [
        "#@title WebGL Demo\n",
        "\n",
        "#@markdown This code exports quantized models for the WebGL demo that is used in the article.\n",
        "#@markdown The demo code can be found at https://github.com/distillpub/post--growing-ca/blob/master/public/ca.js\n",
        "\n",
        "def pack_layer(weight, bias, outputType=np.uint8):\n",
        "  in_ch, out_ch = weight.shape\n",
        "  assert (in_ch%4==0) and (out_ch%4==0) and (bias.shape==(out_ch,))\n",
        "  weight_scale, bias_scale = 1.0, 1.0\n",
        "  if outputType == np.uint8:\n",
        "    weight_scale = 2.0*np.abs(weight).max()\n",
        "    bias_scale = 2.0*np.abs(bias).max()\n",
        "    weight = np.round((weight/weight_scale+0.5)*255)\n",
        "    bias = np.round((bias/bias_scale+0.5)*255)\n",
        "  packed = np.vstack([weight, bias[None,...]])\n",
        "  packed = packed.reshape(in_ch+1, out_ch//4, 4)\n",
        "  packed = outputType(packed)\n",
        "  packed_b64 = base64.b64encode(packed.tobytes()).decode('ascii')\n",
        "  return {'data_b64': packed_b64, 'in_ch': in_ch, 'out_ch': out_ch,\n",
        "          'weight_scale': weight_scale, 'bias_scale': bias_scale,\n",
        "          'type': outputType.__name__}\n",
        "\n",
        "def export_ca_to_webgl_demo(ca, outputType=np.uint8):\n",
        "  # reorder the first layer inputs to meet webgl demo perception layout\n",
        "  chn = ca.channel_n\n",
        "  w1 = ca.weights[0][0, 0].numpy()\n",
        "  w1 = w1.reshape(chn, 3, -1).transpose(1, 0, 2).reshape(3*chn, -1)\n",
        "  layers = [\n",
        "      pack_layer(w1, ca.weights[1].numpy(), outputType),\n",
        "      pack_layer(ca.weights[2][0, 0].numpy(), ca.weights[3].numpy(), outputType)\n",
        "  ]\n",
        "  return json.dumps(layers)\n",
        "\n",
        "with zipfile.ZipFile('webgl_models8.zip', 'w') as zf:\n",
        "  for e in EMOJI:\n",
        "    zf.writestr('ex1_%s.json'%e, export_ca_to_webgl_demo(get_model(e, use_pool=0, damage_n=0)))\n",
        "    run = 1 if e in '😀🕸' else 0  # select runs that happen to quantize better\n",
        "    zf.writestr('ex2_%s.json'%e, export_ca_to_webgl_demo(get_model(e, use_pool=1, damage_n=0, run=run)))\n",
        "    run = 1 if e in '🦎' else 0    # select runs that happen to quantize better\n",
        "    zf.writestr('ex3_%s.json'%e, export_ca_to_webgl_demo(get_model(e, use_pool=1, damage_n=3, run=run)))"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}