diff --git a/asl_core/notebooks/reinforcement_learning/solutions/ppo_with_keras.ipynb b/asl_core/notebooks/reinforcement_learning/solutions/ppo_with_keras.ipynb new file mode 100644 index 000000000..8cedf28ab --- /dev/null +++ b/asl_core/notebooks/reinforcement_learning/solutions/ppo_with_keras.ipynb @@ -0,0 +1,1249 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a0dfdf25-5479-4793-b7ab-d9dfe5667f78", + "metadata": {}, + "source": [ + "# Reinforcement Learning with PPO\n", + "In this notebook, we will implement Proximal Policy Optimization (PPO) from scratch using Keras. Unlike standard Supervised Learning where we fit a model to a fixed dataset, here we train an agent to interact with a dynamic environment (a building simulation).\n", + "\n", + "## Learning Objective\n", + "- **Build a PPO Training System**: Implement the Proximal Policy Optimization algorithm, a state-of-the-art method for continuous Reinforcement Learning.\n", + "- **Create Custom Keras Models for PPO**: Subclass `keras.Model` and override `train_step` to implement complex loss functions that require manual gradient calculation.\n", + "- **Implement Generalized Advantage Estimation(GAE)**: Write a Generalized Advantage Estimation function to calculate stable training targets (advantages) from raw rewards.`\n", + "- **Control Physical Systems**: Train an agent to optimize a pysical system using real-world data" + ] + }, + { + "cell_type": "markdown", + "id": "6868817d-d695-4de1-b94d-c321aa50c7f9", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9b89ddb0-ae1e-4bb0-ade9-d9610ba1eb0b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-12-11 19:12:28.057942: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1765480348.080735 472825 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1765480348.087794 472825 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "2025-12-11 19:12:28.111197: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import keras\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import tensorflow as tf\n", + "from keras import layers" + ] + }, + { + "cell_type": "markdown", + "id": "541f5524-451b-433f-afbc-73d7da20606e", + "metadata": {}, + "source": [ + "## Loading and Normalizing Data" + ] + }, + { + "cell_type": "markdown", + "id": "d11fe860-e35a-4453-9204-a4e6fb269466", + "metadata": {}, + "source": [ + "We are building a control system. In Control Theory terms, the Outdoor Temperature acts as an External Disturbance—a force trying to push our system away from its target state.
\n", + "We use the [**Jena Climate Dataset**](https://www.kaggle.com/datasets/mnassrib/jena-climate), which is sampled every 10 minutes, to drive our simulation. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c7cddc3e-0337-4b21-bd5b-44f0aaf0736a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Date Timep (mbar)T (degC)Tpot (K)Tdew (degC)rh (%)VPmax (mbar)VPact (mbar)VPdef (mbar)sh (g/kg)H2OC (mmol/mol)rho (g/m**3)wv (m/s)max. wv (m/s)wd (deg)
001.01.2009 00:10:00996.52-8.02265.40-8.9093.33.333.110.221.943.121307.751.031.75152.3
101.01.2009 00:20:00996.57-8.41265.01-9.2893.43.233.020.211.893.031309.800.721.50136.1
201.01.2009 00:30:00996.53-8.51264.91-9.3193.93.213.010.201.883.021310.240.190.63171.6
301.01.2009 00:40:00996.51-8.31265.12-9.0794.23.263.070.191.923.081309.190.340.50198.0
401.01.2009 00:50:00996.51-8.27265.15-9.0494.13.273.080.191.923.091309.000.320.63214.3
\n", + "
" + ], + "text/plain": [ + " Date Time p (mbar) T (degC) Tpot (K) Tdew (degC) rh (%) \\\n", + "0 01.01.2009 00:10:00 996.52 -8.02 265.40 -8.90 93.3 \n", + "1 01.01.2009 00:20:00 996.57 -8.41 265.01 -9.28 93.4 \n", + "2 01.01.2009 00:30:00 996.53 -8.51 264.91 -9.31 93.9 \n", + "3 01.01.2009 00:40:00 996.51 -8.31 265.12 -9.07 94.2 \n", + "4 01.01.2009 00:50:00 996.51 -8.27 265.15 -9.04 94.1 \n", + "\n", + " VPmax (mbar) VPact (mbar) VPdef (mbar) sh (g/kg) H2OC (mmol/mol) \\\n", + "0 3.33 3.11 0.22 1.94 3.12 \n", + "1 3.23 3.02 0.21 1.89 3.03 \n", + "2 3.21 3.01 0.20 1.88 3.02 \n", + "3 3.26 3.07 0.19 1.92 3.08 \n", + "4 3.27 3.08 0.19 1.92 3.09 \n", + "\n", + " rho (g/m**3) wv (m/s) max. wv (m/s) wd (deg) \n", + "0 1307.75 1.03 1.75 152.3 \n", + "1 1309.80 0.72 1.50 136.1 \n", + "2 1310.24 0.19 0.63 171.6 \n", + "3 1309.19 0.34 0.50 198.0 \n", + "4 1309.00 0.32 0.63 214.3 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "uri = \"https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip\"\n", + "zip_path = keras.utils.get_file(\n", + " origin=uri, fname=\"jena_climate_2009_2016.csv.zip\"\n", + ")\n", + "\n", + "df = pd.read_csv(zip_path)\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "4cef0835-3040-4176-b8de-7ccf9ba62352", + "metadata": {}, + "source": [ + "Let's split the data into training and test." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1553e02c-8530-4590-87b0-4cd800100d3b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "split_idx = int(len(df) * 0.8)\n", + "\n", + "train_df = df.iloc[:split_idx].copy()\n", + "test_df = df.iloc[split_idx:].copy()" + ] + }, + { + "cell_type": "markdown", + "id": "9bfedba9-656e-4a8f-b38f-482f1bde0df5", + "metadata": {}, + "source": [ + "Neural networks struggle with unscaled data, so let's normalize the data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "db1febdc-a48a-4cfb-93ef-ed17801b28cc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Calculate stats for normalization\n", + "temp_mean = train_df[\"T (degC)\"].mean()\n", + "temp_std = train_df[\"T (degC)\"].std()\n", + "pres_mean = train_df[\"p (mbar)\"].mean()\n", + "pres_std = train_df[\"p (mbar)\"].std()\n", + "\n", + "# Normalize features\n", + "\n", + "\n", + "def normalize_data(df):\n", + " return np.column_stack(\n", + " [\n", + " df[\"T (degC)\"].values, # Raw Outdoor\n", + " (df[\"T (degC)\"].values - temp_mean) / temp_std, # Norm Outdoor\n", + " (df[\"p (mbar)\"].values - pres_mean) / pres_std, # Norm Pressure\n", + " ]\n", + " )\n", + "\n", + "\n", + "train_data_norm = normalize_data(train_df)\n", + "test_data_norm = normalize_data(test_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5fa74ec6-eece-4bd6-a5f8-9b98093d1e26", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.title(\"Normalized Hourly Temperature\")\n", + "plt.plot(train_data_norm[:, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "238a4f44-13b1-4c1d-b731-b43500edd322", + "metadata": { + "tags": [] + }, + "source": [ + "## Defining the Environment\n", + "\n", + "In Reinforcement Learning, the \"Environment\" is the world the agent lives in. We build a custom Physics Simulation class (`BuildingControlEnv`) to represent a room's thermodynamics.\n", + "\n", + "### The Physics Model\n", + "\n", + "$$Temp_{next} = Temp_{current} + \\underbrace{k \\cdot (Temp_{outdoor} - Temp_{current})}_{\\text{Passive Heat Loss}} + \\underbrace{\\text{Action} \\cdot \\text{HvacMaxPower}}_{\\text{Active HVAC}}$$\n", + "\n", + "- Insulation Factor ($k=0.1$): Represents how \"leaky\" the room is1. A higher value means the room temperature matches the outdoors faster.\n", + "- HVAC Power: The agent's chosen action (scaled by HVAC_POWER) adds or removes heat.\n", + "\n", + "\n", + "### The Reward Function (The Objective)\n", + "\n", + "Designing the reward function is the most critical part of RL. We want the agent to balance two conflicting goals:\n", + "- Comfort: Keep the temperature at 22°C.\n", + "- Efficiency: Minimize electricity usage.\n", + "\n", + "### Key Methods\n", + "- `reset()`: Selects a random start time from the dataset and initializes the room at 20°C .\n", + "- `step(action)`: Executes one minute of simulation. It updates the indoor temperature based on the physics model, calculates the reward, returns the next state (normalized indoor temp, outdoor temp, pressure), and increment the idx to the next timestep." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "24552c1b-7775-4f16-8299-8203c726b6b7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Environment Params\n", + "TARGET_TEMP = 22.0 # Confortable temperature (°C).\n", + "HVAC_POWER = 5.0 # Heater strength (=Maximum temperature change in a step).\n", + "INSULATION_FACTOR = 0.1 # Insulation strength (=The effect of the outer temperature on the inner temperature.)\n", + "REWARD_SCALE = 0.1\n", + "ENERGY_COST = 0.1\n", + "\n", + "\n", + "class BuildingControlEnv:\n", + " def __init__(self, data, max_steps=720):\n", + " self.data = data\n", + " self.max_steps = max_steps\n", + " self.target_temp = TARGET_TEMP\n", + " self.insulation = INSULATION_FACTOR\n", + " self.max_power = HVAC_POWER\n", + " self.reward_scale = REWARD_SCALE\n", + " self.energy_cost = ENERGY_COST\n", + " self.reset()\n", + "\n", + " def reset(self, idx=None):\n", + " if not idx:\n", + " # Pick random start\n", + " self.idx = keras.random.randint(\n", + " [1], minval=0, maxval=len(self.data) - self.max_steps - 1\n", + " )[0].numpy()\n", + " else:\n", + " self.idx = idx\n", + " self.step_cnt = 0\n", + " self.indoor = 20.0 # Start at a slightly cold temp\n", + " self.last_action = 0.0\n", + " return self._get_state()\n", + "\n", + " def _get_state(self):\n", + " # State: [Norm Indoor, Norm Outdoor, Norm Pressure, Last Action]\n", + " indoor_norm = (self.indoor - temp_mean) / temp_std\n", + " return keras.ops.stack(\n", + " [\n", + " indoor_norm,\n", + " self.data[self.idx][1],\n", + " self.data[self.idx][2],\n", + " self.last_action,\n", + " ]\n", + " )\n", + "\n", + " def _compute_reward(self, action):\n", + " # Physics Simulation: Heat loss + HVAC Impact\n", + " outdoor = self.data[self.idx][0]\n", + " self.indoor -= self.insulation * (self.indoor - outdoor)\n", + " self.indoor += action * self.max_power\n", + "\n", + " # Reward Engineering\n", + " error = self.indoor - self.target_temp\n", + " comfort_penalty = -self.reward_scale * (error**2)\n", + " comfort_penalty = max(comfort_penalty, -1.0) # Clip\n", + "\n", + " # Add energy cost as penalty\n", + " energy_penalty = -self.energy_cost * (action**2)\n", + "\n", + " return comfort_penalty + energy_penalty\n", + "\n", + " def step(self, action):\n", + " total_reward = self._compute_reward(action)\n", + "\n", + " # 3. Time Step\n", + " self.idx += 1\n", + " self.step_cnt += 1\n", + " self.last_action = action\n", + "\n", + " return self._get_state(), total_reward" + ] + }, + { + "cell_type": "markdown", + "id": "6064ce1e-43e7-4749-95fb-7d8807387376", + "metadata": {}, + "source": [ + "## Implementing PPO with Subclassed Keras Models\n", + "\n", + "### Actor-Critic Network\n", + "To implement Proximal Policy Optimization (PPO), we need a neural network architecture that can do two very different jobs at once. We call this the Actor-Critic architecture.\n", + "\n", + "- The Actor (The \"Doer\"):\n", + " - Goal: Learn what to do (the Policy $\\pi$).\n", + " - Input: The State (Indoor Temp, Outdoor Temp, Pressure).\n", + " - Output: A Gaussian distribution defined by Mean ($\\mu$) and $\\log \\sigma$\n", + " - **Note**: We implement log_std as a standalone trainable variable (self.add_weight) rather than a dense layer output, making it state-independent for stability \n", + "- The Critic (The \"Judge\"):\n", + " - Goal: Learn how good a state is (the Value Function $V(s)$).\n", + " - Input: The same State as the actor.\n", + " - Output: A single number representing the expected sum of future rewards (e.g., \"This state is worth +50 points\").\n", + " - Role: The Critic's prediction is the \"baseline.\" If the Actor gets a reward higher than the Critic predicted, we know the action was good (Positive Advantage).\n", + "\n", + "\n", + "### Implementation\n", + "We subclass `keras.Model` to encapsulate both networks and their custom training logic.\n", + "- `__init__`: We define two separate Sequential models (self.actor and self.critic).\n", + "- `call(inputs)`: This is the forward pass. We run the input state through both the Actor and Critic networks and return three tensors: mu, log_std, and value.\n", + "- `train_step(data)`: This is where the PPO magic happens. We override this method to customize exactly how gradients are computed. This will be used inside `model.fit()` later.\n", + " - Since we use TensorFlow backend, we use `tf.GradientTape()` to record the forward pass.\n", + " - We manually calculate the **PPO Clipped Loss (Actor)** and **MSE Loss (Critic)**.\n", + " - We apply `tape.gradient` to calculate gradients for both networks simultaneously and update them with `self.optimizer`.\n", + " \n", + "### Loss Functions\n", + "#### Actor Loss\n", + "The PPO loss is designed to improve the policy safely. It prevents the \"Cliff Problem\" where a single bad update destroys the agent's knowledge.\n", + "\n", + "$$L^{CLIP}(\\theta) = \\hat{\\mathbb{E}}_t [\\min(r_t(\\theta)\\hat{A}_t, \\text{clip}(r_t(\\theta), 1-\\epsilon, 1+\\epsilon)\\hat{A}_t)]$$\n", + "- The Ratio ($r_t$): Measures how much the new policy differs from the old one.\n", + " - $r_t > 1$: The action is more likely now.\n", + " - $r_t < 1$: The action is less likely now.\n", + "- The Advantage ($\\hat{A}_t$): Did the action lead to a better result than expected?\n", + "- The Clip ($\\epsilon=0.2$): This is the safety brake. We ignore changes that would shift the probability ratio by more than 20%. This ensures we take small, steady steps toward the optimal policy without \"falling off the cliff\" \n", + "\n", + "#### Critic Loss\n", + "The critic minimizes the error in reward prediction (MSE).\n", + "\n", + "#### Total Loss:\n", + "We combine these two objectives, as well as the `entropy` to (A bonus for exploration) into one final number to minimize: `Total Loss = Actor_Loss + (CRITIC_WEIGHT * Critic_Loss) - (ENTROPY_WEIGHT * Entropy)`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bba6032a-be52-4a66-bd83-cc7add0d119e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# PPO Hyperparameters\n", + "CLIP_RATIO = 0.2 # PPO Trust region\n", + "ENTROPY_WEIGHT = 0.01 # Encourage exploration.\n", + "CRITIC_WEIGHT = 0.5 # Weight of Critic loss\n", + "\n", + "\n", + "def gaussian_log_likelihood(actions, mu, log_std):\n", + " log_pi = keras.ops.log(2.0 * np.pi)\n", + " std = keras.ops.exp(log_std)\n", + " var = keras.ops.square(std)\n", + "\n", + " # Formula: -0.5 * ( (x-mu)^2/var + 2*log_std + log(2pi) )\n", + " squared_diff = keras.ops.square(actions - mu) / var\n", + " log_prob = -0.5 * (squared_diff + 2 * log_std + log_pi)\n", + "\n", + " # Sum across the action dimension (axis=-1)\n", + " return keras.ops.sum(log_prob, axis=-1)\n", + "\n", + "\n", + "class ContinuousPPO(keras.Model):\n", + " def __init__(self, state_dim, action_dim):\n", + " super().__init__()\n", + " self.critic_loss = keras.losses.MeanSquaredError()\n", + "\n", + " self.critic = keras.Sequential(\n", + " [\n", + " layers.InputLayer(shape=(state_dim,)),\n", + " layers.Dense(64, activation=\"relu\"),\n", + " layers.Dense(64, activation=\"tanh\"),\n", + " layers.Dense(1, activation=None),\n", + " ]\n", + " )\n", + "\n", + " # ACTOR: Decides 'What' (Mu) and 'How Certain' (LogStd)\n", + " self.actor_mu = keras.Sequential(\n", + " [\n", + " layers.InputLayer(shape=(state_dim,)),\n", + " layers.Dense(64, activation=\"relu\"),\n", + " layers.Dense(64, activation=\"tanh\"),\n", + " layers.Dense(action_dim, activation=\"tanh\"),\n", + " ]\n", + " )\n", + " self.actor_log_std = self.add_weight(\n", + " name=\"log_std\",\n", + " shape=(1, action_dim),\n", + " initializer=\"zeros\",\n", + " trainable=True,\n", + " )\n", + "\n", + " def call(self, inputs):\n", + " values = self.critic(inputs)\n", + " actor_mu = self.actor_mu(inputs)\n", + " actor_log_std = keras.ops.clip(self.actor_log_std, -3, 3)\n", + " return actor_mu, actor_log_std, values\n", + "\n", + " def ppo_loss(\n", + " self, new_log_probs, old_log_probs, advantages, clip_ratio=0.2\n", + " ):\n", + " ratio = keras.ops.exp(new_log_probs - old_log_probs)\n", + " p1 = ratio * advantages\n", + " p2 = (\n", + " keras.ops.clip(ratio, 1.0 - clip_ratio, 1.0 + clip_ratio)\n", + " * advantages\n", + " )\n", + " return -keras.ops.mean(keras.ops.minimum(p1, p2))\n", + "\n", + " def entropy(self, log_std):\n", + " return keras.ops.mean(\n", + " 0.5 * (keras.ops.log(2.0 * np.pi) + 2 * log_std + 1)\n", + " )\n", + "\n", + " def train_step(self, data):\n", + " states = data[\"state\"]\n", + " actions = data[\"action\"]\n", + " advantages = data[\"advantage\"]\n", + " returns = data[\"return\"]\n", + " old_log_probs = data[\"log_prob\"]\n", + "\n", + " with tf.GradientTape() as tape:\n", + " # Prediction\n", + " mu, log_std, values = self(states)\n", + "\n", + " # Reconstruct Gaussian Distribution\n", + " new_log_probs = gaussian_log_likelihood(actions, mu, log_std)\n", + "\n", + " actor_loss = self.ppo_loss(\n", + " new_log_probs, old_log_probs, advantages, CLIP_RATIO\n", + " )\n", + " critic_loss = self.critic_loss(returns, values)\n", + " entropy = self.entropy(log_std)\n", + "\n", + " # KL divergence for early stopping. See the KLEarlyStopping callback defined later.\n", + " log_ratio = new_log_probs - old_log_probs\n", + " ratio = keras.ops.exp(log_ratio)\n", + " approx_kl = keras.ops.mean((ratio - 1.0) - log_ratio)\n", + "\n", + " # Total Loss\n", + " total_loss = (\n", + " actor_loss\n", + " + (CRITIC_WEIGHT * critic_loss)\n", + " - (ENTROPY_WEIGHT * entropy)\n", + " )\n", + "\n", + " # Optimization\n", + " grads = tape.gradient(total_loss, self.trainable_variables)\n", + " self.optimizer.apply_gradients(zip(grads, self.trainable_variables))\n", + "\n", + " return {\n", + " \"actor\": actor_loss,\n", + " \"critic\": critic_loss,\n", + " \"ent\": entropy,\n", + " \"kl\": approx_kl,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "5046e72f-0bcc-42b8-8219-ab246d49b483", + "metadata": {}, + "source": [ + "## Define Generalized Advantage Estimation (GAE)\n", + "\n", + "In Reinforcement Learning, looking at a single reward isn't enough. We need to know if a good result was just luck (noise) or part of a winning streak (signal). **GAE** combines two pieces of information to measure this \"momentum\":\n", + "\n", + "**The Inputs (What we know)**\n", + "\n", + "These are the raw materials we feed into the GAE calculation:\n", + "- `values` (The Expectation): What the Critic predicted would happen.\n", + " - Analogy: \"I expect to get a 70 on this exam.\"\n", + "- `rewards` (The Reality): What actually happened in the environment.\n", + " - Analogy: \"I actually got a 90.\"\n", + "- `next_value` (The Horizon): The Critic's prediction for the state after the current batch ends. This connects our current experience to the future.\n", + "\n", + "**The Outputs (What we use in training)**\n", + "\n", + "These are the calculated signals used to update our neural networks:\n", + "- `advantages` (The Bonus $\\rightarrow$ Trains the Actor): How much better was the action than expected?\n", + " - Formula: `Accumulated Surprise` (Immediate difference + discounted future difference).\n", + " - Meaning: If positive, the agent is performing above baseline. Do this action more.\n", + "- `returns` (The Truth $\\rightarrow$ Trains the Critic): What was the actual total value of the state, in hindsight?\n", + " - Formula: Advantage + Value\n", + " - Meaning: The Critic was wrong. Next time, it should predict this number instead.\n", + "\n", + "**The Calculation Logic**\n", + "\n", + "GAE uses two steps to process these inputs:\n", + "- **Calculate Delta ($\\delta$)**: The immediate surprise for one step.\n", + " - `Delta = (Reward + Future Value) - Current Value`\n", + "- **Calculate Advantage**: The rolling surprise.\n", + " - It looks backwards: A success tomorrow helps justify the action taken today." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fe195f76-4d47-454c-b9d8-2cb61f7ce285", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "GAMMA = 0.99 # Discount factor\n", + "LAMBDA = 0.95 # GAE smoothing\n", + "\n", + "\n", + "def gae(rewards, values, next_value):\n", + " advantages = np.zeros_like(rewards)\n", + " last_gae = 0.0\n", + "\n", + " next_values = np.concatenate((values[1:], [next_value]), axis=0)\n", + "\n", + " # Bellman Error (Deltas) = r + gamma * V(next) - V(current)\n", + " deltas = rewards + (GAMMA * next_values) - values\n", + "\n", + " decay = GAMMA * LAMBDA\n", + " # Iterate backwards\n", + " for t in reversed(range(len(rewards))):\n", + " # Recursive GAE Formula\n", + " advantages[t] = last_gae = deltas[t] + decay * last_gae\n", + "\n", + " returns = advantages + values\n", + " return advantages, returns" + ] + }, + { + "cell_type": "markdown", + "id": "6801f3f4-a9ed-45d1-bc58-a551044e39cf", + "metadata": {}, + "source": [ + "Let's check how GAE works using an example:\n", + "- Scenario: You have a goose.\n", + "- Expectation (Values): You think it lays regular eggs (Worth \\$2).\n", + "- Reality (Rewards): It actually lays GOLDEN eggs (Worth \\$10)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8743c7c2-e67f-4172-9ac1-b54645a855c7", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated Advantage (GAE): \n", + "[44.3 36.5 28.19 19.37 9.98]\n", + "\n", + "Corrected Truth (Returns): \n", + "[46.3 38.5 30.19 21.37 11.98]\n", + "\n", + "Day 1 Return (46.30): The goose is actually worth $46.30 total.\n", + "Day 1 Advantage (44.30): But since you expected $2.0, the 'Good Surprise' is only $44.30.\n" + ] + } + ], + "source": [ + "rewards = [10.0, 10.0, 10.0, 10.0, 10.0] # Reality: It pays $10 daily\n", + "values = [2.0, 2.0, 2.0, 2.0, 2.0] # Expectation: We expected only $2\n", + "next_value = 2.0 # Future expectation is also $2\n", + "\n", + "advantages, returns = gae(rewards, values, next_value)\n", + "\n", + "print(f\"Calculated Advantage (GAE): \\n{np.round(advantages, 2)}\")\n", + "print(f\"\\nCorrected Truth (Returns): \\n{np.round(returns, 2)}\")\n", + "\n", + "print(\n", + " f\"\\nDay 1 Return ({returns[0]:.2f}): The goose is actually worth ${returns[0]:.2f} total.\"\n", + ")\n", + "print(\n", + " f\"Day 1 Advantage ({advantages[0]:.2f}): But since you expected ${values[0]}, the 'Good Surprise' is only ${advantages[0]:.2f}.\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ecc4f56a-165f-4886-bfaa-055a58b9ca7f", + "metadata": {}, + "source": [ + "## PPO Training\n", + "\n", + "We use a standard Python loop for data collection (the \"Rollout\"), but we use `model.fit()` for the optimization phase. " + ] + }, + { + "cell_type": "markdown", + "id": "a4d26718-cd31-4421-826c-b1700a0d9689", + "metadata": {}, + "source": [ + "### Custom Callback\n", + "KLEarlyStopping Callback: PPO is sensitive to large policy updates. If the new policy deviates too far from the old one (measured by KL Divergence), performance collapses.\n", + "\n", + "We implement a custom Callback that checks KL Divergence at the end of every epoch.\n", + "\n", + "If `kl > target_kl` (typically between 0.01-0.05), we set `self.model.stop_training = True`, instantly aborting the update for that batch to save the policy." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3be29d4c-3cb5-47ca-a47f-d6d3dade1b1b", + "metadata": {}, + "outputs": [], + "source": [ + "class KLEarlyStopping(keras.callbacks.Callback):\n", + " def __init__(self, target_kl):\n", + " super().__init__()\n", + " self.target_kl = target_kl\n", + "\n", + " def on_epoch_end(self, epoch, logs=None):\n", + " current_kl = logs.get(\"kl\")\n", + "\n", + " if current_kl > self.target_kl:\n", + " print(\n", + " f\" --> Early stopping at epoch {epoch+1} (KL: {current_kl:.4f})\"\n", + " )\n", + " self.model.stop_training = True" + ] + }, + { + "cell_type": "markdown", + "id": "81b5b760-0f51-4e44-a0e4-3bdb68bf3fcf", + "metadata": {}, + "source": [ + "### The Training Loop: Rollout & Update\n", + "\n", + "Training a PPO agent is different from standard Deep Learning. Since PPO is an **on-policy** method, we cannot simply pass a static dataset to `model.fit()`. Instead, we must generate our own data on the fly.\n", + "\n", + "The training process is a cycle that repeats for a set number of Rollouts (iterations). Each rollout consists of three distinct phases:\n", + "\n", + "#### Phase 1: Data Collection\n", + "We interact with the environment to collect a batch of fresh experience. PPO is an **On-Policy algorithm**, meaning it can only learn from data generated by its current policy. Old data is discarded.\n", + "\n", + "We repeat these steps (see the inner for loop below) for STEPS_PER_ROLLOUT (lenght of one rollout episode) times:\n", + "1. **Observe & Predict**: The agent sees the current state, and the Actor network outputs a mean action ($\\mu$) and a standard deviation ($\\sigma$).\n", + "2. **Sample**: We sample an action from this Gaussian distribution. This adds randomness, allowing the agent to discover new strategies \n", + "3. **Act**: We apply this action to the environment (`env.step`) and receive a **Reward** and the **Next State** \n", + "4. **Store**: We save the State, Action, Reward, and Value Prediction into a temporary buffer \n", + "\n", + "#### Phase 2: Processing\n", + "Once the rollout is complete, we pause to analyze what happened. This is where we calculate the **Generalized Advantage Estimation (GAE)** we defined above. This converts our raw experience into high-quality training targets for the neural network.\n", + "\n", + "#### Phase 3: Training\n", + "Now we update the neural network using the processed data.\n", + "\n", + "We call `model.fit()` to run the PPO Loss function we defined earlier.
\n", + "We train on this specific batch of data for multiple epochs to squeeze out as much learning as possible, but the `KLEarlyStopping` callback watches over this phase to ensure the policy doesn't overfit and remains stable." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "627e5d90-a65d-449a-9262-42bd7a9288f4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0000 00:00:1765480352.271945 472825 gpu_device.cc:2022] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 683 MB memory: -> device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting Training...\n", + " Starting Rollout 0...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "I0000 00:00:1765480367.786944 472867 service.cc:148] XLA service 0x7f6c3800e0f0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", + "I0000 00:00:1765480367.786987 472867 service.cc:156] StreamExecutor device (0): Tesla T4, Compute Capability 7.5\n", + "2025-12-11 19:12:47.841660: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:268] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", + "I0000 00:00:1765480368.069785 472867 cuda_dnn.cc:529] Loaded cuDNN version 90300\n", + "I0000 00:00:1765480369.090409 472867 device_compiler.h:188] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " --> Early stopping at epoch 30 (KL: 0.0288)\n", + " Rollout 1 Result - Reward: -1112.41\n", + " Starting Rollout 1...\n", + " --> Early stopping at epoch 3 (KL: 0.0255)\n", + " Rollout 2 Result - Reward: -975.75\n", + " Starting Rollout 2...\n", + " --> Early stopping at epoch 9 (KL: 0.0253)\n", + " Rollout 3 Result - Reward: -942.31\n", + " Starting Rollout 3...\n", + " --> Early stopping at epoch 12 (KL: 0.0287)\n", + " Rollout 4 Result - Reward: -921.11\n", + " Starting Rollout 4...\n", + " --> Early stopping at epoch 19 (KL: 0.0317)\n", + " Rollout 5 Result - Reward: -845.84\n", + " Starting Rollout 5...\n", + " --> Early stopping at epoch 16 (KL: 0.0293)\n", + " Rollout 6 Result - Reward: -777.18\n", + " Starting Rollout 6...\n", + " --> Early stopping at epoch 14 (KL: 0.0275)\n", + " Rollout 7 Result - Reward: -718.47\n", + " Starting Rollout 7...\n", + " --> Early stopping at epoch 24 (KL: 0.0691)\n", + " Rollout 8 Result - Reward: -708.98\n", + " Starting Rollout 8...\n", + " --> Early stopping at epoch 6 (KL: 0.0361)\n", + " Rollout 9 Result - Reward: -624.22\n", + " Starting Rollout 9...\n", + " --> Early stopping at epoch 17 (KL: 0.0272)\n", + " Rollout 10 Result - Reward: -593.93\n", + " Starting Rollout 10...\n", + " --> Early stopping at epoch 11 (KL: 0.0398)\n", + " Rollout 11 Result - Reward: -570.23\n", + " Starting Rollout 11...\n", + " --> Early stopping at epoch 2 (KL: 0.0258)\n", + " Rollout 12 Result - Reward: -612.50\n", + " Starting Rollout 12...\n", + " --> Early stopping at epoch 10 (KL: 0.0308)\n", + " Rollout 13 Result - Reward: -553.61\n", + " Starting Rollout 13...\n", + " --> Early stopping at epoch 5 (KL: 0.0304)\n", + " Rollout 14 Result - Reward: -538.68\n", + " Starting Rollout 14...\n", + " --> Early stopping at epoch 3 (KL: 0.0750)\n", + " Rollout 15 Result - Reward: -608.09\n", + " Starting Rollout 15...\n", + " --> Early stopping at epoch 2 (KL: 0.0444)\n", + " Rollout 16 Result - Reward: -552.24\n", + " Starting Rollout 16...\n", + " --> Early stopping at epoch 11 (KL: 0.0505)\n", + " Rollout 17 Result - Reward: -546.51\n", + " Starting Rollout 17...\n", + " --> Early stopping at epoch 12 (KL: 0.0270)\n", + " Rollout 18 Result - Reward: -472.21\n", + " Starting Rollout 18...\n", + " --> Early stopping at epoch 1 (KL: 0.0290)\n", + " Rollout 19 Result - Reward: -434.06\n", + " Starting Rollout 19...\n", + " --> Early stopping at epoch 7 (KL: 0.0342)\n", + " Rollout 20 Result - Reward: -408.71\n", + " Starting Rollout 20...\n", + " --> Early stopping at epoch 25 (KL: 0.0599)\n", + " Rollout 21 Result - Reward: -398.07\n", + " Starting Rollout 21...\n", + " --> Early stopping at epoch 2 (KL: 0.0389)\n", + " Rollout 22 Result - Reward: -371.59\n", + " Starting Rollout 22...\n", + " --> Early stopping at epoch 8 (KL: 0.0390)\n", + " Rollout 23 Result - Reward: -335.70\n", + " Starting Rollout 23...\n", + " --> Early stopping at epoch 4 (KL: 0.0575)\n", + " Rollout 24 Result - Reward: -323.16\n", + " Starting Rollout 24...\n", + " --> Early stopping at epoch 13 (KL: 0.0341)\n", + " Rollout 25 Result - Reward: -271.61\n", + " Starting Rollout 25...\n", + " --> Early stopping at epoch 12 (KL: 0.0480)\n", + " Rollout 26 Result - Reward: -251.66\n", + " Starting Rollout 26...\n", + " --> Early stopping at epoch 2 (KL: 0.0353)\n", + " Rollout 27 Result - Reward: -233.77\n", + " Starting Rollout 27...\n", + " --> Early stopping at epoch 10 (KL: 0.0280)\n", + " Rollout 28 Result - Reward: -208.17\n", + " Starting Rollout 28...\n", + " --> Early stopping at epoch 17 (KL: 0.0275)\n", + " Rollout 29 Result - Reward: -195.10\n", + " Starting Rollout 29...\n", + " --> Early stopping at epoch 15 (KL: 0.0432)\n", + " Rollout 30 Result - Reward: -159.61\n", + " Starting Rollout 30...\n", + " --> Early stopping at epoch 19 (KL: 0.0628)\n", + " Rollout 31 Result - Reward: -162.84\n", + " Starting Rollout 31...\n", + " --> Early stopping at epoch 5 (KL: 0.0263)\n", + " Rollout 32 Result - Reward: -132.51\n", + " Starting Rollout 32...\n", + " --> Early stopping at epoch 14 (KL: 0.0533)\n", + " Rollout 33 Result - Reward: -118.08\n", + " Starting Rollout 33...\n", + " --> Early stopping at epoch 1 (KL: 0.1005)\n", + " Rollout 34 Result - Reward: -192.20\n", + " Starting Rollout 34...\n", + " --> Early stopping at epoch 9 (KL: 0.0583)\n", + " Rollout 35 Result - Reward: -106.69\n", + " Starting Rollout 35...\n", + " --> Early stopping at epoch 2 (KL: 0.0277)\n", + " Rollout 36 Result - Reward: -101.38\n", + " Starting Rollout 36...\n", + " --> Early stopping at epoch 4 (KL: 0.0322)\n", + " Rollout 37 Result - Reward: -130.71\n", + " Starting Rollout 37...\n", + " --> Early stopping at epoch 1 (KL: 0.0315)\n", + " Rollout 38 Result - Reward: -102.59\n", + " Starting Rollout 38...\n", + " --> Early stopping at epoch 10 (KL: 0.0741)\n", + " Rollout 39 Result - Reward: -112.38\n", + " Starting Rollout 39...\n", + " --> Early stopping at epoch 8 (KL: 0.0367)\n", + " Rollout 40 Result - Reward: -87.94\n", + " Starting Rollout 40...\n", + " --> Early stopping at epoch 1 (KL: 0.0913)\n", + " Rollout 41 Result - Reward: -88.21\n", + " Starting Rollout 41...\n", + " --> Early stopping at epoch 3 (KL: 0.0441)\n", + " Rollout 42 Result - Reward: -76.67\n", + " Starting Rollout 42...\n", + " --> Early stopping at epoch 6 (KL: 0.0289)\n", + " Rollout 43 Result - Reward: -104.57\n", + " Starting Rollout 43...\n", + " --> Early stopping at epoch 1 (KL: 0.0408)\n", + " Rollout 44 Result - Reward: -67.15\n", + " Starting Rollout 44...\n", + " --> Early stopping at epoch 12 (KL: 0.0414)\n", + " Rollout 45 Result - Reward: -67.95\n", + " Starting Rollout 45...\n", + " --> Early stopping at epoch 11 (KL: 0.0343)\n", + " Rollout 46 Result - Reward: -67.94\n", + " Starting Rollout 46...\n", + " --> Early stopping at epoch 16 (KL: 0.0280)\n", + " Rollout 47 Result - Reward: -55.11\n", + " Starting Rollout 47...\n", + " --> Early stopping at epoch 6 (KL: 0.0685)\n", + " Rollout 48 Result - Reward: -49.95\n", + " Starting Rollout 48...\n", + " --> Early stopping at epoch 5 (KL: 0.0318)\n", + " Rollout 49 Result - Reward: -94.17\n", + " Starting Rollout 49...\n", + " --> Early stopping at epoch 6 (KL: 0.0455)\n", + " Rollout 50 Result - Reward: -90.03\n", + "CPU times: user 11min 16s, sys: 35.8 s, total: 11min 52s\n", + "Wall time: 10min 39s\n" + ] + } + ], + "source": [ + "%%time\n", + "# Training Hyperparameters\n", + "ROLLOUTS = 50 # How many times we simulate and collect data (Outer Loop)\n", + "STEPS_PER_ROLLOUT = 1008 # How many environment steps (buffer size) to collect per epoch. (Inner Loop for data)\n", + "# 1008 = one week, 4320 ≈ one month\n", + "MAX_EPOCHS_PER_ROLLOUT = 50 # How many times we train on that specific batch of data (Inner Loop for the optimizer)\n", + "# KL Early Stopping terminate before this step to avoid overfitting.\n", + "BATCH_SIZE = 32 # How many times to train on the buffer collected above.\n", + "LR = 0.0003 # Learning Rate\n", + "TARGET_KL = 0.025\n", + "\n", + "# Initialize\n", + "env_train = BuildingControlEnv(train_data_norm, max_steps=STEPS_PER_ROLLOUT)\n", + "model = ContinuousPPO(state_dim=4, action_dim=1)\n", + "model.compile(\n", + " optimizer=keras.optimizers.Adam(learning_rate=LR, global_clipnorm=0.5)\n", + ")\n", + "\n", + "print(\"Starting Training...\")\n", + "history = {\n", + " \"actor\": [],\n", + " \"critic\": [],\n", + " \"ent\": [],\n", + " \"rewards\": [],\n", + "}\n", + "\n", + "for rollout in range(ROLLOUTS):\n", + " # --- Phase 1: Data Collection ---\n", + " print(f\" Starting Rollout {rollout}...\")\n", + " states, actions, rewards, values, log_probs = [], [], [], [], []\n", + " state = env_train.reset()\n", + "\n", + " for step in range(STEPS_PER_ROLLOUT):\n", + " # Observe & Predict\n", + " mu, log_std, value_est = model(keras.ops.expand_dims(state, axis=0))\n", + "\n", + " # Sample Action (Exploration)\n", + " std = keras.ops.exp(log_std)\n", + " action_sample = mu + std * keras.random.normal(keras.ops.shape(mu))\n", + " log_prob = gaussian_log_likelihood(action_sample, mu, log_std)\n", + "\n", + " # Take Action\n", + " action = action_sample.numpy()[0, 0]\n", + " next_state, reward = env_train.step(action)\n", + "\n", + " # Store Data\n", + " states.append(state)\n", + " actions.append(action)\n", + " rewards.append(reward)\n", + " values.append(value_est.numpy()[0, 0])\n", + " log_probs.append(log_prob.numpy()[0])\n", + "\n", + " state = next_state\n", + "\n", + " # --- Phase 2: Processing (GAE) ---\n", + " _, _, last_val = model(keras.ops.expand_dims(state, axis=0))\n", + " last_val = last_val.numpy()[0, 0]\n", + "\n", + " advantages, returns = gae(rewards, values, last_val)\n", + "\n", + " # Normalize\n", + " advantages = (advantages - keras.ops.mean(advantages)) / (\n", + " keras.ops.std(advantages) + 1e-8\n", + " )\n", + " returns = (returns - keras.ops.mean(returns)) / (\n", + " keras.ops.std(returns) + 1e-8\n", + " )\n", + "\n", + " # --- Phase 3: Training ---\n", + " dataset = {\n", + " \"state\": np.array(states),\n", + " \"action\": np.array(actions).reshape(-1, 1),\n", + " \"advantage\": advantages,\n", + " \"return\": returns,\n", + " \"log_prob\": np.array(log_probs),\n", + " }\n", + " rollout_history = model.fit(\n", + " dataset,\n", + " batch_size=BATCH_SIZE,\n", + " epochs=MAX_EPOCHS_PER_ROLLOUT,\n", + " verbose=0,\n", + " callbacks=[KLEarlyStopping(target_kl=TARGET_KL)],\n", + " )\n", + "\n", + " history[\"actor\"].append(\n", + " keras.ops.mean(rollout_history.history[\"actor\"]).numpy()\n", + " )\n", + " history[\"critic\"].append(\n", + " keras.ops.mean(rollout_history.history[\"critic\"]).numpy()\n", + " )\n", + " history[\"ent\"].append(\n", + " keras.ops.mean(rollout_history.history[\"ent\"]).numpy()\n", + " )\n", + " history[\"rewards\"].append(keras.ops.sum(rewards).numpy())\n", + "\n", + " print(\n", + " f\" Rollout {rollout+1} Result - Reward: {history['rewards'][-1]:.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "419d5428-6028-4c6e-ba6a-1088239ca723", + "metadata": {}, + "source": [ + "## Evaluation\n", + "\n", + "After training, we switch the model to inference mode.\n", + "\n", + "During training, we sampled actions from a Gaussian distribution (exploration). For evaluation, we use the mean mu directly (exploitation) to check the optimal performance." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9d471f70-7cff-4819-a66c-e410d9a3b019", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "TEST_STEPS = 2000\n", + "test_env = BuildingControlEnv(test_data_norm, max_steps=TEST_STEPS)\n", + "state = test_env.reset()\n", + "\n", + "indoor_log, outdoor_log, action_log = [], [], []\n", + "\n", + "for t in range(TEST_STEPS):\n", + " # Use Mean (mu) for deterministic evaluation\n", + " mu, _, _ = model(keras.ops.expand_dims(state, axis=0), training=False)\n", + " action = mu.numpy()[0, 0]\n", + "\n", + " state, _ = test_env.step(action)\n", + "\n", + " indoor_log.append(test_env.indoor)\n", + " # Denormalize outdoor for plotting\n", + " outdoor_real = (state[1] * temp_std) + temp_mean\n", + " outdoor_log.append(outdoor_real)\n", + " action_log.append(action)" + ] + }, + { + "cell_type": "markdown", + "id": "13761eeb-2948-48aa-8671-176d13cc0753", + "metadata": {}, + "source": [ + "Let's plot the Indoor Temp controlled by HVAC actions vs. Target Temp to visually verify if the agent learned to anticipate weather changes." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "58622185-1965-4e5e-be27-7236704a6dcc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting\n", + "fig, ax1 = plt.subplots(figsize=(12, 6))\n", + "\n", + "ax1.set_xlabel(\"Hours\")\n", + "ax1.set_ylabel(\"Temperature (°C)\")\n", + "ax1.plot(outdoor_log, color=\"gray\", alpha=0.5, label=\"Outdoor\")\n", + "ax1.plot(indoor_log, color=\"blue\", linewidth=2, label=\"Indoor\")\n", + "ax1.axhline(y=TARGET_TEMP, color=\"green\", linestyle=\":\", label=\"Target\")\n", + "ax1.legend(loc=\"upper left\")\n", + "\n", + "ax2 = ax1.twinx()\n", + "ax2.set_ylabel(\"HVAC Power\", color=\"red\")\n", + "ax2.plot(action_log, color=\"red\", alpha=0.3, label=\"Action\")\n", + "ax2.set_ylim(-1.0, 1.0)\n", + "ax2.legend(loc=\"upper right\")\n", + "\n", + "plt.title(\"Smart Thermostat: Evaluation Run\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4a942c50-49f0-429a-93cf-90e9ac983ba8", + "metadata": {}, + "source": [ + "Copyright 2025 Google LLC\n", + "\n", + "Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\n", + "\n", + "https://www.apache.org/licenses/LICENSE-2.0\n", + "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a236026-5016-4e19-9cdb-b837cb658de0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "environment": { + "kernel": "conda-base-py", + "name": "workbench-notebooks.m136", + "type": "gcloud", + "uri": "us-docker.pkg.dev/deeplearning-platform-release/gcr.io/workbench-notebooks:m136" + }, + "kernelspec": { + "display_name": "ASL Core", + "language": "python", + "name": "asl_core" + }, + "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.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}