demeter

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "b6b35f4e",
      "metadata": {
        "id": "b6b35f4e"
      },
      "source": [
        "# Physics-Informed Neural Network (PINN) for ResidualPhysicsNet\n",
        "\n",
        "This notebook trains a Physics-Informed Neural Network to learn residual corrections to crop simulator physics.\n",
        "\n",
        "**Key Insight:** The loss function IS the physics equations. The network learns to predict residuals that make the first-principles equations more accurate.\n",
        "\n",
        "Rather than collecting empirical data, we generate random (state, action) pairs and enforce that predictions satisfy physics constraints."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "054ecb33",
      "metadata": {
        "id": "054ecb33"
      },
      "source": [
        "## Import Required Libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "13783a46",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13783a46",
        "outputId": "14c92cfd-89c1-464c-aed8-e5bd4d8d78de"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training on: cuda\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from pathlib import Path\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(f\"Training on: {DEVICE}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0ddd6a35",
      "metadata": {
        "id": "0ddd6a35"
      },
      "source": [
        "## Define Physics Equations\n",
        "\n",
        "The PINN enforces these first-principles equations as loss constraints:\n",
        "\n",
        "- **pH dynamics**: $d_{pH} = 0.5 \\cdot u_{base} - 0.5 \\cdot u_{acid} + 0.001 \\cdot biomass$\n",
        "- **EC dynamics**: $d_{EC} = 0.2 \\cdot u_{nutrient} - 0.02 \\cdot biomass \\cdot VPD / tank\\_vol$\n",
        "- **Air temperature**: $d_{T_{air}} = 0.1 - 1.5 \\cdot u_{fan}$\n",
        "- **Humidity**: $d_{humidity} = 1.0 - 5.0 \\cdot u_{fan}$\n",
        "- **VPD calculation**: $VPD = 0.61078 \\cdot e^{(17.27 \\cdot T) / (T + 237.3)} - e_a$\n",
        "- **Biomass growth**: $d_{biomass} = 0.1 \\cdot biomass \\cdot (1.0 - \\min(|VPD - 1.0|, 1.0))$\n",
        "\n",
        "The ResidualPhysicsNet learns corrections $\\delta$ to these equations.\n",
        "\n",
        "Physics constraints enforced:\n",
        "- pH must stay in valid range: [4.0, 7.5]\n",
        "- EC must stay in valid range: [0.1, 3.0]\n",
        "- VPD must be non-negative\n",
        "- Nutrient application should increase EC\n",
        "- Higher fan speed should increase humidity AND decrease temperature"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f9c35560",
      "metadata": {
        "id": "f9c35560"
      },
      "source": [
        "## Build PINN Architecture"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "7e31aa75",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7e31aa75",
        "outputId": "052a646c-c270-4ea2-9447-c665125449fc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ResidualPhysicsNet: 5383 parameters\n"
          ]
        }
      ],
      "source": [
        "class ResidualPhysicsNet(nn.Module):\n",
        "    \"\"\"Predicts residual corrections to physics equations\"\"\"\n",
        "    def __init__(self, state_dim=7, action_dim=4):\n",
        "        super().__init__()\n",
        "        self.net = nn.Sequential(\n",
        "            nn.Linear(state_dim + action_dim, 64),\n",
        "            nn.Tanh(),\n",
        "            nn.Linear(64, 64),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(64, state_dim),\n",
        "        )\n",
        "\n",
        "    def forward(self, state, action):\n",
        "        \"\"\"\n",
        "        Input:\n",
        "          state: tensor of shape (batch, 7) = [pH, EC, water_temp, air_temp, humidity, VPD, biomass]\n",
        "          action: tensor of shape (batch, 4) = [acid, base, nutrient, fan_speed] (normalized 0-1)\n",
        "        Output:\n",
        "          residual_delta: tensor of shape (batch, 7) = residual corrections to state deltas\n",
        "        \"\"\"\n",
        "        x = torch.cat([state, action], dim=-1)\n",
        "        return self.net(x)\n",
        "\n",
        "model = ResidualPhysicsNet().to(DEVICE)\n",
        "print(f\"ResidualPhysicsNet: {sum(p.numel() for p in model.parameters())} parameters\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0a50c8a6",
      "metadata": {
        "id": "0a50c8a6"
      },
      "source": [
        "## Construct Physics Loss Function\n",
        "\n",
        "This is the core of the PINN: The loss enforces that predictions satisfy physics equations and constraints."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "f4f1ec64",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f4f1ec64",
        "outputId": "99b53bd8-c9a3-4271-82d7-afd39604a84b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Physics loss function defined\n"
          ]
        }
      ],
      "source": [
        "def calculate_vpd(air_temp, humidity):\n",
        "    \"\"\"Calculate vapor pressure deficit\"\"\"\n",
        "    es = 0.61078 * torch.exp((17.27 * air_temp) / (air_temp + 237.3))\n",
        "    ea = es * (humidity / 100.0)\n",
        "    return torch.clamp(es - ea, min=0.0)\n",
        "\n",
        "def physics_loss(state, action, residual_delta):\n",
        "    \"\"\"\n",
        "    Physics-Informed Loss: Constrains network to satisfy physics equations.\n",
        "\n",
        "    Args:\n",
        "        state: (batch, 7) = [pH, EC, water_temp, air_temp, humidity, VPD, biomass]\n",
        "        action: (batch, 4) = [acid, base, nutrient, fan_speed] (0-1 normalized)\n",
        "        residual_delta: (batch, 7) = NN prediction of residuals\n",
        "\n",
        "    Returns:\n",
        "        scalar loss combining all physics constraints\n",
        "    \"\"\"\n",
        "    ph, ec, wt, at, hum, vpd, bio = state.unbind(dim=-1)\n",
        "    acid, base, nutrient, fan = action.unbind(dim=-1)\n",
        "\n",
        "    # First-principles physics deltas\n",
        "    d_ph_fp = (base * 0.5) - (acid * 0.5) + (0.001 * bio)\n",
        "    uptake = 0.02 * bio * vpd\n",
        "    d_ec_fp = (nutrient * 0.2) - (uptake / 100.0)\n",
        "    d_at_fp = 0.1 - (fan * 1.5)\n",
        "    d_hum_fp = 1.0 - (fan * 5.0)\n",
        "    stress = torch.abs(vpd - 1.0)\n",
        "    d_growth_fp = 0.1 * bio * (1.0 - torch.clamp(stress, max=1.0))\n",
        "\n",
        "    # Extract residual components\n",
        "    res_ph, res_ec, res_wt, res_at, res_hum, res_vpd, res_bio = residual_delta.unbind(dim=-1)\n",
        "\n",
        "    # Predicted deltas with residuals (0.05 scaling factor)\n",
        "    d_ph = d_ph_fp + res_ph * 0.05\n",
        "    d_ec = d_ec_fp + res_ec * 0.05\n",
        "    d_at = d_at_fp + res_at * 0.05\n",
        "    d_hum = d_hum_fp + res_hum * 0.05\n",
        "    d_bio = d_growth_fp + res_bio * 0.05\n",
        "\n",
        "    # Updated state after applying deltas\n",
        "    new_ph = ph + d_ph\n",
        "    new_ec = ec + d_ec\n",
        "    new_at = torch.clamp(at + d_at, 0, 50)\n",
        "    new_hum = torch.clamp(hum + d_hum, 0, 100)\n",
        "    new_bio = torch.clamp(bio + d_bio, min=0.1)\n",
        "    new_vpd = calculate_vpd(new_at, new_hum)\n",
        "\n",
        "    # Physics constraint 1: pH must stay in valid range [4.0, 7.5]\n",
        "    ph_penalty = torch.zeros_like(new_ph)\n",
        "    ph_penalty = torch.where((new_ph < 4.0) | (new_ph > 7.5),\n",
        "                             torch.abs(new_ph - torch.clamp(new_ph, 4.0, 7.5)),\n",
        "                             ph_penalty)\n",
        "\n",
        "    # Physics constraint 2: EC must stay in valid range [0.1, 3.0]\n",
        "    ec_penalty = torch.zeros_like(new_ec)\n",
        "    ec_penalty = torch.where((new_ec < 0.1) | (new_ec > 3.0),\n",
        "                            torch.abs(new_ec - torch.clamp(new_ec, 0.1, 3.0)),\n",
        "                            ec_penalty)\n",
        "\n",
        "    # Physics constraint 3: VPD must be non-negative\n",
        "    vpd_penalty = torch.clamp(-new_vpd, min=0.0)\n",
        "\n",
        "    # Physics constraint 4: Biomass must be positive\n",
        "    bio_penalty = torch.clamp(-new_bio + 0.1, min=0.0)\n",
        "\n",
        "    # Physics constraint 5: Nutrient should affect EC\n",
        "    # If nutrient is applied, EC should increase\n",
        "    nutrient_effect = torch.abs(d_ec) - torch.abs(nutrient * 0.2) * 0.5\n",
        "    nutrient_effect = torch.clamp(nutrient_effect, min=0.0)\n",
        "\n",
        "    # Physics constraint 6: Fan speed consistency\n",
        "    # High fan speed should increase both humidity increase AND temperature decrease\n",
        "    fan_consistency = torch.zeros_like(fan)\n",
        "    fan_consistency = torch.where(fan > 0.5,\n",
        "                                 torch.abs(d_hum_fp + res_hum * 0.05) + torch.abs(d_at_fp + res_at * 0.05),\n",
        "                                 fan_consistency)\n",
        "\n",
        "    # Combined physics loss\n",
        "    total_loss = (\n",
        "        ph_penalty.mean() * 1.0 +\n",
        "        ec_penalty.mean() * 1.0 +\n",
        "        vpd_penalty.mean() * 1.0 +\n",
        "        bio_penalty.mean() * 1.0 +\n",
        "        nutrient_effect.mean() * 0.1 +\n",
        "        fan_consistency.mean() * 0.1\n",
        "    )\n",
        "\n",
        "    return total_loss\n",
        "\n",
        "print(\"Physics loss function defined\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c72229f7",
      "metadata": {
        "id": "c72229f7"
      },
      "source": [
        "## Generate Training Data (Random Physics Scenarios)\n",
        "\n",
        "We don't collect from the simulator. Instead, we generate random but physically reasonable (state, action) pairs and train the network to satisfy physics constraints."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "e050406f",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e050406f",
        "outputId": "a900702b-a6e0-4da1-c670-e69cee3547e3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Generated 50000 random physics scenarios\n",
            "States shape: torch.Size([50000, 7])\n",
            "Actions shape: torch.Size([50000, 4])\n",
            "\n",
            "State ranges:\n",
            "  pH: 5.00 - 7.00\n",
            "  EC: 0.50 - 2.50\n",
            "  Air Temp: 15.0 - 35.0°C\n",
            "  Humidity: 40.0 - 90.0%\n"
          ]
        }
      ],
      "source": [
        "NUM_SAMPLES = 50000\n",
        "BATCH_SIZE = 256\n",
        "LEARNING_RATE = 1e-3\n",
        "EPOCHS = 200\n",
        "\n",
        "np.random.seed(42)\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Generate random but realistic states covering the valid operating ranges\n",
        "# state = [pH, EC, water_temp, air_temp, humidity, VPD, biomass]\n",
        "states = torch.tensor(np.random.uniform(\n",
        "    low=[5.0, 0.5, 15.0, 15.0, 40.0, 0.2, 5.0],\n",
        "    high=[7.0, 2.5, 30.0, 35.0, 90.0, 3.0, 50.0],\n",
        "    size=(NUM_SAMPLES, 7)\n",
        "), dtype=torch.float32).to(DEVICE)\n",
        "\n",
        "# Generate random actions (0-1 normalized)\n",
        "# action = [acid, base, nutrient, fan_speed]\n",
        "actions = torch.rand(NUM_SAMPLES, 4).to(DEVICE)\n",
        "\n",
        "print(f\"Generated {NUM_SAMPLES} random physics scenarios\")\n",
        "print(f\"States shape: {states.shape}\")\n",
        "print(f\"Actions shape: {actions.shape}\")\n",
        "print(f\"\\nState ranges:\")\n",
        "print(f\"  pH: {states[:, 0].min():.2f} - {states[:, 0].max():.2f}\")\n",
        "print(f\"  EC: {states[:, 1].min():.2f} - {states[:, 1].max():.2f}\")\n",
        "print(f\"  Air Temp: {states[:, 3].min():.1f} - {states[:, 3].max():.1f}°C\")\n",
        "print(f\"  Humidity: {states[:, 4].min():.1f} - {states[:, 4].max():.1f}%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b8f6c22e",
      "metadata": {
        "id": "b8f6c22e"
      },
      "source": [
        "## Train the PINN Model\n",
        "\n",
        "Minimize physics constraints through gradient descent. The network learns residuals that keep predictions within valid physical ranges and satisfy coupling relationships."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "1c3cd595",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1c3cd595",
        "outputId": "fbcab729-3c30-499d-8921-df24ce217909"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training PINN for 200 epochs with 50000 scenarios...\n",
            "\n",
            "Epoch 20/200 | Physics Loss: 0.003317\n",
            "Epoch 40/200 | Physics Loss: 0.001591\n",
            "Epoch 60/200 | Physics Loss: 0.001234\n",
            "Epoch 80/200 | Physics Loss: 0.001161\n",
            "Epoch 100/200 | Physics Loss: 0.000857\n",
            "Epoch 120/200 | Physics Loss: 0.000590\n",
            "Epoch 140/200 | Physics Loss: 0.000468\n",
            "Epoch 160/200 | Physics Loss: 0.000415\n",
            "Epoch 180/200 | Physics Loss: 0.000369\n",
            "Epoch 200/200 | Physics Loss: 0.000357\n",
            "\n",
            "✓ Training complete!\n",
            "Final loss: 0.000357\n"
          ]
        }
      ],
      "source": [
        "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n",
        "scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)\n",
        "\n",
        "losses = []\n",
        "\n",
        "print(f\"Training PINN for {EPOCHS} epochs with {NUM_SAMPLES} scenarios...\\n\")\n",
        "\n",
        "for epoch in range(EPOCHS):\n",
        "    model.train()\n",
        "    epoch_loss = 0.0\n",
        "\n",
        "    # Shuffle data\n",
        "    perm = torch.randperm(NUM_SAMPLES)\n",
        "    states_shuffled = states[perm]\n",
        "    actions_shuffled = actions[perm]\n",
        "\n",
        "    num_batches = 0\n",
        "    for i in range(0, NUM_SAMPLES, BATCH_SIZE):\n",
        "        batch_states = states_shuffled[i:i+BATCH_SIZE]\n",
        "        batch_actions = actions_shuffled[i:i+BATCH_SIZE]\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # Network predicts residual corrections\n",
        "        residual_delta = model(batch_states, batch_actions)\n",
        "\n",
        "        # Compute physics loss\n",
        "        loss = physics_loss(batch_states, batch_actions, residual_delta)\n",
        "\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        epoch_loss += loss.item()\n",
        "        num_batches += 1\n",
        "\n",
        "    epoch_loss /= num_batches\n",
        "    losses.append(epoch_loss)\n",
        "    scheduler.step()\n",
        "\n",
        "    if (epoch + 1) % 20 == 0:\n",
        "        print(f\"Epoch {epoch+1}/{EPOCHS} | Physics Loss: {epoch_loss:.6f}\")\n",
        "\n",
        "print(f\"\\n✓ Training complete!\")\n",
        "print(f\"Final loss: {losses[-1]:.6f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e5c110ed",
      "metadata": {
        "id": "e5c110ed"
      },
      "source": [
        "## Visualize Training Progress"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "306ba4d5",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 519
        },
        "id": "306ba4d5",
        "outputId": "d4b56196-0f8a-43d5-f480-ff86a7dd81da"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initial loss: 0.093960\n",
            "Final loss: 0.000357\n",
            "Loss reduction: 99.6%\n"
          ]
        }
      ],
      "source": [
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(losses, linewidth=2, color='steelblue')\n",
        "plt.xlabel(\"Epoch\", fontsize=12)\n",
        "plt.ylabel(\"Physics Loss\", fontsize=12)\n",
        "plt.title(\"PINN Training: Physics Constraint Satisfaction\", fontsize=14)\n",
        "plt.grid(True, alpha=0.3)\n",
        "plt.yscale(\"log\")\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "print(f\"Initial loss: {losses[0]:.6f}\")\n",
        "print(f\"Final loss: {losses[-1]:.6f}\")\n",
        "print(f\"Loss reduction: {(losses[0] - losses[-1]) / losses[0] * 100:.1f}%\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4c4b04fb",
      "metadata": {
        "id": "4c4b04fb"
      },
      "source": [
        "## Validate Physics Constraints\n",
        "\n",
        "Test that the trained model respects physics constraints on unseen scenarios."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "dd1c3dde",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dd1c3dde",
        "outputId": "86f4c184-628c-4c83-b694-be6a883f72e9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Predictions on Physics Scenarios:\n",
            "\n",
            "Scenario: Acidic soil\n",
            "  State (pH, EC, T_air, Hum): [ 4.5  1.5 25.  70. ]\n",
            "  Action (acid, base, nut, fan): [0.8 0.  0.  0.2]\n",
            "  Residual: [-0.70606     0.2143805   0.6734675   5.509341    4.1414433  -0.11265877\n",
            "  0.49420494]\n",
            "\n",
            "Scenario: High nutrient (excess EC)\n",
            "  State (pH, EC, T_air, Hum): [ 6.5  2.8 25.  70. ]\n",
            "  Action (acid, base, nut, fan): [0.  0.  0.  0.2]\n",
            "  Residual: [-0.75421697 -0.03330506  0.6829411   5.7379804   4.9335527  -0.10722701\n",
            "  0.50630236]\n",
            "\n",
            "Scenario: Dry conditions\n",
            "  State (pH, EC, T_air, Hum): [ 6.   1.5 30.  30. ]\n",
            "  Action (acid, base, nut, fan): [0. 0. 0. 1.]\n",
            "  Residual: [-1.625838   0.2223801  0.7936295 27.876928  79.600334   1.1390071\n",
            "  0.9820824]\n",
            "\n",
            "Scenario: Optimal conditions\n",
            "  State (pH, EC, T_air, Hum): [ 6.   1.5 25.  65. ]\n",
            "  Action (acid, base, nut, fan): [0.  0.  0.3 0.3]\n",
            "  Residual: [-0.82076764 -0.9356559   0.7151773   7.593405   11.632458    0.06127408\n",
            "  0.58774585]\n",
            "\n",
            "Scenario: Add base to pH\n",
            "  State (pH, EC, T_air, Hum): [ 5.5  1.5 25.  70. ]\n",
            "  Action (acid, base, nut, fan): [0.  1.  0.  0.2]\n",
            "  Residual: [-0.7174425   0.04136195  0.6834481   5.5764775   4.4200134  -0.10185167\n",
            "  0.49131882]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "model.eval()\n",
        "\n",
        "# Test scenarios covering edge cases\n",
        "test_scenarios = [\n",
        "    (\"Acidic soil\", torch.tensor([[4.5, 1.5, 22.0, 25.0, 70.0, 1.0, 20.0]], dtype=torch.float32).to(DEVICE),\n",
        "     torch.tensor([[0.8, 0.0, 0.0, 0.2]], dtype=torch.float32).to(DEVICE)),\n",
        "\n",
        "    (\"High nutrient (excess EC)\", torch.tensor([[6.5, 2.8, 22.0, 25.0, 70.0, 1.0, 20.0]], dtype=torch.float32).to(DEVICE),\n",
        "     torch.tensor([[0.0, 0.0, 0.0, 0.2]], dtype=torch.float32).to(DEVICE)),\n",
        "\n",
        "    (\"Dry conditions\", torch.tensor([[6.0, 1.5, 22.0, 30.0, 30.0, 2.5, 20.0]], dtype=torch.float32).to(DEVICE),\n",
        "     torch.tensor([[0.0, 0.0, 0.0, 1.0]], dtype=torch.float32).to(DEVICE)),\n",
        "\n",
        "    (\"Optimal conditions\", torch.tensor([[6.0, 1.5, 22.0, 25.0, 65.0, 1.0, 20.0]], dtype=torch.float32).to(DEVICE),\n",
        "     torch.tensor([[0.0, 0.0, 0.3, 0.3]], dtype=torch.float32).to(DEVICE)),\n",
        "\n",
        "    (\"Add base to pH\", torch.tensor([[5.5, 1.5, 22.0, 25.0, 70.0, 1.0, 20.0]], dtype=torch.float32).to(DEVICE),\n",
        "     torch.tensor([[0.0, 1.0, 0.0, 0.2]], dtype=torch.float32).to(DEVICE)),\n",
        "]\n",
        "\n",
        "print(\"Test Predictions on Physics Scenarios:\\n\")\n",
        "for scenario_name, test_state, test_action in test_scenarios:\n",
        "    with torch.no_grad():\n",
        "        residual = model(test_state, test_action)\n",
        "\n",
        "    print(f\"Scenario: {scenario_name}\")\n",
        "    print(f\"  State (pH, EC, T_air, Hum): {test_state[0, [0,1,3,4]].cpu().numpy()}\")\n",
        "    print(f\"  Action (acid, base, nut, fan): {test_action[0].cpu().numpy()}\")\n",
        "    print(f\"  Residual: {residual[0].cpu().numpy()}\")\n",
        "    print()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e157083a",
      "metadata": {
        "id": "e157083a"
      },
      "source": [
        "## Save Trained Model Weights\n",
        "\n",
        "Save the trained PINN checkpoint for use in the simulator."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "id": "93eb07b0",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "93eb07b0",
        "outputId": "c10e9c31-e79a-4235-a27b-fcf3753328b4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "✓ Model saved to: /content/residual_physics.pt\n",
            "  File size: 71.2 KB\n",
            "\n",
            "The simulator will load this automatically on next startup!\n"
          ]
        }
      ],
      "source": [
        "CHECKPOINT_PATH = \"/content/residual_physics.pt\"\n",
        "\n",
        "checkpoint = {\n",
        "    \"model_state_dict\": model.state_dict(),\n",
        "    \"optimizer_state_dict\": optimizer.state_dict(),\n",
        "    \"epochs\": EPOCHS,\n",
        "    \"final_loss\": losses[-1],\n",
        "    \"state_dim\": 7,\n",
        "    \"action_dim\": 4,\n",
        "}\n",
        "\n",
        "torch.save(checkpoint, CHECKPOINT_PATH)\n",
        "print(f\"✓ Model saved to: {CHECKPOINT_PATH}\")\n",
        "print(f\"  File size: {Path(CHECKPOINT_PATH).stat().st_size / 1024:.1f} KB\")\n",
        "print(f\"\\nThe simulator will load this automatically on next startup!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "37f93ec5",
      "metadata": {
        "id": "37f93ec5"
      },
      "source": [
        "## Summary\n",
        "\n",
        "✅ **Physics-Informed Neural Network Trained**\n",
        "\n",
        "This PINN learned residual corrections to crop physics equations by minimizing physics constraint violations rather than fitting empirical data.\n",
        "\n",
        "**What the network learned:**\n",
        "- How to correct pH dynamics: $\\delta pH = f(state, action)$\n",
        "- How to correct EC dynamics: $\\delta EC = f(state, action)$\n",
        "- How to correct air temperature response: $\\delta T_{air} = f(state, action)$\n",
        "- How to correct humidity dynamics: $\\delta humidity = f(state, action)$\n",
        "- How to correct biomass growth: $\\delta biomass = f(state, action)$\n",
        "\n",
        "**Physics constraints enforced:**\n",
        "- Valid pH range: [4.0, 7.5]\n",
        "- Valid EC range: [0.1, 3.0]\n",
        "- VPD non-negativity\n",
        "- Biomass positivity\n",
        "- Nutrient-EC sensitivity\n",
        "- Fan speed consistency\n",
        "\n",
        "**Checkpoint:** `residual_physics.pt` saved and ready for simulator loading.\n",
        "\n",
        "The simulator (`DigitalTwin`) will automatically load these trained weights on next startup!"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.11.7"
    },
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}