play.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset size: 111611\n",
      "Batch shapes - Bitmaps: (32, 28, 28), Coords: (32, 100, 2)\n"
     ]
    }
   ],
   "source": [
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import numpy as np\n",
    "import json\n",
    "from typing import Tuple, Dict, Any\n",
    "from flax.training import train_state\n",
    "import tensorflow as tf\n",
    "\n",
    "class PhotoSketchDataset:\n",
    "    def __init__(self, data_path: str, num_points: int = 100, image_size: int = 28):\n",
    "        self.data_path = data_path\n",
    "        self.num_points = num_points\n",
    "        self.image_size = image_size\n",
    "        self.drawings = []\n",
    "        \n",
    "        # Load the NDJSON file\n",
    "        with open(data_path, 'r') as f:\n",
    "            for line in f:\n",
    "                drawing_data = json.loads(line)\n",
    "                if drawing_data[\"recognized\"]:  # Only use recognized drawings\n",
    "                    self.drawings.append(drawing_data)\n",
    "        \n",
    "        # Load bitmap data\n",
    "        bitmap_path = self.data_path.replace('-simplified-bird.ndjson', '-numpy_bitmap-bird.npy')\n",
    "        self.bitmaps = np.load(bitmap_path)\n",
    "        \n",
    "        # Convert to numpy arrays for better performance\n",
    "        self._preprocess_data()\n",
    "    \n",
    "    def _preprocess_data(self):\n",
    "        \"\"\"Preprocess all data at once for better performance\"\"\"\n",
    "        processed_points = []\n",
    "        processed_bitmaps = []\n",
    "        \n",
    "        for idx in range(len(self.drawings)):\n",
    "            points, bitmap = self._process_single_item(idx)\n",
    "            processed_points.append(points)\n",
    "            processed_bitmaps.append(bitmap)\n",
    "        \n",
    "        self.processed_points = np.stack(processed_points)\n",
    "        self.processed_bitmaps = np.stack(processed_bitmaps)\n",
    "    \n",
    "    def _process_single_item(self, idx: int) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        \"\"\"Process a single drawing item\"\"\"\n",
    "        drawing_data = self.drawings[idx]\n",
    "        strokes = drawing_data[\"drawing\"]\n",
    "        \n",
    "        # Convert strokes to absolute coordinates\n",
    "        all_points = []\n",
    "        for stroke in strokes:\n",
    "            x_coords = np.array(stroke[0])\n",
    "            y_coords = np.array(stroke[1])\n",
    "            points = np.stack([x_coords, y_coords], axis=1)\n",
    "            all_points.append(points)\n",
    "        \n",
    "        # Concatenate all strokes\n",
    "        all_points = np.concatenate(all_points, axis=0)\n",
    "        \n",
    "        # Normalize coordinates to [0, 1]\n",
    "        all_points = all_points.astype(np.float32)\n",
    "        all_points[:, 0] = all_points[:, 0] / 255.0  # X coordinates\n",
    "        all_points[:, 1] = all_points[:, 1] / 255.0  # Y coordinates\n",
    "        \n",
    "        # Sample or pad to desired number of points\n",
    "        if len(all_points) > self.num_points:\n",
    "            indices = np.random.choice(len(all_points), self.num_points, replace=False)\n",
    "            all_points = all_points[indices]\n",
    "        else:\n",
    "            padding = np.pad(\n",
    "                all_points,\n",
    "                ((0, self.num_points - len(all_points)), (0, 0)),\n",
    "                mode='wrap'\n",
    "            )\n",
    "            all_points = padding\n",
    "        \n",
    "        # Get and process bitmap\n",
    "        bitmap = self.bitmaps[idx]\n",
    "        bitmap = bitmap.reshape(self.image_size, self.image_size)\n",
    "        bitmap = bitmap.astype(np.float32) / 255.0\n",
    "        \n",
    "        return all_points, bitmap\n",
    "\n",
    "    def get_dataset(self, batch_size: int = 32, shuffle: bool = True) -> tf.data.Dataset:\n",
    "        \"\"\"Create a tf.data.Dataset for efficient batching and prefetching\"\"\"\n",
    "        # Convert numpy arrays to tensors\n",
    "        points_tensor = tf.convert_to_tensor(self.processed_points, dtype=tf.float32)\n",
    "        bitmaps_tensor = tf.convert_to_tensor(self.processed_bitmaps, dtype=tf.float32)\n",
    "        \n",
    "        # Create dataset\n",
    "        dataset = tf.data.Dataset.from_tensor_slices((bitmaps_tensor, points_tensor))\n",
    "        \n",
    "        if shuffle:\n",
    "            dataset = dataset.shuffle(buffer_size=len(self.drawings))\n",
    "        \n",
    "        # Batch and prefetch\n",
    "        dataset = dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n",
    "        \n",
    "        return dataset\n",
    "\n",
    "def get_dataloaders(data_path: str, batch_size: int = 32, num_points: int = 100) -> Tuple[tf.data.Dataset, tf.data.Dataset]:\n",
    "    \"\"\"Create train and test datasets\"\"\"\n",
    "    dataset = PhotoSketchDataset(data_path, num_points=num_points)\n",
    "    \n",
    "    # Calculate split sizes\n",
    "    total_size = len(dataset.drawings)\n",
    "    train_size = int(0.8 * total_size)\n",
    "    \n",
    "    # Create train/test splits\n",
    "    indices = np.random.permutation(total_size)\n",
    "    train_indices = indices[:train_size]\n",
    "    test_indices = indices[train_size:]\n",
    "    \n",
    "    # Split the preprocessed data\n",
    "    train_points = dataset.processed_points[train_indices]\n",
    "    train_bitmaps = dataset.processed_bitmaps[train_indices]\n",
    "    test_points = dataset.processed_points[test_indices]\n",
    "    test_bitmaps = dataset.processed_bitmaps[test_indices]\n",
    "    \n",
    "    # Create datasets\n",
    "    train_dataset = tf.data.Dataset.from_tensor_slices((train_bitmaps, train_points))\n",
    "    test_dataset = tf.data.Dataset.from_tensor_slices((test_bitmaps, test_points))\n",
    "    \n",
    "    # Configure datasets\n",
    "    train_dataset = train_dataset.shuffle(buffer_size=len(train_indices))\n",
    "    train_dataset = train_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n",
    "    test_dataset = test_dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n",
    "    \n",
    "    return train_dataset, test_dataset\n",
    "\n",
    "# Utility functions for visualization\n",
    "def show_samples(dataset: tf.data.Dataset, num_samples: int = 5):\n",
    "    \"\"\"\n",
    "    Show samples from the dataset\n",
    "    Args:\n",
    "        dataset: tf.data.Dataset instance\n",
    "        num_samples: Number of samples to show\n",
    "    \"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "    \n",
    "    # Get samples\n",
    "    samples = next(iter(dataset.take(1)))\n",
    "    bitmaps, coords = samples\n",
    "    \n",
    "    # Convert to numpy for matplotlib\n",
    "    bitmaps = bitmaps.numpy()\n",
    "    coords = coords.numpy()\n",
    "    \n",
    "    fig, axes = plt.subplots(2, num_samples, figsize=(15, 6))\n",
    "    \n",
    "    for i in range(min(num_samples, bitmaps.shape[0])):\n",
    "        # Plot bitmap\n",
    "        axes[0, i].imshow(bitmaps[i], cmap='gray')\n",
    "        axes[0, i].set_title(f'Bitmap {i+1}')\n",
    "        axes[0, i].axis('off')\n",
    "        \n",
    "        # Plot vector coordinates\n",
    "        axes[1, i].scatter(coords[i, :, 0], coords[i, :, 1], s=1, c='black', alpha=0.5)\n",
    "        axes[1, i].set_xlim(0, 1)\n",
    "        axes[1, i].set_ylim(0, 1)\n",
    "        axes[1, i].invert_yaxis()  # Invert Y axis to match image coordinates\n",
    "        axes[1, i].set_aspect('equal')\n",
    "        axes[1, i].set_title(f'Vector {i+1}')\n",
    "        axes[1, i].axis('off')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# Test the dataset implementation\n",
    "def test_dataset():\n",
    "    # Create a small test dataset\n",
    "    dataset = PhotoSketchDataset('../data/full-simplified-bird.ndjson', num_points=100)\n",
    "    train_ds, test_ds = get_dataloaders(\n",
    "        '../data/full-simplified-bird.ndjson',\n",
    "        batch_size=32,\n",
    "        num_points=100\n",
    "    )\n",
    "    \n",
    "    # Print dataset info\n",
    "    print(f\"Dataset size: {len(dataset.drawings)}\")\n",
    "    \n",
    "    # Test batch iteration\n",
    "    for bitmaps, coords in train_ds.take(1):\n",
    "        print(f\"Batch shapes - Bitmaps: {bitmaps.shape}, Coords: {coords.shape}\")\n",
    "        break\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    test_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original coords shape: (4, 100, 2)\n",
      "Noised coords shape: (4, 100, 2)\n",
      "Timesteps shape: (4,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# diffusion.py\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from jax import random\n",
    "from typing import Tuple, Optional\n",
    "from functools import partial\n",
    "\n",
    "class DiffusionProcess:\n",
    "    def __init__(\n",
    "        self,\n",
    "        num_timesteps: int = 1000,\n",
    "        beta_start: float = 0.0001,\n",
    "        beta_end: float = 0.02,\n",
    "        dtype: jnp.dtype = jnp.float32\n",
    "    ):\n",
    "        self.num_timesteps = num_timesteps\n",
    "        self.dtype = dtype\n",
    "        \n",
    "        # Define noise schedule\n",
    "        self.betas = jnp.linspace(beta_start, beta_end, num_timesteps, dtype=dtype)\n",
    "        self.alphas = 1.0 - self.betas\n",
    "        self.alphas_cumprod = jnp.cumprod(self.alphas)\n",
    "        \n",
    "        # Pre-compute values for sampling\n",
    "        self.sqrt_alphas_cumprod = jnp.sqrt(self.alphas_cumprod)\n",
    "        self.sqrt_one_minus_alphas_cumprod = jnp.sqrt(1.0 - self.alphas_cumprod)\n",
    "        \n",
    "        # Pre-compute values for inference\n",
    "        self.sqrt_recip_alphas = jnp.sqrt(1.0 / self.alphas)\n",
    "        alphas_cumprod_prev = jnp.append(jnp.array([1.0]), self.alphas_cumprod[:-1])\n",
    "        self.posterior_variance = self.betas * (1.0 - alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)\n",
    "\n",
    "    def _sample_timesteps_impl(self, key: jnp.ndarray, batch_size: int) -> jnp.ndarray:\n",
    "        \"\"\"Implementation of timestep sampling, separated for proper JIT compilation\"\"\"\n",
    "        return random.randint(\n",
    "            key,\n",
    "            shape=(batch_size,),\n",
    "            minval=0,\n",
    "            maxval=self.num_timesteps,\n",
    "            dtype=jnp.int32\n",
    "        )\n",
    "\n",
    "    def sample_timesteps(self, key: jnp.ndarray, batch_size: int) -> jnp.ndarray:\n",
    "        \"\"\"\n",
    "        Sample random timesteps for a batch.\n",
    "        \n",
    "        Args:\n",
    "            key: JAX PRNG key\n",
    "            batch_size: Size of batch to generate timesteps for\n",
    "            \n",
    "        Returns:\n",
    "            timesteps: Random timesteps array\n",
    "        \"\"\"\n",
    "        # Create a JIT-compiled version of the implementation with batch_size as static\n",
    "        sample_fn = jax.jit(\n",
    "            self._sample_timesteps_impl,\n",
    "            static_argnums=(1,)\n",
    "        )\n",
    "        return sample_fn(key, batch_size)\n",
    "\n",
    "    @partial(jax.jit, static_argnums=(0,))\n",
    "    def add_noise(\n",
    "        self,\n",
    "        key: jnp.ndarray,\n",
    "        sketch_coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray\n",
    "    ) -> Tuple[jnp.ndarray, jnp.ndarray]:\n",
    "        \"\"\"\n",
    "        Add noise to sketch coordinates based on timestep.\n",
    "        \"\"\"\n",
    "        noise = random.normal(\n",
    "            key,\n",
    "            sketch_coords.shape,\n",
    "            dtype=self.dtype\n",
    "        )\n",
    "        \n",
    "        sqrt_alphas = jnp.take(self.sqrt_alphas_cumprod, timesteps)\n",
    "        sqrt_one_minus_alphas = jnp.take(self.sqrt_one_minus_alphas_cumprod, timesteps)\n",
    "        \n",
    "        sqrt_alphas = sqrt_alphas[:, None, None]\n",
    "        sqrt_one_minus_alphas = sqrt_one_minus_alphas[:, None, None]\n",
    "        \n",
    "        noised_coords = sqrt_alphas * sketch_coords + sqrt_one_minus_alphas * noise\n",
    "        return noised_coords, noise\n",
    "\n",
    "    @partial(jax.jit, static_argnums=(0,))\n",
    "    def remove_noise(\n",
    "        self,\n",
    "        noised_coords: jnp.ndarray,\n",
    "        pred_noise: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"\n",
    "        Remove predicted noise from noised coordinates.\n",
    "        \"\"\"\n",
    "        sqrt_alphas = jnp.take(self.sqrt_alphas_cumprod, timesteps)\n",
    "        sqrt_one_minus_alphas = jnp.take(self.sqrt_one_minus_alphas_cumprod, timesteps)\n",
    "        \n",
    "        sqrt_alphas = sqrt_alphas[:, None, None]\n",
    "        sqrt_one_minus_alphas = sqrt_one_minus_alphas[:, None, None]\n",
    "        \n",
    "        return (noised_coords - sqrt_one_minus_alphas * pred_noise) / sqrt_alphas\n",
    "\n",
    "    @partial(jax.jit, static_argnums=(0,))\n",
    "    def q_sample(\n",
    "        self,\n",
    "        key: jnp.ndarray,\n",
    "        sketch_coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Sample from the forward diffusion process.\"\"\"\n",
    "        noised_coords, _ = self.add_noise(key, sketch_coords, timesteps)\n",
    "        return noised_coords\n",
    "\n",
    "    @partial(jax.jit, static_argnums=(0,))\n",
    "    def p_sample(\n",
    "        self,\n",
    "        key: jnp.ndarray,\n",
    "        model_fn,\n",
    "        noised_coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray,\n",
    "        clip_denoised: bool = True\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Sample from the reverse diffusion process (single step).\"\"\"\n",
    "        pred_noise = model_fn(noised_coords, timesteps)\n",
    "        pred_coords = self.remove_noise(noised_coords, pred_noise, timesteps)\n",
    "        \n",
    "        if clip_denoised:\n",
    "            pred_coords = jnp.clip(pred_coords, -1.0, 1.0)\n",
    "        return pred_coords\n",
    "\n",
    "def test_diffusion():\n",
    "    \"\"\"Test the diffusion process implementation\"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "    \n",
    "    # Initialize\n",
    "    key = random.PRNGKey(0)\n",
    "    diffusion = DiffusionProcess()\n",
    "    \n",
    "    # Create dummy data\n",
    "    batch_size = 4\n",
    "    num_points = 100\n",
    "    key, subkey = random.split(key)\n",
    "    sketch_coords = random.normal(\n",
    "        subkey,\n",
    "        shape=(batch_size, num_points, 2)\n",
    "    )\n",
    "    \n",
    "    # Sample timesteps\n",
    "    key, subkey = random.split(key)\n",
    "    timesteps = diffusion.sample_timesteps(subkey, batch_size)\n",
    "    \n",
    "    # Add noise\n",
    "    key, subkey = random.split(key)\n",
    "    noised_coords, noise = diffusion.add_noise(subkey, sketch_coords, timesteps)\n",
    "    \n",
    "    # Test shapes\n",
    "    print(f\"Original coords shape: {sketch_coords.shape}\")\n",
    "    print(f\"Noised coords shape: {noised_coords.shape}\")\n",
    "    print(f\"Timesteps shape: {timesteps.shape}\")\n",
    "    \n",
    "    # Visualize noising process for first example\n",
    "    plt.figure(figsize=(15, 5))\n",
    "    \n",
    "    # Original\n",
    "    plt.subplot(131)\n",
    "    plt.scatter(sketch_coords[0, :, 0], sketch_coords[0, :, 1], s=1)\n",
    "    plt.title(\"Original\")\n",
    "    plt.axis('equal')\n",
    "    \n",
    "    # Noised\n",
    "    plt.subplot(132)\n",
    "    plt.scatter(noised_coords[0, :, 0], noised_coords[0, :, 1], s=1)\n",
    "    plt.title(f\"Noised (t={timesteps[0]})\")\n",
    "    plt.axis('equal')\n",
    "    \n",
    "    # Noise\n",
    "    plt.subplot(133)\n",
    "    plt.scatter(noise[0, :, 0], noise[0, :, 1], s=1)\n",
    "    plt.title(\"Added Noise\")\n",
    "    plt.axis('equal')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    test_diffusion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input coords shape: (4, 100, 2)\n",
      "Output coords shape: (4, 100, 2)\n",
      "Test successful!\n"
     ]
    }
   ],
   "source": [
    "# decoder.py\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import flax.linen as nn\n",
    "from typing import Optional, Tuple\n",
    "import math\n",
    "from functools import partial\n",
    "\n",
    "class PositionalEncoding(nn.Module):\n",
    "    \"\"\"Positional encoding module using sinusoidal functions\"\"\"\n",
    "    d_model: int\n",
    "    max_len: int = 5000\n",
    "    \n",
    "    def setup(self):\n",
    "        position = jnp.arange(self.max_len)[:, None]\n",
    "        div_term = jnp.exp(\n",
    "            jnp.arange(0, self.d_model, 2) * (-math.log(10000.0) / self.d_model)\n",
    "        )\n",
    "        \n",
    "        pe = jnp.zeros((self.max_len, self.d_model))\n",
    "        pe = pe.at[:, 0::2].set(jnp.sin(position * div_term))\n",
    "        pe = pe.at[:, 1::2].set(jnp.cos(position * div_term))\n",
    "        \n",
    "        self.pe = pe\n",
    "    \n",
    "    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:\n",
    "        x = x + self.pe[:x.shape[1]]\n",
    "        return x\n",
    "\n",
    "class TimestepEmbedding(nn.Module):\n",
    "    \"\"\"Timestep embedding module\"\"\"\n",
    "    embed_dim: int\n",
    "    \n",
    "    @nn.compact\n",
    "    def __call__(self, timesteps: jnp.ndarray) -> jnp.ndarray:\n",
    "        timesteps = timesteps[:, None].astype(jnp.float32)\n",
    "        x = nn.Dense(self.embed_dim)(timesteps)\n",
    "        x = nn.silu(x)\n",
    "        x = nn.Dense(self.embed_dim)(x)\n",
    "        return x\n",
    "\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    \"\"\"Multi-head attention module with proper masking support\"\"\"\n",
    "    num_heads: int\n",
    "    d_model: int\n",
    "    dropout_rate: float = 0.1\n",
    "    deterministic: bool = True\n",
    "    \n",
    "    def setup(self):\n",
    "        head_dim = self.d_model // self.num_heads\n",
    "        self.scale = head_dim ** -0.5\n",
    "        \n",
    "        self.qkv = nn.Dense(3 * self.d_model, use_bias=False)\n",
    "        self.proj = nn.Dense(self.d_model)\n",
    "        self.dropout = nn.Dropout(rate=self.dropout_rate)\n",
    "    \n",
    "    def __call__(\n",
    "        self,\n",
    "        x: jnp.ndarray,\n",
    "        mask: Optional[jnp.ndarray] = None,\n",
    "        deterministic: Optional[bool] = None\n",
    "    ) -> jnp.ndarray:\n",
    "        deterministic = self.deterministic if deterministic is None else deterministic\n",
    "        batch_size, seq_len = x.shape[:2]\n",
    "        \n",
    "        # Get query, key, value projections\n",
    "        qkv = self.qkv(x)\n",
    "        qkv = qkv.reshape(batch_size, seq_len, 3, self.num_heads, -1)\n",
    "        qkv = qkv.transpose(2, 0, 3, 1, 4)\n",
    "        q, k, v = qkv[0], qkv[1], qkv[2]\n",
    "        \n",
    "        # Compute attention\n",
    "        attn = (q @ k.transpose(0, 1, 3, 2)) * self.scale\n",
    "        \n",
    "        if mask is not None:\n",
    "            attn = jnp.where(mask == 0, float('-inf'), attn)\n",
    "        \n",
    "        attn = jax.nn.softmax(attn, axis=-1)\n",
    "        attn = self.dropout(attn, deterministic=deterministic)\n",
    "        \n",
    "        x = (attn @ v).transpose(0, 2, 1, 3).reshape(batch_size, seq_len, self.d_model)\n",
    "        x = self.proj(x)\n",
    "        x = self.dropout(x, deterministic=deterministic)\n",
    "        \n",
    "        return x\n",
    "\n",
    "class TransformerDecoderLayer(nn.Module):\n",
    "    \"\"\"Single transformer decoder layer\"\"\"\n",
    "    d_model: int\n",
    "    nhead: int\n",
    "    dim_feedforward: int = 2048\n",
    "    dropout: float = 0.1\n",
    "    deterministic: bool = True\n",
    "    \n",
    "    @nn.compact\n",
    "    def __call__(\n",
    "        self,\n",
    "        tgt: jnp.ndarray,\n",
    "        memory: jnp.ndarray,\n",
    "        tgt_mask: Optional[jnp.ndarray] = None,\n",
    "        memory_mask: Optional[jnp.ndarray] = None,\n",
    "        deterministic: Optional[bool] = None\n",
    "    ) -> jnp.ndarray:\n",
    "        deterministic = self.deterministic if deterministic is None else deterministic\n",
    "        \n",
    "        # Self attention\n",
    "        x = nn.LayerNorm()(tgt)\n",
    "        x = MultiHeadAttention(\n",
    "            num_heads=self.nhead,\n",
    "            d_model=self.d_model,\n",
    "            dropout_rate=self.dropout,\n",
    "            deterministic=deterministic\n",
    "        )(x, mask=tgt_mask)\n",
    "        tgt = tgt + x\n",
    "        \n",
    "        # Cross attention\n",
    "        x = nn.LayerNorm()(tgt)\n",
    "        x = MultiHeadAttention(\n",
    "            num_heads=self.nhead,\n",
    "            d_model=self.d_model,\n",
    "            dropout_rate=self.dropout,\n",
    "            deterministic=deterministic\n",
    "        )(x, mask=memory_mask)\n",
    "        tgt = tgt + x\n",
    "        \n",
    "        # Feedforward\n",
    "        x = nn.LayerNorm()(tgt)\n",
    "        x = nn.Dense(self.dim_feedforward)(x)\n",
    "        x = nn.gelu(x)\n",
    "        x = nn.Dropout(rate=self.dropout)(x, deterministic=deterministic)\n",
    "        x = nn.Dense(self.d_model)(x)\n",
    "        x = nn.Dropout(rate=self.dropout)(x, deterministic=deterministic)\n",
    "        tgt = tgt + x\n",
    "        \n",
    "        return tgt\n",
    "\n",
    "class TransformerDecoder(nn.Module):\n",
    "    \"\"\"Complete transformer decoder\"\"\"\n",
    "    d_model: int = 512\n",
    "    nhead: int = 8\n",
    "    num_layers: int = 6\n",
    "    dim_feedforward: int = 2048\n",
    "    dropout: float = 0.1\n",
    "    max_seq_length: int = 1000\n",
    "    deterministic: bool = True\n",
    "    \n",
    "    def setup(self):\n",
    "        # Create embedding modules\n",
    "        self.coord_embed = nn.Dense(self.d_model)\n",
    "        self.timestep_embed = TimestepEmbedding(self.d_model)\n",
    "        self.pos_encoder = PositionalEncoding(self.d_model, self.max_seq_length)\n",
    "        \n",
    "        # Create decoder layers\n",
    "        self.layers = [\n",
    "            TransformerDecoderLayer(\n",
    "                d_model=self.d_model,\n",
    "                nhead=self.nhead,\n",
    "                dim_feedforward=self.dim_feedforward,\n",
    "                dropout=self.dropout,\n",
    "                deterministic=self.deterministic\n",
    "            )\n",
    "            for _ in range(self.num_layers)\n",
    "        ]\n",
    "        \n",
    "        # Output projection\n",
    "        self.output_proj = nn.Dense(2)\n",
    "    \n",
    "    def __call__(\n",
    "        self,\n",
    "        noised_coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray,\n",
    "        image_embedding: jnp.ndarray,\n",
    "        key_padding_mask: Optional[jnp.ndarray] = None,\n",
    "        deterministic: Optional[bool] = None\n",
    "    ) -> jnp.ndarray:\n",
    "        deterministic = self.deterministic if deterministic is None else deterministic\n",
    "        \n",
    "        # Embed coordinates\n",
    "        x = self.coord_embed(noised_coords)\n",
    "        \n",
    "        # Add positional encoding\n",
    "        x = self.pos_encoder(x)\n",
    "        \n",
    "        # Get timestep embeddings and expand to sequence length\n",
    "        t_emb = self.timestep_embed(timesteps)\n",
    "        t_emb = jnp.expand_dims(t_emb, axis=1)\n",
    "        t_emb = jnp.tile(t_emb, (1, x.shape[1], 1))\n",
    "        \n",
    "        # Combine coordinate embeddings with timestep embeddings\n",
    "        x = x + t_emb\n",
    "        \n",
    "        # Prepare image embedding as memory for cross-attention\n",
    "        memory = jnp.expand_dims(image_embedding, axis=1)\n",
    "        \n",
    "        # Apply transformer decoder layers\n",
    "        for layer in self.layers:\n",
    "            x = layer(\n",
    "                x,\n",
    "                memory,\n",
    "                tgt_mask=None,\n",
    "                memory_mask=None,\n",
    "                deterministic=deterministic\n",
    "            )\n",
    "        \n",
    "        # Project back to coordinates\n",
    "        pred_coords = self.output_proj(x)\n",
    "        \n",
    "        return pred_coords\n",
    "\n",
    "def create_decoder_params(\n",
    "    key: jnp.ndarray,\n",
    "    batch_size: int = 1,\n",
    "    seq_length: int = 100,\n",
    "    d_model: int = 512\n",
    ") -> dict:\n",
    "    \"\"\"Initialize decoder parameters\"\"\"\n",
    "    decoder = TransformerDecoder(d_model=d_model)\n",
    "    \n",
    "    # Create dummy inputs for initialization\n",
    "    dummy_coords = jnp.ones((batch_size, seq_length, 2))\n",
    "    dummy_timesteps = jnp.zeros((batch_size,), dtype=jnp.int32)\n",
    "    dummy_image_embedding = jnp.ones((batch_size, d_model))\n",
    "    \n",
    "    # Initialize parameters\n",
    "    return decoder.init(\n",
    "        key,\n",
    "        dummy_coords,\n",
    "        dummy_timesteps,\n",
    "        dummy_image_embedding,\n",
    "        deterministic=True\n",
    "    )\n",
    "\n",
    "def test_decoder():\n",
    "    \"\"\"Test the transformer decoder implementation\"\"\"\n",
    "    import jax.random as random\n",
    "    \n",
    "    # Create random key\n",
    "    key = random.PRNGKey(0)\n",
    "    \n",
    "    # Create dummy inputs\n",
    "    batch_size = 4\n",
    "    seq_length = 100\n",
    "    d_model = 256\n",
    "    \n",
    "    noised_coords = jnp.ones((batch_size, seq_length, 2))\n",
    "    timesteps = jnp.zeros((batch_size,), dtype=jnp.int32)\n",
    "    image_embedding = jnp.ones((batch_size, d_model))\n",
    "    \n",
    "    # Initialize model\n",
    "    decoder = TransformerDecoder(d_model=d_model)\n",
    "    params = create_decoder_params(key, batch_size, seq_length, d_model)\n",
    "    \n",
    "    # Forward pass\n",
    "    output = decoder.apply(\n",
    "        params,\n",
    "        noised_coords,\n",
    "        timesteps,\n",
    "        image_embedding,\n",
    "        deterministic=True\n",
    "    )\n",
    "    \n",
    "    print(f\"Input coords shape: {noised_coords.shape}\")\n",
    "    print(f\"Output coords shape: {output.shape}\")\n",
    "    print(\"Test successful!\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    test_decoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input shape: (4, 28, 28)\n",
      "Output shape: (4, 256)\n",
      "Output embedding dimension: 256\n",
      "Test successful!\n"
     ]
    }
   ],
   "source": [
    "#encoder.py\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "import flax.linen as nn\n",
    "from typing import Tuple, Optional, Dict, Any\n",
    "from functools import partial\n",
    "\n",
    "class ConvBNAct(nn.Module):\n",
    "    \"\"\"Convolution-BatchNorm-Activation block\"\"\"\n",
    "    features: int\n",
    "    kernel_size: Tuple[int, int] = (3, 3)\n",
    "    strides: Tuple[int, int] = (1, 1)\n",
    "    padding: str = 'SAME'\n",
    "    use_bias: bool = False\n",
    "    \n",
    "    @nn.compact\n",
    "    def __call__(self, x: jnp.ndarray, training: bool = True) -> jnp.ndarray:\n",
    "        x = nn.Conv(\n",
    "            features=self.features,\n",
    "            kernel_size=self.kernel_size,\n",
    "            strides=self.strides,\n",
    "            padding=self.padding,\n",
    "            use_bias=self.use_bias\n",
    "        )(x)\n",
    "        x = nn.BatchNorm(\n",
    "            use_running_average=not training,\n",
    "            momentum=0.9,\n",
    "            epsilon=1e-5\n",
    "        )(x)\n",
    "        return nn.relu(x)\n",
    "\n",
    "class SEBlock(nn.Module):\n",
    "    \"\"\"Squeeze-and-Excitation block for channel attention\"\"\"\n",
    "    features: int\n",
    "    reduction_ratio: int = 4\n",
    "    \n",
    "    @nn.compact\n",
    "    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:\n",
    "        input_channels = x.shape[-1]\n",
    "        \n",
    "        # Global Average Pooling\n",
    "        pooled = jnp.mean(x, axis=(1, 2), keepdims=True)\n",
    "        \n",
    "        # Reduction\n",
    "        reduced = nn.Conv(\n",
    "            features=max(1, input_channels // self.reduction_ratio),\n",
    "            kernel_size=(1, 1)\n",
    "        )(pooled)\n",
    "        reduced = nn.relu(reduced)\n",
    "        \n",
    "        # Expansion\n",
    "        expanded = nn.Conv(\n",
    "            features=input_channels,\n",
    "            kernel_size=(1, 1)\n",
    "        )(reduced)\n",
    "        weights = nn.sigmoid(expanded)\n",
    "        \n",
    "        return x * weights\n",
    "\n",
    "class InvertedResidual(nn.Module):\n",
    "    \"\"\"MobileNetV3 Inverted Residual block\"\"\"\n",
    "    features: int\n",
    "    stride: int\n",
    "    expand_ratio: int = 6\n",
    "    use_se: bool = True\n",
    "    \n",
    "    @nn.compact\n",
    "    def __call__(self, x: jnp.ndarray, training: bool = True) -> jnp.ndarray:\n",
    "        input_channels = x.shape[-1]\n",
    "        expanded_features = input_channels * self.expand_ratio\n",
    "        \n",
    "        # Expansion\n",
    "        if self.expand_ratio != 1:\n",
    "            residual = ConvBNAct(\n",
    "                features=expanded_features,\n",
    "                kernel_size=(1, 1)\n",
    "            )(x, training=training)\n",
    "        else:\n",
    "            residual = x\n",
    "        \n",
    "        # Depthwise\n",
    "        residual = nn.Conv(\n",
    "            features=expanded_features,\n",
    "            kernel_size=(3, 3),\n",
    "            strides=(self.stride, self.stride),\n",
    "            padding='SAME',\n",
    "            feature_group_count=expanded_features\n",
    "        )(residual)\n",
    "        residual = nn.BatchNorm(use_running_average=not training)(residual)\n",
    "        residual = nn.relu(residual)\n",
    "        \n",
    "        # SE block\n",
    "        if self.use_se:\n",
    "            residual = SEBlock(features=expanded_features)(residual)\n",
    "        \n",
    "        # Projection\n",
    "        residual = ConvBNAct(\n",
    "            features=self.features,\n",
    "            kernel_size=(1, 1)\n",
    "        )(residual, training=training)\n",
    "        \n",
    "        # Skip connection\n",
    "        if self.stride == 1 and input_channels == self.features:\n",
    "            return x + residual\n",
    "        return residual\n",
    "\n",
    "class BitmapEncoder(nn.Module):\n",
    "    \"\"\"Encodes bitmap images into fixed-dimensional embeddings\"\"\"\n",
    "    embed_dim: int = 256\n",
    "    \n",
    "    @nn.compact\n",
    "    def __call__(self, bitmap: jnp.ndarray, training: bool = True) -> jnp.ndarray:\n",
    "        # Ensure input has correct shape\n",
    "        if bitmap.ndim == 3:\n",
    "            bitmap = jnp.expand_dims(bitmap, axis=-1)\n",
    "        \n",
    "        # Initial conv to get to 3 channels\n",
    "        x = nn.Conv(features=3, kernel_size=(1, 1))(bitmap)\n",
    "        \n",
    "        # Early layers adapted for 28x28 input\n",
    "        x = ConvBNAct(\n",
    "            features=16,\n",
    "            kernel_size=(3, 3),\n",
    "            strides=(2, 2)\n",
    "        )(x, training=training)\n",
    "        \n",
    "        x = InvertedResidual(\n",
    "            features=24,\n",
    "            stride=2,\n",
    "            expand_ratio=4,\n",
    "            use_se=True\n",
    "        )(x, training=training)\n",
    "        \n",
    "        x = InvertedResidual(\n",
    "            features=32,\n",
    "            stride=1,\n",
    "            expand_ratio=4,\n",
    "            use_se=True\n",
    "        )(x, training=training)\n",
    "        \n",
    "        # Feature processor\n",
    "        x = ConvBNAct(\n",
    "            features=64,\n",
    "            kernel_size=(1, 1)\n",
    "        )(x, training=training)\n",
    "        \n",
    "        x = ConvBNAct(\n",
    "            features=self.embed_dim,\n",
    "            kernel_size=(1, 1)\n",
    "        )(x, training=training)\n",
    "        \n",
    "        # Global average pooling\n",
    "        x = jnp.mean(x, axis=(1, 2))\n",
    "        \n",
    "        return x\n",
    "\n",
    "def create_encoder_params(\n",
    "    key: jnp.ndarray,\n",
    "    batch_size: int = 1,\n",
    "    image_size: Tuple[int, int] = (28, 28),\n",
    "    embed_dim: int = 256\n",
    ") -> Dict[str, Any]:\n",
    "    \"\"\"Initialize encoder parameters\"\"\"\n",
    "    encoder = BitmapEncoder(embed_dim=embed_dim)\n",
    "    dummy_bitmap = jnp.ones((batch_size, *image_size))\n",
    "    \n",
    "    variables = encoder.init(\n",
    "        {'params': key, 'batch_stats': key},\n",
    "        dummy_bitmap,\n",
    "        training=False\n",
    "    )\n",
    "    \n",
    "    return variables\n",
    "\n",
    "def test_encoder():\n",
    "    \"\"\"Test the bitmap encoder implementation\"\"\"\n",
    "    import jax.random as random\n",
    "    \n",
    "    # Create random key\n",
    "    key = random.PRNGKey(0)\n",
    "    key, subkey = random.split(key)\n",
    "    \n",
    "    # Create dummy batch\n",
    "    batch_size = 4\n",
    "    image_size = (28, 28)\n",
    "    embed_dim = 256\n",
    "    \n",
    "    # Initialize model\n",
    "    encoder = BitmapEncoder(embed_dim=embed_dim)\n",
    "    variables = create_encoder_params(subkey, batch_size, image_size, embed_dim)\n",
    "    \n",
    "    # Create dummy batch\n",
    "    dummy_batch = jnp.ones((batch_size, *image_size))\n",
    "    \n",
    "    # Forward pass\n",
    "    output = encoder.apply(\n",
    "        variables,\n",
    "        dummy_batch,\n",
    "        training=False,\n",
    "        mutable=['batch_stats']\n",
    "    )\n",
    "    \n",
    "    # When training=True, output is a tuple (output, mutated_variables)\n",
    "    # When training=False, output is just the tensor\n",
    "    if isinstance(output, tuple):\n",
    "        output, updated_variables = output\n",
    "    \n",
    "    print(f\"Input shape: {dummy_batch.shape}\")\n",
    "    print(f\"Output shape: {output.shape}\")\n",
    "    print(f\"Output embedding dimension: {output.shape[-1]}\")\n",
    "    print(\"Test successful!\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    test_encoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Losses without target bitmap:\n",
      "coord_loss: 0.18516159057617188\n",
      "raster_loss: 4.524770736694336\n",
      "total_loss: 2.44754695892334\n",
      "\n",
      "Losses with target bitmap:\n",
      "coord_loss: 0.18516159057617188\n",
      "raster_loss: 8.001110076904297\n",
      "total_loss: 4.18571662902832\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#losses.py\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from jax import lax\n",
    "import flax.linen as nn\n",
    "from typing import Tuple, Dict, Optional\n",
    "from functools import partial\n",
    "\n",
    "class NimbleLoss(nn.Module):\n",
    "    \"\"\"Loss module for sketch generation\"\"\"\n",
    "    coord_weight: float = 1.0\n",
    "    raster_weight: float = 0.5\n",
    "    canvas_size: Tuple[int, int] = (28, 28)  # Bitmap size\n",
    "    \n",
    "    def coordinate_loss(\n",
    "        self,\n",
    "        pred_coords: jnp.ndarray,\n",
    "        target_coords: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Compute L2 loss between predicted and target coordinates\"\"\"\n",
    "        return jnp.mean((pred_coords - target_coords) ** 2)\n",
    "\n",
    "    def _rasterize_line(\n",
    "        self,\n",
    "        x0: jnp.ndarray,\n",
    "        y0: jnp.ndarray,\n",
    "        x1: jnp.ndarray,\n",
    "        y1: jnp.ndarray,\n",
    "        canvas: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Rasterize a single line using JAX control flow\"\"\"\n",
    "        dx = jnp.abs(x1 - x0)\n",
    "        dy = jnp.abs(y1 - y0)\n",
    "        \n",
    "        def swap_points(x0, y0, x1, y1):\n",
    "            return y0, x0, y1, x1\n",
    "\n",
    "        # Handle steep lines\n",
    "        steep = dy > dx\n",
    "        x0, y0, x1, y1 = lax.cond(\n",
    "            steep,\n",
    "            lambda args: swap_points(*args),\n",
    "            lambda args: args,\n",
    "            (x0, y0, x1, y1)\n",
    "        )\n",
    "        \n",
    "        # Ensure x0 <= x1\n",
    "        swap = x0 > x1\n",
    "        x0, x1 = lax.cond(\n",
    "            swap,\n",
    "            lambda x: (x[1], x[0]),\n",
    "            lambda x: x,\n",
    "            (x0, x1)\n",
    "        )\n",
    "        y0, y1 = lax.cond(\n",
    "            swap,\n",
    "            lambda y: (y[1], y[0]),\n",
    "            lambda y: y,\n",
    "            (y0, y1)\n",
    "        )\n",
    "        \n",
    "        dx = x1 - x0\n",
    "        dy = jnp.abs(y1 - y0)\n",
    "        ystep = jnp.where(y0 < y1, 1, -1)\n",
    "        \n",
    "        def plot_point(args):\n",
    "            x, y, canvas = args\n",
    "            # Handle steep vs non-steep lines\n",
    "            plot_x = lax.cond(steep, lambda: y, lambda: x)\n",
    "            plot_y = lax.cond(steep, lambda: x, lambda: y)\n",
    "            \n",
    "            # Check bounds\n",
    "            valid = (plot_x >= 0) & (plot_x < canvas.shape[1]) & \\\n",
    "                   (plot_y >= 0) & (plot_y < canvas.shape[0])\n",
    "            \n",
    "            # Update canvas\n",
    "            return lax.cond(\n",
    "                valid,\n",
    "                lambda: canvas.at[plot_y, plot_x].set(1.0),\n",
    "                lambda: canvas\n",
    "            )\n",
    "        \n",
    "        def body_fn(i, state):\n",
    "            x = x0 + i\n",
    "            y = y0 + (ystep * dy * i / dx).astype(jnp.int32)\n",
    "            canvas = plot_point((x, y, state))\n",
    "            return canvas\n",
    "        \n",
    "        # Draw the line using fori_loop\n",
    "        canvas = lax.fori_loop( # a JAX equivalent of a Python for-loop, optimized for performance and compilation with jit.\n",
    "            0,\n",
    "            dx.astype(jnp.int32) + 1,\n",
    "            body_fn,\n",
    "            canvas\n",
    "        )\n",
    "        \n",
    "        return canvas\n",
    "\n",
    "    @partial(jax.jit, static_argnums=(0,))\n",
    "    def rasterize_strokes(\n",
    "        self,\n",
    "        coords: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Rasterize vector coordinates to image\"\"\"\n",
    "        batch_size, num_points, _ = coords.shape\n",
    "        H, W = self.canvas_size\n",
    "        \n",
    "        # Scale coordinates to pixel space\n",
    "        coords = coords * jnp.array([W - 1, H - 1])\n",
    "        coords = coords.astype(jnp.int32)\n",
    "        \n",
    "        def rasterize_single(coords_single):\n",
    "            # Initialize empty canvas\n",
    "            canvas = jnp.zeros(self.canvas_size)\n",
    "            \n",
    "            def draw_segment(i, canvas):\n",
    "                x0, y0 = coords_single[i]\n",
    "                x1, y1 = coords_single[i + 1]\n",
    "                return self._rasterize_line(x0, y0, x1, y1, canvas)\n",
    "            \n",
    "            return lax.fori_loop(0, num_points - 1, draw_segment, canvas)\n",
    "        \n",
    "        # Vectorize over batch\n",
    "        return jax.vmap(rasterize_single)(coords)\n",
    "    \n",
    "    def rasterization_loss(\n",
    "        self,\n",
    "        pred_coords: jnp.ndarray,\n",
    "        target_coords: jnp.ndarray,\n",
    "        target_bitmap: Optional[jnp.ndarray] = None\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Compute rasterization loss\"\"\"\n",
    "        pred_raster = self.rasterize_strokes(pred_coords)\n",
    "        \n",
    "        if target_bitmap is not None:\n",
    "            # Binary cross entropy with target bitmap\n",
    "            epsilon = 1e-7\n",
    "            pred_raster = jnp.clip(pred_raster, epsilon, 1.0 - epsilon)\n",
    "            bce = -(target_bitmap * jnp.log(pred_raster) + \n",
    "                   (1 - target_bitmap) * jnp.log(1 - pred_raster))\n",
    "            return jnp.mean(bce)\n",
    "        else:\n",
    "            # Compare with rasterized target coordinates\n",
    "            target_raster = self.rasterize_strokes(target_coords)\n",
    "            pred_raster = jnp.clip(pred_raster, 1e-7, 1.0 - 1e-7)\n",
    "            bce = -(target_raster * jnp.log(pred_raster) + \n",
    "                   (1 - target_raster) * jnp.log(1 - pred_raster))\n",
    "            return jnp.mean(bce)\n",
    "    \n",
    "    @partial(jax.jit, static_argnums=(0,))\n",
    "    def __call__(\n",
    "        self,\n",
    "        pred_coords: jnp.ndarray,\n",
    "        target_coords: jnp.ndarray,\n",
    "        target_bitmap: Optional[jnp.ndarray] = None\n",
    "    ) -> Dict[str, jnp.ndarray]:\n",
    "        \"\"\"Compute combined loss\"\"\"\n",
    "        coord_loss = self.coordinate_loss(pred_coords, target_coords)\n",
    "        raster_loss = self.rasterization_loss(pred_coords, target_coords, target_bitmap)\n",
    "        \n",
    "        total_loss = self.coord_weight * coord_loss + self.raster_weight * raster_loss\n",
    "        \n",
    "        return {\n",
    "            'coord_loss': coord_loss,\n",
    "            'raster_loss': raster_loss,\n",
    "            'total_loss': total_loss\n",
    "        }\n",
    "\n",
    "def test_losses():\n",
    "    \"\"\"Test the loss implementation\"\"\"\n",
    "    import jax.random as random\n",
    "    import matplotlib.pyplot as plt\n",
    "    \n",
    "    # Create random key\n",
    "    key = random.PRNGKey(0)\n",
    "    \n",
    "    # Create dummy data\n",
    "    batch_size = 4\n",
    "    num_points = 100\n",
    "    H, W = 28, 28\n",
    "    \n",
    "    # Generate random coordinates\n",
    "    key, subkey1, subkey2 = random.split(key, 3)\n",
    "    pred_coords = random.uniform(subkey1, (batch_size, num_points, 2))\n",
    "    target_coords = random.uniform(subkey2, (batch_size, num_points, 2))\n",
    "    \n",
    "    # Create random target bitmap\n",
    "    key, subkey = random.split(key)\n",
    "    target_bitmap = random.bernoulli(subkey, shape=(batch_size, H, W)).astype(jnp.float32)\n",
    "    \n",
    "    # Initialize loss\n",
    "    criterion = NimbleLoss()\n",
    "    \n",
    "    # Test without target bitmap\n",
    "    losses = criterion(pred_coords, target_coords)\n",
    "    print(\"\\nLosses without target bitmap:\")\n",
    "    for k, v in losses.items():\n",
    "        print(f\"{k}: {v}\")\n",
    "        \n",
    "    # Test with target bitmap\n",
    "    losses = criterion(pred_coords, target_coords, target_bitmap)\n",
    "    print(\"\\nLosses with target bitmap:\")\n",
    "    for k, v in losses.items():\n",
    "        print(f\"{k}: {v}\")\n",
    "    \n",
    "    # Visualize rasterization\n",
    "    rasterized = criterion.rasterize_strokes(pred_coords)\n",
    "    \n",
    "    # Plot first example\n",
    "    plt.figure(figsize=(15, 5))\n",
    "    \n",
    "    plt.subplot(131)\n",
    "    plt.scatter(pred_coords[0, :, 0], pred_coords[0, :, 1], s=1)\n",
    "    plt.title(\"Vector Coordinates\")\n",
    "    plt.axis('equal')\n",
    "    \n",
    "    plt.subplot(132)\n",
    "    plt.imshow(rasterized[0], cmap='gray')\n",
    "    plt.title(\"Rasterized Output\")\n",
    "    \n",
    "    plt.subplot(133)\n",
    "    plt.imshow(target_bitmap[0], cmap='gray')\n",
    "    plt.title(\"Target Bitmap\")\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    test_losses()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: mps\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 2791/2791 [33:56<00:00,  1.37it/s, loss=8.88, coord_loss=17.6, raster_loss=1.4] \n",
      "Validation: 100%|██████████| 698/698 [03:53<00:00,  2.98it/s]\n"
     ]
    }
   ],
   "source": [
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from jax import random\n",
    "import flax.linen as nn\n",
    "from flax.training import train_state\n",
    "from flax.training import checkpoints\n",
    "import optax\n",
    "import tensorflow as tf\n",
    "from pathlib import Path\n",
    "from typing import Tuple, Dict, Optional, Any\n",
    "from tqdm import tqdm\n",
    "import logging\n",
    "from functools import partial\n",
    "from jax.tree_util import tree_map\n",
    "\n",
    "from dataset import get_dataloaders\n",
    "from encoder import BitmapEncoder\n",
    "from decoder import TransformerDecoder\n",
    "from diffusion import DiffusionProcess\n",
    "from losses import NimbleLoss\n",
    "\n",
    "def get_device_name():\n",
    "    \"\"\"Get the best available device\"\"\"\n",
    "    if jax.default_backend() == \"gpu\":\n",
    "        return \"cuda\"\n",
    "    elif jax.default_backend() == \"cpu\":\n",
    "        # Check for MPS (Apple Silicon)\n",
    "        try:\n",
    "            if tf.config.list_physical_devices(\"GPU\"):\n",
    "                return \"mps\"\n",
    "        except:\n",
    "            pass\n",
    "    return \"cpu\"\n",
    "\n",
    "\n",
    "class TrainState(train_state.TrainState):\n",
    "    batch_stats: Dict[str, Any]\n",
    "\n",
    "\n",
    "def create_train_state(\n",
    "    rng: jnp.ndarray,\n",
    "    learning_rate: float,\n",
    "    batch_size: int = 1,\n",
    "    optimizer: Optional[optax.GradientTransformation] = None,\n",
    ") -> TrainState:\n",
    "    \"\"\"Initialize training state with optimized configuration\"\"\"\n",
    "    # Split PRNG key\n",
    "    rng, encoder_key, decoder_key = random.split(rng, 3)\n",
    "\n",
    "    # Initialize models\n",
    "    encoder = BitmapEncoder(embed_dim=256)\n",
    "    decoder = TransformerDecoder(d_model=256)\n",
    "\n",
    "    # Initialize parameters with optimized settings\n",
    "    encoder_variables = encoder.init(\n",
    "        {\"params\": encoder_key, \"batch_stats\": encoder_key},\n",
    "        jnp.ones((batch_size, 28, 28)),\n",
    "        training=True,\n",
    "    )\n",
    "\n",
    "    decoder_variables = decoder.init(\n",
    "        {\"params\": decoder_key},\n",
    "        jnp.ones((batch_size, 100, 2)),\n",
    "        jnp.zeros((batch_size,), dtype=jnp.int32),\n",
    "        jnp.ones((batch_size, 256)),\n",
    "        deterministic=False,\n",
    "    )\n",
    "\n",
    "    # Combine parameters and batch stats\n",
    "    params = {\n",
    "        \"encoder\": encoder_variables[\"params\"],\n",
    "        \"decoder\": decoder_variables[\"params\"],\n",
    "    }\n",
    "    batch_stats = {\"encoder\": encoder_variables.get(\"batch_stats\", {})}\n",
    "\n",
    "    # Use provided optimizer or create default\n",
    "    if optimizer is None:\n",
    "        optimizer = optax.adam(learning_rate)\n",
    "\n",
    "    return TrainState.create(\n",
    "        apply_fn=None, params=params, tx=optimizer, batch_stats=batch_stats\n",
    "    )\n",
    "\n",
    "\n",
    "class NimbleTrainer:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate: float = 1e-5,  # Further reduced learning rate\n",
    "        checkpoint_dir: str = \"checkpoints\",\n",
    "        use_wandb: bool = False,\n",
    "        batch_size: int = 32,\n",
    "    ):\n",
    "        \"\"\"Initialize trainer with further optimized configurations\"\"\"\n",
    "        # Previous initialization code remains the same\n",
    "        self.device = get_device_name()\n",
    "        print(f\"Using device: {self.device}\")\n",
    "\n",
    "        self.checkpoint_dir = Path(checkpoint_dir)\n",
    "        self.checkpoint_dir.mkdir(exist_ok=True)\n",
    "        self.use_wandb = use_wandb\n",
    "\n",
    "        # Initialize models\n",
    "        self.encoder = BitmapEncoder(embed_dim=256)\n",
    "        self.decoder = TransformerDecoder(d_model=256)\n",
    "        self.diffusion = DiffusionProcess()\n",
    "        self.criterion = NimbleLoss(\n",
    "            coord_weight=0.5,  # Reduced coordinate weight\n",
    "            raster_weight=0.05,  # Further reduced raster weight\n",
    "        )\n",
    "\n",
    "        # Initialize PRNG key\n",
    "        self.rng = random.PRNGKey(0)\n",
    "\n",
    "        # Create training state with optimized schedule\n",
    "        schedule = optax.warmup_cosine_decay_schedule(\n",
    "            init_value=0.0,\n",
    "            peak_value=learning_rate,\n",
    "            warmup_steps=200,  # Increased warmup steps\n",
    "            decay_steps=15000,  # Increased decay steps\n",
    "            end_value=learning_rate / 20.0,  # More aggressive decay\n",
    "        )\n",
    "\n",
    "        # Enhanced optimizer chain\n",
    "        optimizer = optax.chain(\n",
    "            optax.clip_by_global_norm(0.5),  # More aggressive gradient clipping\n",
    "            optax.scale_by_adam(b1=0.9, b2=0.99),  # Adjusted beta parameters\n",
    "            optax.scale_by_schedule(schedule),\n",
    "        )\n",
    "\n",
    "        self.state = create_train_state(\n",
    "            self.rng, learning_rate, batch_size, optimizer=optimizer\n",
    "        )\n",
    "\n",
    "        # Setup logging\n",
    "        logging.basicConfig(level=logging.INFO)\n",
    "        self.logger = logging.getLogger(__name__)\n",
    "\n",
    "        # Enhanced loss normalization\n",
    "        self.coord_scale = 2000.0  # Increased coordinate scaling\n",
    "        self.raster_scale = 0.5  # Reduced raster scaling\n",
    "\n",
    "    def _forward(\n",
    "        self,\n",
    "        params: Dict,\n",
    "        batch_stats: Dict,\n",
    "        bitmap: jnp.ndarray,\n",
    "        coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray,\n",
    "        training: bool = True,\n",
    "        rngs: Optional[Dict[str, jnp.ndarray]] = None,\n",
    "    ) -> Tuple[jnp.ndarray, Dict[str, Any]]:\n",
    "        \"\"\"Forward pass through the models\"\"\"\n",
    "        # Get variables\n",
    "        encoder_variables = {\n",
    "            \"params\": params[\"encoder\"],\n",
    "            \"batch_stats\": batch_stats[\"encoder\"],\n",
    "        }\n",
    "        decoder_variables = {\"params\": params[\"decoder\"]}\n",
    "\n",
    "        # Default RNGs if none provided\n",
    "        if rngs is None:\n",
    "            rngs = {}\n",
    "\n",
    "        # Run encoder\n",
    "        encoder_output = self.encoder.apply(\n",
    "            encoder_variables,\n",
    "            bitmap,\n",
    "            training=training,\n",
    "            mutable=[\"batch_stats\"] if training else False,\n",
    "            rngs=rngs,\n",
    "        )\n",
    "        if training:\n",
    "            image_embeddings, new_encoder_stats = encoder_output\n",
    "            new_batch_stats = {\"encoder\": new_encoder_stats[\"batch_stats\"]}\n",
    "        else:\n",
    "            image_embeddings = encoder_output\n",
    "            new_batch_stats = {}\n",
    "\n",
    "        # Run decoder\n",
    "        pred_coords = self.decoder.apply(\n",
    "            decoder_variables,\n",
    "            coords,\n",
    "            timesteps,\n",
    "            image_embeddings,\n",
    "            deterministic=not training,\n",
    "            rngs=rngs,\n",
    "        )\n",
    "\n",
    "        return pred_coords, new_batch_stats\n",
    "\n",
    "    @partial(jax.jit, static_argnames=(\"self\", \"training\"))\n",
    "    def _forward_jit(\n",
    "        self,\n",
    "        params: Dict,\n",
    "        batch_stats: Dict,\n",
    "        bitmap: jnp.ndarray,\n",
    "        coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray,\n",
    "        training: bool = True,\n",
    "        rngs: Optional[Dict[str, jnp.ndarray]] = None,\n",
    "    ) -> Tuple[jnp.ndarray, Dict[str, Any]]:\n",
    "        return self._forward(\n",
    "            params, batch_stats, bitmap, coords, timesteps, training, rngs\n",
    "        )\n",
    "\n",
    "    def compute_loss(\n",
    "        self,\n",
    "        pred_coords: jnp.ndarray,\n",
    "        target_coords: jnp.ndarray,\n",
    "        target_bitmap: jnp.ndarray,\n",
    "    ) -> Dict[str, jnp.ndarray]:\n",
    "        \"\"\"Compute losses with enhanced normalization\"\"\"\n",
    "        # Apply pre-normalization to coordinates\n",
    "        pred_coords = pred_coords / self.coord_scale\n",
    "        target_coords = target_coords / self.coord_scale\n",
    "\n",
    "        losses = self.criterion(pred_coords, target_coords, target_bitmap)\n",
    "\n",
    "        # Post-process losses\n",
    "        losses = {\n",
    "            \"coord_loss\": losses[\"coord_loss\"] * self.coord_scale,\n",
    "            \"raster_loss\": losses[\"raster_loss\"] * self.raster_scale,\n",
    "            \"total_loss\": (\n",
    "                losses[\"coord_loss\"] * self.coord_scale * self.criterion.coord_weight\n",
    "                + losses[\"raster_loss\"]\n",
    "                * self.raster_scale\n",
    "                * self.criterion.raster_weight\n",
    "            ),\n",
    "        }\n",
    "\n",
    "        return losses\n",
    "\n",
    "    @partial(jax.jit, static_argnames=(\"self\",))\n",
    "    def compute_loss_jit(\n",
    "        self,\n",
    "        pred_coords: jnp.ndarray,\n",
    "        target_coords: jnp.ndarray,\n",
    "        target_bitmap: jnp.ndarray,\n",
    "    ) -> Dict[str, jnp.ndarray]:\n",
    "        return self.compute_loss(pred_coords, target_coords, target_bitmap)\n",
    "\n",
    "    def _train_step_impl(\n",
    "        self,\n",
    "        state: TrainState,\n",
    "        bitmap: jnp.ndarray,\n",
    "        coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray,\n",
    "        noise_key: jnp.ndarray,\n",
    "        dropout_key: jnp.ndarray,\n",
    "    ) -> Tuple[TrainState, Dict[str, jnp.ndarray]]:\n",
    "        \"\"\"Implementation of single training step\"\"\"\n",
    "        # Add noise to target coordinates\n",
    "        noised_coords, noise = self.diffusion.add_noise(noise_key, coords, timesteps)\n",
    "\n",
    "        # Prepare RNG dict for dropout\n",
    "        rngs = {\"dropout\": dropout_key}\n",
    "\n",
    "        # Forward pass and loss computation\n",
    "        pred_coords, new_batch_stats = self._forward_jit(\n",
    "            state.params,\n",
    "            state.batch_stats,\n",
    "            bitmap,\n",
    "            noised_coords,\n",
    "            timesteps,\n",
    "            True,  # training\n",
    "            rngs=rngs,\n",
    "        )\n",
    "\n",
    "        losses = self.compute_loss_jit(pred_coords, coords, bitmap)\n",
    "\n",
    "        # Compute gradients\n",
    "        grad_fn = jax.value_and_grad(lambda p: losses[\"total_loss\"])\n",
    "        _, grads = grad_fn(state.params)\n",
    "\n",
    "        # Update parameters and batch stats\n",
    "        state = state.apply_gradients(grads=grads, batch_stats=new_batch_stats)\n",
    "\n",
    "        return state, losses\n",
    "\n",
    "    @partial(jax.jit, static_argnames=(\"self\",))\n",
    "    def train_step_jit(\n",
    "        self,\n",
    "        state: TrainState,\n",
    "        bitmap: jnp.ndarray,\n",
    "        coords: jnp.ndarray,\n",
    "        timesteps: jnp.ndarray,\n",
    "        noise_key: jnp.ndarray,\n",
    "        dropout_key: jnp.ndarray,\n",
    "    ) -> Tuple[TrainState, Dict[str, jnp.ndarray]]:\n",
    "        return self._train_step_impl(\n",
    "            state, bitmap, coords, timesteps, noise_key, dropout_key\n",
    "        )\n",
    "\n",
    "    def train_step(\n",
    "        self,\n",
    "        state: TrainState,\n",
    "        batch: Tuple[jnp.ndarray, jnp.ndarray],\n",
    "        rng: jnp.ndarray,\n",
    "    ) -> Tuple[TrainState, Dict[str, jnp.ndarray]]:\n",
    "        \"\"\"Single training step with proper handling of dynamic shapes\"\"\"\n",
    "        bitmap, coords = batch\n",
    "\n",
    "        # Split PRNG keys for different random operations\n",
    "        rng, timestep_key, noise_key, dropout_key = random.split(rng, 4)\n",
    "\n",
    "        # Sample timesteps\n",
    "        timesteps = self.diffusion.sample_timesteps(timestep_key, bitmap.shape[0])\n",
    "\n",
    "        return self.train_step_jit(\n",
    "            state, bitmap, coords, timesteps, noise_key, dropout_key\n",
    "        )\n",
    "\n",
    "    def eval_step(\n",
    "        self,\n",
    "        state: TrainState,\n",
    "        batch: Tuple[jnp.ndarray, jnp.ndarray],\n",
    "        rng: jnp.ndarray,\n",
    "    ) -> Dict[str, jnp.ndarray]:\n",
    "        \"\"\"Single evaluation step\"\"\"\n",
    "        bitmap, target_coords = batch\n",
    "\n",
    "        # Split PRNG keys\n",
    "        rng, timestep_key, noise_key = random.split(rng, 3)\n",
    "\n",
    "        # Sample timesteps\n",
    "        timesteps = self.diffusion.sample_timesteps(timestep_key, bitmap.shape[0])\n",
    "\n",
    "        # Add noise to target coordinates\n",
    "        noised_coords, noise = self.diffusion.add_noise(\n",
    "            noise_key, target_coords, timesteps\n",
    "        )\n",
    "\n",
    "        # Forward pass (no dropout in eval)\n",
    "        pred_coords, _ = self._forward_jit(\n",
    "            state.params,\n",
    "            state.batch_stats,\n",
    "            bitmap,\n",
    "            noised_coords,\n",
    "            timesteps,\n",
    "            False,  # not training\n",
    "        )\n",
    "\n",
    "        # Compute losses\n",
    "        return self.compute_loss_jit(pred_coords, target_coords, bitmap)\n",
    "\n",
    "    @partial(jax.jit, static_argnames=(\"self\",))\n",
    "    def eval_step_jit(self, *args, **kwargs):\n",
    "        return self.eval_step(*args, **kwargs)\n",
    "\n",
    "    def train(\n",
    "        self,\n",
    "        train_dataset: tf.data.Dataset,\n",
    "        val_dataset: Optional[tf.data.Dataset] = None,\n",
    "        num_epochs: int = 100,\n",
    "        validate_every: int = 1,\n",
    "    ):\n",
    "        \"\"\"Train the model\"\"\"\n",
    "        best_val_loss = float(\"inf\")\n",
    "\n",
    "        for epoch in range(num_epochs):\n",
    "            self.logger.info(f\"Epoch {epoch + 1}/{num_epochs}\")\n",
    "\n",
    "            # Training\n",
    "            train_losses = []\n",
    "            pbar = tqdm(train_dataset, desc=\"Training\")\n",
    "            for batch in pbar:\n",
    "                # Convert TF tensors to JAX arrays\n",
    "                bitmap = jnp.array(batch[0].numpy())\n",
    "                coords = jnp.array(batch[1].numpy())\n",
    "\n",
    "                # Split PRNG key\n",
    "                self.rng, step_key = random.split(self.rng)\n",
    "\n",
    "                # Training step\n",
    "                self.state, losses = self.train_step(\n",
    "                    self.state, (bitmap, coords), step_key\n",
    "                )\n",
    "                train_losses.append(losses)\n",
    "\n",
    "                # Update progress bar\n",
    "                pbar.set_postfix(\n",
    "                    {\n",
    "                        \"loss\": float(losses[\"total_loss\"]),\n",
    "                        \"coord_loss\": float(losses[\"coord_loss\"]),\n",
    "                        \"raster_loss\": float(losses[\"raster_loss\"]),\n",
    "                    }\n",
    "                )\n",
    "\n",
    "            # Calculate average training losses using updated JAX function\n",
    "            from jax.tree_util import tree_map\n",
    "\n",
    "            train_metrics = tree_map(lambda *x: jnp.mean(jnp.stack(x)), *train_losses)\n",
    "\n",
    "            # Save regular checkpoint every 10 epochs\n",
    "            if (epoch + 1) % 10 == 0:\n",
    "                self.save_checkpoint(\n",
    "                    epoch,\n",
    "                    train_metrics,\n",
    "                    is_best=False,\n",
    "                    checkpoint_name=f\"checkpoint_epoch_{epoch}\",\n",
    "                )\n",
    "\n",
    "            # Validation\n",
    "            if val_dataset is not None and epoch % validate_every == 0:\n",
    "                val_losses = []\n",
    "                for batch in tqdm(val_dataset, desc=\"Validation\"):\n",
    "                    bitmap = jnp.array(batch[0].numpy())\n",
    "                    coords = jnp.array(batch[1].numpy())\n",
    "\n",
    "                    self.rng, step_key = random.split(self.rng)\n",
    "                    losses = self.eval_step(self.state, (bitmap, coords), step_key)\n",
    "                    val_losses.append(losses)\n",
    "\n",
    "                # Calculate average validation losses\n",
    "                val_metrics = tree_map(lambda *x: jnp.mean(jnp.stack(x)), *val_losses)\n",
    "\n",
    "                # Log metrics\n",
    "                self.logger.info(\n",
    "                    f\"Train Loss: {float(train_metrics['total_loss']):.4f}, \"\n",
    "                    f\"Val Loss: {float(val_metrics['total_loss']):.4f}\"\n",
    "                )\n",
    "\n",
    "                if self.use_wandb:\n",
    "                    metrics = {\n",
    "                        **{f\"train_{k}\": float(v) for k, v in train_metrics.items()},\n",
    "                        **{f\"val_{k}\": float(v) for k, v in val_metrics.items()},\n",
    "                    }\n",
    "                    wandb.log(metrics, step=epoch)\n",
    "\n",
    "                # Check and save best model\n",
    "                current_val_loss = float(val_metrics[\"total_loss\"])\n",
    "                if current_val_loss < best_val_loss:\n",
    "                    best_val_loss = current_val_loss\n",
    "                    self.logger.info(f\"New best validation loss: {best_val_loss:.4f}\")\n",
    "                    # Save best model in a separate directory\n",
    "                    best_checkpoint_path = f\"best_model_epoch_{epoch}\"\n",
    "                    self.save_checkpoint(\n",
    "                        epoch,\n",
    "                        val_metrics,\n",
    "                        is_best=True,\n",
    "                        checkpoint_name=best_checkpoint_path,\n",
    "                    )\n",
    "\n",
    "    def save_checkpoint(\n",
    "        self,\n",
    "        epoch: int,\n",
    "        metrics: Dict[str, jnp.ndarray],\n",
    "        is_best: bool = False,\n",
    "        checkpoint_name: str = None,\n",
    "    ):\n",
    "        \"\"\"Save model checkpoint\"\"\"\n",
    "        checkpoint = {\n",
    "            \"epoch\": epoch,\n",
    "            \"state\": self.state,\n",
    "            \"metrics\": metrics,\n",
    "            \"best_val_loss\": getattr(self, \"best_val_loss\", None),\n",
    "        }\n",
    "\n",
    "        if checkpoint_name is None:\n",
    "            checkpoint_name = f\"checkpoint_epoch_{epoch}\"\n",
    "\n",
    "        # Convert to absolute path\n",
    "        checkpoint_path = self.checkpoint_dir.absolute() / checkpoint_name\n",
    "\n",
    "        # Set keep parameter based on checkpoint type\n",
    "        if is_best:\n",
    "            keep = 1  # Only keep the best checkpoint\n",
    "        else:\n",
    "            keep = 2  # Keep last 2 regular checkpoints\n",
    "\n",
    "        checkpoints.save_checkpoint(\n",
    "            str(checkpoint_path),  # Convert Path to string\n",
    "            checkpoint,\n",
    "            epoch,\n",
    "            keep=keep,  # Always specify a number for keep\n",
    "        )\n",
    "\n",
    "        self.logger.info(\n",
    "            f\"Saved {'best ' if is_best else ''}checkpoint to {checkpoint_path}\"\n",
    "        )\n",
    "\n",
    "    def load_checkpoint(self, checkpoint_path: str):\n",
    "        \"\"\"Load model checkpoint\"\"\"\n",
    "        # Convert to absolute path if necessary\n",
    "        checkpoint_path = Path(checkpoint_path).absolute()\n",
    "        checkpoint = checkpoints.restore_checkpoint(str(checkpoint_path), target=None)\n",
    "        self.state = checkpoint[\"state\"]\n",
    "        if \"best_val_loss\" in checkpoint:\n",
    "            self.best_val_loss = checkpoint[\"best_val_loss\"]\n",
    "        return checkpoint[\"epoch\"], checkpoint[\"metrics\"]\n",
    "\n",
    "\n",
    "def main():\n",
    "    \"\"\"Main training function with improved configurations\"\"\"\n",
    "    # Get datasets\n",
    "    train_ds, val_ds = get_dataloaders(\n",
    "        data_path=\"../data/full-simplified-bird.ndjson\", batch_size=32, num_points=100\n",
    "    )\n",
    "\n",
    "    # Create trainer with improved hyperparameters\n",
    "    trainer = NimbleTrainer(\n",
    "        learning_rate=3e-5, use_wandb=False, batch_size=32  # Lower learning rate\n",
    "    )\n",
    "\n",
    "    # Start training\n",
    "    trainer.train(\n",
    "        train_ds,\n",
    "        val_ds,\n",
    "        num_epochs=1,\n",
    "        # num_epochs=100, // Lol i cant wait. If you have gpu you can.\n",
    "        validate_every=1,\n",
    "    )\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing inference model...\n",
      "Using device: cpu\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jeff/.pyenv/versions/3.11.4/lib/python3.11/site-packages/orbax/checkpoint/_src/serialization/type_handlers.py:1175: UserWarning: Couldn't find sharding info under RestoreArgs. Populating sharding info from sharding file. Please note restoration time will be slightly increased due to reading from file instead of directly from RestoreArgs. Note also that this option is unsafe when restoring on a different topology than the checkpoint was saved with.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checkpoint keys: dict_keys(['best_val_loss', 'epoch', 'metrics', 'state'])\n",
      "State keys: dict_keys(['batch_stats', 'opt_state', 'params', 'step'])\n",
      "Encoder params keys: ['ConvBNAct_0', 'ConvBNAct_1', 'ConvBNAct_2', 'Conv_0', 'InvertedResidual_0', 'InvertedResidual_1']\n",
      "Decoder params keys: ['coord_embed', 'layers_0', 'layers_1', 'layers_2', 'layers_3', 'layers_4', 'layers_5', 'output_proj', 'timestep_embed']\n",
      "Batch stats keys: ['ConvBNAct_0', 'ConvBNAct_1', 'ConvBNAct_2', 'InvertedResidual_0', 'InvertedResidual_1']\n",
      "Successfully loaded checkpoint from /Users/jeff/Documents/cactus-brain/ai/projects/research/nimble/deploy-jax/checkpoints/best_model/checkpoint_0\n",
      "\n",
      "Test with image file...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2100x300 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Test with image file completed successfully\n",
      "\n",
      "Test with numpy array...\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAACBcAAAEyCAYAAACr/6rUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA810lEQVR4nO3de3RV5bkv/ocNaCJGDErksiUIatwEFSsqWKiXVilYqXda9QiK9sRdrbq32tizxcuuNN3abh32knpq0V311Bsqx0urnuIpVFBpxRZaUaEEa1rBghKPgFzm7w9/pMTgnK82koR+PmNkDDLXN8/7rpm13rFY68k7u2RZlgUAAAAAAAAAwAf4h/aeAAAAAAAAAADQsWkuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAABoI0uXLo0uXbrEbbfd9rGOM3DgwJg0aVKb1Zs0aVLsvPPObVbvb9GR5sJfaS5oB7fddlt06dIl5s2b195TiYiId955J66++up46qmnkvJPPfVUdOnSJe67776Pd2LAduu3v/1tnHLKKVFZWRklJSXRv3//OOaYY+Lmm29ukZs6dWo8+OCD7TPJ/9+6deviq1/9avTr1y9KS0vjsMMOiyeeeKJd5wR8NJ1l7XnuuefiggsuiOrq6ujRo0cMGDAgTjvttHjppZdyf279+vUxZMiQ6NKlS9xwww2tbn/llVfilFNOifLy8thpp51i1KhRMXPmzI/rbgAfQWdZp97vuuuuiy5dusTQoUNb3bZ+/fq45pprYtCgQbHjjjvGoEGD4utf/3ps2LChVfZXv/pVfPazn41ddtklysrK4thjj4358+dvg3sApOos69SkSZOiS5cuH/j12muvbfXn3nzzzaioqPjA972sU9DxdZZ1KiJ9TfF6CjqmzZ/1be2rtra2vafXyttvvx1XXXVVDB06NHr06BG77bZbDBs2LC666KJobGz8WMZsbGyMq6++2jq0nenW3hOg/b3zzjtxzTXXRETEkUce2b6TAbZ7Tz/9dBx11FExYMCAOO+886JPnz7x6quvxty5c+Omm26KCy+8sDk7derUOOWUU+KEE05ot/lOmjQp7rvvvrj44otjn332idtuuy3GjRsXM2fOjFGjRrXbvIAPpzOtPd/85jfjl7/8ZZx66qlxwAEHxJ///Of4zne+E5/4xCdi7ty5W/3wLiLi5ptvjmXLlm31tldffTVGjhwZXbt2jcsuuyx69OgR06ZNi2OPPTb+z//5P/GpT33q47xLQILOtE5t6Y9//GNMnTo1evTosdXbzzzzzLj33nvjnHPOieHDh8fcuXPjyiuvjGXLlsUtt9zSnPv1r38do0aNij333DOuuuqq2LRpU3zve9+LI444Ip599tmoqqraVncJ+ACdaZ367//9v8dnPvOZFseyLIuampoYOHBg9O/ff6s/N2XKlHjnnXe2ept1Cjq+zrROfZg1xesp6Niuvfba2GuvvVocGzp0aFRWVsaaNWuie/fu7TSzv1q/fn186lOfihdffDEmTpwYF154Ybz99tuxcOHCuOuuu+LEE0+Mfv36tfm4jY2Ncc0118TAgQNj2LBhbV6f9qG5AIBt6rrrrouePXvGc889F7vuumuL25YvX94+k/oAzz77bPzkJz+J66+/Pi699NKIiDjrrLNi6NChcfnll8fTTz/dzjMEUnWmtedf/uVf4q677ooddtih+diECRNi//33j7q6urjjjjta/czy5cvj2muvja9+9asxZcqUVrfX1dXFm2++GQsWLGh+Q+m8886L/fbbLy655JL41a9+9fHdISBJZ1qntnTppZfGiBEjYuPGjfHGG2+0uO25556Le+65J6688sq49tprIyKipqYmdt999/j2t78dF1xwQRxwwAEREXHllVdGaWlpzJkzJ3bbbbeIeO+N9H333Te+9rWvxf33379t7xjQSmdap0aOHBkjR45scWz27NnxzjvvxBlnnLHVn1mwYEF8//vfjylTpmz19ZR1Cjq+zrROpa4pXk9Bxzd27NgYPnz4Vm8rKSnZxrPZugcffDCef/75uPPOO+P0009vcdvatWvj3XffbaeZ0Rm5LEIHsfm6Ia+99lqccMIJsfPOO0fv3r3j0ksvjY0bNzbnNl+j5YYbboj//M//jMrKyigtLY0jjjgiFixY0KLmkUceudWdCCZNmhQDBw5srte7d++IiLjmmmuat2y5+uqrP9T8r7766ujSpUu89NJLceaZZ0bPnj2jd+/eceWVV0aWZfHqq6/G5z//+dhll12iT58+8a1vfavFz7/77rsxZcqUOPjgg6Nnz57Ro0ePGD169Fa36v3LX/4S/+2//bfYZZddYtddd42JEyfGCy+8sNVr17z44otxyimnRK9evaKkpCSGDx8eM2bM+FD3DWhbixcvjurq6lb/yYuIqKioaP53ly5d4v/9v/8Xt99+e/PatOW1o1577bU455xzYo899ogdd9wxqqur40c/+lGLepsv43L33XfH1772tejTp0/06NEjxo8fH6+++mrhXO+7777o2rVrfOlLX2o+VlJSEpMnT445c+Yk1QA6hs609hx++OEtGgsiIvbZZ5+orq6O3//+91v9mdra2qiqqoozzzxzq7fPmjUrDjrooBZ/qbLTTjvF+PHj49e//nW8/PLLhfMCPl6daZ3a7Be/+EXcd999ceONN2719lmzZkVExBe+8IUWx7/whS9ElmVx9913t8h+5jOfaX4jPCKib9++ccQRR8TDDz8cb7/9dvK8gI9HZ1yntnTXXXdFly5dWr2hvtlFF10UJ554YowePXqrt1unoOPrTOtU6pri9RR0Xps/z9vyc6vUzwIjIm644YY4/PDDY7fddovS0tI4+OCDP/LlyhcvXhwREZ/85Cdb3VZSUhK77LJL7s/Pnz8/evfuHUceeWTzWlK0Vj711FNxyCGHRETE2Wef3bzebnk+nnnmmRg3blyUl5dHjx494oADDoibbrqp1fgp54ttx84FHcjGjRtjzJgxcdhhh8UNN9wQTz75ZHzrW9+KwYMHx/nnn98i+1//9V/R1NQUX/7yl2Pt2rVx0003xdFHHx2//e1vY4899kges3fv3vH9738/zj///DjxxBPjpJNOioho7nb8sCZMmBD/9E//FHV1dfHII4/E17/+9ejVq1f84Ac/iKOPPjq++c1vxp133hmXXnppHHLIIc1b8K5evTp++MMfxhe/+MU477zzoqmpKW699dYYM2ZMPPvss83bpWzatCmOP/74ePbZZ+P888+P/fbbLx566KGYOHFiq7ksXLgwPvnJT0b//v2jtrY2evToEffcc0+ccMIJcf/998eJJ574ke4j8LeprKyMOXPmxIIFCz5wa++IiB//+Mdx7rnnxqGHHtr84f7gwYMjIuL111+PESNGRJcuXeKCCy6I3r17x2OPPRaTJ0+O1atXx8UXX9yi1ubrAH/1q1+N5cuXx4033hif+cxnYv78+VFaWvqBc3j++edj3333bfXi6tBDD42I915U7bnnnh/lNADbWGdae7Ymy7J4/fXXo7q6utVtzz77bNx+++0xe/bs6NKly1Z/ft26dVFeXt7q+E477RQR712Xc5999vlQcwLaVmdbpzZu3BgXXnhhnHvuubH//vtvNbNu3bqIiFa1tlx7tsxubcyddtop3n333ViwYEGMGDEid07Ax6uzrVNbWr9+fdxzzz1x+OGHN//BzZbuvffeePrpp+P3v/99LF26dKs1rFPQ8XWmdSp1TfF6Cjq+t956q9UubrvvvvsH5lM/C7zpppti/PjxccYZZ8S7774bP/nJT+LUU0+Nhx9+OI477rgPNcfKysqIeO+zxX/7t3/7wPePtua5556LMWPGxPDhw+Ohhx6K0tLSpLXyn/7pn+Laa6+NKVOmxJe+9KXmBs7DDz88IiKeeOKJ+NznPhd9+/aNiy66KPr06RO///3v4+GHH46LLrroQ58vtqGMbW7atGlZRGTPPfdc87GJEydmEZFde+21LbIHHXRQdvDBBzd//4c//CGLiKy0tDT74x//2Hz8mWeeySIiu+SSS5qPHXHEEdkRRxzRavyJEydmlZWVzd+vWLEii4jsqquuSpr/zJkzs4jI7r333uZjV111VRYR2Ze+9KXmYxs2bMj+8R//MevSpUtWV1fXfHzVqlVZaWlpNnHixBbZdevWtRhn1apV2R577JGdc845zcfuv//+LCKyG2+8sfnYxo0bs6OPPjqLiGzatGnNxz/96U9n+++/f7Z27drmY5s2bcoOP/zwbJ999km6r0Dbe/zxx7OuXbtmXbt2zUaOHJldfvnl2c9+9rPs3XffbZXt0aNHi7Vis8mTJ2d9+/bN3njjjRbHv/CFL2Q9e/bM3nnnnSzL/rpe9e/fP1u9enVz7p577skiIrvpppty51pdXZ0dffTRrY4vXLgwi4isvr4+5S4DHUBnWnu25sc//nEWEdmtt97a4vimTZuyQw89NPviF7+YZdlfXytef/31LXLHH398tuuuu7aYT5Zl2ciRI7OIyG644YYPPSegbXW2deo73/lO1rNnz2z58uVZlr33/8/q6uoWmc3/f/vxj3/c4nh9fX0WEdnQoUObj+2///7Zvvvum23YsKH52Lp167IBAwZkEZHdd999hXMCPl6dbZ3a0v/+3/87i4jse9/7Xqvb3nnnnWzAgAHZFVdc0WLsLd/3yjLrFHQGnWmdSl1TvJ6CjmvzZ31b+8qyv75Hs+XnVqmfBWZZ1rzebPbuu+9mQ4cObfV+dWVl5VbXs/fXqqqqyiIiq6yszCZNmpTdeuut2euvv94qO3HixKxHjx5ZlmXZ7Nmzs1122SU77rjjWnzWlrpWPvfcc63OQZa995ngXnvtlVVWVmarVq1qcdumTZtazCX1fLHtuCxCB1NTU9Pi+9GjR8eSJUta5U444YTo379/8/eHHnpoHHbYYfHoo49+7HPMc+655zb/u2vXrjF8+PDIsiwmT57cfHzXXXeNqqqqFvera9euzdv/btq0KVauXBkbNmyI4cOHx69//evm3E9/+tPo3r17nHfeec3H/uEf/iG+/OUvt5jHypUr4+c//3mcdtpp0dTUFG+88Ua88cYb8Ze//CXGjBkTL7/8crz22mttfv+BYsccc0zMmTMnxo8fHy+88EL8x3/8R4wZMyb69++fdNmSLMvi/vvvj+OPPz6yLGt+fr/xxhsxZsyYeOutt1qsGxERZ511VpSVlTV/f8opp0Tfvn0L18w1a9bEjjvu2Or45mtlrVmzJuUuAx1AZ1p73u/FF1+ML3/5yzFy5MhWuzXddttt8dvf/ja++c1v5tY4//zz480334wJEybE888/Hy+99FJcfPHFMW/evIiwnkFH0JnWqb/85S8xZcqUuPLKK5svs7c148aNi8rKyrj00ktj+vTp0dDQEPfcc0/8j//xP6Jbt24t1p5//ud/jpdeeikmT54cv/vd72LBggVx1llnxZ/+9KeIsE5BR9CZ1qn3u+uuu6J79+5x2mmntbqtrq4u1q9fH1/72tdya1inoOPrTOtU6pri9RR0fN/97nfjiSeeaPFVJOWzwC13Ilm1alW89dZbMXr06FbrUIrS0tJ45pln4rLLLouI995Pmjx5cvTt2zcuvPDC5l1StjRz5swYM2ZMfPrTn47p06c3v0/+UdbK93v++efjD3/4Q1x88cWtLmWztV0VUj87ZdvQXNCBlJSUtHpjpry8PFatWtUqu7Vta/fdd98P3LptWxkwYECL73v27BklJSWttoDp2bNnq/t1++23xwEHHBAlJSWx2267Re/eveORRx6Jt956qznT0NAQffv2bd72abO99967xfevvPJKZFnW/GbXll9XXXVVREQsX778b76/wEdzyCGHxPTp02PVqlXx7LPPxhVXXBFNTU1xyimnxO9+97vcn12xYkW8+eabccstt7R6fp999tkR0fr5/f41s0uXLrH33nsXrpmlpaVbfWG1du3a5tuBzqOzrD1b+vOf/xzHHXdc9OzZM+67777o2rVr822rV6+OK664Ii677LLCS7SMHTs2br755vjFL34Rn/jEJ6KqqioeeeSRuO666yIiYuedd06eE/Dx6Szr1L/9279Fr1694sILL8zNlZSUxCOPPBK77bZbnHzyyTFw4MA466yzYsqUKdGrV68Wa09NTU187Wtfi7vuuiuqq6tj//33j8WLF8fll18eEdYp6Cg6yzq1pbfffjseeuihGDNmTIvrkEe8dy3k66+/Pq677rrCdcY6BZ1DZ1mnUtcUr6eg4zv00EPjM5/5TIuvPKmfBT788MMxYsSIKCkpiV69ejVf5nzLz8w+jJ49e8Z//Md/xNKlS2Pp0qVx6623RlVVVXznO9+Jf//3f2+RXbt2bRx33HFx0EEHxT333NP8x8ERH22tfL/FixdHRORewmazD/PZKdtGt/aeAH+15ZvFbaFLly6RZVmr4xs3bmzTcba0tfvwQfdry7ndcccdMWnSpDjhhBPisssui4qKiujatWt84xvfaF5kPoxNmzZFRMSll14aY8aM2Wrm/Q0JwLa3ww47xCGHHBKHHHJI7LvvvnH22WfHvffe29wEtDWbn99nnnlmq7/g3eyAAw5ok/n17dt3q7ucbO747tevX5uMA2xbHX3t2eytt96KsWPHxptvvhmzZs1qtebccMMN8e6778aECROa37j64x//GBHvdbQvXbo0+vXr1/wfwAsuuCDOPvvs+M1vfhM77LBDDBs2LG699daIeK9JFeg4OvI69fLLL8ctt9wSN954YzQ2NjYfX7t2baxfvz6WLl0au+yyS/Tq1SsiIqqrq2PBggXxu9/9LlatWhVDhgyJ0tLSuOSSS+KII45oUfu6666LSy+9NBYuXBg9e/aM/fffv/kvia1T0LF05HXq/R588MF455134owzzmh125QpU6J///5x5JFHNr+e+vOf/xwR771xvnTp0hgwYED8wz+89/dZ1inoPDrDOpW6png9BduXlM8CZ82aFePHj49PfepT8b3vfS/69u0b3bt3j2nTpsVdd931N8+hsrIyzjnnnDjxxBNj0KBBceedd8bXv/715tt33HHHGDduXDz00EPx05/+ND73uc8137at18q2/uyUv53mgk7q5ZdfbnXspZdeioEDBzZ/X15evtVtQRoaGlp8v7UtRra1++67LwYNGhTTp09vMZ/3v9irrKyMmTNnxjvvvNNi94JXXnmlRW7QoEEREdG9e/fCLjGgYxg+fHhE/PWD+4itr0+9e/eOsrKy2LhxY/Lz+/1rZpZl8corrxS+yBk2bFjMnDkzVq9eHbvsskvz8Weeeab5dqBz64hrT8R7H9Idf/zx8dJLL8WTTz4ZQ4YMaZVZtmxZrFq1Kqqrq1vdNnXq1Jg6dWo8//zzLdaqHj16xMiRI5u/f/LJJ6O0tDQ++clPJt0nYNvraOvUa6+9Fps2bYqvfOUr8ZWvfKXV7XvttVdcdNFFceONN7aY75Zr1aOPPhqbNm3a6jzLy8tj1KhRzd8/+eST8Y//+I+x3377Jd0nYNvraOvU+915552x8847x/jx41vdtmzZsnjllVea30fa0j//8z9HxHtNm1tu12udgs6nI69TqWuK11Pw9+X++++PkpKS+NnPftbisr3Tpk1r03HKy8tj8ODBsWDBghbHu3TpEnfeeWd8/vOfj1NPPTUee+yxOPLIIyPiw62VH/T54+DBgyMiYsGCBT7D64RcFqGTevDBB1v8Ne2zzz4bzzzzTIwdO7b52ODBg+PFF1+MFStWNB974YUX4pe//GWLWps/pH/zzTc/3knn2Nx5tOVuBs8880zMmTOnRW7MmDGxfv36+J//8382H9u0aVN897vfbZGrqKiII488Mn7wgx+0eNG42ZbnBNi2Zs6cudVdVTZfi66qqqr5WI8ePVqtTV27do2TTz457r///lYveiK2/vz+r//6r2hqamr+/r777os//elPLdbMrTnllFNi48aNccsttzQfW7duXUybNi0OO+ywwm3IgY6jM609GzdujAkTJsScOXPi3nvvbdEMsKWvfOUr8cADD7T4+sEPfhAREZMmTYoHHngg9tprrw8c5+mnn47p06fH5MmTo2fPnrlzAj5+nWWdGjp0aKu154EHHojq6uoYMGBAPPDAAzF58uQP/Pk1a9bElVdeGX379o0vfvGLH5iLiLj77rvjueeei4svvrj5r4aB9tNZ1qn313zyySfjxBNPbHWJzYiIr3/9663Ws83bAl9++eXxwAMPRI8ePT6wvnUKOpbOuE5tKXVN8XoKtn9du3aNLl26tNiJfOnSpfHggw9+pHovvPBCvPHGG62ONzQ0xO9+97sW6+NmO+ywQ0yfPj0OOeSQOP744+PZZ59tnlvqWrn5ddT719tPfOITsddee8WNN97Y6ratreN0LHYu6KT23nvvGDVqVJx//vmxbt26uPHGG2O33XZrvn5SRMQ555wT3/72t2PMmDExefLkWL58edTX10d1dXWsXr26OVdaWhpDhgyJu+++O/bdd9/o1atXDB06NOlaJ23lc5/7XEyfPj1OPPHEOO644+IPf/hD1NfXx5AhQ+Ltt99uzp1wwglx6KGHxr/+67/GK6+8Evvtt1/MmDEjVq5cGREtu6C++93vxqhRo2L//feP8847LwYNGhSvv/56zJkzJ/74xz/GCy+8sM3uH/BXF154Ybzzzjtx4oknxn777RfvvvtuPP3003H33XfHwIEDm6/LFBFx8MEHx5NPPhnf/va3o1+/frHXXnvFYYcdFnV1dTFz5sw47LDD4rzzzoshQ4bEypUr49e//nU8+eSTzWvCZr169YpRo0bF2WefHa+//nrceOONsffee8d5552XO9fDDjssTj311Ljiiiti+fLlsffee8ftt9/efE0qoPPoTGvPv/7rv8aMGTPi+OOPj5UrV8Ydd9zR4vYzzzwzIt77j9gnPvGJFrdt3s63uro6TjjhhObjDQ0Ncdppp8X48eOjT58+sXDhwqivr48DDjggpk6d+mFPJ/Ax6Czr1O67795ifdls804F77/ttNNOi379+sWQIUNi9erV8aMf/SiWLFkSjzzySJSVlTXnfvGLX8S1114bxx57bOy2224xd+7cmDZtWnz2s5+Niy666MOfUKDNdZZ1akt33313bNiwYauXRIiIFn/Zu9nmXQoOOeSQFmuadQo6vs60Tn2YNcXrKfj7c9xxx8W3v/3t+OxnPxunn356LF++PL773e/G3nvvHb/5zW8+dL0nnngirrrqqhg/fnyMGDEidt5551iyZEn86Ec/inXr1sXVV1+91Z8rLS2Nhx9+OI4++ugYO3Zs/N//+39j6NChyWvl4MGDY9ddd436+vooKyuLHj16xGGHHRZ77bVXfP/734/jjz8+hg0bFmeffXb07ds3XnzxxVi4cGH87Gc/+1tOHx+3jG1u2rRpWURkzz33XPOxiRMnZj169GiVveqqq7Itf01/+MMfsojIrr/++uxb3/pWtueee2Y77rhjNnr06OyFF15o9fN33HFHNmjQoGyHHXbIhg0blv3sZz/LJk6cmFVWVrbIPf3009nBBx+c7bDDDllEZFddddUHzn/mzJlZRGT33ntvq3muWLGiRfaD7tcRRxyRVVdXN3+/adOmbOrUqVllZWW24447ZgcddFD28MMPb3WuK1asyE4//fSsrKws69mzZzZp0qTsl7/8ZRYR2U9+8pMW2cWLF2dnnXVW1qdPn6x79+5Z//79s8997nPZfffd94H3D/h4PfbYY9k555yT7bffftnOO++c7bDDDtnee++dXXjhhdnrr7/eIvviiy9mn/rUp7LS0tIsIrKJEyc23/b6669nX/7yl7M999wz6969e9anT5/s05/+dHbLLbc0ZzavV//rf/2v7IorrsgqKiqy0tLS7LjjjssaGhqS5rtmzZrs0ksvzfr06ZPtuOOO2SGHHJL99Kc/bZNzAWw7nWntOeKII7KI+MCvPFu+VtzSypUrs89//vNZnz59sh122CHba6+9sq9+9avZ6tWrE84esC10pnVqa97/f7zNvvnNb2b77bdfVlJSkpWXl2fjx4/Pnn/++Va5V155JTv22GOz3XffPdtxxx2z/fbbL/vGN76RrVu37iPNB2h7nXGdGjFiRFZRUZFt2LAh+We29r5XllmnoDPoTOvUh1lTvJ6Cjmlrn/VtafN7NNOmTWs+lvpZYJZl2a233prts88+zc/nadOmbTVXWVnZYg3bmiVLlmRTpkxpfm3UrVu3rHfv3tlxxx2X/fznP2+R3doc33jjjWzIkCFZnz59spdffjnLsrS1Msuy7KGHHsqGDBmSdevWrdX5mD17dnbMMcdkZWVlWY8ePbIDDjggu/nmmz/S+WLb6ZJl9pfoTJYuXRp77bVXXH/99XHppZe293Q6jAcffDBOPPHEmD17tmsGA82eeuqpOOqoo+Lee++NU045pb2nA/ydsPYAHZ11CujorFNAR2edAuDvlYvs0OmsWbOmxfcbN26Mm2++OXbZZZdWWwMDAAAAAAAA8Lfr1t4TgA/rwgsvjDVr1sTIkSNj3bp1MX369Hj66adj6tSpUVpa2t7TAwAAAAAAANjuaC6g0zn66KPjW9/6Vjz88MOxdu3a2HvvvePmm2+OCy64oL2nBgAAAAAAALBd6pJlWdbekwAAAAAAAAAAOq5/aO8JAAAAAAAAAAAdm+YCAAAAAAAAACCX5gIAAAAAAAAAIFe31OD5559fmCkrK0uqVVNTU5iZNWtWUq2UMU866aSkWgsWLCjMPPXUU4WZO++8M2m8CRMmFGb69euXVGvRokWFmQEDBiTV2rBhQ2Fm5syZhZmJEycmjXfMMccUZqZMmZJUq6mpqTDT2NiYVGvSpEmFmfvvv78wM2/evKTxKioqCjNTp05NqrVkyZLCzIEHHphUq76+vjDzn//5n0m1AAAAAAAAgM7JzgUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABAri5ZlmUpwVtvvbUwU15enjRoY2NjYWbx4sVJtTZs2FCYqaqqSqq1fPnywkzK3E8++eSk8R5//PHCTEVFRVKtVatWFWbWr1+fVGvt2rWFmQEDBiTVSjFx4sTCTFNTU1Kt0tLSwswPf/jDpFqnnXZaYeauu+4qzKxZsyZpvBQp9y8i4sUXXyzM7LHHHkm1Fi1aVJj5+c9/nlQLAAAAAAAA6JzsXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTqlhp8/PHHCzNVVVVJtZqamgozZWVlSbVmzpxZmBk9enRSrW7dik/H2rVrCzNz5sxJGm/Dhg2FmdTzMH/+/MLM8OHDk2rdc889hZmSkpLCzBlnnJE03ty5cwszixYtSqqVch4qKyuTas2ePbsws2bNmsJMr169ksZLOacjR45MqjVkyJDCzA477JBU6/XXX0/KAQAAAAAAANsvOxcAAAAAAAAAALk0FwAAAAAAAAAAuTQXAAAAAAAAAAC5NBcAAAAAAAAAALk0FwAAAAAAAAAAuTQXAAAAAAAAAAC5NBcAAAAAAAAAALk0FwAAAAAAAAAAubpkWZalBC+55JLCTGVlZdKgP/zhDwsz48aNS6rV1NRUmOnWrVtSrYkTJxZmpkyZUpgZNmxY0nilpaWFmZT7FxFRVVVVmDnwwAOTaq1YsaIwM3/+/MJM6txffPHFwsy//Mu/JNVKeWytXr06qdZxxx1XmFmzZk1hZsOGDUnjDRo0qDCzcOHCpFqjR48uzCxYsCCpVq9evQozp512WlItAAAAAAAAoHOycwEAAAAAAAAAkEtzAQAAAAAAAACQS3MBANut+vr6GDhwYNTX17f3VAAAAAAAADo1zQUAbLfq6uqioaEh6urq2nsqAAAAAAAAnZrmAgC2W7W1tVFZWRm1tbXtPRUAAAAAAIBOrVt7TwAAPi41NTVRU1PT3tMAAAAAAADo9OxcAAAAAAAAAADk0lwAAB9BfX19DBw4MOrr69t7KgAAAAAAAB87zQUA8BHU1dVFQ0ND1NXVtfdUAAAAAAAAPnbdUoOrVq0qzAwbNiyp1vDhwwsz/fr1S6rV0NBQmKmoqEiqNX369MLM6NGjCzNlZWVJ46Wc0/Xr1yfVmjdvXmFm5syZSbVSxkz5/XTv3j1pvEMOOaQws3z58qRa5eXlhZmU8x4RMXbs2MLMokWLCjMLFy5MGm/FihWFmQ0bNiTVWrp0aWGmsbExqVbK4+a0005LqgXbk9ra2qirq4va2tr2ngoAAAAAAMDHLrm5AAD4q5qamqipqWnvaQAAAAAAAGwTLosAAH+n6uvrY+DAgVFfX9/eUwEAAAAAADo4zQUAH4EPZdke1NXVRUNDQ9TV1bX3VAAAAAAAgA5OcwHAR+BDWbYHtbW1UVlZGbW1te09FQAAAAAAoIPTXADwEfhQ9u/D9r5DRU1NTSxdujRqamraeyoAAAAAAEAHp7kA4CPwoezfBztUAAAAAAAAvEdzAQB8ADtUAAAAAAAAvKdbe08AADqqmpoau1MAAAAAAADEh2guGD16dJsNetRRRxVmVq1alVQrJZc692XLlhVmGhsb22y8RYsWFWYWL16cVGvw4MGFmVGjRiXVmj17dmEm5TykampqKszcfvvtSbVOPfXUwkzq72fu3LmFmZS5V1dXJ4134403FmbKysqSaq1fv74wk/KYiYiYPn16Uo7tX319fdTV1UVtba0P3AEAAAAAAP7OuCwCAEnq6uqioaEh6urq2nsqAAAAAAAAbGOaCwBIUltbG5WVlVFbW9veUwEAAAAAAGAbS74sAgB/32pqalwOAQAAAAAA4O+UnQsAAAAAAAAAgFyaCwAAAAAAAACAXJoLAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXJoLAAAAAAAAAIBc3VKDDQ0NhZmRI0e2Wa0FCxYk1RowYEBhZtasWUm1lixZUpgZNGhQYWbOnDlJ4y1cuLAwM3r06KRavXv3LszMnTs3qdb69esLM1VVVYWZefPmJY332c9+tjBTVlaWVOtPf/pTYeaxxx5LqnXZZZcVZkpLSwszKY+riLTfYep5SMml/A4jIurr65NyAAAAAAAAwPbLzgUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABArm6pwV69ehVmSkpKkmotWbKkMNO9e/ekWsuWLSvMjBs3LqlWWVlZYSZl7sOGDUsa79hjjy3MXHPNNUm1DjrooMLMmjVrkmqlnIcBAwYUZhYvXpw03jPPPFOYWbVqVVKt6urqwswVV1yRVOuJJ54ozBxwwAFJtVIceeSRhZk99tgjqVZTU1NhZsaMGUm1Ro8enZQDAAAAAAAAtl92LgAAAAAAAAAAcmkuAADaRH19fQwcODDq6+vbeyoAAAAAAEAb01wAALSJurq6aGhoiLq6uvaeCgAAAAAA0MY0FwAAbaK2tjYqKyujtra2vacCAAAAAAC0sW7tPQEAYPtQU1MTNTU17T0NAAAAAADgY2DnAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIFe31GB5eXlhpnv37km1BgwYUJgpLS1NqtXQ0FCYWbx4cVKt4cOHF2YqKysLMw899FDSeGvWrCnMjBw5MqlWr169CjMLFixIqrVw4cLCTGNjY2Em5TETEbHvvvsWZv70pz8l1Zo9e3ZhpqmpKalWiieffLIwk/J4j4ioqKgozDzzzDNJtVIeW0ceeWRSrSlTphRmxo4dm1QLAAAAAAAA6JzsXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTqlhqcN29eYaZr165JtVatWlWYKS0tTarVvXv3wkxFRUVSrYULFxZmxo0bV5hZsGBB0ngbNmwozKSeh8cff7wwM3LkyKRaxx57bGGmvr6+MHPGGWckjTdz5szCTL9+/ZJqLV++vDCzfv36pFqnn356Yebee+8tzIwfPz5pvG7dip+O1dXVSbWWLFlSmHn11VeTat18881JOQAAAAAAAGD7ZecCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIFe31GBpaWmbDdrY2FiYefzxx5NqjRs3rjAzb968pFqPPvpoYWbw4MGFmcrKyjYb7+STT06q1b1798LM7rvvnlSrrKysMHPqqacWZmbOnJk03vLlywszc+fOTap1zDHHFGYWLVqUVOvtt98uzIwYMaLNxtuwYUNh5sADD0yq9cgjjxRmjj322KRaa9asScoBAAAAAAAA2y87FwAAAAAAAAAAuTQXAAAAAAAAAAC5NBcAAAAAAAAAALk0FwAAAAAAAAAAuTQXAAAAAAAAAAC5NBcAAAAAAAAAALk0FwAAAAAAAAAAuTQXAAAAAAAAAAC5NBcAAAAAAAAAALm6tWWxX/7yl0m5qqqqwkxTU1NSrfLy8jarddJJJ7XJeI8++mjSeKeffnph5je/+U1SraOOOqow86tf/Sqp1k033VSYSfkdDhgwIGm8oUOHFmZSf4cVFRWFmbVr1ybVWrVqVWGmX79+hZmysrKk8UpLSwsz8+fPT6rVq1evwszIkSOTai1evDgpBwAAAAAAAGy/7FwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAQLL6+voYOHBg1NfXt/dUAAAAAAAA2IY0FwCQrK6uLhoaGqKurq69pwIAAAAAAMA21C01OGrUqMLMihUrkmqVlZUVZkpKSpJqpfz17Mknn5xUq6mpqTAza9aswsyIESOSxttpp50KM717906qdcwxxxRmysvLk2pVVVUVZhobGwszo0ePThpv0aJFhZlJkyYl1ZozZ05hJuXxF5E2/xkzZhRmBg0alDRev379CjMp5yoi7TGY+hx75513knL8faitrY26urqora1t76kAAAAAAACwDSU3FwBATU1N1NTUtPc0AAAAAAAA2MZcFgEAAAAAAAAAyKW5AAAAAAAAAADIpbkAAAAAAAAAAMiluQAAAAAAAAAAyKW5AAAAAAAAAADIpbkAAAAAAAAAAMiluQAAAAAAAAAAyKW5AAAAAAAAAADI1S01OHPmzMLM4MGDk2otWLCgzWpddtllhZmUuUdELF++vDDT1NTUJpmIiA0bNhRmGhsbk2otW7asMHP33Xcn1Ro6dGhhpnv37m02Xq9evQozAwYMSKqVMq85c+Yk1SovLy/MlJSUFGZS7l9ExD333FOYqaqqSqq1du3awsykSZOSag0bNqwwc+aZZybVAgAAAAAAADonOxcAAAAAAAAAALk0FwAAAAAAAAAAuTQXAAAAAAAAAAC5NBcAAAAAAAAAALk0FwAAAAAAAAAAuTQXAEAbq6+vj4EDB0Z9fX17TwUAAAAAAKBNaC4AgDZWV1cXDQ0NUVdX195TAQAAAAAAaBOaCwCgjdXW1kZlZWXU1ta291QAAAAAAADaRLfUYFNTU2Fm8ODBSbWmT59emKmqqkqqlbLldGlpaVKtZcuWFWZGjBhRmJkwYULSeDNmzGizWsuXLy/MVFZWJtUqLy8vzKScq379+iWN171798LM+eefn1Rr+PDhhZmuXbsm1UqZ/7x58wozqed91KhRhZkVK1Yk1Up5nD7++ONJtYAPr6amJmpqatp7GgAAAAAAAG3GzgUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABArm6pwUmTJhVmVq5cmVRrwIABhZmJEycm1brzzjsLM+eee25Sreuvv74ws2rVqsLM9OnTk8YrKysrzMyaNSup1rx58woz/fr1S6pVXV1dmFm8eHFhZv369UnjjRs3rs1qpVi7dm1SbsaMGYWZbt2Kn0KNjY1J47WllLlXVVUl1Ro6dOjfOh0AAAAAAACgk7NzAQAAAAAAAACQS3MBAAAAAAAAAJBLcwEAAAAAAAAAkEtzAQAAAAAAAACQS3MBAFFfXx8DBw6M+vr69p4KAAAAAAAAHZDmAgCirq4uGhoaoq6urr2nAgAAAAAAQAekuQCAqK2tjcrKyqitrW3vqQAAAAAAANABdWvvCQDQ/mpqaqKmpqa9pwEAAAAAAEAHZecCAAAAAAAAACBX8s4F119/fWHm2muvTarVr1+/wsyUKVOSag0fPrwwM2/evKRaVVVVhZkBAwYUZu64446k8fr371+YKSsrS6pVUVFRmEk576nWrl1bmJk5c2abjbdhw4ak3LJlywozvXv3TqpVXl5emOnVq1ebjZcy927d0p6yjz76aFIuxaJFiwozkydPbrPxAAAAAAAAgI7HzgUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABArm6pwQEDBhRm5syZk1SrrKysMDNs2LCkWk1NTYWZhoaGpFopY86fP78ws2TJkqTxhg4dWpjp1atXUq3S0tLCzOjRo5Nq9evXrzAzfPjwwkzqeW9sbGyTTETa+Uo5VxERRx11VGHmtttuK8x8/vOfTxov5TmW+nhYsWJFYaZ3795JtSoqKpJyAAAAAAAAwPbLzgUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAECubqnB0tLSwsyiRYuSaq1ataows3jx4qRa48ePL8yUlZUl1aqoqCjMrF27tk3qRETMnDmzMHPssccm1SovL2+T8SIili1bVpg56qijCjMXXnhh0njXXnttYSbl8RcRMXHixMJMyv2LiPj3f//3wszw4cPbbLyqqqrCTLduaU/ZlStXFmYOPPDApFqpz2sAAAAAAABg+2XnAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgl+YCAAAAAAAAACBXt9RgSUlJYWbQoEFJtVasWFGYKS0tTar1xBNPFGaGDx+eVKuqqqowU15eXpgZN25c0nhz5swpzDQ1NSXVGj9+fGFmypQpSbVGjBhRmJkxY0ZhJuUxkzreokWLkmrNnTu3MDNr1qykWinzP/DAAwsz3/nOd5LGS/kdpj4eKisrCzPLli1LqnXUUUcl5QAAAAAAAIDtl50LAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXJoLAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXJoLAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXN1Sg4MHDy7MbNiwIanWvHnzCjODBg1KqnXZZZcVZmbNmpVUq3fv3oWZxYsXF2YWLVqUNF5VVVVhpqSkJKnW/fffX5iZMWNGUq2GhobCzIQJEwozKY+ZiIgBAwYUZqZPn55Uq7y8vDBz7rnnJtVauXJlYWbmzJmFmZTHaEREU1NTYaaxsTGp1tSpUwszl19+eVKt1Oc1AAAAAAAAsP2ycwEAAAAAAAAAkEtzAQAAAAAAAACQS3MBAAAAAAAAAJBLcwEAAAAAAAAAkEtzAQAAAAAAAACQS3MBAAAAAAAAAJBLcwEAdAD19fUxcODAqK+vb++pAAAAAAAAtKK5AAA6gLq6umhoaIi6urr2ngoAAAAAAEAr3VKDEyZMKMw0NjYm1Zo/f35hZsOGDUm1Fi1aVJgZPHhwUq0zzzyzMJNyHqqqqpLGW7hwYVIuxTe+8Y3CzAUXXJBUq7y8vDCT8rsuKytLGi8lt2bNmqRay5cvL8w88cQTSbWGDx9emJk0aVJh5tFHH00aL+Ux361b2lP2kksuKcw0NDQk1Ur5/Zx00klJteic6uvro66uLmpra6Ompqa9p7Pdqq2tbT7PAAAAAAAAHY2dCwDI5S/qt42amppYunSpBg4AAAAAAKBD0lwAQK7a2tqorKz0F/UAAAAAAAB/xzQXAJDLX9TzUdTX18fAgQOjvr6+vacCAAAAAAC0Ac0FAECbczkNAAAAAADYvmguAADanMtpAAAAAADA9qVbe08AANj+1NTUuJQGAAAAAABsR+xcAAAAAAAAAADk0lwAAAAAAAAAAORKvizCjBkz2iQTEbF48eLCzJQpU5Jq/eUvfynMvPrqq0m1KioqCjN77rlnYaZ///5J491+++2FmWHDhiXVSjlfDQ0NSbVOOumkwsySJUsKMwsWLEgab+HChYWZ0047LanWzJkzCzOrV69OqrVy5crCzJw5cwozVVVVSeP169evMDN37tykWr17926T8SIili1blpQDAAAAAAAAtl92LgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJ1Sw3W19cXZq644oqkWosWLSrMNDU1JdUaOHBgYeapp55KqlVRUVGYefvttwszL7zwQtJ4ZWVlhZlBgwYl1Vq1alVhZvz48Um15s2bV5iprKwszFRVVSWNN2PGjMLMY489llQr5bE1atSopFoLFy4szKSch+rq6qTxXnnllcJM6vPijDPOKMzcdtttSbVSHg8AAAAAAADA9s3OBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAEAuzQUAAAAAAAAAQC7NBQAAAAAAAABALs0FAAAAAAAAAECubqnBsWPHFmYaGxuTas2fP78ws3bt2qRakydPLsz069cvqdaiRYsKMxUVFYWZlPsXEXHMMccUZkaOHJlUq6SkpDAzb968pFopysvLCzPduqU9vFIeN6m/wxEjRhRmRo8enVQr5XddX19fmDn33HOTxttxxx0LM9XV1Um1Uh6Dc+fOTaoFAAAAAAAAYOcCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgl+YCAAAAAAAAACCX5gIAAAAAAAAAIJfmAgAAAAAAAAAgV7fU4Nq1awszq1atSqq1YcOGwky3bmlTW7hwYWHm2GOPTapVWVlZmKmvry/M1NTUJI2Xcr6WL1+eVGvevHltVquxsbEw071798LMmjVrksabMGFCYSblMRMRMWvWrMLMokWLkmqVlpYWZsrKygozDQ0NSeNVVFQUZqqqqpJqlZeXF2ZGjx6dVCv19wgAAAAAAABsv+xcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTSXAAAAAAAAAAA5NJcAAAAAAAAAADk0lwAAAAAAAAAAOTqkmVZlhKcPXt2YWbRokVJg65Zs6YwM2DAgKRaS5YsKcyUlZUl1UqZV0VFRWFm+fLlSeONGDGiMPPEE08k1UpRWlqalJs5c2ZhprGxsTBzxhlnJI03atSopFyKO++8szDTr1+/pForVqwozKQ8tp5//vmk8fbbb7/CzLBhw5Jqvfvuu0m5FLvttlthZuzYsW02HgAAAAAAANDx2LkAAAAAAAAAAMiluQAAAAAAAAAAyKW5AAAAAAAAAADIpbkAAAAAAAAAAMiluQAAAAAAAAAAyKW5AAAAAAAAAADIpbkAAAAAAAAAAMiluQAAAAAAAAAAyKW5AAAAAAAAAADI1S01OH/+/MLME088kVRr1KhRhZk777wzqdZRRx1VmOnXr19SrZKSksLM7NmzCzNVVVVJ482bN68wM3r06KRas2bNKsxUV1cn1dp9990LM+vWrSvMpJ737t27J+VSLFmypDCzYcOGpFpNTU2FmTVr1hRmKisrk8ZrbGxsk0xExPDhwwszZWVlSbVSHltjx45NqgUAAAAAAAB0TnYuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJpLgAAAAAAAAAAcmkuAAAAAAAAAAByaS4AAAAAAAAAAHJ1ybIsa+9JAAAAAAAAAAAdl50LAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXJoLAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXJoLAAAAAAAAAIBcmgsAAAAAAAAAgFyaCwAAAAAAAACAXP8fKtxU1IrSUvcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 2100x300 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Test with numpy array completed successfully\n",
      "\n",
      "Test with PIL Image...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2100x300 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Test with PIL Image completed successfully\n",
      "\n",
      "All tests completed.\n"
     ]
    }
   ],
   "source": [
    "# inference.py\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from jax import random\n",
    "import flax.linen as nn\n",
    "from flax.training import checkpoints\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "from typing import Optional, Union, Tuple, List\n",
    "from pathlib import Path\n",
    "from functools import partial\n",
    "\n",
    "from encoder import BitmapEncoder\n",
    "from decoder import TransformerDecoder\n",
    "from diffusion import DiffusionProcess\n",
    "\n",
    "class NimbleInference:\n",
    "    def __init__(\n",
    "        self,\n",
    "        checkpoint_path: str,\n",
    "        image_size: Tuple[int, int] = (28, 28),\n",
    "        num_points: int = 100\n",
    "    ):\n",
    "        \"\"\"Initialize inference model\"\"\"\n",
    "        self.image_size = image_size\n",
    "        self.num_points = num_points\n",
    "        self.rng = random.PRNGKey(0)\n",
    "        \n",
    "        self.device = self._get_device()\n",
    "        print(f\"Using device: {self.device}\")\n",
    "        \n",
    "        try:\n",
    "            self.encoder = BitmapEncoder(embed_dim=256)\n",
    "            self.decoder = TransformerDecoder(d_model=256)\n",
    "            self.diffusion = DiffusionProcess()\n",
    "            \n",
    "            self._forward_encoder_impl = jax.jit(self._forward_encoder_impl)\n",
    "            self._forward_decoder_impl = jax.jit(self._forward_decoder_impl)\n",
    "            \n",
    "        except Exception as e:\n",
    "            raise RuntimeError(f\"Failed to initialize models: {str(e)}\")\n",
    "        \n",
    "        self._load_checkpoint_with_verification(checkpoint_path)\n",
    "\n",
    "    def _process_input(\n",
    "        self, \n",
    "        input_data: Union[str, Image.Image, jnp.ndarray, np.ndarray]\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Process input into bitmap array\"\"\"\n",
    "        if isinstance(input_data, str):\n",
    "            input_data = Image.open(input_data).convert('L')\n",
    "        \n",
    "        if isinstance(input_data, Image.Image):\n",
    "            input_data = input_data.resize(self.image_size)\n",
    "            input_data = np.array(input_data)\n",
    "        \n",
    "        if isinstance(input_data, np.ndarray):\n",
    "            if input_data.ndim == 3:\n",
    "                input_data = np.mean(input_data, axis=2)\n",
    "            if input_data.shape != self.image_size:\n",
    "                temp_img = Image.fromarray((input_data * 255).astype('uint8'))\n",
    "                temp_img = temp_img.resize(self.image_size)\n",
    "                input_data = np.array(temp_img)\n",
    "        \n",
    "        bitmap = jnp.array(input_data, dtype=jnp.float32) / 255.0\n",
    "        if bitmap.ndim == 2:\n",
    "            bitmap = bitmap[None, ..., None]\n",
    "        elif bitmap.ndim == 3 and bitmap.shape[-1] > 1:\n",
    "            bitmap = jnp.mean(bitmap, axis=-1)[None, ..., None]\n",
    "        \n",
    "        return bitmap\n",
    "\n",
    "    def _forward_encoder_impl(\n",
    "        self,\n",
    "        encoder_params: dict,\n",
    "        batch_stats: dict,\n",
    "        bitmap: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Implementation of encoder forward pass\"\"\"\n",
    "        encoder_variables = {\n",
    "            'params': encoder_params,\n",
    "            'batch_stats': batch_stats\n",
    "        }\n",
    "        return self.encoder.apply(\n",
    "            encoder_variables,\n",
    "            bitmap,\n",
    "            training=False,\n",
    "            mutable=False\n",
    "        )\n",
    "\n",
    "    def _forward_decoder_impl(\n",
    "        self,\n",
    "        decoder_params: dict,\n",
    "        coords: jnp.ndarray,\n",
    "        t: jnp.ndarray,\n",
    "        image_embedding: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Implementation of decoder forward pass\"\"\"\n",
    "        decoder_variables = {'params': decoder_params}\n",
    "        return self.decoder.apply(\n",
    "            decoder_variables,\n",
    "            coords,\n",
    "            t,\n",
    "            image_embedding,\n",
    "            deterministic=True\n",
    "        )\n",
    "\n",
    "    def _forward_encoder(\n",
    "        self,\n",
    "        bitmap: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Forward pass through encoder using stored parameters\"\"\"\n",
    "        return self._forward_encoder_impl(\n",
    "            self.encoder_params,\n",
    "            self.batch_stats,\n",
    "            bitmap\n",
    "        )\n",
    "\n",
    "    def _forward_decoder(\n",
    "        self,\n",
    "        coords: jnp.ndarray,\n",
    "        t: jnp.ndarray,\n",
    "        image_embedding: jnp.ndarray\n",
    "    ) -> jnp.ndarray:\n",
    "        \"\"\"Forward pass through decoder using stored parameters\"\"\"\n",
    "        return self._forward_decoder_impl(\n",
    "            self.decoder_params,\n",
    "            coords,\n",
    "            t,\n",
    "            image_embedding\n",
    "        )\n",
    "\n",
    "    def _get_device(self) -> str:\n",
    "        \"\"\"Get the best available device with error handling\"\"\"\n",
    "        try:\n",
    "            if jax.default_backend() == \"gpu\":\n",
    "                return \"cuda\"\n",
    "            elif jax.default_backend() == \"cpu\":\n",
    "                try:\n",
    "                    if any(dev.device_type == \"gpu\" for dev in jax.local_devices()):\n",
    "                        return \"mps\"\n",
    "                except:\n",
    "                    pass\n",
    "            return \"cpu\"\n",
    "        except Exception as e:\n",
    "            print(f\"Warning: Error detecting device, defaulting to CPU. Error: {str(e)}\")\n",
    "            return \"cpu\"\n",
    "    \n",
    "    def _load_checkpoint_with_verification(self, checkpoint_path: str):\n",
    "        \"\"\"Load and verify checkpoint with proper parameter restructuring\"\"\"\n",
    "        try:\n",
    "            checkpoint_path = Path(checkpoint_path).absolute()\n",
    "            if not checkpoint_path.exists():\n",
    "                checkpoint_with_suffix = checkpoint_path.parent / \"checkpoint_0\"\n",
    "                if checkpoint_with_suffix.exists():\n",
    "                    checkpoint_path = checkpoint_with_suffix\n",
    "                else:\n",
    "                    raise FileNotFoundError(\n",
    "                        f\"Checkpoint path does not exist: {checkpoint_path}\\n\"\n",
    "                        f\"Attempted alternate path: {checkpoint_with_suffix}\"\n",
    "                    )\n",
    "            \n",
    "            checkpoint = checkpoints.restore_checkpoint(str(checkpoint_path), target=None)\n",
    "            if checkpoint is None:\n",
    "                raise ValueError(f\"Failed to load checkpoint from {checkpoint_path}\")\n",
    "            \n",
    "            print(\"Checkpoint keys:\", checkpoint.keys())\n",
    "            \n",
    "            if 'state' not in checkpoint:\n",
    "                raise ValueError(\"Checkpoint missing 'state' key\")\n",
    "            \n",
    "            state = checkpoint['state']\n",
    "            print(\"State keys:\", state.keys())\n",
    "            \n",
    "            if 'params' not in state or 'batch_stats' not in state:\n",
    "                raise ValueError(\"State missing required keys: params and/or batch_stats\")\n",
    "            \n",
    "            # Extract encoder and decoder parameters separately\n",
    "            self.encoder_params = state['params']['encoder']\n",
    "            self.decoder_params = state['params']['decoder']\n",
    "            self.batch_stats = state['batch_stats']['encoder']\n",
    "            \n",
    "            # Debug print to verify parameter structure\n",
    "            print(\"Encoder params keys:\", list(self.encoder_params.keys()))\n",
    "            print(\"Decoder params keys:\", list(self.decoder_params.keys()))\n",
    "            print(\"Batch stats keys:\", list(self.batch_stats.keys()))\n",
    "            \n",
    "            print(f\"Successfully loaded checkpoint from {checkpoint_path}\")\n",
    "            \n",
    "        except Exception as e:\n",
    "            error_msg = (\n",
    "                f\"Error loading checkpoint: {str(e)}\\n\\n\"\n",
    "                \"Potential solutions:\\n\"\n",
    "                \"1. Ensure you have run the training process first\\n\"\n",
    "                \"2. Check the checkpoint path is correct\\n\"\n",
    "                \"3. Verify the checkpoint file isn't corrupted\\n\"\n",
    "                \"4. Make sure you're using the same model version that created the checkpoint\"\n",
    "            )\n",
    "            raise RuntimeError(error_msg) from e\n",
    "\n",
    "    def generate(\n",
    "        self,\n",
    "        input_data: Union[str, Image.Image, jnp.ndarray, np.ndarray],\n",
    "        temperature: float = 1.0,\n",
    "        return_process: bool = False\n",
    "    ) -> Union[jnp.ndarray, Tuple[jnp.ndarray, List[jnp.ndarray]]]:\n",
    "        \"\"\"Generate sketch coordinates from input image\"\"\"\n",
    "        bitmap = self._process_input(input_data)\n",
    "        image_embedding = self._forward_encoder(bitmap)\n",
    "        \n",
    "        self.rng, init_key = random.split(self.rng)\n",
    "        coords = random.normal(\n",
    "            init_key,\n",
    "            shape=(1, self.num_points, 2)\n",
    "        ) * temperature\n",
    "        \n",
    "        process = [] if return_process else None\n",
    "        \n",
    "        timesteps = jnp.arange(self.diffusion.num_timesteps - 1, -1, -1)\n",
    "        \n",
    "        for t in timesteps:\n",
    "            if process is not None:\n",
    "                process.append(coords)\n",
    "            \n",
    "            t_batch = jnp.array([t])\n",
    "            pred_coords = self._forward_decoder(coords, t_batch, image_embedding)\n",
    "            \n",
    "            if t > 0:\n",
    "                coords = self.diffusion.remove_noise(coords, pred_coords, t_batch)\n",
    "                self.rng, noise_key = random.split(self.rng)\n",
    "                noise = random.normal(noise_key, coords.shape) * temperature\n",
    "                coords = coords + noise * (t / self.diffusion.num_timesteps)\n",
    "        \n",
    "        if return_process:\n",
    "            return coords, process\n",
    "        return coords\n",
    "\n",
    "    def visualize_generation(\n",
    "        self,\n",
    "        input_data: Union[str, Image.Image, jnp.ndarray, np.ndarray],\n",
    "        temperature: float = 1.0,\n",
    "        num_steps: int = 5\n",
    "    ):\n",
    "        \"\"\"Visualize the generation process\"\"\"\n",
    "        coords, process = self.generate(input_data, temperature, return_process=True)\n",
    "        bitmap = self._process_input(input_data)\n",
    "        bitmap_display = np.array(bitmap[0, ..., 0])\n",
    "        \n",
    "        step_indices = np.linspace(0, len(process) - 1, num_steps, dtype=int)\n",
    "        \n",
    "        fig, axes = plt.subplots(1, num_steps + 2, figsize=(3 * (num_steps + 2), 3))\n",
    "        \n",
    "        axes[0].imshow(bitmap_display, cmap='gray')\n",
    "        axes[0].set_title(\"Input Image\")\n",
    "        axes[0].axis(\"off\")\n",
    "        \n",
    "        for i, idx in enumerate(step_indices):\n",
    "            step_coords = np.array(process[idx][0])\n",
    "            axes[i + 1].scatter(step_coords[:, 0], step_coords[:, 1], s=1, c=\"black\")\n",
    "            axes[i + 1].set_xlim(0, 1)\n",
    "            axes[i + 1].set_ylim(0, 1)\n",
    "            axes[i + 1].invert_yaxis()\n",
    "            axes[i + 1].set_aspect(\"equal\")\n",
    "            axes[i + 1].axis(\"off\")\n",
    "            axes[i + 1].set_title(f\"Step {idx}\")\n",
    "        \n",
    "        final_coords = np.array(coords[0])\n",
    "        axes[-1].scatter(final_coords[:, 0], final_coords[:, 1], s=1, c=\"black\")\n",
    "        axes[-1].set_xlim(0, 1)\n",
    "        axes[-1].set_ylim(0, 1)\n",
    "        axes[-1].invert_yaxis()\n",
    "        axes[-1].set_aspect(\"equal\")\n",
    "        axes[-1].axis(\"off\")\n",
    "        axes[-1].set_title(\"Final Sketch\")\n",
    "        \n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "def test_inference():\n",
    "    \"\"\"Test the inference and visualization with enhanced error handling\"\"\"\n",
    "    try:\n",
    "        print(\"Initializing inference model...\")\n",
    "        inferencer = NimbleInference(\n",
    "            checkpoint_path=\"checkpoints/best_model/checkpoint\",\n",
    "            image_size=(28, 28),\n",
    "            num_points=100\n",
    "        )\n",
    "        \n",
    "        test_cases = [\n",
    "            (\"Test with image file\", \"../test_images/bird_0.jpg\"),\n",
    "            (\"Test with numpy array\", np.random.rand(100, 100, 3)),\n",
    "            (\"Test with PIL Image\", Image.fromarray(\n",
    "                (np.random.rand(100, 100, 3) * 255).astype('uint8')\n",
    "            ))\n",
    "        ]\n",
    "        \n",
    "        for test_name, test_input in test_cases:\n",
    "            try:\n",
    "                print(f\"\\n{test_name}...\")\n",
    "                inferencer.visualize_generation(test_input, temperature=0.8)\n",
    "                print(f\"✓ {test_name} completed successfully\")\n",
    "            except Exception as e:\n",
    "                print(f\"✗ {test_name} failed: {str(e)}\")\n",
    "        \n",
    "        return True\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"\\nTest failed with error:\")\n",
    "        print(f\"{str(e)}\")\n",
    "        print(\"\\nPlease ensure:\")\n",
    "        print(\"1. The model has been trained and checkpoints are saved\")\n",
    "        print(\"2. All required dependencies are installed\")\n",
    "        print(\"3. Test images are available in the correct location\")\n",
    "        return False\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    success = test_inference();\n",
    "    if success:\n",
    "        print(\"\\nAll tests completed.\")\n",
    "    else:\n",
    "        print(\"\\nTests failed. Please check the error messages above.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.11.4",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}