{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7324eaa9",
   "metadata": {},
   "source": [
    "# Tutorial 03: Physics-based Pattern Generation Using LPF Framework\n",
    "\n",
    "## Introduction\n",
    "\n",
    "This tutorial demonstrates how to generate ladybird patterns using the **LPF** with PDE parameters from the LadybirdMNIST datset.\n",
    "\n",
    "### What This Tutorial Covers\n",
    "\n",
    "1. Loading Model Configurations\n",
    "    - Extract PDE parameters from the `models` configuration\n",
    "    - Parse JSON-formatted model specifications\n",
    "    - Understand parameter meanings and their effects on patterns\n",
    "\n",
    "2. **Setting Up LPF Simulations**\n",
    "   - Initialize reaction-diffusion solvers with dataset parameters\n",
    "   - Configure domain specifications and boundary conditions\n",
    "   - Set appropriate time steps and iteration counts\n",
    "\n",
    "3. **Pattern Generation Process**\n",
    "   - Run reaction-diffusion simulations\n",
    "   - Monitor convergence and stability\n",
    "   - Generate patterns matching dataset labels\n",
    "\n",
    "4. **Visualization and Analysis**\n",
    "   - Visualize intermediate states during pattern formation\n",
    "   - Compare generated patterns with original dataset images\n",
    "   - Analyze the relationship between parameters and resulting patterns\n",
    "\n",
    "## Prerequisites\n",
    "\n",
    "Before starting this tutorial, you need to install the LPF framework:\n",
    "\n",
    "```bash\n",
    "pip install lpf\n",
    "```\n",
    "\n",
    "For development version or additional features, install from source:\n",
    "- [LPF GitHub Repository](https://github.com/your-repo/lpf)\n",
    "\n",
    "## Important Notes\n",
    "\n",
    "⚠️ **Computational Requirements**: Pattern generation is computationally intensive. Each simulation may take 2-3 minutes depending on:\n",
    "- Grid resolution (default: 128×128)\n",
    "- Number of iterations (typically 500,000)\n",
    "- System specifications\n",
    "\n",
    "⚠️ **Memory Usage**: Large-scale simulations with high resolution may require significant RAM\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9c38106c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from PIL import Image\n",
    "from datetime import datetime\n",
    "from datasets import load_dataset\n",
    "\n",
    "# LPF components\n",
    "from lpf.initializers import LiawInitializer\n",
    "from lpf.models import LiawModel\n",
    "from lpf.solvers import EulerSolver, RungeKuttaSolver"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36127905",
   "metadata": {},
   "source": [
    "## 1. Loading Model Configurations from LadybirdMNIST Dataset\n",
    "\n",
    "First, we'll load the LadybirdMNIST datset and examine the model configurations that contain the PDE parameters needed for pattern generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ea35840a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading LadybirdMNIST dataset...\n",
      "Dataset structure:\n",
      "DatasetDict({\n",
      "    train: Dataset({\n",
      "        features: ['id', 'label', 'model_json'],\n",
      "        num_rows: 60000\n",
      "    })\n",
      "    test: Dataset({\n",
      "        features: ['id', 'label', 'model_json'],\n",
      "        num_rows: 10000\n",
      "    })\n",
      "})\n",
      "\n",
      "Train set: 60000 samples\n",
      "Test set: 10000 samples\n",
      "\n",
      "Sample ID: 1483518086234970557\n",
      "Label: 3\n",
      "Model JSON: {\"model\": \"LiawModel\", \"index\": 8, \"width\": 128, \"height\": 128, \"dx\": 0.1, \"thr_color\": 0.5, \"color_u\": [5, 5, 5], \"color_v\": [231, 79, 3], \"initializer\": \"LiawInitializer\", \"u0\": 2.5417754650115967, \"v0\": 1.0, \"n_init_pts\": 25, \"init_pts_0\": [17, 64], \"init_pts_1\": [21, 89], \"init_pts_2\": [23, 84], \"init_pts_3\": [41, 0], \"init_pts_4\": [37, 68], \"init_pts_5\": [32, 26], \"init_pts_6\": [89, 32], \"init_pts_7\": [50, 70], \"init_pts_8\": [79, 64], \"init_pts_9\": [78, 117], \"init_pts_10\": [79, 88], \"init_pts_11\": [67, 50], \"init_pts_12\": [11, 34], \"init_pts_13\": [93, 85], \"init_pts_14\": [65, 63], \"init_pts_15\": [32, 71], \"init_pts_16\": [85, 57], \"init_pts_17\": [84, 103], \"init_pts_18\": [37, 63], \"init_pts_19\": [63, 91], \"init_pts_20\": [0, 0], \"init_pts_21\": [0, 0], \"init_pts_22\": [0, 0], \"init_pts_23\": [0, 0], \"init_pts_24\": [0, 0], \"solver\": \"EulerSolver\", \"dt\": 0.01, \"n_iters\": 500000, \"Du\": 0.0005005555637923848, \"Dv\": 0.07500000000000001, \"ru\": 0.17458988270167908, \"rv\": 0.13353777365013922, \"k\": 0.21288995293268248, \"su\": 0.001, \"sv\": 0.025000000000000005, \"mu\": 0.07999999999999999}\n"
     ]
    }
   ],
   "source": [
    "# Load the LadybirdMNIST datset (models configuration)\n",
    "print(\"Loading LadybirdMNIST dataset...\")\n",
    "ds = load_dataset('cxinsys/ladybirdmnist', 'models')\n",
    "\n",
    "print(\"Dataset structure:\")\n",
    "print(ds)\n",
    "print(f\"\\nTrain set: {ds['train'].num_rows} samples\")\n",
    "print(f\"Test set: {ds['test'].num_rows} samples\")\n",
    "\n",
    "# Examine the first model configuration\n",
    "sample_model = ds['train'][0]\n",
    "print(f\"\\nSample ID: {sample_model['id']}\")\n",
    "print(f\"Label: {sample_model['label']}\")\n",
    "print(f\"Model JSON: {sample_model['model_json']}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd8a91c7",
   "metadata": {},
   "source": [
    "### Parsing JSON Model Specifications\n",
    "\n",
    "Now let's parse the JSON-formatted model specifications to understand the PDE parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "12039772",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================================\n",
      "model          : LiawModel\n",
      "index          : 8\n",
      "width          : 128\n",
      "height         : 128\n",
      "dx             : 0.1\n",
      "thr_color      : 0.5\n",
      "color_u        : [5, 5, 5]\n",
      "color_v        : [231, 79, 3]\n",
      "initializer    : LiawInitializer\n",
      "u0             : 2.5417754650115967\n",
      "v0             : 1.0\n",
      "n_init_pts     : 25\n",
      "solver         : EulerSolver\n",
      "dt             : 0.01\n",
      "n_iters        : 500000\n",
      "Du             : 0.0005005555637923848\n",
      "Dv             : 0.07500000000000001\n",
      "ru             : 0.17458988270167908\n",
      "rv             : 0.13353777365013922\n",
      "k              : 0.21288995293268248\n",
      "su             : 0.001\n",
      "sv             : 0.025000000000000005\n",
      "mu             : 0.07999999999999999\n"
     ]
    }
   ],
   "source": [
    "# Parse the JSON model configuration\n",
    "model_json = json.loads(ds['train'][0]['model_json'])\n",
    "print(\"=\" * 50)\n",
    "for key, value in model_json.items():\n",
    "    if key.startswith('init_pts_'):\n",
    "        continue  # Skip individual init points for brevity\n",
    "    print(f\"{key:15}: {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc802560",
   "metadata": {},
   "source": [
    "## 2. Setting Up LPF Simulations\n",
    "\n",
    "Now we'll configure the LPF framework components using the parameters from the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7d07946f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting up LPF components...\n",
      "1. Creating LiawInitializer...\n",
      "2. Parsing LiawModel parameters...\n"
     ]
    }
   ],
   "source": [
    "# Prepare model configurations for LPF\n",
    "model_dicts = [model_json]\n",
    "\n",
    "print(\"Setting up LPF components...\")\n",
    "\n",
    "# Initialize the LiawInitializer\n",
    "print(\"1. Creating LiawInitializer...\")\n",
    "initializer = LiawInitializer()\n",
    "initializer.update(model_dicts)\n",
    "\n",
    "# Parse parameters for the LiawModel\n",
    "print(\"2. Parsing LiawModel parameters...\")\n",
    "params = LiawModel.parse_params(model_dicts)\n",
    "\n",
    "# Set computational parameters\n",
    "device = 'cpu'\n",
    "n_iters = model_json['n_iters']\n",
    "dpath_output = './output_tutorial'\n",
    "\n",
    "# Create output directory if it doesn't exist\n",
    "os.makedirs(dpath_output, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc7d31fb",
   "metadata": {},
   "source": [
    "## Initialize the Reaction-Diffusion Model\n",
    "\n",
    "Now we'll create the LiawModel with the parsed parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ebb691d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating LiawModel...\n"
     ]
    }
   ],
   "source": [
    "# Create the LiawModel instance\n",
    "print(\"Creating LiawModel...\")\n",
    "model = LiawModel(\n",
    "    initializer=initializer,\n",
    "    params=params,\n",
    "    dx=model_json['dx'],\n",
    "    width=model_json['width'],\n",
    "    height=model_json['height'],\n",
    "    device=device\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "476e219f",
   "metadata": {},
   "source": [
    "## 3. Pattern Generation Process\n",
    "\n",
    "Now we'll run the reaction-diffusion simulation to generate the ladybird pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "da3d0a67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing EulerSolver...\n",
      "Starting simulation with 500,000 iterations...\n",
      "This may take several minutes depending on your system...\n",
      "Progress will be reported every 100,000 iterations.\n",
      "\n",
      "- [Iteration #1] elapsed time: 7.94816e-03 sec.\n",
      "- [Iteration #100000] elapsed time: 2.50095e+01 sec.\n",
      "- [Iteration #200000] elapsed time: 2.50669e+01 sec.\n",
      "- [Iteration #300000] elapsed time: 2.50627e+01 sec.\n",
      "- [Iteration #400000] elapsed time: 2.51013e+01 sec.\n",
      "- [Iteration #500000] elapsed time: 2.50848e+01 sec.\n",
      "- [Duration] : 1.25424e+02 sec.\n",
      "\n",
      "==================================================\n",
      "Simulation completed!\n",
      "Total elapsed time: 125.42 seconds\n",
      "Average time per iteration: 0.251 ms\n"
     ]
    }
   ],
   "source": [
    "# Initialize the solver\n",
    "print(\"Initializing EulerSolver...\")\n",
    "solver = EulerSolver()\n",
    "\n",
    "print(f\"Starting simulation with {n_iters:,} iterations...\")\n",
    "print(\"This may take several minutes depending on your system...\")\n",
    "print(\"Progress will be reported every 100,000 iterations.\\n\")\n",
    "\n",
    "# Record start time\n",
    "t_start = time.time()\n",
    "\n",
    "# Run the simulation\n",
    "solver.solve(\n",
    "    model=model,\n",
    "    dt=model_json['dt'],\n",
    "    n_iters=n_iters,\n",
    "    period_output=100000,\n",
    "    dpath_model=dpath_output,\n",
    "    dpath_ladybird=dpath_output,\n",
    "    dpath_pattern=dpath_output,\n",
    "    verbose=1\n",
    ")\n",
    "\n",
    "# Record end time\n",
    "t_end = time.time()\n",
    "elapsed_time = t_end - t_start\n",
    "\n",
    "print(f\"\\n{'='*50}\")\n",
    "print(f\"Simulation completed!\")\n",
    "print(f\"Total elapsed time: {elapsed_time:.2f} seconds\")\n",
    "print(f\"Average time per iteration: {elapsed_time/n_iters*1000:.3f} ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "460aab0c",
   "metadata": {},
   "source": [
    "## 4. Visualization and Analysis\n",
    "\n",
    "Let's visualize the generated patterns and analyze the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fb645b93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated files:\n",
      "ladybird_000001.png\n",
      "ladybird_100000.png\n",
      "ladybird_200000.png\n",
      "ladybird_300000.png\n",
      "ladybird_400000.png\n",
      "ladybird_500000.png\n",
      "pattern_000001.png\n",
      "pattern_100000.png\n",
      "pattern_200000.png\n",
      "pattern_300000.png\n",
      "pattern_400000.png\n",
      "pattern_500000.png\n",
      "\n",
      " All files in ./output_tutorial:\n",
      "output_tutorial/\n",
      "  model_1/\n",
      "    pattern_100000.png\n",
      "    ladybird_500000.png\n",
      "    pattern_400000.png\n",
      "    ladybird_000001.png\n",
      "    ladybird_100000.png\n",
      "    pattern_300000.png\n",
      "    pattern_500000.png\n",
      "    ladybird_200000.png\n",
      "    pattern_000001.png\n",
      "    ladybird_400000.png\n",
      "    pattern_200000.png\n",
      "    ladybird_300000.png\n",
      "  models/\n",
      "    model_1.json\n"
     ]
    }
   ],
   "source": [
    "# Check what files were gnerated \n",
    "print(\"Generated files:\")\n",
    "if os.path.exists(os.path.join(dpath_output, 'model_1')):\n",
    "    files = os.listdir(os.path.join(dpath_output, 'model_1'))\n",
    "    for file in sorted(files):\n",
    "        print(f\"{file}\")\n",
    "else:\n",
    "    print(\"Model output directory not found.\")\n",
    "\n",
    "# List all files in output directory\n",
    "print(f\"\\n All files in {dpath_output}:\")\n",
    "for root, dirs, files in os.walk(dpath_output):\n",
    "    level = root.replace(dpath_output, '').count(os.sep)\n",
    "    indent = ' ' * 2 * level\n",
    "    print(f\"{indent}{os.path.basename(root)}/\")\n",
    "    subindent = ' ' * 2 * (level + 1)\n",
    "    for file in files:\n",
    "        print(f\"{subindent}{file}\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9b9ff116",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading generated pattern...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Display the generated pattern\n",
    "try:\n",
    "    pattern_path = os.path.join(dpath_output, 'model_1', f'pattern_{n_iters}.png')\n",
    "    if os.path.exists(pattern_path):\n",
    "        print(\"Loading generated pattern...\")\n",
    "        img_pattern = Image.open(pattern_path)\n",
    "        \n",
    "        # Create a figure with subplots\n",
    "        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(4, 2))\n",
    "\n",
    "        ax1.imshow(img_pattern)\n",
    "        ax1.set_title(f'Generated Pattern \\n({n_iters:,} iterations)', fontsize=12)\n",
    "        ax1.axis('off')\n",
    "                \n",
    "        # Try to load and display the ladybird image\n",
    "        ladybird_path = os.path.join(dpath_output, 'model_1', f'ladybird_{n_iters}.png')\n",
    "        if os.path.exists(ladybird_path):\n",
    "            img_ladybird = Image.open(ladybird_path)\n",
    "            ax2.imshow(img_ladybird)\n",
    "            ax2.set_title(f'Generated Ladybird \\n({img_ladybird.size[0]}×{img_ladybird.size[1]})', fontsize=12)\n",
    "            ax2.axis('off')\n",
    "        else:\n",
    "            ax2.text(0.5, 0.5, 'Ladybird image\\\\nnot generated', \n",
    "                    ha='center', va='center', transform=ax2.transAxes, fontsize=14)\n",
    "            ax2.set_title('Ladybird Output', fontsize=12)\n",
    "            ax2.axis('off')\n",
    "        \n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "    \n",
    "        \n",
    "    else:\n",
    "        print(f\"Pattern file not found at: {pattern_path}\")\n",
    "        print(\"Available files:\", os.listdir(os.path.join(dpath_output, 'model_1')) if os.path.exists(os.path.join(dpath_output, 'model_1')) else \"No model_1 directory\")\n",
    "        \n",
    "except Exception as e:\n",
    "    print(f\"Error loading images: {e}\")\n",
    "    print(\"This might be normal if the simulation was interrupted or files haven't been generated yet.\")\n",
    "        "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ladybirdmnist",
   "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
}