main_qtab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! python3 -V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! wget -O dacapo-bench.jar https://downloads.sourceforge.net/project/dacapobench/9.12-bach-MR1/dacapo-9.12-MR1-bach.jar\n",
    "# ! wget -O gcviewer-1.36.jar http://sourceforge.net/projects/gcviewer/files/gcviewer-1.36.jar/download\n",
    "# ! wget -O jdk.tar.gz https://download.bell-sw.com/java/11.0.20+8/bellsoft-jdk11.0.20+8-linux-amd64.tar.gz\n",
    "# # MACOS\n",
    "# # ! wget -O jdk.tar.gz https://download.bell-sw.com/java/11.0.20.1+1/bellsoft-jdk11.0.20.1+1-macos-amd64.tar.gz\n",
    "# # ! wget -O jdk.zip https://download.bell-sw.com/java/11.0.20.1+1/bellsoft-jdk11.0.20.1+1-windows-amd64.zip\n",
    "# # ! wget https://sourceforge.net/projects/gcviewer/files/gcviewer-1.36.jar/download\n",
    "# ! tar xzf jdk.tar.gz && rm -fv jdk.tar.gz\n",
    "# ! java -version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! ./jdk-11.0.20/bin/java -jar dacapo/dacapochopin.jar -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !  ./jdk-11.0.20/bin/java -jar dacapo-bench.jar xalan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! ./jdk-11.0.20/bin/java -XX:+UseParallelGC -Xmx4g -Xms128m  -cp dacapo-bench.jar \\\n",
    "# -Xlog:gc=debug:file=gc-avrora.txt -Dvmstat.enable_jfr=yes \\\n",
    "# -Dvmstat.csv=yes Harness -v -n 5 xalan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! pip install gym\n",
    "# ! mkdir /home/ellkrauze/tmp\n",
    "# ! export TMPDIR=/home/ellkrauze/tmp && pip install tensorflow\n",
    "# ! export TMPDIR=/home/ellkrauze/tmp && pip install protobuf==3.20.*\n",
    "# ! export TMPDIR=/home/ellkrauze/tmp && pip  install --force-reinstall -U tensorflow==2.3.0 keras keras-rl2 h5py==2.10.*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GCViewer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Download jar from http://sourceforge.net/projects/gcviewer/files/gcviewer-1.36.jar/download\n",
    "# ! java -cp gcviewer-1.36.jar com.tagtraum.perf.gcviewer.GCViewer gc-avrora.txt summary.csv -t SUMMARY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow DQN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-10-27 08:36:31.243495: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-10-27 08:36:31.278703: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-10-27 08:36:31.279628: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-10-27 08:36:31.990423: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import imageio\n",
    "import logging\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "\n",
    "import reverb\n",
    "\n",
    "from tf_agents.drivers import py_driver\n",
    "from tf_agents.replay_buffers import reverb_replay_buffer\n",
    "from tf_agents.replay_buffers import reverb_utils\n",
    "from tf_agents.policies import py_tf_eager_policy\n",
    "\n",
    "from tf_agents.agents.dqn import dqn_agent\n",
    "from tf_agents.agents.categorical_dqn import categorical_dqn_agent\n",
    "from tf_agents.drivers import dynamic_step_driver\n",
    "from tf_agents.environments import suite_gym\n",
    "from tf_agents.environments import tf_py_environment\n",
    "from tf_agents.eval import metric_utils\n",
    "from tf_agents.metrics import tf_metrics\n",
    "from tf_agents.networks import categorical_q_network, sequential\n",
    "from tf_agents.policies import random_tf_policy, policy_saver\n",
    "from tf_agents.replay_buffers import tf_uniform_replay_buffer\n",
    "from tf_agents.trajectories import trajectory\n",
    "from tf_agents.utils import common\n",
    "from tf_agents.specs import tensor_spec\n",
    "from tf_agents.drivers.dynamic_step_driver import DynamicStepDriver\n",
    "\n",
    "# from PyEnvironments import CurveEnv, CurveMultipleEnv, JVMEnv\n",
    "# from PyEnvironments import JVMEnv\n",
    "from PyEnvironmentsTest import JVMEnv # !!!\n",
    "\n",
    "# from tf_agents.environments import TimeLimit \n",
    "from tf_agents.environments.wrappers import TimeLimit \n",
    "from tf_agents.networks import actor_distribution_network\n",
    "from tf_agents.agents.reinforce import reinforce_agent\n",
    "\n",
    "from tf_agents.specs import from_spec\n",
    "# from tf_agents.trajectories import time_step_spec\n",
    "from tf_agents import trajectories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_iterations = 15000 # @param {type:\"integer\"}\n",
    "\n",
    "initial_collect_steps = 10000  # @param {type:\"integer\"} \n",
    "collect_steps_per_iteration = 1  # @param {type:\"integer\"}\n",
    "replay_buffer_capacity = 100000  # @param {type:\"integer\"}\n",
    "\n",
    "batch_size = 128  # @param {type:\"integer\"}\n",
    "learning_rate = 1e-6\n",
    "gamma = 0.9999 # The discount factor determines the importance of future rewards\n",
    "gradient_clipping = 1\n",
    "log_interval = 200  # @param {type:\"integer\"}\n",
    "\n",
    "num_atoms = 51  # @param {type:\"integer\"}\n",
    "min_q_value = -20  # @param {type:\"integer\"}\n",
    "max_q_value = 20  # @param {type:\"integer\"}\n",
    "n_step_update = 10  # @param {type:\"integer\"}\n",
    "\n",
    "target_update_period = 1000\n",
    "\n",
    "num_eval_episodes = 10  # @param {type:\"integer\"}\n",
    "eval_interval = 100  # @param {type:\"integer\"}\n",
    "\n",
    "train_step_counter = tf.Variable(0)\n",
    "global_step = tf.compat.v1.train.get_or_create_global_step()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully initialized a JVM Environment!\n",
      " JDK: /home/vsakovskaya/gc-ml/jdk-11.0.20/bin,\n",
      " Benchmark: avrora (/home/vsakovskaya/gc-ml/dacapo/dacapochopin.jar),\n",
      " Number of iterations: 5,\n",
      " Goal: avgGCPause,\n",
      " Number of JVM options: 2,\n",
      " JVM options: {'MaxTenuringThreshold': {'min': 1, 'max': 16}, 'ParallelGCThreads': {'min': 4, 'max': 24}},\n",
      " Env. default state: [list([7, 12]) 0.47],\n",
      " Env. default goal value: 0.47,\n",
      "\n",
      "Successfully initialized a JVM Environment!\n",
      " JDK: /home/vsakovskaya/gc-ml/jdk-11.0.20/bin,\n",
      " Benchmark: kafka (/home/vsakovskaya/gc-ml/dacapo/dacapochopin.jar),\n",
      " Number of iterations: 5,\n",
      " Goal: avgGCPause,\n",
      " Number of JVM options: 2,\n",
      " JVM options: {'MaxTenuringThreshold': {'min': 1, 'max': 16}, 'ParallelGCThreads': {'min': 4, 'max': 24}},\n",
      " Env. default state: [list([7, 12]) 0.34],\n",
      " Env. default goal value: 0.34,\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# JDK used for benchmarking\n",
    "# TEST_JDK_PATH = \"/Users/ellkrauze/projects/gc-ml/jdk-11.0.20.1.jdk\"\n",
    "TEST_JDK_PATH = \"/home/vsakovskaya/gc-ml/jdk-11.0.20\"\n",
    "\n",
    "# DaCapo benchmark name\n",
    "BM = \"avrora\"\n",
    "BM_TEST = \"kafka\"\n",
    "BM_PATH = \"/home/vsakovskaya/gc-ml/dacapo/dacapochopin.jar\"\n",
    "CALLBACK_PATH = \"/home/vsakovskaya/gc-ml/dacapo/DacapoCallback/DacapoChopin/VMStatCallback.java\"\n",
    "\n",
    "# =================\n",
    "dataset_path = \"dataset/data\"\n",
    "tempdir = \"tmp\"\n",
    "checkpoint_dir = os.path.join(tempdir, 'checkpoint')\n",
    "policy_dir = os.path.join(tempdir, 'policy')\n",
    "# =================\n",
    "\n",
    "env = JVMEnv(\n",
    "    jdk=TEST_JDK_PATH, \n",
    "    bm_path=BM_PATH, \n",
    "    callback_path=CALLBACK_PATH,\n",
    "    bm=BM, \n",
    "    verbose=True\n",
    ")\n",
    "\n",
    "env_test = JVMEnv(\n",
    "        jdk=TEST_JDK_PATH, \n",
    "        bm_path=BM_PATH, \n",
    "        callback_path=CALLBACK_PATH,\n",
    "        bm=BM_TEST,\n",
    "        verbose=True\n",
    "    )\n",
    "\n",
    "# train_env = tf_py_environment.TFPyEnvironment(env, isolation=True)\n",
    "# eval_env = tf_py_environment.TFPyEnvironment(env, isolation=True)\n",
    "# test_env = tf_py_environment.TFPyEnvironment(env_test)\n",
    "\n",
    "## Add wrapper: End episodes after specified number of steps\n",
    "# https://www.tensorflow.org/agents/api_docs/python/tf_agents/environments/TimeLimit\n",
    "\n",
    "max_steps = 10\n",
    "\n",
    "train_env = TimeLimit(env, duration=max_steps)\n",
    "eval_env = TimeLimit(env, duration=max_steps)\n",
    "test_env = TimeLimit(env_test, duration=max_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "action_spec = from_spec(train_env.action_spec())\n",
    "observation_spec = from_spec(train_env.observation_spec())\n",
    "reward_spec = from_spec(train_env.reward_spec())\n",
    "# time_step_spec = train_env.time_step_spec()\n",
    "time_step_spec = trajectories.time_step_spec(observation_spec, reward_spec)\n",
    "\n",
    "fc_layer_params = (100, 75, 50)\n",
    "\n",
    "actor_net = actor_distribution_network.ActorDistributionNetwork(\n",
    "    observation_spec,\n",
    "    action_spec,\n",
    "    fc_layer_params=fc_layer_params)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)\n",
    "\n",
    "train_step_counter = tf.Variable(0)\n",
    "\n",
    "agent = reinforce_agent.ReinforceAgent(\n",
    "    time_step_spec,\n",
    "    action_spec,\n",
    "    actor_network=actor_net,\n",
    "    optimizer=optimizer,\n",
    "    normalize_returns=True,\n",
    "    train_step_counter=train_step_counter)\n",
    "agent.initialize()\n",
    "\n",
    "random_policy = random_tf_policy.RandomTFPolicy(\n",
    "  time_step_spec = time_step_spec,\n",
    "  action_spec = action_spec,\n",
    "  automatic_state_reset=True,\n",
    "  clip=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(\n",
    "    data_spec=agent.collect_data_spec,\n",
    "    batch_size=batch_size,\n",
    "    max_length=replay_buffer_capacity)\n",
    "\n",
    "tf_policy_saver = policy_saver.PolicySaver(agent.policy)\n",
    "replay_buffer_observer = replay_buffer.add_batch\n",
    "trajectories = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Optional] Visualize Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = []\n",
    "y = []\n",
    "pairs = []\n",
    "rews = []\n",
    "for each in trajectories:\n",
    "    pairs.append(each[0].numpy()[0])\n",
    "    x.append(each[0][0][0].numpy())\n",
    "    y.append(each[0][0][1].numpy())\n",
    "    rews.append(each[1])\n",
    "    # print(each[1])\n",
    "\n",
    "# rewards_df = pd.DataFrame(pairs, rews, columns=[\"MaxTenuringThreshold\", \"ParallelGCThreads\"])\n",
    "# rewards_df = rewards_df.reset_index()\n",
    "# rewards_df = rewards_df.rename(columns={'index': 'reward'})\n",
    "\n",
    "# rewards_df.sort_values(by='reward', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: title={'center': 'Frequency of flag pairs in a dataset'}, xlabel='MaxTenuringThreshold,ParallelGCThreads'>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame(pairs, columns=[\"MaxTenuringThreshold\", \"ParallelGCThreads\"])\n",
    "df.value_counts().head(100).plot(figsize=(15,5), kind='bar', title=\"Frequency of flag pairs in a dataset\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# setting the dimensions of the plot\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "x = df.pivot_table(index='MaxTenuringThreshold',columns='ParallelGCThreads',aggfunc='size',fill_value=0)\n",
    "idx = x.max(axis=1).sort_values(ascending=0).index\n",
    "sns.heatmap(x, annot=True, ax=ax, fmt=\"\")\n",
    "ax.set_title(\"Trajectories Frequency\")\n",
    "ax.invert_yaxis()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot data as heatmap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "fig, ax = plt.subplots(figsize=(5, 5))\n",
    "cached_states = env._perf_states\n",
    "X = [cached_states[i][\"args\"][0] for i in cached_states.keys()]\n",
    "Y = [cached_states[i][\"args\"][1] for i in cached_states.keys()]\n",
    "Z = [cached_states[i][\"goal\"] for i in cached_states.keys()]\n",
    "\n",
    "data = pd.DataFrame({'MaxTenuringThreshold': X, 'ParallelGCThreads': Y, 'Average GC Pause': Z})\n",
    "data_pivoted = data.pivot(\"MaxTenuringThreshold\", \"ParallelGCThreads\", \"Average GC Pause\")\n",
    "ax = sns.heatmap(data_pivoted, annot=True, ax=ax, fmt=\".2f\")\n",
    "ax.invert_yaxis()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[reverb/cc/platform/tfrecord_checkpointer.cc:162]  Initializing TFRecordCheckpointer in /tmp/tmpvtomh1dz.\n",
      "[reverb/cc/platform/tfrecord_checkpointer.cc:567] Loading latest checkpoint from /tmp/tmpvtomh1dz\n",
      "[reverb/cc/platform/default/server.cc:71] Started replay server on port 41519\n"
     ]
    }
   ],
   "source": [
    "table_name = 'uniform_table'\n",
    "replay_buffer_signature = tensor_spec.from_spec(\n",
    "      agent.collect_data_spec)\n",
    "replay_buffer_signature = tensor_spec.add_outer_dim(\n",
    "      replay_buffer_signature)\n",
    "table = reverb.Table(\n",
    "    table_name,\n",
    "    max_size=replay_buffer_capacity,\n",
    "    sampler=reverb.selectors.Uniform(),\n",
    "    remover=reverb.selectors.Fifo(),\n",
    "    rate_limiter=reverb.rate_limiters.MinSize(1),\n",
    "    signature=replay_buffer_signature)\n",
    "\n",
    "reverb_server = reverb.Server([table])\n",
    "\n",
    "replay_buffer = reverb_replay_buffer.ReverbReplayBuffer(\n",
    "    agent.collect_data_spec,\n",
    "    table_name=table_name,\n",
    "    sequence_length=None,\n",
    "    local_server=reverb_server)\n",
    "\n",
    "rb_observer = reverb_utils.ReverbAddEpisodeObserver(\n",
    "    replay_buffer.py_client,\n",
    "    table_name,\n",
    "    replay_buffer_capacity\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_avg_return(environment, policy, num_episodes=10):\n",
    "\n",
    "  total_return = 0.0\n",
    "  for _ in range(num_episodes):\n",
    "\n",
    "    time_step = environment.reset()\n",
    "    episode_return = 0.0\n",
    "\n",
    "    while not time_step.is_last():\n",
    "      action_step = policy.action(time_step)\n",
    "      time_step = environment.step(action_step.action)\n",
    "      episode_return += time_step.reward\n",
    "    \n",
    "    # print(f\"episode return: {episode_return}\")\n",
    "    total_return += episode_return\n",
    "\n",
    "  avg_return = total_return / num_episodes\n",
    "  return avg_return\n",
    "  # return avg_return.numpy()[0]\n",
    "\n",
    "\n",
    "def collect_episode(environment, policy, num_episodes):\n",
    "  driver = py_driver.PyDriver(\n",
    "    environment,\n",
    "    py_tf_eager_policy.PyTFEagerPolicy(\n",
    "      policy, use_tf_function=True),\n",
    "    [rb_observer],\n",
    "    max_episodes=num_episodes)\n",
    "  initial_time_step = environment.reset()\n",
    "  driver.run(initial_time_step)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "agent.train = common.function(agent.train)\n",
    "# Reset the train step\n",
    "agent.train_step_counter.assign(0)\n",
    "agent.initialize()\n",
    "\n",
    "# Evaluate the agent's policy once before training.\n",
    "avg_return = compute_avg_return(eval_env, agent.policy, 100)\n",
    "returns = [avg_return]\n",
    "\n",
    "loss = []\n",
    "returns = []\n",
    "collect_episodes_per_iteration = 2 \n",
    "\n",
    "for _ in range(num_iterations):\n",
    "# for _ in range(1000):\n",
    "\n",
    "  # Collect a few episodes using collect_policy and save to the replay buffer.\n",
    "  collect_episode(\n",
    "      train_env, agent.collect_policy, collect_episodes_per_iteration)\n",
    "\n",
    "  # Use data from the buffer and update the agent's network.\n",
    "  iterator = iter(replay_buffer.as_dataset(sample_batch_size=1))\n",
    "  trajectories, _ = next(iterator)\n",
    "  train_loss = agent.train(experience=trajectories)  \n",
    "\n",
    "  replay_buffer.clear()\n",
    "\n",
    "  step = agent.train_step_counter.numpy()\n",
    "\n",
    "  if step % log_interval == 0:\n",
    "    print('step = {0}: loss = {1}'.format(step, train_loss.loss))\n",
    "\n",
    "  if step % eval_interval == 0:\n",
    "    avg_return = compute_avg_return(eval_env, agent.policy, num_eval_episodes)\n",
    "    print('step = {0}: Average Return = {1}'.format(step, avg_return))\n",
    "    returns.append(avg_return)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WandB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! export WANDB_NOTEBOOK_NAME=\"main.ipynb\"\n",
    "import wandb\n",
    "\n",
    "WANDB_KEY = \"4b077df3688052b0f43705d6b4d712c05fb979b7\"\n",
    "config = dict(\n",
    "    competition = 'GC ML',\n",
    "    _wandb_kernel = 'lemon',\n",
    "    seed = 42,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set this to True when you want to run hyperparameter tuning\n",
    "hyperparameter_tuning = True\n",
    "\n",
    "def train_agent():\n",
    "    run = wandb.init(config = config)\n",
    "    \n",
    "    optimizer = tf.keras.optimizers.Adam(\n",
    "        learning_rate=run.config.learning_rate)\n",
    "\n",
    "    train_step_counter = tf.Variable(0)\n",
    "\n",
    "    agent = reinforce_agent.ReinforceAgent(\n",
    "        time_step_spec,\n",
    "        action_spec,\n",
    "        actor_network=actor_net,\n",
    "        optimizer=optimizer,\n",
    "        normalize_returns=True,\n",
    "        train_step_counter=train_step_counter,\n",
    "        gamma=run.config.gamma,\n",
    "    )\n",
    "    agent.initialize()\n",
    "\n",
    "# Define sweep config\n",
    "sweep_configuration = {\n",
    "    'method': 'random',\n",
    "    'name': 'rl_greed',\n",
    "    \"metric\": {\n",
    "        \"name\" : \"loss\",\n",
    "        \"goal\": \"minimize\"\n",
    "    },\n",
    "    \"parameters\" : {\n",
    "        \"learning_rate\": {\n",
    "            \"min\": 0.001,\n",
    "            \"max\": 0.01\n",
    "        },\n",
    "        \n",
    "    },\n",
    "    'run_cap' : 32\n",
    "}\n",
    "\n",
    "if hyperparameter_tuning:\n",
    "    # Initialize sweep by passing in config. (Optional) Provide a name of the project.\n",
    "    sweep_id = wandb.sweep(sweep=sweep_configuration, project=\"Predicting-City-Status-Task\",)\n",
    "\n",
    "    # Start sweep job.\n",
    "    wandb.agent(sweep_id, function=train_agent)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "my-env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}