{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"2022-01-20-rl-social.ipynb","provenance":[{"file_id":"https://github.com/recohut/nbs/blob/main/raw/T098537%20%7C%20Building%20an%20RL%20Agent%20to%20manage%20social%20media%20accounts%20on%20the%20web.ipynb","timestamp":1644653336407},{"file_id":"12No3I0gmuettQ3DX5TXZI69FsjgFqTKm","timestamp":1638512065762},{"file_id":"1G-E2x6mzYYG8pvbgbHRO3QTM68fN9yQs","timestamp":1638511589199},{"file_id":"1P927fpgrxOd_nYl_ivXhz-yPLGUyyWjZ","timestamp":1638510924062},{"file_id":"1kbq3C9K_CcdkD4nGqRKBO_QRuIFc3CKa","timestamp":1638508636433}],"collapsed_sections":[],"toc_visible":true,"mount_file_id":"1kbq3C9K_CcdkD4nGqRKBO_QRuIFc3CKa","authorship_tag":"ABX9TyMcyvJV6hf/34Rb0ZkZcjR0"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","metadata":{"id":"LhETGbFeyexq"},"source":["# Building an RL Agent to manage social media accounts on the web"]},{"cell_type":"code","metadata":{"id":"fsn3Y3yObopB"},"source":["!wget -q --show-progress https://github.com/RecoHut-Projects/drl-recsys/raw/S990517/tools/webgym.zip\n","!unzip webgym.zip"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"Ct-TsEZqajVL"},"source":["!pip install selenium\n","!apt-get update # to update ubuntu to correctly run apt install\n","!apt install chromium-chromedriver\n","!cp /usr/lib/chromium-browser/chromedriver /usr/bin"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"I5zXnSjmeOJl"},"source":["import sys\n","sys.path.insert(0,'/usr/lib/chromium-browser/chromedriver')"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"6aCFmU0TjUIA"},"source":["import webgym"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"_ODJjGqoa5ml"},"source":["import argparse\n","import os\n","import copy\n","import random\n","from collections import deque\n","from datetime import datetime\n","\n","import gym\n","import numpy as np\n","import tensorflow as tf\n","from tensorflow.keras.layers import (\n","    Conv2D,\n","    Dense,\n","    Dropout,\n","    Flatten,\n","    Input,\n","    Lambda,\n","    MaxPool2D,\n","    concatenate,\n",")"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"2SsdztX_pc6j"},"source":["%load_ext tensorboard"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"lxcyEZCVdYN-"},"source":["tf.keras.backend.set_floatx(\"float64\")"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"tnLHxGIj8iYF"},"source":["## Social Media Like Reply Agent"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"B8YIBwEudcT9","executionInfo":{"status":"ok","timestamp":1638512367533,"user_tz":-330,"elapsed":483,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"e0c35986-51af-4fea-e8b0-fb4ac4b07841"},"source":["parser = argparse.ArgumentParser(prog=\"TFRL-SocialMedia-Like-Reply-Agent\")\n","parser.add_argument(\"--env\", default=\"MiniWoBSocialMediaReplyVisualEnv-v0\")\n","parser.add_argument(\"--update-freq\", type=int, default=16)\n","parser.add_argument(\"--epochs\", type=int, default=3)\n","parser.add_argument(\"--actor-lr\", type=float, default=1e-4)\n","parser.add_argument(\"--critic-lr\", type=float, default=1e-4)\n","parser.add_argument(\"--clip-ratio\", type=float, default=0.1)\n","parser.add_argument(\"--gae-lambda\", type=float, default=0.95)\n","parser.add_argument(\"--gamma\", type=float, default=0.99)\n","parser.add_argument(\"--logdir\", default=\"logs\")\n","\n","args = parser.parse_args([])\n","logdir = os.path.join(\n","    args.logdir, parser.prog, args.env, datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",")\n","print(f\"Saving training logs to:{logdir}\")\n","writer = tf.summary.create_file_writer(logdir)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Saving training logs to:logs/TFRL-SocialMedia-Like-Reply-Agent/MiniWoBSocialMediaReplyVisualEnv-v0/20211203-061930\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kz9QGt6Wdd6c","executionInfo":{"status":"ok","timestamp":1638512499116,"user_tz":-330,"elapsed":51844,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"218c6b60-3de3-4d59-b54b-179656f7226b"},"source":["class Actor:\n","    def __init__(self, state_dim, action_dim, action_bound, std_bound):\n","        self.state_dim = state_dim\n","        self.action_dim = action_dim\n","        self.action_bound = np.array(action_bound)\n","        self.std_bound = std_bound\n","        self.weight_initializer = tf.keras.initializers.he_normal()\n","        self.eps = 1e-5\n","        self.model = self.nn_model()\n","        self.model.summary()  # Print a summary of the Actor model\n","        self.opt = tf.keras.optimizers.Nadam(args.actor_lr)\n","\n","    def nn_model(self):\n","        obs_input = Input(self.state_dim, name=\"im_obs\")\n","        conv1 = Conv2D(\n","            filters=64,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"same\",\n","            input_shape=self.state_dim,\n","            data_format=\"channels_last\",\n","            activation=\"relu\",\n","        )(obs_input)\n","        pool1 = MaxPool2D(pool_size=(3, 3), strides=1)(conv1)\n","        conv2 = Conv2D(\n","            filters=32,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool1)\n","        pool2 = MaxPool2D(pool_size=(3, 3), strides=1)(conv2)\n","        conv3 = Conv2D(\n","            filters=16,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool2)\n","        pool3 = MaxPool2D(pool_size=(3, 3), strides=1)(conv3)\n","        conv4 = Conv2D(\n","            filters=8,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool3)\n","        pool4 = MaxPool2D(pool_size=(3, 3), strides=1)(conv4)\n","        flat = Flatten()(pool4)\n","        dense1 = Dense(\n","            16, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(flat)\n","        dropout1 = Dropout(0.3)(dense1)\n","        dense2 = Dense(\n","            8, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(dropout1)\n","        dropout2 = Dropout(0.3)(dense2)\n","        # action_dim[0] = 2\n","        output_val = Dense(\n","            self.action_dim[0],\n","            activation=\"relu\",\n","            kernel_initializer=self.weight_initializer,\n","        )(dropout2)\n","        # Scale & clip x[i] to be in range [0, action_bound[i]]\n","        action_bound = copy.deepcopy(self.action_bound)\n","        mu_output = Lambda(\n","            lambda x: tf.clip_by_value(x * action_bound, 1e-9, action_bound),\n","            name=\"mu_output\",\n","        )(output_val)\n","        std_output_1 = Dense(\n","            self.action_dim[0],\n","            activation=\"softplus\",\n","            kernel_initializer=self.weight_initializer,\n","        )(dropout2)\n","        std_output = Lambda(\n","            lambda x: tf.clip_by_value(\n","                x * action_bound, 1e-9, action_bound / 2, name=\"std_output\"\n","            )\n","        )(std_output_1)\n","        return tf.keras.models.Model(\n","            inputs=obs_input, outputs=[mu_output, std_output], name=\"Actor\"\n","        )\n","\n","    def get_action(self, state):\n","        # Convert [Image] to np.array(np.adarray)\n","        state_np = np.array([np.array(s) for s in state])\n","        if len(state_np.shape) == 3:\n","            # Convert (w, h, c) to (1, w, h, c)\n","            state_np = np.expand_dims(state_np, 0)\n","        mu, std = self.model.predict(state_np)\n","        action = np.random.normal(mu[0], std[0] + self.eps, size=self.action_dim).astype(\n","            \"int\"\n","        )\n","        # Clip action to be between 0 and max obs screen size\n","        action = np.clip(action, 0, self.action_bound)\n","        # 1 Action per instance of env; Env expects: (num_instances, actions)\n","        action = (action,)\n","        log_policy = self.log_pdf(mu, std, action)\n","        return log_policy, action\n","\n","    def log_pdf(self, mu, std, action):\n","        std = tf.clip_by_value(std, self.std_bound[0], self.std_bound[1])\n","        var = std ** 2\n","        log_policy_pdf = -0.5 * (action - mu) ** 2 / var - 0.5 * tf.math.log(\n","            var * 2 * np.pi\n","        )\n","        return tf.reduce_sum(log_policy_pdf, 1, keepdims=True)\n","\n","    def compute_loss(self, log_old_policy, log_new_policy, actions, gaes):\n","        # Avoid INF in exp by setting 80 as the upper bound since,\n","        # tf.exp(x) for x>88 yeilds NaN (float32)\n","        ratio = tf.exp(\n","            tf.minimum(log_new_policy - tf.stop_gradient(log_old_policy), 80)\n","        )\n","        gaes = tf.stop_gradient(gaes)\n","        clipped_ratio = tf.clip_by_value(\n","            ratio, 1.0 - args.clip_ratio, 1.0 + args.clip_ratio\n","        )\n","        surrogate = -tf.minimum(ratio * gaes, clipped_ratio * gaes)\n","        return tf.reduce_mean(surrogate)\n","\n","    def train(self, log_old_policy, states, actions, gaes):\n","        with tf.GradientTape() as tape:\n","            mu, std = self.model(states, training=True)\n","            log_new_policy = self.log_pdf(mu, std, actions)\n","            loss = self.compute_loss(log_old_policy, log_new_policy, actions, gaes)\n","        grads = tape.gradient(loss, self.model.trainable_variables)\n","        self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n","        return loss\n","\n","    def save(self, model_dir: str, version: int = 1):\n","        actor_model_save_dir = os.path.join(\n","            model_dir, \"actor\", str(version), \"model.savedmodel\"\n","        )\n","        self.model.save(actor_model_save_dir, save_format=\"tf\")\n","        print(f\"Actor model saved at:{actor_model_save_dir}\")\n","\n","\n","class Critic:\n","    def __init__(self, state_dim):\n","        self.state_dim = state_dim\n","        self.weight_initializer = tf.keras.initializers.he_normal()\n","        self.model = self.nn_model()\n","        self.model.summary()  # Print a summary of the Critic model\n","        self.opt = tf.keras.optimizers.Nadam(args.critic_lr)\n","\n","    def nn_model(self):\n","        obs_input = Input(self.state_dim)\n","        conv1 = Conv2D(\n","            filters=64,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"same\",\n","            input_shape=self.state_dim,\n","            data_format=\"channels_last\",\n","            activation=\"relu\",\n","        )(obs_input)\n","        pool1 = MaxPool2D(pool_size=(3, 3), strides=2)(conv1)\n","        conv2 = Conv2D(\n","            filters=32,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool1)\n","        pool2 = MaxPool2D(pool_size=(3, 3), strides=2)(conv2)\n","        conv3 = Conv2D(\n","            filters=16,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool2)\n","        pool3 = MaxPool2D(pool_size=(3, 3), strides=1)(conv3)\n","        conv4 = Conv2D(\n","            filters=8,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool3)\n","        pool4 = MaxPool2D(pool_size=(3, 3), strides=1)(conv4)\n","        flat = Flatten()(pool4)\n","        dense1 = Dense(\n","            16, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(flat)\n","        dropout1 = Dropout(0.3)(dense1)\n","        dense2 = Dense(\n","            8, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(dropout1)\n","        dropout2 = Dropout(0.3)(dense2)\n","        value = Dense(\n","            1, activation=\"linear\", kernel_initializer=self.weight_initializer\n","        )(dropout2)\n","\n","        return tf.keras.models.Model(inputs=obs_input, outputs=value, name=\"Critic\")\n","\n","    def compute_loss(self, v_pred, td_targets):\n","        mse = tf.keras.losses.MeanSquaredError()\n","        return mse(td_targets, v_pred)\n","\n","    def train(self, states, td_targets):\n","        with tf.GradientTape() as tape:\n","            v_pred = self.model(states, training=True)\n","            # assert v_pred.shape == td_targets.shape\n","            loss = self.compute_loss(v_pred, tf.stop_gradient(td_targets))\n","        grads = tape.gradient(loss, self.model.trainable_variables)\n","        self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n","        return loss\n","\n","    def save(self, model_dir: str, version: int = 1):\n","        critic_model_save_dir = os.path.join(\n","            model_dir, \"critic\", str(version), \"model.savedmodel\"\n","        )\n","        self.model.save(critic_model_save_dir, save_format=\"tf\")\n","        print(f\"Critic model saved at:{critic_model_save_dir}\")\n","\n","\n","class PPOAgent:\n","    def __init__(self, env):\n","        self.env = env\n","        self.state_dim = self.env.observation_space.shape\n","        self.action_dim = self.env.action_space.shape\n","        # Set action_bounds to be within the actual task-window/browser-view of the agent\n","        self.action_bound = [self.env.task_width, self.env.task_height]\n","        self.std_bound = [1e-2, 1.0]\n","\n","        self.actor = Actor(\n","            self.state_dim, self.action_dim, self.action_bound, self.std_bound\n","        )\n","        self.critic = Critic(self.state_dim)\n","\n","    def gae_target(self, rewards, v_values, next_v_value, done):\n","        n_step_targets = np.zeros_like(rewards)\n","        gae = np.zeros_like(rewards)\n","        gae_cumulative = 0\n","        forward_val = 0\n","\n","        if not done:\n","            forward_val = next_v_value\n","\n","        for k in reversed(range(0, len(rewards))):\n","            delta = rewards[k] + args.gamma * forward_val - v_values[k]\n","            gae_cumulative = args.gamma * args.gae_lambda * gae_cumulative + delta\n","            gae[k] = gae_cumulative\n","            forward_val = v_values[k]\n","            n_step_targets[k] = gae[k] + v_values[k]\n","        return gae, n_step_targets\n","\n","    def train(self, max_episodes=1000):\n","        with writer.as_default():\n","            for ep in range(max_episodes):\n","                state_batch = []\n","                action_batch = []\n","                reward_batch = []\n","                old_policy_batch = []\n","\n","                episode_reward, done = 0, False\n","\n","                state = self.env.reset()\n","                prev_state = state\n","                step_num = 0\n","\n","                while not done:\n","                    # self.env.render()\n","                    log_old_policy, action = self.actor.get_action(state)\n","\n","                    next_state, reward, dones, _ = self.env.step(action)\n","                    step_num += 1\n","                    print(\n","                        f\"ep#:{ep} step#:{step_num} step_rew:{reward} action:{action} dones:{dones}\"\n","                    )\n","                    done = np.all(dones)\n","                    if done:\n","                        next_state = prev_state\n","                    else:\n","                        prev_state = next_state\n","                    state = np.array([np.array(s) for s in state])\n","                    next_state = np.array([np.array(s) for s in next_state])\n","                    reward = np.reshape(reward, [1, 1])\n","                    log_old_policy = np.reshape(log_old_policy, [1, 1])\n","\n","                    state_batch.append(state)\n","                    action_batch.append(action)\n","                    reward_batch.append((reward + 8) / 8)\n","                    old_policy_batch.append(log_old_policy)\n","\n","                    if len(state_batch) >= args.update_freq or done:\n","                        states = np.array([state.squeeze() for state in state_batch])\n","                        # Convert ([x, y],) to [x, y]\n","                        actions = np.array([action[0] for action in action_batch])\n","                        rewards = np.array(\n","                            [reward.squeeze() for reward in reward_batch]\n","                        )\n","                        old_policies = np.array(\n","                            [old_pi.squeeze() for old_pi in old_policy_batch]\n","                        )\n","\n","                        v_values = self.critic.model.predict(states)\n","                        next_v_value = self.critic.model.predict(next_state)\n","\n","                        gaes, td_targets = self.gae_target(\n","                            rewards, v_values, next_v_value, done\n","                        )\n","                        actor_losses, critic_losses = [], []\n","                        for epoch in range(args.epochs):\n","                            actor_loss = self.actor.train(\n","                                old_policies, states, actions, gaes\n","                            )\n","                            actor_losses.append(actor_loss)\n","                            critic_loss = self.critic.train(states, td_targets)\n","                            critic_losses.append(critic_loss)\n","                        # Plot mean actor & critic losses on every update\n","                        tf.summary.scalar(\"actor_loss\", np.mean(actor_losses), step=ep)\n","                        tf.summary.scalar(\n","                            \"critic_loss\", np.mean(critic_losses), step=ep\n","                        )\n","\n","                        state_batch = []\n","                        action_batch = []\n","                        reward_batch = []\n","                        old_policy_batch = []\n","\n","                    episode_reward += reward[0][0]\n","                    state = next_state[0]\n","\n","                print(f\"Episode#{ep} Reward:{episode_reward} Actions:{action_batch}\")\n","                tf.summary.scalar(\"episode_reward\", episode_reward, step=ep)\n","\n","    def save(self, model_dir: str, version: int = 1):\n","        self.actor.save(model_dir, version)\n","        self.critic.save(model_dir, version)\n","\n","\n","if __name__ == \"__main__\":\n","    env_name = args.env\n","    env = gym.make(env_name)\n","    cta_agent = PPOAgent(env)\n","    cta_agent.train(max_episodes=2)\n","    # Model saving\n","    model_dir = \"trained_models\"\n","    agent_name = f\"PPO_{env_name}-v0\"\n","    agent_version = 1\n","    agent_model_path = os.path.join(model_dir, agent_name)\n","    cta_agent.save(agent_model_path, agent_version)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Model: \"Actor\"\n","__________________________________________________________________________________________________\n"," Layer (type)                   Output Shape         Param #     Connected to                     \n","==================================================================================================\n"," im_obs (InputLayer)            [(None, 64, 64, 3)]  0           []                               \n","                                                                                                  \n"," conv2d_4 (Conv2D)              (None, 64, 64, 64)   1792        ['im_obs[0][0]']                 \n","                                                                                                  \n"," max_pooling2d_4 (MaxPooling2D)  (None, 62, 62, 64)  0           ['conv2d_4[0][0]']               \n","                                                                                                  \n"," conv2d_5 (Conv2D)              (None, 60, 60, 32)   18464       ['max_pooling2d_4[0][0]']        \n","                                                                                                  \n"," max_pooling2d_5 (MaxPooling2D)  (None, 58, 58, 32)  0           ['conv2d_5[0][0]']               \n","                                                                                                  \n"," conv2d_6 (Conv2D)              (None, 56, 56, 16)   4624        ['max_pooling2d_5[0][0]']        \n","                                                                                                  \n"," max_pooling2d_6 (MaxPooling2D)  (None, 54, 54, 16)  0           ['conv2d_6[0][0]']               \n","                                                                                                  \n"," conv2d_7 (Conv2D)              (None, 52, 52, 8)    1160        ['max_pooling2d_6[0][0]']        \n","                                                                                                  \n"," max_pooling2d_7 (MaxPooling2D)  (None, 50, 50, 8)   0           ['conv2d_7[0][0]']               \n","                                                                                                  \n"," flatten_1 (Flatten)            (None, 20000)        0           ['max_pooling2d_7[0][0]']        \n","                                                                                                  \n"," dense_3 (Dense)                (None, 16)           320016      ['flatten_1[0][0]']              \n","                                                                                                  \n"," dropout_2 (Dropout)            (None, 16)           0           ['dense_3[0][0]']                \n","                                                                                                  \n"," dense_4 (Dense)                (None, 8)            136         ['dropout_2[0][0]']              \n","                                                                                                  \n"," dropout_3 (Dropout)            (None, 8)            0           ['dense_4[0][0]']                \n","                                                                                                  \n"," dense_5 (Dense)                (None, 2)            18          ['dropout_3[0][0]']              \n","                                                                                                  \n"," dense_6 (Dense)                (None, 2)            18          ['dropout_3[0][0]']              \n","                                                                                                  \n"," mu_output (Lambda)             (None, 2)            0           ['dense_5[0][0]']                \n","                                                                                                  \n"," lambda (Lambda)                (None, 2)            0           ['dense_6[0][0]']                \n","                                                                                                  \n","==================================================================================================\n","Total params: 346,228\n","Trainable params: 346,228\n","Non-trainable params: 0\n","__________________________________________________________________________________________________\n","Model: \"Critic\"\n","_________________________________________________________________\n"," Layer (type)                Output Shape              Param #   \n","=================================================================\n"," input_1 (InputLayer)        [(None, 64, 64, 3)]       0         \n","                                                                 \n"," conv2d_8 (Conv2D)           (None, 64, 64, 64)        1792      \n","                                                                 \n"," max_pooling2d_8 (MaxPooling  (None, 31, 31, 64)       0         \n"," 2D)                                                             \n","                                                                 \n"," conv2d_9 (Conv2D)           (None, 29, 29, 32)        18464     \n","                                                                 \n"," max_pooling2d_9 (MaxPooling  (None, 14, 14, 32)       0         \n"," 2D)                                                             \n","                                                                 \n"," conv2d_10 (Conv2D)          (None, 12, 12, 16)        4624      \n","                                                                 \n"," max_pooling2d_10 (MaxPoolin  (None, 10, 10, 16)       0         \n"," g2D)                                                            \n","                                                                 \n"," conv2d_11 (Conv2D)          (None, 8, 8, 8)           1160      \n","                                                                 \n"," max_pooling2d_11 (MaxPoolin  (None, 6, 6, 8)          0         \n"," g2D)                                                            \n","                                                                 \n"," flatten_2 (Flatten)         (None, 288)               0         \n","                                                                 \n"," dense_7 (Dense)             (None, 16)                4624      \n","                                                                 \n"," dropout_4 (Dropout)         (None, 16)                0         \n","                                                                 \n"," dense_8 (Dense)             (None, 8)                 136       \n","                                                                 \n"," dropout_5 (Dropout)         (None, 8)                 0         \n","                                                                 \n"," dense_9 (Dense)             (None, 1)                 9         \n","                                                                 \n","=================================================================\n","Total params: 30,809\n","Trainable params: 30,809\n","Non-trainable params: 0\n","_________________________________________________________________\n","ep#:0 step#:1 step_rew:[0.0] action:(array([ 70, 210]),) dones:[False]\n","ep#:0 step#:2 step_rew:[0.0] action:(array([160, 196]),) dones:[False]\n","ep#:0 step#:3 step_rew:[0.0] action:(array([ 43, 193]),) dones:[False]\n","ep#:0 step#:4 step_rew:[0.0] action:(array([160, 209]),) dones:[False]\n","ep#:0 step#:5 step_rew:[0.0] action:(array([160, 205]),) dones:[False]\n","ep#:0 step#:6 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:0 step#:7 step_rew:[0.0] action:(array([132, 202]),) dones:[False]\n","ep#:0 step#:8 step_rew:[0.0] action:(array([160, 201]),) dones:[False]\n","ep#:0 step#:9 step_rew:[0.0] action:(array([ 41, 210]),) dones:[False]\n","ep#:0 step#:10 step_rew:[0.0] action:(array([160, 205]),) dones:[False]\n","ep#:0 step#:11 step_rew:[0.0] action:(array([160, 205]),) dones:[False]\n","ep#:0 step#:12 step_rew:[0.0] action:(array([ 75, 210]),) dones:[False]\n","ep#:0 step#:13 step_rew:[0.0] action:(array([160, 205]),) dones:[False]\n","ep#:0 step#:14 step_rew:[0.0] action:(array([160, 190]),) dones:[False]\n","ep#:0 step#:15 step_rew:[0.0] action:(array([160, 202]),) dones:[False]\n","ep#:0 step#:16 step_rew:[0.0] action:(array([106, 200]),) dones:[False]\n","ep#:0 step#:17 step_rew:[0.0] action:(array([ 51, 188]),) dones:[False]\n","ep#:0 step#:18 step_rew:[0.0] action:(array([ 59, 210]),) dones:[False]\n","ep#:0 step#:19 step_rew:[0.0] action:(array([ 94, 203]),) dones:[False]\n","ep#:0 step#:20 step_rew:[0.0] action:(array([160, 208]),) dones:[False]\n","ep#:0 step#:21 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:0 step#:22 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:0 step#:23 step_rew:[0.0] action:(array([ 50, 207]),) dones:[False]\n","ep#:0 step#:24 step_rew:[0.0] action:(array([137, 210]),) dones:[False]\n","ep#:0 step#:25 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:0 step#:26 step_rew:[0.0] action:(array([133, 204]),) dones:[False]\n","ep#:0 step#:27 step_rew:[0.0] action:(array([ 66, 210]),) dones:[False]\n","ep#:0 step#:28 step_rew:[0.0] action:(array([ 42, 207]),) dones:[False]\n","ep#:0 step#:29 step_rew:[0.0] action:(array([115, 209]),) dones:[False]\n","ep#:0 step#:30 step_rew:[0.0] action:(array([101, 210]),) dones:[False]\n","ep#:0 step#:31 step_rew:[0.0] action:(array([160, 208]),) dones:[False]\n","ep#:0 step#:32 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:root:Cannot call CoordClick(coords: (68, 205)) on instance 0, which is already done\n"]},{"output_type":"stream","name":"stdout","text":["ep#:0 step#:33 step_rew:[-1.0] action:(array([ 68, 205]),) dones:[True]\n","Episode#0 Reward:-1.0 Actions:[]\n","ep#:1 step#:1 step_rew:[0.0] action:(array([160, 197]),) dones:[False]\n","ep#:1 step#:2 step_rew:[0.0] action:(array([160, 196]),) dones:[False]\n","ep#:1 step#:3 step_rew:[0.0] action:(array([160, 201]),) dones:[False]\n","ep#:1 step#:4 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:5 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:6 step_rew:[0.0] action:(array([160, 192]),) dones:[False]\n","ep#:1 step#:7 step_rew:[0.0] action:(array([160, 203]),) dones:[False]\n","ep#:1 step#:8 step_rew:[0.0] action:(array([160, 205]),) dones:[False]\n","ep#:1 step#:9 step_rew:[0.0] action:(array([ 43, 210]),) dones:[False]\n","ep#:1 step#:10 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:11 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:12 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:13 step_rew:[0.0] action:(array([121, 205]),) dones:[False]\n","ep#:1 step#:14 step_rew:[0.0] action:(array([133, 210]),) dones:[False]\n","ep#:1 step#:15 step_rew:[0.0] action:(array([160, 206]),) dones:[False]\n","ep#:1 step#:16 step_rew:[0.0] action:(array([ 30, 210]),) dones:[False]\n","ep#:1 step#:17 step_rew:[0.0] action:(array([129, 210]),) dones:[False]\n","ep#:1 step#:18 step_rew:[0.0] action:(array([160, 193]),) dones:[False]\n","ep#:1 step#:19 step_rew:[0.0] action:(array([109, 204]),) dones:[False]\n","ep#:1 step#:20 step_rew:[0.0] action:(array([  0, 200]),) dones:[False]\n","ep#:1 step#:21 step_rew:[0.0] action:(array([104, 210]),) dones:[False]\n","ep#:1 step#:22 step_rew:[0.0] action:(array([150, 201]),) dones:[False]\n","ep#:1 step#:23 step_rew:[0.0] action:(array([  4, 210]),) dones:[False]\n","ep#:1 step#:24 step_rew:[0.0] action:(array([150, 203]),) dones:[False]\n","ep#:1 step#:25 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:26 step_rew:[0.0] action:(array([124, 210]),) dones:[False]\n","ep#:1 step#:27 step_rew:[0.0] action:(array([114, 208]),) dones:[False]\n","ep#:1 step#:28 step_rew:[0.0] action:(array([110, 208]),) dones:[False]\n","ep#:1 step#:29 step_rew:[0.0] action:(array([160, 210]),) dones:[False]\n","ep#:1 step#:30 step_rew:[0.0] action:(array([142, 210]),) dones:[False]\n","ep#:1 step#:31 step_rew:[0.0] action:(array([160, 203]),) dones:[False]\n","ep#:1 step#:32 step_rew:[0.0] action:(array([112, 210]),) dones:[False]\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:root:Cannot call CoordClick(coords: (160, 202)) on instance 0, which is already done\n"]},{"output_type":"stream","name":"stdout","text":["ep#:1 step#:33 step_rew:[-1.0] action:(array([160, 202]),) dones:[True]\n","Episode#1 Reward:-1.0 Actions:[]\n","WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaReplyVisualEnv-v0-v0/actor/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stderr","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaReplyVisualEnv-v0-v0/actor/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stdout","text":["Actor model saved at:trained_models/PPO_MiniWoBSocialMediaReplyVisualEnv-v0-v0/actor/1/model.savedmodel\n","WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaReplyVisualEnv-v0-v0/critic/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stderr","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaReplyVisualEnv-v0-v0/critic/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stdout","text":["Critic model saved at:trained_models/PPO_MiniWoBSocialMediaReplyVisualEnv-v0-v0/critic/1/model.savedmodel\n"]}]},{"cell_type":"code","metadata":{"id":"Z2Ln02kN-kyR"},"source":["%tensorboard --logdir /content/logs/TFRL-SocialMedia-Like-Reply-Agent/MiniWoBSocialMediaReplyVisualEnv-v0"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"REy4PvyI-xjo"},"source":["![image.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"LbSHkK-191Rz"},"source":["## Social Media Mute Agent"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"IVfl2f449c_M","executionInfo":{"status":"ok","timestamp":1638512604578,"user_tz":-330,"elapsed":464,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"871f329d-2829-4675-8d99-7968a82f7c2d"},"source":["parser = argparse.ArgumentParser(prog=\"TFRL-SocialMedia-Mute-User-Agent\")\n","parser.add_argument(\"--env\", default=\"MiniWoBSocialMediaMuteUserVisualEnv-v0\")\n","parser.add_argument(\"--update-freq\", type=int, default=16)\n","parser.add_argument(\"--epochs\", type=int, default=3)\n","parser.add_argument(\"--actor-lr\", type=float, default=1e-4)\n","parser.add_argument(\"--critic-lr\", type=float, default=1e-4)\n","parser.add_argument(\"--clip-ratio\", type=float, default=0.1)\n","parser.add_argument(\"--gae-lambda\", type=float, default=0.95)\n","parser.add_argument(\"--gamma\", type=float, default=0.99)\n","parser.add_argument(\"--logdir\", default=\"logs\")\n","\n","args = parser.parse_args([])\n","logdir = os.path.join(\n","    args.logdir, parser.prog, args.env, datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",")\n","print(f\"Saving training logs to:{logdir}\")\n","writer = tf.summary.create_file_writer(logdir)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Saving training logs to:logs/TFRL-SocialMedia-Mute-User-Agent/MiniWoBSocialMediaMuteUserVisualEnv-v0/20211203-062327\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"UJEVcH6F9c8e","executionInfo":{"status":"ok","timestamp":1638512681452,"user_tz":-330,"elapsed":41629,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"484098c3-4f51-498f-b730-56e2cf7d8dd8"},"source":["class Actor:\n","    def __init__(self, state_dim, action_dim, action_bound, std_bound):\n","        self.state_dim = state_dim\n","        self.action_dim = action_dim\n","        self.action_bound = np.array(action_bound)\n","        self.std_bound = std_bound\n","        self.weight_initializer = tf.keras.initializers.he_normal()\n","        self.eps = 1e-5\n","        self.model = self.nn_model()\n","        self.model.summary()  # Print a summary of the Actor model\n","        self.opt = tf.keras.optimizers.Nadam(args.actor_lr)\n","\n","    def nn_model(self):\n","        obs_input = Input(self.state_dim, name=\"im_obs\")\n","        conv1 = Conv2D(\n","            filters=64,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"same\",\n","            input_shape=self.state_dim,\n","            data_format=\"channels_last\",\n","            activation=\"relu\",\n","        )(obs_input)\n","        pool1 = MaxPool2D(pool_size=(3, 3), strides=1)(conv1)\n","        conv2 = Conv2D(\n","            filters=32,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool1)\n","        pool2 = MaxPool2D(pool_size=(3, 3), strides=1)(conv2)\n","        conv3 = Conv2D(\n","            filters=16,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool2)\n","        pool3 = MaxPool2D(pool_size=(3, 3), strides=1)(conv3)\n","        conv4 = Conv2D(\n","            filters=8,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool3)\n","        pool4 = MaxPool2D(pool_size=(3, 3), strides=1)(conv4)\n","        flat = Flatten()(pool4)\n","        dense1 = Dense(\n","            16, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(flat)\n","        dropout1 = Dropout(0.3)(dense1)\n","        dense2 = Dense(\n","            8, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(dropout1)\n","        dropout2 = Dropout(0.3)(dense2)\n","        # action_dim[0] = 2\n","        output_val = Dense(\n","            self.action_dim[0],\n","            activation=\"relu\",\n","            kernel_initializer=self.weight_initializer,\n","        )(dropout2)\n","        # Scale & clip x[i] to be in range [0, action_bound[i]]\n","        action_bound = copy.deepcopy(self.action_bound)\n","        mu_output = Lambda(\n","            lambda x: tf.clip_by_value(x * action_bound, 1e-9, action_bound),\n","            name=\"mu_output\",\n","        )(output_val)\n","        std_output_1 = Dense(\n","            self.action_dim[0],\n","            activation=\"softplus\",\n","            kernel_initializer=self.weight_initializer,\n","        )(dropout2)\n","        std_output = Lambda(\n","            lambda x: tf.clip_by_value(\n","                x * action_bound, 1e-9, action_bound / 2, name=\"std_output\"\n","            )\n","        )(std_output_1)\n","        return tf.keras.models.Model(\n","            inputs=obs_input, outputs=[mu_output, std_output], name=\"Actor\"\n","        )\n","\n","    def get_action(self, state):\n","        # Convert [Image] to np.array(np.adarray)\n","        state_np = np.array([np.array(s) for s in state])\n","        if len(state_np.shape) == 3:\n","            # Convert (w, h, c) to (1, w, h, c)\n","            state_np = np.expand_dims(state_np, 0)\n","        mu, std = self.model.predict(state_np)\n","        action = np.random.normal(mu[0], std[0] + self.eps, size=self.action_dim).astype(\n","            \"int\"\n","        )\n","        # Clip action to be between 0 and max obs screen size\n","        action = np.clip(action, 0, self.action_bound)\n","        # 1 Action per instance of env; Env expects: (num_instances, actions)\n","        action = (action,)\n","        log_policy = self.log_pdf(mu, std, action)\n","        return log_policy, action\n","\n","    def log_pdf(self, mu, std, action):\n","        std = tf.clip_by_value(std, self.std_bound[0], self.std_bound[1])\n","        var = std ** 2\n","        log_policy_pdf = -0.5 * (action - mu) ** 2 / var - 0.5 * tf.math.log(\n","            var * 2 * np.pi\n","        )\n","        return tf.reduce_sum(log_policy_pdf, 1, keepdims=True)\n","\n","    def compute_loss(self, log_old_policy, log_new_policy, actions, gaes):\n","        # Avoid INF in exp by setting 80 as the upper bound since,\n","        # tf.exp(x) for x>88 yeilds NaN (float32)\n","        ratio = tf.exp(\n","            tf.minimum(log_new_policy - tf.stop_gradient(log_old_policy), 80)\n","        )\n","        gaes = tf.stop_gradient(gaes)\n","        clipped_ratio = tf.clip_by_value(\n","            ratio, 1.0 - args.clip_ratio, 1.0 + args.clip_ratio\n","        )\n","        surrogate = -tf.minimum(ratio * gaes, clipped_ratio * gaes)\n","        return tf.reduce_mean(surrogate)\n","\n","    def train(self, log_old_policy, states, actions, gaes):\n","        with tf.GradientTape() as tape:\n","            mu, std = self.model(states, training=True)\n","            log_new_policy = self.log_pdf(mu, std, actions)\n","            loss = self.compute_loss(log_old_policy, log_new_policy, actions, gaes)\n","        grads = tape.gradient(loss, self.model.trainable_variables)\n","        self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n","        return loss\n","\n","    def save(self, model_dir: str, version: int = 1):\n","        actor_model_save_dir = os.path.join(\n","            model_dir, \"actor\", str(version), \"model.savedmodel\"\n","        )\n","        self.model.save(actor_model_save_dir, save_format=\"tf\")\n","        print(f\"Actor model saved at:{actor_model_save_dir}\")\n","\n","\n","class Critic:\n","    def __init__(self, state_dim):\n","        self.state_dim = state_dim\n","        self.weight_initializer = tf.keras.initializers.he_normal()\n","        self.model = self.nn_model()\n","        self.model.summary()  # Print a summary of the Critic model\n","        self.opt = tf.keras.optimizers.Nadam(args.critic_lr)\n","\n","    def nn_model(self):\n","        obs_input = Input(self.state_dim)\n","        conv1 = Conv2D(\n","            filters=64,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"same\",\n","            input_shape=self.state_dim,\n","            data_format=\"channels_last\",\n","            activation=\"relu\",\n","        )(obs_input)\n","        pool1 = MaxPool2D(pool_size=(3, 3), strides=2)(conv1)\n","        conv2 = Conv2D(\n","            filters=32,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool1)\n","        pool2 = MaxPool2D(pool_size=(3, 3), strides=2)(conv2)\n","        conv3 = Conv2D(\n","            filters=16,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool2)\n","        pool3 = MaxPool2D(pool_size=(3, 3), strides=1)(conv3)\n","        conv4 = Conv2D(\n","            filters=8,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool3)\n","        pool4 = MaxPool2D(pool_size=(3, 3), strides=1)(conv4)\n","        flat = Flatten()(pool4)\n","        dense1 = Dense(\n","            16, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(flat)\n","        dropout1 = Dropout(0.3)(dense1)\n","        dense2 = Dense(\n","            8, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(dropout1)\n","        dropout2 = Dropout(0.3)(dense2)\n","        value = Dense(\n","            1, activation=\"linear\", kernel_initializer=self.weight_initializer\n","        )(dropout2)\n","\n","        return tf.keras.models.Model(inputs=obs_input, outputs=value, name=\"Critic\")\n","\n","    def compute_loss(self, v_pred, td_targets):\n","        mse = tf.keras.losses.MeanSquaredError()\n","        return mse(td_targets, v_pred)\n","\n","    def train(self, states, td_targets):\n","        with tf.GradientTape() as tape:\n","            v_pred = self.model(states, training=True)\n","            # assert v_pred.shape == td_targets.shape\n","            loss = self.compute_loss(v_pred, tf.stop_gradient(td_targets))\n","        grads = tape.gradient(loss, self.model.trainable_variables)\n","        self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n","        return loss\n","\n","    def save(self, model_dir: str, version: int = 1):\n","        critic_model_save_dir = os.path.join(\n","            model_dir, \"critic\", str(version), \"model.savedmodel\"\n","        )\n","        self.model.save(critic_model_save_dir, save_format=\"tf\")\n","        print(f\"Critic model saved at:{critic_model_save_dir}\")\n","\n","\n","class PPOAgent:\n","    def __init__(self, env):\n","        self.env = env\n","        self.state_dim = self.env.observation_space.shape\n","        self.action_dim = self.env.action_space.shape\n","        # Set action_bounds to be within the actual task-window/browser-view of the agent\n","        self.action_bound = [self.env.task_width, self.env.task_height]\n","        self.std_bound = [1e-2, 1.0]\n","\n","        self.actor = Actor(\n","            self.state_dim, self.action_dim, self.action_bound, self.std_bound\n","        )\n","        self.critic = Critic(self.state_dim)\n","\n","    def gae_target(self, rewards, v_values, next_v_value, done):\n","        n_step_targets = np.zeros_like(rewards)\n","        gae = np.zeros_like(rewards)\n","        gae_cumulative = 0\n","        forward_val = 0\n","\n","        if not done:\n","            forward_val = next_v_value\n","\n","        for k in reversed(range(0, len(rewards))):\n","            delta = rewards[k] + args.gamma * forward_val - v_values[k]\n","            gae_cumulative = args.gamma * args.gae_lambda * gae_cumulative + delta\n","            gae[k] = gae_cumulative\n","            forward_val = v_values[k]\n","            n_step_targets[k] = gae[k] + v_values[k]\n","        return gae, n_step_targets\n","\n","    def train(self, max_episodes=1000):\n","        with writer.as_default():\n","            for ep in range(max_episodes):\n","                state_batch = []\n","                action_batch = []\n","                reward_batch = []\n","                old_policy_batch = []\n","\n","                episode_reward, done = 0, False\n","\n","                state = self.env.reset()\n","                prev_state = state\n","                step_num = 0\n","\n","                while not done:\n","                    # self.env.render()\n","                    log_old_policy, action = self.actor.get_action(state)\n","\n","                    next_state, reward, dones, _ = self.env.step(action)\n","                    step_num += 1\n","                    print(\n","                        f\"ep#:{ep} step#:{step_num} step_rew:{reward} action:{action} dones:{dones}\"\n","                    )\n","                    done = np.all(dones)\n","                    if done:\n","                        next_state = prev_state\n","                    else:\n","                        prev_state = next_state\n","                    state = np.array([np.array(s) for s in state])\n","                    next_state = np.array([np.array(s) for s in next_state])\n","                    reward = np.reshape(reward, [1, 1])\n","                    log_old_policy = np.reshape(log_old_policy, [1, 1])\n","\n","                    state_batch.append(state)\n","                    action_batch.append(action)\n","                    reward_batch.append((reward + 8) / 8)\n","                    old_policy_batch.append(log_old_policy)\n","\n","                    if len(state_batch) >= args.update_freq or done:\n","                        states = np.array([state.squeeze() for state in state_batch])\n","                        # Convert ([x, y],) to [x, y]\n","                        actions = np.array([action[0] for action in action_batch])\n","                        rewards = np.array(\n","                            [reward.squeeze() for reward in reward_batch]\n","                        )\n","                        old_policies = np.array(\n","                            [old_pi.squeeze() for old_pi in old_policy_batch]\n","                        )\n","\n","                        v_values = self.critic.model.predict(states)\n","                        next_v_value = self.critic.model.predict(next_state)\n","\n","                        gaes, td_targets = self.gae_target(\n","                            rewards, v_values, next_v_value, done\n","                        )\n","                        actor_losses, critic_losses = [], []\n","                        for epoch in range(args.epochs):\n","                            actor_loss = self.actor.train(\n","                                old_policies, states, actions, gaes\n","                            )\n","                            actor_losses.append(actor_loss)\n","                            critic_loss = self.critic.train(states, td_targets)\n","                            critic_losses.append(critic_loss)\n","                        # Plot mean actor & critic losses on every update\n","                        tf.summary.scalar(\"actor_loss\", np.mean(actor_losses), step=ep)\n","                        tf.summary.scalar(\n","                            \"critic_loss\", np.mean(critic_losses), step=ep\n","                        )\n","\n","                        state_batch = []\n","                        action_batch = []\n","                        reward_batch = []\n","                        old_policy_batch = []\n","\n","                    episode_reward += reward[0][0]\n","                    state = next_state[0]\n","\n","                print(f\"Episode#{ep} Reward:{episode_reward} Actions:{action_batch}\")\n","                tf.summary.scalar(\"episode_reward\", episode_reward, step=ep)\n","\n","    def save(self, model_dir: str, version: int = 1):\n","        self.actor.save(model_dir, version)\n","        self.critic.save(model_dir, version)\n","\n","\n","if __name__ == \"__main__\":\n","    env_name = args.env\n","    env = gym.make(env_name)\n","    cta_agent = PPOAgent(env)\n","    cta_agent.train(max_episodes=2)\n","    # Model saving\n","    model_dir = \"trained_models\"\n","    agent_name = f\"PPO_{env_name}\"\n","    agent_version = 1\n","    agent_model_path = os.path.join(model_dir, agent_name)\n","    cta_agent.save(agent_model_path, agent_version)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Model: \"Actor\"\n","__________________________________________________________________________________________________\n"," Layer (type)                   Output Shape         Param #     Connected to                     \n","==================================================================================================\n"," im_obs (InputLayer)            [(None, 64, 64, 3)]  0           []                               \n","                                                                                                  \n"," conv2d_20 (Conv2D)             (None, 64, 64, 64)   1792        ['im_obs[0][0]']                 \n","                                                                                                  \n"," max_pooling2d_20 (MaxPooling2D  (None, 62, 62, 64)  0           ['conv2d_20[0][0]']              \n"," )                                                                                                \n","                                                                                                  \n"," conv2d_21 (Conv2D)             (None, 60, 60, 32)   18464       ['max_pooling2d_20[0][0]']       \n","                                                                                                  \n"," max_pooling2d_21 (MaxPooling2D  (None, 58, 58, 32)  0           ['conv2d_21[0][0]']              \n"," )                                                                                                \n","                                                                                                  \n"," conv2d_22 (Conv2D)             (None, 56, 56, 16)   4624        ['max_pooling2d_21[0][0]']       \n","                                                                                                  \n"," max_pooling2d_22 (MaxPooling2D  (None, 54, 54, 16)  0           ['conv2d_22[0][0]']              \n"," )                                                                                                \n","                                                                                                  \n"," conv2d_23 (Conv2D)             (None, 52, 52, 8)    1160        ['max_pooling2d_22[0][0]']       \n","                                                                                                  \n"," max_pooling2d_23 (MaxPooling2D  (None, 50, 50, 8)   0           ['conv2d_23[0][0]']              \n"," )                                                                                                \n","                                                                                                  \n"," flatten_5 (Flatten)            (None, 20000)        0           ['max_pooling2d_23[0][0]']       \n","                                                                                                  \n"," dense_17 (Dense)               (None, 16)           320016      ['flatten_5[0][0]']              \n","                                                                                                  \n"," dropout_10 (Dropout)           (None, 16)           0           ['dense_17[0][0]']               \n","                                                                                                  \n"," dense_18 (Dense)               (None, 8)            136         ['dropout_10[0][0]']             \n","                                                                                                  \n"," dropout_11 (Dropout)           (None, 8)            0           ['dense_18[0][0]']               \n","                                                                                                  \n"," dense_19 (Dense)               (None, 2)            18          ['dropout_11[0][0]']             \n","                                                                                                  \n"," dense_20 (Dense)               (None, 2)            18          ['dropout_11[0][0]']             \n","                                                                                                  \n"," mu_output (Lambda)             (None, 2)            0           ['dense_19[0][0]']               \n","                                                                                                  \n"," lambda_2 (Lambda)              (None, 2)            0           ['dense_20[0][0]']               \n","                                                                                                  \n","==================================================================================================\n","Total params: 346,228\n","Trainable params: 346,228\n","Non-trainable params: 0\n","__________________________________________________________________________________________________\n","Model: \"Critic\"\n","_________________________________________________________________\n"," Layer (type)                Output Shape              Param #   \n","=================================================================\n"," input_3 (InputLayer)        [(None, 64, 64, 3)]       0         \n","                                                                 \n"," conv2d_24 (Conv2D)          (None, 64, 64, 64)        1792      \n","                                                                 \n"," max_pooling2d_24 (MaxPoolin  (None, 31, 31, 64)       0         \n"," g2D)                                                            \n","                                                                 \n"," conv2d_25 (Conv2D)          (None, 29, 29, 32)        18464     \n","                                                                 \n"," max_pooling2d_25 (MaxPoolin  (None, 14, 14, 32)       0         \n"," g2D)                                                            \n","                                                                 \n"," conv2d_26 (Conv2D)          (None, 12, 12, 16)        4624      \n","                                                                 \n"," max_pooling2d_26 (MaxPoolin  (None, 10, 10, 16)       0         \n"," g2D)                                                            \n","                                                                 \n"," conv2d_27 (Conv2D)          (None, 8, 8, 8)           1160      \n","                                                                 \n"," max_pooling2d_27 (MaxPoolin  (None, 6, 6, 8)          0         \n"," g2D)                                                            \n","                                                                 \n"," flatten_6 (Flatten)         (None, 288)               0         \n","                                                                 \n"," dense_21 (Dense)            (None, 16)                4624      \n","                                                                 \n"," dropout_12 (Dropout)        (None, 16)                0         \n","                                                                 \n"," dense_22 (Dense)            (None, 8)                 136       \n","                                                                 \n"," dropout_13 (Dropout)        (None, 8)                 0         \n","                                                                 \n"," dense_23 (Dense)            (None, 1)                 9         \n","                                                                 \n","=================================================================\n","Total params: 30,809\n","Trainable params: 30,809\n","Non-trainable params: 0\n","_________________________________________________________________\n","ep#:0 step#:1 step_rew:[0.0] action:(array([ 93, 111]),) dones:[False]\n","ep#:0 step#:2 step_rew:[0.0] action:(array([  0, 152]),) dones:[False]\n","ep#:0 step#:3 step_rew:[0.0] action:(array([91, 35]),) dones:[False]\n","ep#:0 step#:4 step_rew:[0.0] action:(array([20,  0]),) dones:[False]\n","ep#:0 step#:5 step_rew:[0.0] action:(array([19,  0]),) dones:[False]\n","ep#:0 step#:6 step_rew:[0.0] action:(array([60, 45]),) dones:[False]\n","ep#:0 step#:7 step_rew:[0.0] action:(array([ 0, 80]),) dones:[False]\n","ep#:0 step#:8 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:0 step#:9 step_rew:[0.0] action:(array([143,   0]),) dones:[False]\n","ep#:0 step#:10 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:0 step#:11 step_rew:[0.0] action:(array([  0, 142]),) dones:[False]\n","ep#:0 step#:12 step_rew:[0.0] action:(array([ 93, 115]),) dones:[False]\n","ep#:0 step#:13 step_rew:[0.0] action:(array([  0, 105]),) dones:[False]\n","ep#:0 step#:14 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:0 step#:15 step_rew:[0.0] action:(array([ 26, 113]),) dones:[False]\n","ep#:0 step#:16 step_rew:[0.0] action:(array([97,  0]),) dones:[False]\n","ep#:0 step#:17 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:0 step#:18 step_rew:[0.0] action:(array([160,   0]),) dones:[False]\n","ep#:0 step#:19 step_rew:[0.0] action:(array([110,  51]),) dones:[False]\n","ep#:0 step#:20 step_rew:[0.0] action:(array([84,  0]),) dones:[False]\n","ep#:0 step#:21 step_rew:[0.0] action:(array([50,  0]),) dones:[False]\n","ep#:0 step#:22 step_rew:[0.0] action:(array([ 0, 15]),) dones:[False]\n","ep#:0 step#:23 step_rew:[0.0] action:(array([54,  0]),) dones:[False]\n","ep#:0 step#:24 step_rew:[0.0] action:(array([ 0, 73]),) dones:[False]\n","ep#:0 step#:25 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:root:Cannot call CoordClick(coords: (0, 14)) on instance 0, which is already done\n"]},{"output_type":"stream","name":"stdout","text":["ep#:0 step#:26 step_rew:[0.0] action:(array([80, 81]),) dones:[False]\n","ep#:0 step#:27 step_rew:[-1.0] action:(array([ 0, 14]),) dones:[True]\n","Episode#0 Reward:-1.0 Actions:[]\n","ep#:1 step#:1 step_rew:[0.0] action:(array([ 0, 48]),) dones:[False]\n","ep#:1 step#:2 step_rew:[0.0] action:(array([60, 83]),) dones:[False]\n","ep#:1 step#:3 step_rew:[0.0] action:(array([95,  0]),) dones:[False]\n","ep#:1 step#:4 step_rew:[0.0] action:(array([  0, 184]),) dones:[False]\n","ep#:1 step#:5 step_rew:[0.0] action:(array([0, 4]),) dones:[False]\n","ep#:1 step#:6 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:7 step_rew:[0.0] action:(array([160,   0]),) dones:[False]\n","ep#:1 step#:8 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:9 step_rew:[0.0] action:(array([29, 43]),) dones:[False]\n","ep#:1 step#:10 step_rew:[0.0] action:(array([ 0, 81]),) dones:[False]\n","ep#:1 step#:11 step_rew:[0.0] action:(array([65,  0]),) dones:[False]\n","ep#:1 step#:12 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:13 step_rew:[0.0] action:(array([  0, 210]),) dones:[False]\n","ep#:1 step#:14 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:15 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:16 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:17 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:18 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:19 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:20 step_rew:[0.0] action:(array([0, 0]),) dones:[False]\n","ep#:1 step#:21 step_rew:[0.0] action:(array([ 0, 50]),) dones:[False]\n","ep#:1 step#:22 step_rew:[0.0] action:(array([ 0, 80]),) dones:[False]\n","ep#:1 step#:23 step_rew:[0.0] action:(array([31,  0]),) dones:[False]\n","ep#:1 step#:24 step_rew:[0.0] action:(array([ 84, 161]),) dones:[False]\n","ep#:1 step#:25 step_rew:[0.0] action:(array([ 0, 28]),) dones:[False]\n","ep#:1 step#:26 step_rew:[0.0] action:(array([1, 0]),) dones:[False]\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:root:Cannot call CoordClick(coords: (0, 140)) on instance 0, which is already done\n"]},{"output_type":"stream","name":"stdout","text":["ep#:1 step#:27 step_rew:[0.0] action:(array([  0, 172]),) dones:[False]\n","ep#:1 step#:28 step_rew:[-1.0] action:(array([  0, 140]),) dones:[True]\n","Episode#1 Reward:-1.0 Actions:[]\n","WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaMuteUserVisualEnv-v0/actor/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stderr","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaMuteUserVisualEnv-v0/actor/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stdout","text":["Actor model saved at:trained_models/PPO_MiniWoBSocialMediaMuteUserVisualEnv-v0/actor/1/model.savedmodel\n","WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"]},{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaMuteUserVisualEnv-v0/critic/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stderr","text":["INFO:tensorflow:Assets written to: trained_models/PPO_MiniWoBSocialMediaMuteUserVisualEnv-v0/critic/1/model.savedmodel/assets\n"]},{"output_type":"stream","name":"stdout","text":["Critic model saved at:trained_models/PPO_MiniWoBSocialMediaMuteUserVisualEnv-v0/critic/1/model.savedmodel\n"]}]},{"cell_type":"code","metadata":{"id":"D_2THOMX-2E7"},"source":["%tensorboard --logdir /content/logs/TFRL-SocialMedia-Mute-User-Agent/MiniWoBSocialMediaMuteUserVisualEnv-v0"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"tNF2n2F5_Hsy"},"source":["![image.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"VlOVmEIW95ae"},"source":["## Social Media Mute Agent DDPG"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"c42WjLsm-AZL","executionInfo":{"status":"ok","timestamp":1638512751595,"user_tz":-330,"elapsed":495,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"04a53a2c-5992-4d07-e720-3af8650c63cf"},"source":["parser = argparse.ArgumentParser(\n","    prog=\"TFRL-SocialMedia-Mute-User-DDPGAgent\"\n",")\n","parser.add_argument(\"--env\", default=\"MiniWoBSocialMediaMuteUserVisualEnv-v0\")\n","parser.add_argument(\"--actor_lr\", type=float, default=0.0005)\n","parser.add_argument(\"--critic_lr\", type=float, default=0.001)\n","parser.add_argument(\"--batch_size\", type=int, default=64)\n","parser.add_argument(\"--tau\", type=float, default=0.05)\n","parser.add_argument(\"--gamma\", type=float, default=0.99)\n","parser.add_argument(\"--train_start\", type=int, default=2000)\n","parser.add_argument(\"--logdir\", default=\"logs\")\n","\n","args = parser.parse_args([])\n","logdir = os.path.join(\n","    args.logdir, parser.prog, args.env, datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",")\n","print(f\"Saving training logs to:{logdir}\")\n","writer = tf.summary.create_file_writer(logdir)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Saving training logs to:logs/TFRL-SocialMedia-Mute-User-DDPGAgent/MiniWoBSocialMediaMuteUserVisualEnv-v0/20211203-062554\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"mBdf2ZsM-AWs","executionInfo":{"status":"ok","timestamp":1638512832169,"user_tz":-330,"elapsed":33164,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"e35c00bb-270e-481c-e073-fbad2c65b974"},"source":["class ReplayBuffer:\n","    def __init__(self, capacity=10000):\n","        self.buffer = deque(maxlen=capacity)\n","\n","    def store(self, state, action, reward, next_state, done):\n","        self.buffer.append([state, action, reward, next_state, done])\n","\n","    def sample(self):\n","        sample = random.sample(self.buffer, args.batch_size)\n","        states, actions, rewards, next_states, done = map(np.asarray, zip(*sample))\n","        states = np.array(states).reshape(args.batch_size, -1)\n","        next_states = np.array(next_states).reshape(args.batch_size, -1)\n","        return states, actions, rewards, next_states, done\n","\n","    def size(self):\n","        return len(self.buffer)\n","\n","\n","class Actor:\n","    def __init__(self, state_dim, action_dim, action_bound):\n","        self.state_dim = state_dim\n","        self.action_dim = action_dim\n","        self.action_bound = action_bound\n","        self.weight_initializer = tf.keras.initializers.he_normal()\n","        self.eps = 1e-5\n","        self.model = self.nn_model()\n","        self.opt = tf.keras.optimizers.Adam(args.actor_lr)\n","\n","    def nn_model(self):\n","        obs_input = Input(self.state_dim)\n","        conv1 = Conv2D(\n","            filters=64,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"same\",\n","            input_shape=self.state_dim,\n","            data_format=\"channels_last\",\n","            activation=\"relu\",\n","        )(obs_input)\n","        pool1 = MaxPool2D(pool_size=(3, 3), strides=1)(conv1)\n","        conv2 = Conv2D(\n","            filters=32,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool1)\n","        pool2 = MaxPool2D(pool_size=(3, 3), strides=1)(conv2)\n","        conv3 = Conv2D(\n","            filters=16,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool2)\n","        pool3 = MaxPool2D(pool_size=(3, 3), strides=1)(conv3)\n","        conv4 = Conv2D(\n","            filters=8,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool3)\n","        pool4 = MaxPool2D(pool_size=(3, 3), strides=1)(conv4)\n","        flat = Flatten()(pool4)\n","        dense1 = Dense(\n","            16, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(flat)\n","        dropout1 = Dropout(0.3)(dense1)\n","        dense2 = Dense(\n","            8, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(dropout1)\n","        dropout2 = Dropout(0.3)(dense2)\n","        # action_dim[0] = 2\n","        output_val = Dense(\n","            self.action_dim[0],\n","            activation=\"relu\",\n","            kernel_initializer=self.weight_initializer,\n","        )(dropout2)\n","        # Scale & clip x[i] to be in range [0, action_bound[i]]\n","        mu_output = Lambda(\n","            lambda x: tf.clip_by_value(x * self.action_bound, 1e-9, self.action_bound)\n","        )(output_val)\n","        return tf.keras.models.Model(inputs=obs_input, outputs=mu_output, name=\"Actor\")\n","\n","    def train(self, states, q_grads):\n","        with tf.GradientTape() as tape:\n","            grads = tape.gradient(\n","                self.model(states), self.model.trainable_variables, -q_grads\n","            )\n","        self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n","\n","    def predict(self, state):\n","        return self.model.predict(state)\n","\n","    def get_action(self, state):\n","        # Convert [Image] to np.array(np.adarray)\n","        state_np = np.array([np.array(s) for s in state])\n","        if len(state_np.shape) == 3:\n","            # Convert (w, h, c) to (1, w, h, c)\n","            state_np = np.expand_dims(state_np, 0)\n","        action = self.model.predict(state_np)\n","        # Clip action to be between 0 and max obs screen size\n","        action = np.clip(action, 0, self.action_bound)\n","        # 1 Action per instance of env; Env expects: (num_instances, actions)\n","        return action\n","\n","\n","class Critic:\n","    def __init__(self, state_dim, action_dim):\n","        self.state_dim = state_dim\n","        self.action_dim = action_dim\n","        self.weight_initializer = tf.keras.initializers.he_normal()\n","        self.model = self.nn_model()\n","        self.opt = tf.keras.optimizers.Adam(args.critic_lr)\n","\n","    def nn_model(self):\n","        obs_input = Input(self.state_dim)\n","        conv1 = Conv2D(\n","            filters=64,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"same\",\n","            input_shape=self.state_dim,\n","            data_format=\"channels_last\",\n","            activation=\"relu\",\n","        )(obs_input)\n","        pool1 = MaxPool2D(pool_size=(3, 3), strides=2)(conv1)\n","        conv2 = Conv2D(\n","            filters=32,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool1)\n","        pool2 = MaxPool2D(pool_size=(3, 3), strides=2)(conv2)\n","        conv3 = Conv2D(\n","            filters=16,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool2)\n","        pool3 = MaxPool2D(pool_size=(3, 3), strides=1)(conv3)\n","        conv4 = Conv2D(\n","            filters=8,\n","            kernel_size=(3, 3),\n","            strides=(1, 1),\n","            padding=\"valid\",\n","            activation=\"relu\",\n","        )(pool3)\n","        pool4 = MaxPool2D(pool_size=(3, 3), strides=1)(conv4)\n","        flat = Flatten()(pool4)\n","        dense1 = Dense(\n","            16, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(flat)\n","        dropout1 = Dropout(0.3)(dense1)\n","        dense2 = Dense(\n","            8, activation=\"relu\", kernel_initializer=self.weight_initializer\n","        )(dropout1)\n","        dropout2 = Dropout(0.3)(dense2)\n","        value = Dense(\n","            1, activation=\"linear\", kernel_initializer=self.weight_initializer\n","        )(dropout2)\n","\n","        return tf.keras.models.Model(inputs=obs_input, outputs=value, name=\"Critic\")\n","\n","    def predict(self, inputs):\n","        return self.model.predict(inputs)\n","\n","    def q_gradients(self, states, actions):\n","        actions = tf.convert_to_tensor(actions)\n","        with tf.GradientTape() as tape:\n","            tape.watch(actions)\n","            q_values = self.model([states, actions])\n","            q_values = tf.squeeze(q_values)\n","        return tape.gradient(q_values, actions)\n","\n","    def compute_loss(self, v_pred, td_targets):\n","        mse = tf.keras.losses.MeanSquaredError()\n","        return mse(td_targets, v_pred)\n","\n","    def train(self, states, actions, td_targets):\n","        with tf.GradientTape() as tape:\n","            v_pred = self.model([states, actions], training=True)\n","            assert v_pred.shape == td_targets.shape\n","            loss = self.compute_loss(v_pred, tf.stop_gradient(td_targets))\n","        grads = tape.gradient(loss, self.model.trainable_variables)\n","        self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n","        return loss\n","\n","\n","class DDPGAgent:\n","    def __init__(self, env):\n","        self.env = env\n","        self.state_dim = self.env.observation_space.shape\n","        self.action_dim = self.env.action_space.shape\n","        self.action_bound = self.env.action_space.high\n","\n","        self.buffer = ReplayBuffer()\n","\n","        self.actor = Actor(self.state_dim, self.action_dim, self.action_bound)\n","        self.critic = Critic(self.state_dim, self.action_dim)\n","\n","        self.target_actor = Actor(self.state_dim, self.action_dim, self.action_bound)\n","        self.target_critic = Critic(self.state_dim, self.action_dim)\n","\n","        actor_weights = self.actor.model.get_weights()\n","        critic_weights = self.critic.model.get_weights()\n","        self.target_actor.model.set_weights(actor_weights)\n","        self.target_critic.model.set_weights(critic_weights)\n","\n","    def update_target(self):\n","        actor_weights = self.actor.model.get_weights()\n","        t_actor_weights = self.target_actor.model.get_weights()\n","        critic_weights = self.critic.model.get_weights()\n","        t_critic_weights = self.target_critic.model.get_weights()\n","\n","        for i in range(len(actor_weights)):\n","            t_actor_weights[i] = (\n","                args.tau * actor_weights[i] + (1 - args.tau) * t_actor_weights[i]\n","            )\n","\n","        for i in range(len(critic_weights)):\n","            t_critic_weights[i] = (\n","                args.tau * critic_weights[i] + (1 - args.tau) * t_critic_weights[i]\n","            )\n","\n","        self.target_actor.model.set_weights(t_actor_weights)\n","        self.target_critic.model.set_weights(t_critic_weights)\n","\n","    def get_td_target(self, rewards, q_values, dones):\n","        targets = np.asarray(q_values)\n","        for i in range(q_values.shape[0]):\n","            if dones[i]:\n","                targets[i] = rewards[i]\n","            else:\n","                targets[i] = args.gamma * q_values[i]\n","        return targets\n","\n","    def add_ou_noise(self, x, rho=0.15, mu=0, dt=1e-1, sigma=0.2, dim=1):\n","        return (\n","            x + rho * (mu - x) * dt + sigma * np.sqrt(dt) * np.random.normal(size=dim)\n","        )\n","\n","    def replay_experience(self):\n","        for _ in range(10):\n","            states, actions, rewards, next_states, dones = self.buffer.sample()\n","            target_q_values = self.target_critic.predict(\n","                [next_states, self.target_actor.predict(next_states)]\n","            )\n","            td_targets = self.get_td_target(rewards, target_q_values, dones)\n","\n","            self.critic.train(states, actions, td_targets)\n","\n","            s_actions = self.actor.predict(states)\n","            s_grads = self.critic.q_gradients(states, s_actions)\n","            grads = np.array(s_grads).reshape((-1, self.action_dim))\n","            self.actor.train(states, grads)\n","            self.update_target()\n","\n","    def train(self, max_episodes=1000):\n","        with writer.as_default():\n","            for ep in range(max_episodes):\n","                step_num, episode_reward, done = 0, 0, False\n","\n","                state = self.env.reset()\n","                prev_state = state\n","                bg_noise = np.random.randint(\n","                    self.env.action_space.low,\n","                    self.env.action_space.high,\n","                    self.env.action_space.shape,\n","                )\n","                while not done:\n","                    # self.env.render()\n","                    action = self.actor.get_action(state)\n","                    noise = self.add_ou_noise(bg_noise, dim=self.action_dim)\n","                    action = np.clip(action + noise, 0, self.action_bound).astype(\"int\")\n","\n","                    next_state, reward, dones, _ = self.env.step(action)\n","                    done = np.all(dones)\n","                    if done:\n","                        next_state = prev_state\n","                    else:\n","                        prev_state = next_state\n","\n","                    for (s, a, r, s_n, d) in zip(\n","                        next_state, action, reward, next_state, dones\n","                    ):\n","                        self.buffer.store(s, a, (r + 8) / 8, s_n, d)\n","                        episode_reward += r\n","\n","                    step_num += 1  # 1 across num_instances\n","                    print(\n","                        f\"ep#:{ep} step#:{step_num} step_rew:{reward} action:{action} dones:{dones}\"\n","                    )\n","\n","                    bg_noise = noise\n","                    state = next_state\n","                if (\n","                    self.buffer.size() >= args.batch_size\n","                    and self.buffer.size() >= args.train_start\n","                ):\n","                    self.replay_experience()\n","                print(f\"Episode#{ep} Reward:{episode_reward}\")\n","                tf.summary.scalar(\"episode_reward\", episode_reward, step=ep)\n","\n","\n","if __name__ == \"__main__\":\n","    env_name = \"MiniWoBSocialMediaMuteUserVisualEnv-v0\"\n","    env = gym.make(env_name)\n","    agent = DDPGAgent(env)\n","    agent.train(max_episodes=2)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["ep#:0 step#:1 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:2 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:3 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:4 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:5 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:6 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:7 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:8 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:9 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:10 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:11 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:12 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:13 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:14 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:15 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:16 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:17 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:18 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:19 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:20 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:21 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:22 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:23 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:24 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:25 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:26 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:27 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:28 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:29 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:30 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:31 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:32 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:33 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:34 step_rew:[0.0] action:[[160 210]] dones:[False]\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:root:Cannot call CoordClick(coords: (160, 210)) on instance 0, which is already done\n"]},{"output_type":"stream","name":"stdout","text":["ep#:0 step#:35 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:0 step#:36 step_rew:[-1.0] action:[[160 210]] dones:[True]\n","Episode#0 Reward:-1.0\n","ep#:1 step#:1 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:2 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:3 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:4 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:5 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:6 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:7 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:8 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:9 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:10 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:11 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:12 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:13 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:14 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:15 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:16 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:17 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:18 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:19 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:20 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:21 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:22 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:23 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:24 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:25 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:26 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:27 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:28 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:29 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:30 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:31 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:32 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:33 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:34 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:35 step_rew:[0.0] action:[[160 210]] dones:[False]\n"]},{"output_type":"stream","name":"stderr","text":["WARNING:root:Cannot call CoordClick(coords: (160, 210)) on instance 0, which is already done\n"]},{"output_type":"stream","name":"stdout","text":["ep#:1 step#:36 step_rew:[0.0] action:[[160 210]] dones:[False]\n","ep#:1 step#:37 step_rew:[-1.0] action:[[160 210]] dones:[True]\n","Episode#1 Reward:-1.0\n"]}]},{"cell_type":"code","metadata":{"id":"rx8UzI52dmn4"},"source":["%tensorboard --logdir /content/logs/TFRL-SocialMedia-Mute-User-DDPGAgent/MiniWoBSocialMediaMuteUserVisualEnv-v0"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"E2ITqp9G_hAN"},"source":["![image.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"y_ucjqQ9tuZk"},"source":["---"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"bW0aBsS5tuZs","executionInfo":{"status":"ok","timestamp":1638513146554,"user_tz":-330,"elapsed":4127,"user":{"displayName":"Sparsh Agarwal","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"13037694610922482904"}},"outputId":"80ec06f9-f3be-4809-bd59-1544c47260fe"},"source":["!pip install -q watermark\n","%reload_ext watermark\n","%watermark -a \"Sparsh A.\" -m -iv -u -t -d -p selenium"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Author: Sparsh A.\n","\n","Last updated: 2021-12-03 06:32:29\n","\n","selenium: 4.1.0\n","\n","Compiler    : GCC 7.5.0\n","OS          : Linux\n","Release     : 5.4.104+\n","Machine     : x86_64\n","Processor   : x86_64\n","CPU cores   : 2\n","Architecture: 64bit\n","\n","argparse  : 1.1\n","sys       : 3.7.12 (default, Sep 10 2021, 00:21:48) \n","[GCC 7.5.0]\n","gym       : 0.17.3\n","tensorflow: 2.7.0\n","IPython   : 5.5.0\n","numpy     : 1.19.5\n","\n"]}]},{"cell_type":"markdown","metadata":{"id":"ilEAuT87tuZt"},"source":["---"]},{"cell_type":"markdown","metadata":{"id":"QXts9r8TtuZv"},"source":["**END**"]}]}