{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0dea6035",
   "metadata": {},
   "outputs": [],
   "source": [
    "from lightning_modules import (\n",
    "    AnyOrderInsertionFlowModule,\n",
    ")\n",
    "from sampling import any_order_mask_insertion_euler_sampling, SamplingTraceDatapoint\n",
    "import torch\n",
    "\n",
    "\n",
    "torch.set_float32_matmul_precision('high')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "594f721e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Jul 11 16:54:02 2025       \n",
      "+-----------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 575.57.08              Driver Version: 575.57.08      CUDA Version: 12.9     |\n",
      "|-----------------------------------------+------------------------+----------------------+\n",
      "| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |\n",
      "|                                         |                        |               MIG M. |\n",
      "|=========================================+========================+======================|\n",
      "|   0  NVIDIA H100 80GB HBM3          On  |   00000000:26:00.0 Off |                  Off |\n",
      "| N/A   25C    P0             67W /  700W |       0MiB /  81559MiB |      0%      Default |\n",
      "|                                         |                        |             Disabled |\n",
      "+-----------------------------------------+------------------------+----------------------+\n",
      "                                                                                         \n",
      "+-----------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                              |\n",
      "|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |\n",
      "|        ID   ID                                                               Usage      |\n",
      "|=========================================================================================|\n",
      "|  No running processes found                                                             |\n",
      "+-----------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "89c3826a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_length_distribution(samples, bin_size=5, figsize=(10, 6), color='blue', show_stats=True):\n",
    "    \"\"\"\n",
    "    Plot the distribution of sequence lengths from generated samples.\n",
    "    \n",
    "    Args:\n",
    "        samples: Tensor of shape [batch_size, max_length] containing the generated samples\n",
    "        bin_size: Size of bins for the histogram (default: 5)\n",
    "        figsize: Figure size as tuple (width, height) (default: (10, 6))\n",
    "        color: Color of the histogram bars (default: 'blue')\n",
    "        show_stats: Whether to print basic statistics (default: True)\n",
    "        \n",
    "    Returns:\n",
    "        fig, ax: The figure and axis objects for further customization\n",
    "    \"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "    import numpy as np\n",
    "    \n",
    "    # Get the lengths of samples (number of non-padding tokens)\n",
    "    lengths = (samples != 3).sum(dim=-1).cpu().numpy()\n",
    "    \n",
    "    # Define bins with intervals of bin_size\n",
    "    min_length = int(np.floor(lengths.min() / bin_size) * bin_size)  # Round down to nearest multiple of bin_size\n",
    "    max_length = int(np.ceil(lengths.max() / bin_size) * bin_size)   # Round up to nearest multiple of bin_size\n",
    "    bins = np.arange(min_length, max_length + bin_size, bin_size)    # +bin_size to include the max value\n",
    "    \n",
    "    # Count samples in each bin and calculate percentages\n",
    "    hist, bin_edges = np.histogram(lengths, bins=bins)\n",
    "    percentages = 100 * hist / len(lengths)  # Convert to percentages\n",
    "    \n",
    "    # Create a histogram to visualize the distribution with percentages\n",
    "    fig, ax = plt.subplots(figsize=figsize)\n",
    "    ax.bar(\n",
    "        (bin_edges[:-1] + bin_edges[1:]) / 2,  # Center of each bin\n",
    "        percentages,\n",
    "        width=np.diff(bin_edges) * 0.9,  # Slightly narrower than bin width for visual clarity\n",
    "        alpha=0.7,\n",
    "        color=color,\n",
    "        edgecolor='black'\n",
    "    )\n",
    "    ax.set_xlabel('Sample Length (tokens)')\n",
    "    ax.set_ylabel('Percentage (%)')\n",
    "    ax.set_title(f'Distribution of Sample Lengths ({bin_size}-unit bins)')\n",
    "    ax.grid(alpha=0.3)\n",
    "    \n",
    "    # Add percentage values above each bar\n",
    "    for i, p in enumerate(percentages):\n",
    "        if p > 0:  # Only add text for non-zero percentages\n",
    "            ax.text(\n",
    "                (bin_edges[i] + bin_edges[i+1]) / 2,  # Center of the bar\n",
    "                p + 0.5,  # Slightly above the bar\n",
    "                f'{p:.1f}%',  # Format with 1 decimal place\n",
    "                ha='center'\n",
    "            )\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # Display some basic statistics\n",
    "    if show_stats:\n",
    "        print(f\"Min length: {lengths.min()}\")\n",
    "        print(f\"Max length: {lengths.max()}\")\n",
    "        print(f\"Mean length: {lengths.mean():.2f}\")\n",
    "        print(f\"Median length: {np.median(lengths):.2f}\")\n",
    "        print(f\"Standard deviation: {np.std(lengths):.2f}\")\n",
    "        print(f\"Most common length: {np.bincount(lengths).argmax()}\")\n",
    "        print(f\"Sum of percentages: {np.sum(percentages):.1f}%\")  # Should be 100%\n",
    "    \n",
    "    return fig, ax\n",
    "\n",
    "def plot_length_evolution(trace, sample_id, steps=None, normalize_x=True, model=None, final_length=None, valid=None):\n",
    "    \"\"\"\n",
    "    Plot the evolution of the length (number of non-pad tokens) for a specific sample during sampling.\n",
    "    \n",
    "    Args:\n",
    "        trace: List of tensors with shape [batch_size, max_length] representing the sampling state at each step\n",
    "        sample_id: Index of the sample to inspect (0 to batch_size-1)\n",
    "        steps: Number of steps to plot. If None, plot all steps.\n",
    "        normalize_x: If True, normalize x-axis to range [0, 1] representing sampling progress\n",
    "        model: The model used for sampling, to access its insertion schedule\n",
    "        final_length: The final expected length, used to scale the insertion schedule\n",
    "        valid: List of boolean tensors indicating which samples are valid at each step\n",
    "    \"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "    import numpy as np\n",
    "    import torch\n",
    "    \n",
    "    # Validate sample_id\n",
    "    if sample_id < 0 or sample_id >= trace[0].shape[0]:\n",
    "        raise ValueError(f\"sample_id must be between 0 and {trace[0].shape[0]-1}\")\n",
    "    \n",
    "    # If steps is not provided, use the length of trace\n",
    "    if steps is None:\n",
    "        steps = len(trace)\n",
    "    else:\n",
    "        steps = min(steps, len(trace))\n",
    "    \n",
    "    # Calculate length at each step for the specified sample\n",
    "    lengths = []\n",
    "    for step in range(steps):\n",
    "        # Count non-pad tokens (tokens that are not 3)\n",
    "        length = (trace[step][sample_id] != 3).sum().item()\n",
    "        lengths.append(length)\n",
    "    \n",
    "    # Create the plot with two y-axes\n",
    "    fig, ax1 = plt.subplots(figsize=(10, 6))\n",
    "    \n",
    "    if normalize_x:\n",
    "        # Normalize x-axis from 0 to 1 (representing progress percentage)\n",
    "        x_values = np.linspace(0, 1, steps)\n",
    "        ax1.set_xlabel('Normalized Sampling Progress')\n",
    "    else:\n",
    "        # Use raw step numbers\n",
    "        x_values = np.arange(steps)\n",
    "        ax1.set_xlabel('Step')\n",
    "    \n",
    "    # Plot the actual length evolution on the first y-axis\n",
    "    ax1.plot(x_values, lengths, marker='o', linestyle='-', markersize=4, color='blue', label='Actual Length')\n",
    "    ax1.set_ylabel('Length (non-pad tokens)', color='blue')\n",
    "    ax1.tick_params(axis='y', labelcolor='blue')\n",
    "    \n",
    "    # Add annotations for start and end lengths\n",
    "    ax1.text(x_values[0], lengths[0], f'{lengths[0]}', verticalalignment='bottom', color='blue')\n",
    "    ax1.text(x_values[-1], lengths[-1], f'{lengths[-1]}', verticalalignment='bottom', color='blue')\n",
    "    \n",
    "    # Highlight significant changes\n",
    "    length_changes = np.diff(lengths)\n",
    "    significant_steps = [i+1 for i, change in enumerate(length_changes) if abs(change) > 0]\n",
    "    \n",
    "    for step in significant_steps:\n",
    "        x_pos = x_values[step]\n",
    "        ax1.axvline(x=x_pos, color='r', linestyle='--', alpha=0.2)\n",
    "    \n",
    "    # If model is provided, plot the theoretical insertion schedule\n",
    "    if model is not None and hasattr(model, 'interpolant') and hasattr(model.interpolant, 'insertion_schedule'):\n",
    "        # Generate time points\n",
    "        time_points = torch.linspace(0, 1, 100, device=trace[0].device)\n",
    "        \n",
    "        # Get the schedule values\n",
    "        schedule_values = model.interpolant.insertion_schedule.at(time_points).cpu().numpy()\n",
    "        \n",
    "        # If final_length is not provided, use the actual final length\n",
    "        if final_length is None:\n",
    "            final_length = lengths[-1]\n",
    "        \n",
    "        # Scale the schedule values to match the token count\n",
    "        scaled_schedule = schedule_values * final_length\n",
    "        \n",
    "        # Plot the schedule\n",
    "        ax1.plot(time_points.cpu().numpy(), scaled_schedule, 'r--', label='Theoretical Schedule')\n",
    "    \n",
    "    # If valid is provided, plot cumulative invalid count on a second y-axis\n",
    "    if valid is not None and len(valid) > 0:\n",
    "        # Create a second y-axis\n",
    "        ax2 = ax1.twinx()\n",
    "        ax2.set_ylabel('Cumulative Invalid Count', color='green')\n",
    "        ax2.tick_params(axis='y', labelcolor='green')\n",
    "        \n",
    "        # Extract boolean values for the specific sample\n",
    "        invalid_counts = []\n",
    "        cumulative_invalid = 0\n",
    "        \n",
    "        # Ensure we don't go beyond the length of valid\n",
    "        valid_steps = min(steps, len(valid))\n",
    "        \n",
    "        for step in range(valid_steps):\n",
    "            # Check if the sample is valid at this step\n",
    "            if not valid[step][sample_id].item():\n",
    "                cumulative_invalid += 1\n",
    "            invalid_counts.append(cumulative_invalid)\n",
    "        \n",
    "        # If valid has fewer steps than trace, pad with the last value\n",
    "        if valid_steps < steps:\n",
    "            invalid_counts.extend([invalid_counts[-1]] * (steps - valid_steps))\n",
    "        \n",
    "        # Plot the cumulative invalid count\n",
    "        ax2.plot(x_values, invalid_counts, color='green', linestyle='-', marker='.', label='Cumulative Invalid')\n",
    "        \n",
    "        # Add a legend for the second y-axis\n",
    "        lines1, labels1 = ax1.get_legend_handles_labels()\n",
    "        lines2, labels2 = ax2.get_legend_handles_labels()\n",
    "        ax2.legend(lines1 + lines2, labels1 + labels2, loc='upper left')\n",
    "    else:\n",
    "        ax1.legend(loc='upper left')\n",
    "    \n",
    "    plt.title(f'Evolution of Length for Sample {sample_id}')\n",
    "    plt.grid(True, alpha=0.3)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # Print summary statistics\n",
    "    print(f\"Initial length: {lengths[0]}\")\n",
    "    print(f\"Final length: {lengths[-1]}\")\n",
    "    print(f\"Number of length changes: {len(significant_steps)}\")\n",
    "    if valid is not None:\n",
    "        print(f\"Final cumulative invalid count: {invalid_counts[-1] if invalid_counts else 0}\")\n",
    "    \n",
    "    # Return the lengths for further analysis if needed\n",
    "    return lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "485bd86f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AnyOrderInsertionFlowModule(\n",
       "  (model): OptimizedModule(\n",
       "    (_orig_mod): AnyOrderMaskInsertionFlow(\n",
       "      (vocab_embed): EmbeddingLayer()\n",
       "      (sigma_map): TimestepEmbedder(\n",
       "        (mlp): Sequential(\n",
       "          (0): Linear(in_features=256, out_features=64, bias=True)\n",
       "          (1): SiLU()\n",
       "          (2): Linear(in_features=64, out_features=64, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (rotary_emb): Rotary()\n",
       "      (blocks): ModuleList(\n",
       "        (0-2): 3 x DDiTBlock(\n",
       "          (norm1): LayerNorm()\n",
       "          (attn_qkv): Linear(in_features=256, out_features=768, bias=False)\n",
       "          (attn_out): Linear(in_features=256, out_features=256, bias=False)\n",
       "          (dropout1): Dropout(p=0.0, inplace=False)\n",
       "          (norm2): LayerNorm()\n",
       "          (mlp): Sequential(\n",
       "            (0): Linear(in_features=256, out_features=1024, bias=True)\n",
       "            (1): GELU(approximate='tanh')\n",
       "            (2): Linear(in_features=1024, out_features=256, bias=True)\n",
       "          )\n",
       "          (dropout2): Dropout(p=0.0, inplace=False)\n",
       "          (adaLN_modulation): Linear(in_features=64, out_features=1536, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (length_block): ModuleList(\n",
       "        (0): DDiTBlock(\n",
       "          (norm1): LayerNorm()\n",
       "          (attn_qkv): Linear(in_features=256, out_features=768, bias=False)\n",
       "          (attn_out): Linear(in_features=256, out_features=256, bias=False)\n",
       "          (dropout1): Dropout(p=0.0, inplace=False)\n",
       "          (norm2): LayerNorm()\n",
       "          (mlp): Sequential(\n",
       "            (0): Linear(in_features=256, out_features=1024, bias=True)\n",
       "            (1): GELU(approximate='tanh')\n",
       "            (2): Linear(in_features=1024, out_features=256, bias=True)\n",
       "          )\n",
       "          (dropout2): Dropout(p=0.0, inplace=False)\n",
       "          (adaLN_modulation): Linear(in_features=64, out_features=1536, bias=True)\n",
       "        )\n",
       "      )\n",
       "      (output_layer): DDitFinalLayer(\n",
       "        (norm_final): LayerNorm()\n",
       "        (linear): Linear(in_features=256, out_features=4, bias=True)\n",
       "        (adaLN_modulation): Linear(in_features=64, out_features=512, bias=True)\n",
       "      )\n",
       "      (len_pred): ScalarLengthHead(\n",
       "        (adaLN): Linear(in_features=64, out_features=512, bias=True)\n",
       "        (norm): LayerNorm()\n",
       "        (proj1): Linear(in_features=256, out_features=256, bias=True)\n",
       "        (act): GELU(approximate='none')\n",
       "        (proj2): Linear(in_features=256, out_features=1, bias=True)\n",
       "        (softplus): Softplus(beta=1.0, threshold=20.0)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkpoint_path = \"/n/netscratch/albergo_lab/Lab/brianlck/interpretable-flow/checkpoints/bracket/any_order/20250711-151647/last.ckpt\"\n",
    "\n",
    "model = AnyOrderInsertionFlowModule.load_from_checkpoint(checkpoint_path)\n",
    "# model.swap_to_ema()\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "14e5855e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi 32 20\n",
      "hi 64 20\n",
      "0.00013176546296497739 1.0980455247081448e-05\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5714285714285714"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lengths = {4: 0.1, 16: 0.4, 32: 0.4, 64: 0.1}\n",
    "\n",
    "def binomial_mass(k, n, p):\n",
    "    \"\"\"\n",
    "    Calculate the probability mass function (PMF) for a binomial distribution.\n",
    "    \n",
    "    Args:\n",
    "        k (int): Number of successes\n",
    "        n (int): Number of trials\n",
    "        p (float): Probability of success in a single trial\n",
    "        \n",
    "    Returns:\n",
    "        float: Probability mass P(X = k)\n",
    "    \"\"\"\n",
    "    import math\n",
    "    \n",
    "    # Calculate binomial coefficient (n choose k)\n",
    "    try:\n",
    "        binom_coef = math.factorial(n) / (math.factorial(k) * math.factorial(n - k))\n",
    "    except ValueError:\n",
    "        # Handle cases where k > n or negative values\n",
    "        return 0.0\n",
    "        \n",
    "    # Calculate probability mass\n",
    "    return binom_coef * (p ** k) * ((1 - p) ** (n - k))\n",
    "\n",
    "\n",
    "def calculate_rate(alpha_t, len_t):\n",
    "    nom, denom = 0, 0\n",
    "\n",
    "    for length, probability in lengths.items():\n",
    "        if length >= len_t:\n",
    "            print(\"hi\", length, len_t)\n",
    "            nom += (length - len_t) * probability * binomial_mass(len_t, length, alpha_t)\n",
    "            denom += probability * binomial_mass(len_t, length, alpha_t)\n",
    "    \n",
    "    print(nom, denom)\n",
    "    return nom / ((len_t + 1) * denom)\n",
    "\n",
    "\n",
    "calculate_rate(0.9, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6caf3a17",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 12\u001b[39m\n\u001b[32m      9\u001b[39m len_t = \u001b[32m20\u001b[39m\n\u001b[32m     10\u001b[39m t = \u001b[32m0.9\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m12\u001b[39m xt = \u001b[43mconstruct_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlen_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m64\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m     13\u001b[39m t = torch.tensor([t], device=model.device)\n\u001b[32m     14\u001b[39m alpha_t = model.interpolant.insertion_schedule.at(t).item()\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 5\u001b[39m, in \u001b[36mconstruct_tensor\u001b[39m\u001b[34m(length, max_length)\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mconstruct_tensor\u001b[39m(length, max_length):\n\u001b[32m      2\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m torch.tensor(\n\u001b[32m      3\u001b[39m         [\u001b[32m0\u001b[39m] * (length) + [\u001b[32m3\u001b[39m] * (max_length - length),\n\u001b[32m      4\u001b[39m         dtype=torch.int64,\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m         device=\u001b[43mmodel\u001b[49m.device\n\u001b[32m      6\u001b[39m     ).unsqueeze(\u001b[32m0\u001b[39m)\n",
      "\u001b[31mNameError\u001b[39m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "def construct_tensor(length, max_length):\n",
    "    return torch.tensor(\n",
    "        [0] * (length) + [3] * (max_length - length),\n",
    "        dtype=torch.int64,\n",
    "        device=model.device\n",
    "    ).unsqueeze(0)  # Add batch dimension\n",
    "\n",
    "\n",
    "len_t = 20\n",
    "t = 0.9\n",
    "\n",
    "xt = construct_tensor(len_t, 64)\n",
    "t = torch.tensor([t], device=model.device)\n",
    "alpha_t = model.interpolant.insertion_schedule.at(t).item()\n",
    "\n",
    "print(xt.tolist(), t.item(), alpha_t)\n",
    "\n",
    "print(model(xt, t).expected_gaps, calculate_rate(alpha_t, len_t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2b5d5cc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, fix the calculate_rate function to remove debugging print statements\n",
    "def calculate_rate(alpha_t, len_t):\n",
    "    nom, denom = 0, 0\n",
    "\n",
    "    for length, probability in lengths.items():\n",
    "        if length >= len_t:\n",
    "            nom += (length - len_t) * probability * binomial_mass(len_t, length, alpha_t)\n",
    "            denom += probability * binomial_mass(len_t, length, alpha_t)\n",
    "    \n",
    "    # Ensure denom is not zero to prevent division by zero\n",
    "    if denom == 0:\n",
    "        return 0.0\n",
    "    \n",
    "    return nom / (denom)  # Prevent division by zero\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf89eaa6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a0b49879",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final step, removing mask token from sampling\n",
      "tensor([0., 0., 0.,  ..., 0., 0., 0.], device='cuda:0')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min length: 3\n",
      "Max length: 64\n",
      "Mean length: 23.83\n",
      "Median length: 16.00\n",
      "Standard deviation: 14.60\n",
      "Most common length: 16\n",
      "Sum of percentages: 100.0%\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<Figure size 1000x600 with 1 Axes>,\n",
       " <Axes: title={'center': 'Distribution of Sample Lengths (5-unit bins)'}, xlabel='Sample Length (tokens)', ylabel='Percentage (%)'>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sampling import any_order_mask_insertion_tau_leaping_sampling\n",
    "\n",
    "steps = 20000\n",
    "batch_size = 2000\n",
    "\n",
    "samples, trace = any_order_mask_insertion_euler_sampling(\n",
    "    model,\n",
    "    steps=steps,\n",
    "    mask=0,\n",
    "    pad=3,\n",
    "    batch_size=batch_size,\n",
    "    max_length=64,\n",
    "    return_trace=False,\n",
    ")\n",
    "\n",
    "\n",
    "plot_length_distribution(samples, bin_size=5, figsize=(10, 6), color='blue', show_stats=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f244d9ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 8.,  4.,  9.,  4.,  4.,  4., 10.,  3., 10.,  4., 11.,  3.,  4.,  4.,\n",
       "         4.,  4.,  2.,  4.,  3.,  4., 10.,  4.,  3., 10.,  4.,  9.,  4.,  3.,\n",
       "         4.,  4.,  4.,  3.,  4.,  4.,  4.,  4.,  3.,  4.,  4.,  4.,  3., 12.,\n",
       "         9.,  4.,  4.,  4.,  8.,  4.,  3.,  4.,  2.,  8.,  3.,  4.,  4.,  3.,\n",
       "         3.,  9.,  3.,  9.,  3.,  3.,  8.,  3.,  3., 10.,  4., 10.,  4.,  4.,\n",
       "         4.,  3.,  2.,  3.,  9.,  4.,  4.,  4.,  7., 10.,  3.,  3.,  9.,  4.,\n",
       "         3.,  9., 11.,  4.,  4.,  4.,  4.,  3.,  3., 12.,  4.,  4.,  4.,  3.,\n",
       "         8.,  3.], device='cuda:0')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lengths = {4: 0.1, 16: 0.4, 32: 0.4, 64: 0.1}\n",
    "\n",
    "def binomial_mass(k, n, p):\n",
    "    \"\"\"\n",
    "    Calculate the probability mass function (PMF) for a binomial distribution.\n",
    "    \n",
    "    Args:\n",
    "        k (int): Number of successes\n",
    "        n (int): Number of trials\n",
    "        p (float): Probability of success in a single trial\n",
    "        \n",
    "    Returns:\n",
    "        float: Probability mass P(X = k)\n",
    "    \"\"\"\n",
    "    import math\n",
    "    \n",
    "    # Calculate binomial coefficient (n choose k)\n",
    "    try:\n",
    "        binom_coef = math.factorial(n) / (math.factorial(k) * math.factorial(n - k))\n",
    "    except ValueError:\n",
    "        # Handle cases where k > n or negative values\n",
    "        return 0.0\n",
    "        \n",
    "    # Calculate probability mass\n",
    "    return binom_coef * (p ** k) * ((1 - p) ** (n - k))\n",
    "\n",
    "def calculate_rate_batch(alpha_t, len_t):\n",
    "    \"\"\"\n",
    "    Calculate rate for a batch of alpha_t and len_t values.\n",
    "    \n",
    "    Args:\n",
    "        alpha_t (torch.Tensor): Tensor of shape (batch_size,)\n",
    "        len_t (torch.Tensor): Tensor of shape (batch_size,)\n",
    "        \n",
    "    Returns:\n",
    "        torch.Tensor: Tensor of shape (batch_size,) containing calculated rates\n",
    "    \"\"\"\n",
    "    batch_size = alpha_t.shape[0]\n",
    "    device = alpha_t.device\n",
    "    \n",
    "    # Initialize tensors for numerator and denominator\n",
    "    nom = torch.zeros(batch_size, device=device)\n",
    "    denom = torch.zeros(batch_size, device=device)\n",
    "    \n",
    "    for length, probability in lengths.items():\n",
    "        # Create mask for valid entries where len_t <= length\n",
    "        valid_mask = (len_t <= length) & (len_t >= 0)\n",
    "        \n",
    "        if not valid_mask.any():\n",
    "            continue\n",
    "        \n",
    "        valid_indices = valid_mask.nonzero(as_tuple=True)[0]\n",
    "        valid_len_t = len_t[valid_indices]\n",
    "        valid_alpha_t = alpha_t[valid_indices]\n",
    "        \n",
    "        # Calculate binomial probabilities efficiently using torch distribution\n",
    "        binom_dist = torch.distributions.Binomial(total_count=length, probs=valid_alpha_t)\n",
    "        binom_probs = binom_dist.log_prob(valid_len_t).exp()\n",
    "        \n",
    "        # Update numerator and denominator for valid indices\n",
    "        nom[valid_indices] += (length - valid_len_t) * probability * binom_probs\n",
    "        denom[valid_indices] += probability * binom_probs\n",
    "    \n",
    "    # Handle division by zero in a vectorized way\n",
    "    result = torch.zeros_like(nom)\n",
    "    div_mask = denom > 0\n",
    "    result[div_mask] = nom[div_mask] / (denom[div_mask])\n",
    "    \n",
    "    return result\n",
    "\n",
    "# Keep the original function for backward compatibility\n",
    "def calculate_rate(alpha_t, len_t):\n",
    "    \"\"\"Legacy scalar version of calculate_rate\"\"\"\n",
    "    if isinstance(alpha_t, torch.Tensor) and alpha_t.ndim > 0:\n",
    "        return calculate_rate_batch(alpha_t, len_t)\n",
    "    \n",
    "    nom, denom = 0, 0\n",
    "    for length, probability in lengths.items():\n",
    "        if length >= len_t:\n",
    "            nom += (length - len_t) * probability * binomial_mass(len_t, length, alpha_t)\n",
    "            denom += probability * binomial_mass(len_t, length, alpha_t)\n",
    "    \n",
    "    if denom == 0:\n",
    "        return 0.0\n",
    "    \n",
    "    return nom /  denom\n",
    "\n",
    "insertion_schedule = model.interpolant.insertion_schedule\n",
    "\n",
    "def sample(batch_size):\n",
    "    steps = 10000\n",
    "    dt = 1.0 / steps\n",
    "    t = torch.full((batch_size,), 0.0, device=model.device)\n",
    "    x = torch.full((batch_size,), 0, device=model.device)  # Initialize with padding token (3)\n",
    "\n",
    "    for i in range(steps):\n",
    "        rate = calculate_rate(insertion_schedule.at(t), x)\n",
    "        rate = rate * insertion_schedule.rate_scale_factor(t)\n",
    "        inc = torch.poisson(rate * dt).long()\n",
    "        x = x + inc\n",
    "\n",
    "        t = t + dt\n",
    "\n",
    "    return x\n",
    "\n",
    "sample(100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a46aee98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial length: 0\n",
      "Final length: 32\n",
      "Number of length changes: 32\n",
      "Final cumulative invalid count: 0\n"
     ]
    }
   ],
   "source": [
    "sample_id = 100\n",
    "lengths = plot_length_evolution(trace, sample_id, normalize_x=True, model=model, final_length=None, valid=valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8058f57f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min length: 3\n",
      "Max length: 64\n",
      "Mean length: 21.45\n",
      "Median length: 16.00\n",
      "Sum of percentages: 100.0%\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "03650899",
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name 'get' from 'data' (/n/netscratch/albergo_lab/Lab/brianlck/interpretable-flow/data/__init__.py)",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mImportError\u001b[39m                               Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[49]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mdata\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m get\n",
      "\u001b[31mImportError\u001b[39m: cannot import name 'get' from 'data' (/n/netscratch/albergo_lab/Lab/brianlck/interpretable-flow/data/__init__.py)"
     ]
    }
   ],
   "source": [
    "from data import get"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "01564892",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_trace(trace: list[SamplingTraceDatapoint]):\n",
    "    event_type_mapping = dict(change=\"c\", insertion=\"i\")\n",
    "    token_mapping = {0: \"m\", 1: \"(\", 2: \")\"}\n",
    "\n",
    "    def _process_datapoint(datapoint: SamplingTraceDatapoint):\n",
    "        return dict(\n",
    "            t=datapoint.t,\n",
    "            a=event_type_mapping[datapoint.event_type],\n",
    "            tk=token_mapping[datapoint.token],\n",
    "            i=datapoint.position,\n",
    "        )\n",
    "\n",
    "    return [_process_datapoint(datapoint) for datapoint in trace]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "63efdf7b",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "3",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mKeyError\u001b[39m                                  Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[34]\u001b[39m\u001b[32m, line 8\u001b[39m\n\u001b[32m      5\u001b[39m \u001b[38;5;28mid\u001b[39m = \u001b[32m19\u001b[39m\n\u001b[32m      6\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m \u001b[32m0\u001b[39m <= \u001b[38;5;28mid\u001b[39m < batch_size, \u001b[33m\"\u001b[39m\u001b[33mid must be in [0, batch_size)\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m8\u001b[39m events = \u001b[43mprocess_trace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mid\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      9\u001b[39m \u001b[38;5;28mprint\u001b[39m(events)\n\u001b[32m     11\u001b[39m display(\n\u001b[32m     12\u001b[39m     HTML(\u001b[33mf\u001b[39m\u001b[33m\"\"\"\u001b[39m\n\u001b[32m     13\u001b[39m \u001b[33m<style>\u001b[39m\n\u001b[32m   (...)\u001b[39m\u001b[32m     70\u001b[39m \u001b[33m\"\"\"\u001b[39m)\n\u001b[32m     71\u001b[39m )\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 13\u001b[39m, in \u001b[36mprocess_trace\u001b[39m\u001b[34m(trace)\u001b[39m\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_process_datapoint\u001b[39m(datapoint: SamplingTraceDatapoint):\n\u001b[32m      6\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mdict\u001b[39m(\n\u001b[32m      7\u001b[39m         t=datapoint.t,\n\u001b[32m      8\u001b[39m         a=event_type_mapping[datapoint.event_type],\n\u001b[32m      9\u001b[39m         tk=token_mapping[datapoint.token],\n\u001b[32m     10\u001b[39m         i=datapoint.position,\n\u001b[32m     11\u001b[39m     )\n\u001b[32m---> \u001b[39m\u001b[32m13\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m[\u001b[49m\u001b[43m_process_datapoint\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdatapoint\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdatapoint\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mtrace\u001b[49m\u001b[43m]\u001b[49m\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 13\u001b[39m, in \u001b[36m<listcomp>\u001b[39m\u001b[34m(.0)\u001b[39m\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_process_datapoint\u001b[39m(datapoint: SamplingTraceDatapoint):\n\u001b[32m      6\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mdict\u001b[39m(\n\u001b[32m      7\u001b[39m         t=datapoint.t,\n\u001b[32m      8\u001b[39m         a=event_type_mapping[datapoint.event_type],\n\u001b[32m      9\u001b[39m         tk=token_mapping[datapoint.token],\n\u001b[32m     10\u001b[39m         i=datapoint.position,\n\u001b[32m     11\u001b[39m     )\n\u001b[32m---> \u001b[39m\u001b[32m13\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m [\u001b[43m_process_datapoint\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdatapoint\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m datapoint \u001b[38;5;129;01min\u001b[39;00m trace]\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 9\u001b[39m, in \u001b[36mprocess_trace.<locals>._process_datapoint\u001b[39m\u001b[34m(datapoint)\u001b[39m\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_process_datapoint\u001b[39m(datapoint: SamplingTraceDatapoint):\n\u001b[32m      6\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mdict\u001b[39m(\n\u001b[32m      7\u001b[39m         t=datapoint.t,\n\u001b[32m      8\u001b[39m         a=event_type_mapping[datapoint.event_type],\n\u001b[32m----> \u001b[39m\u001b[32m9\u001b[39m         tk=\u001b[43mtoken_mapping\u001b[49m\u001b[43m[\u001b[49m\u001b[43mdatapoint\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtoken\u001b[49m\u001b[43m]\u001b[49m,\n\u001b[32m     10\u001b[39m         i=datapoint.position,\n\u001b[32m     11\u001b[39m     )\n",
      "\u001b[31mKeyError\u001b[39m: 3"
     ]
    }
   ],
   "source": [
    "from IPython.display import display, HTML\n",
    "import json\n",
    "\n",
    "# Select the index of the tensor to visualize\n",
    "id = 19\n",
    "assert 0 <= id < batch_size, \"id must be in [0, batch_size)\"\n",
    "\n",
    "events = process_trace(trace[id])\n",
    "print(events)\n",
    "\n",
    "display(\n",
    "    HTML(f\"\"\"\n",
    "<style>\n",
    ".token {{\n",
    "    display: inline-block;\n",
    "    padding: 5px 10px;\n",
    "    margin: 2px;\n",
    "    border: 1px solid #aaa;\n",
    "    border-radius: 4px;\n",
    "    font-family: monospace;\n",
    "    transition: background 0.5s;\n",
    "}}\n",
    ".hi-i {{ background: lightgreen; }}\n",
    ".hi-c {{ background: yellow; }}\n",
    "#s {{ min-height: 30px; margin-bottom: 20px; }}\n",
    "</style>\n",
    "<div id=\"s\"></div>\n",
    "<button id=\"r\">Replay</button>\n",
    "<script>\n",
    "var ev = {json.dumps(events)};\n",
    "var s = [];\n",
    "var delay = 100; // Delay between steps (ms)\n",
    "\n",
    "function render(hIdx, action) {{\n",
    "    var container = document.getElementById(\"s\");\n",
    "    container.innerHTML = \"\";\n",
    "    s.forEach(function(token, idx) {{\n",
    "        var span = document.createElement(\"span\");\n",
    "        span.className = \"token\" + (idx === hIdx ? \" hi-\" + action : \"\");\n",
    "        span.textContent = token;\n",
    "        container.appendChild(span);\n",
    "    }});\n",
    "}}\n",
    "\n",
    "async function run() {{\n",
    "    s = [];\n",
    "    render();\n",
    "    \n",
    "    for (const e of ev) {{\n",
    "        if (e.a === \"i\") {{\n",
    "            // Insert token at position e.i\n",
    "            var pos = (e.i < 0 || e.i > s.length) ? Math.floor(s.length / 2) : e.i;\n",
    "            s.splice(pos, 0, e.tk);\n",
    "            render(pos, \"i\");\n",
    "        }} else {{\n",
    "            // Change token at position e.i\n",
    "            var pos = (e.i === undefined || e.i < 0 || e.i >= s.length) ? Math.floor(s.length / 2) : e.i;\n",
    "            s[pos] = e.tk;\n",
    "            render(pos, \"c\");\n",
    "        }}\n",
    "        \n",
    "        // Small delay to make the animation visible (but still synchronous in execution order)\n",
    "        await new Promise(resolve => setTimeout(resolve, delay));\n",
    "    }}\n",
    "}}\n",
    "\n",
    "document.getElementById(\"r\").onclick = run;\n",
    "run(); // Start automatically\n",
    "</script>\n",
    "\"\"\")\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d5210d9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "interpretable-flow",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}